<form method="POST">
    <h3>Editing: NormalizerFormatter.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);

/*
 * This file is part of the Monolog package.
 *
 * (c) Jordi Boggiano &lt;j.boggiano@seld.be&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Monolog\Formatter;

use Monolog\DateTimeImmutable;
use Monolog\Utils;
use Throwable;

/**
 * Normalizes incoming records to remove objects/resources so it's easier to dump to various targets
 *
 * @author Jordi Boggiano &lt;j.boggiano@seld.be&gt;
 */
class NormalizerFormatter implements FormatterInterface
{
    public const SIMPLE_DATE = &quot;Y-m-d\TH:i:sP&quot;;

    /** @var string */
    protected $dateFormat;
    /** @var int */
    protected $maxNormalizeDepth = 9;
    /** @var int */
    protected $maxNormalizeItemCount = 1000;

    /** @var int */
    private $jsonEncodeOptions = Utils::DEFAULT_JSON_FLAGS;

    /**
     * @param string|null $dateFormat The format of the timestamp: one supported by DateTime::format
     */
    public function __construct(?string $dateFormat = null)
    {
        $this-&gt;dateFormat = null === $dateFormat ? static::SIMPLE_DATE : $dateFormat;
        if (!function_exists('json_encode')) {
            throw new \RuntimeException('PHP\'s json extension is required to use Monolog\'s NormalizerFormatter');
        }
    }

    /**
     * {@inheritDoc}
     *
     * @param mixed[] $record
     */
    public function format(array $record)
    {
        return $this-&gt;normalize($record);
    }

    /**
     * {@inheritDoc}
     */
    public function formatBatch(array $records)
    {
        foreach ($records as $key =&gt; $record) {
            $records[$key] = $this-&gt;format($record);
        }

        return $records;
    }

    public function getDateFormat(): string
    {
        return $this-&gt;dateFormat;
    }

    public function setDateFormat(string $dateFormat): self
    {
        $this-&gt;dateFormat = $dateFormat;

        return $this;
    }

    /**
     * The maximum number of normalization levels to go through
     */
    public function getMaxNormalizeDepth(): int
    {
        return $this-&gt;maxNormalizeDepth;
    }

    public function setMaxNormalizeDepth(int $maxNormalizeDepth): self
    {
        $this-&gt;maxNormalizeDepth = $maxNormalizeDepth;

        return $this;
    }

    /**
     * The maximum number of items to normalize per level
     */
    public function getMaxNormalizeItemCount(): int
    {
        return $this-&gt;maxNormalizeItemCount;
    }

    public function setMaxNormalizeItemCount(int $maxNormalizeItemCount): self
    {
        $this-&gt;maxNormalizeItemCount = $maxNormalizeItemCount;

        return $this;
    }

    /**
     * Enables `json_encode` pretty print.
     */
    public function setJsonPrettyPrint(bool $enable): self
    {
        if ($enable) {
            $this-&gt;jsonEncodeOptions |= JSON_PRETTY_PRINT;
        } else {
            $this-&gt;jsonEncodeOptions &amp;= ~JSON_PRETTY_PRINT;
        }

        return $this;
    }

    /**
     * @param  mixed                $data
     * @return null|scalar|array&lt;array|scalar|null&gt;
     */
    protected function normalize($data, int $depth = 0)
    {
        if ($depth &gt; $this-&gt;maxNormalizeDepth) {
            return 'Over ' . $this-&gt;maxNormalizeDepth . ' levels deep, aborting normalization';
        }

        if (null === $data || is_scalar($data)) {
            if (is_float($data)) {
                if (is_infinite($data)) {
                    return ($data &gt; 0 ? '' : '-') . 'INF';
                }
                if (is_nan($data)) {
                    return 'NaN';
                }
            }

            return $data;
        }

        if (is_array($data)) {
            $normalized = [];

            $count = 1;
            foreach ($data as $key =&gt; $value) {
                if ($count++ &gt; $this-&gt;maxNormalizeItemCount) {
                    $normalized['...'] = 'Over ' . $this-&gt;maxNormalizeItemCount . ' items ('.count($data).' total), aborting normalization';
                    break;
                }

                $normalized[$key] = $this-&gt;normalize($value, $depth + 1);
            }

            return $normalized;
        }

        if ($data instanceof \DateTimeInterface) {
            return $this-&gt;formatDate($data);
        }

        if (is_object($data)) {
            if ($data instanceof Throwable) {
                return $this-&gt;normalizeException($data, $depth);
            }

            if ($data instanceof \JsonSerializable) {
                /** @var null|scalar|array&lt;array|scalar|null&gt; $value */
                $value = $data-&gt;jsonSerialize();
            } elseif (\get_class($data) === '__PHP_Incomplete_Class') {
                $accessor = new \ArrayObject($data);
                $value = (string) $accessor['__PHP_Incomplete_Class_Name'];
            } elseif (method_exists($data, '__toString')) {
                /** @var string $value */
                $value = $data-&gt;__toString();
            } else {
                // the rest is normalized by json encoding and decoding it
                /** @var null|scalar|array&lt;array|scalar|null&gt; $value */
                $value = json_decode($this-&gt;toJson($data, true), true);
            }

            return [Utils::getClass($data) =&gt; $value];
        }

        if (is_resource($data)) {
            return sprintf('[resource(%s)]', get_resource_type($data));
        }

        return '[unknown('.gettype($data).')]';
    }

    /**
     * @return mixed[]
     */
    protected function normalizeException(Throwable $e, int $depth = 0)
    {
        if ($depth &gt; $this-&gt;maxNormalizeDepth) {
            return ['Over ' . $this-&gt;maxNormalizeDepth . ' levels deep, aborting normalization'];
        }

        if ($e instanceof \JsonSerializable) {
            return (array) $e-&gt;jsonSerialize();
        }

        $data = [
            'class' =&gt; Utils::getClass($e),
            'message' =&gt; $e-&gt;getMessage(),
            'code' =&gt; (int) $e-&gt;getCode(),
            'file' =&gt; $e-&gt;getFile().':'.$e-&gt;getLine(),
        ];

        if ($e instanceof \SoapFault) {
            if (isset($e-&gt;faultcode)) {
                $data['faultcode'] = $e-&gt;faultcode;
            }

            if (isset($e-&gt;faultactor)) {
                $data['faultactor'] = $e-&gt;faultactor;
            }

            if (isset($e-&gt;detail)) {
                if (is_string($e-&gt;detail)) {
                    $data['detail'] = $e-&gt;detail;
                } elseif (is_object($e-&gt;detail) || is_array($e-&gt;detail)) {
                    $data['detail'] = $this-&gt;toJson($e-&gt;detail, true);
                }
            }
        }

        $trace = $e-&gt;getTrace();
        foreach ($trace as $frame) {
            if (isset($frame['file'])) {
                $data['trace'][] = $frame['file'].':'.$frame['line'];
            }
        }

        if ($previous = $e-&gt;getPrevious()) {
            $data['previous'] = $this-&gt;normalizeException($previous, $depth + 1);
        }

        return $data;
    }

    /**
     * Return the JSON representation of a value
     *
     * @param  mixed             $data
     * @throws \RuntimeException if encoding fails and errors are not ignored
     * @return string            if encoding fails and ignoreErrors is true 'null' is returned
     */
    protected function toJson($data, bool $ignoreErrors = false): string
    {
        return Utils::jsonEncode($data, $this-&gt;jsonEncodeOptions, $ignoreErrors);
    }

    /**
     * @return string
     */
    protected function formatDate(\DateTimeInterface $date)
    {
        // in case the date format isn't custom then we defer to the custom DateTimeImmutable
        // formatting logic, which will pick the right format based on whether useMicroseconds is on
        if ($this-&gt;dateFormat === self::SIMPLE_DATE &amp;&amp; $date instanceof DateTimeImmutable) {
            return (string) $date;
        }

        return $date-&gt;format($this-&gt;dateFormat);
    }

    public function addJsonEncodeOption(int $option): self
    {
        $this-&gt;jsonEncodeOptions |= $option;

        return $this;
    }

    public function removeJsonEncodeOption(int $option): self
    {
        $this-&gt;jsonEncodeOptions &amp;= ~$option;

        return $this;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>