<form method="POST">
    <h3>Editing: JsonFormatter.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 Throwable;

/**
 * Encodes whatever record data is passed to it as json
 *
 * This can be useful to log to databases or remote APIs
 *
 * @author Jordi Boggiano &lt;j.boggiano@seld.be&gt;
 *
 * @phpstan-import-type Record from \Monolog\Logger
 */
class JsonFormatter extends NormalizerFormatter
{
    public const BATCH_MODE_JSON = 1;
    public const BATCH_MODE_NEWLINES = 2;

    /** @var self::BATCH_MODE_* */
    protected $batchMode;
    /** @var bool */
    protected $appendNewline;
    /** @var bool */
    protected $ignoreEmptyContextAndExtra;
    /** @var bool */
    protected $includeStacktraces = false;

    /**
     * @param self::BATCH_MODE_* $batchMode
     */
    public function __construct(int $batchMode = self::BATCH_MODE_JSON, bool $appendNewline = true, bool $ignoreEmptyContextAndExtra = false, bool $includeStacktraces = false)
    {
        $this-&gt;batchMode = $batchMode;
        $this-&gt;appendNewline = $appendNewline;
        $this-&gt;ignoreEmptyContextAndExtra = $ignoreEmptyContextAndExtra;
        $this-&gt;includeStacktraces = $includeStacktraces;

        parent::__construct();
    }

    /**
     * The batch mode option configures the formatting style for
     * multiple records. By default, multiple records will be
     * formatted as a JSON-encoded array. However, for
     * compatibility with some API endpoints, alternative styles
     * are available.
     */
    public function getBatchMode(): int
    {
        return $this-&gt;batchMode;
    }

    /**
     * True if newlines are appended to every formatted record
     */
    public function isAppendingNewlines(): bool
    {
        return $this-&gt;appendNewline;
    }

    /**
     * {@inheritDoc}
     */
    public function format(array $record): string
    {
        $normalized = $this-&gt;normalize($record);

        if (isset($normalized['context']) &amp;&amp; $normalized['context'] === []) {
            if ($this-&gt;ignoreEmptyContextAndExtra) {
                unset($normalized['context']);
            } else {
                $normalized['context'] = new \stdClass;
            }
        }
        if (isset($normalized['extra']) &amp;&amp; $normalized['extra'] === []) {
            if ($this-&gt;ignoreEmptyContextAndExtra) {
                unset($normalized['extra']);
            } else {
                $normalized['extra'] = new \stdClass;
            }
        }

        return $this-&gt;toJson($normalized, true) . ($this-&gt;appendNewline ? &quot;\n&quot; : '');
    }

    /**
     * {@inheritDoc}
     */
    public function formatBatch(array $records): string
    {
        switch ($this-&gt;batchMode) {
            case static::BATCH_MODE_NEWLINES:
                return $this-&gt;formatBatchNewlines($records);

            case static::BATCH_MODE_JSON:
            default:
                return $this-&gt;formatBatchJson($records);
        }
    }

    /**
     * @return self
     */
    public function includeStacktraces(bool $include = true): self
    {
        $this-&gt;includeStacktraces = $include;

        return $this;
    }

    /**
     * Return a JSON-encoded array of records.
     *
     * @phpstan-param Record[] $records
     */
    protected function formatBatchJson(array $records): string
    {
        return $this-&gt;toJson($this-&gt;normalize($records), true);
    }

    /**
     * Use new lines to separate records instead of a
     * JSON-encoded array.
     *
     * @phpstan-param Record[] $records
     */
    protected function formatBatchNewlines(array $records): string
    {
        $instance = $this;

        $oldNewline = $this-&gt;appendNewline;
        $this-&gt;appendNewline = false;
        array_walk($records, function (&amp;$value, $key) use ($instance) {
            $value = $instance-&gt;format($value);
        });
        $this-&gt;appendNewline = $oldNewline;

        return implode(&quot;\n&quot;, $records);
    }

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

        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 (is_object($data)) {
            if ($data instanceof \DateTimeInterface) {
                return $this-&gt;formatDate($data);
            }

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

            // if the object has specific json serializability we want to make sure we skip the __toString treatment below
            if ($data instanceof \JsonSerializable) {
                return $data;
            }

            if (method_exists($data, '__toString')) {
                return $data-&gt;__toString();
            }

            return $data;
        }

        if (is_resource($data)) {
            return parent::normalize($data);
        }

        return $data;
    }

    /**
     * Normalizes given exception with or without its own stack trace based on
     * `includeStacktraces` property.
     *
     * {@inheritDoc}
     */
    protected function normalizeException(Throwable $e, int $depth = 0): array
    {
        $data = parent::normalizeException($e, $depth);
        if (!$this-&gt;includeStacktraces) {
            unset($data['trace']);
        }

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