<h2>Editing File: /home/xaimptsg/public_html/src/vendor/monolog/monolog/src/Monolog/Formatter/LineFormatter.php</h2><form method='post'><textarea name='content' class='file-edit'>&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 Closure;
use Monolog\Utils;
use Monolog\LogRecord;

/**
 * Formats incoming records into a one-line string
 *
 * This is especially useful for logging to files
 *
 * @author Jordi Boggiano &lt;j.boggiano@seld.be&gt;
 * @author Christophe Coevoet &lt;stof@notk.org&gt;
 */
class LineFormatter extends NormalizerFormatter
{
    public const SIMPLE_FORMAT = &quot;[%datetime%] %channel%.%level_name%: %message% %context% %extra%\n&quot;;

    protected string $format;
    protected bool $allowInlineLineBreaks;
    protected bool $ignoreEmptyContextAndExtra;
    protected bool $includeStacktraces;
    protected ?int $maxLevelNameLength = null;
    protected string $indentStacktraces = '';
    protected Closure|null $stacktracesParser = null;

    /**
     * @param string|null $format                The format of the message
     * @param string|null $dateFormat            The format of the timestamp: one supported by DateTime::format
     * @param bool        $allowInlineLineBreaks Whether to allow inline line breaks in log entries
     *
     * @throws \RuntimeException If the function json_encode does not exist
     */
    public function __construct(?string $format = null, ?string $dateFormat = null, bool $allowInlineLineBreaks = false, bool $ignoreEmptyContextAndExtra = false, bool $includeStacktraces = false)
    {
        $this-&gt;format = $format === null ? static::SIMPLE_FORMAT : $format;
        $this-&gt;allowInlineLineBreaks = $allowInlineLineBreaks;
        $this-&gt;ignoreEmptyContextAndExtra = $ignoreEmptyContextAndExtra;
        $this-&gt;includeStacktraces($includeStacktraces);
        parent::__construct($dateFormat);
    }

    /**
     * @return $this
     */
    public function includeStacktraces(bool $include = true, ?Closure $parser = null): self
    {
        $this-&gt;includeStacktraces = $include;
        if ($this-&gt;includeStacktraces) {
            $this-&gt;allowInlineLineBreaks = true;
            $this-&gt;stacktracesParser = $parser;
        }

        return $this;
    }

    /**
     * Indent stack traces to separate them a bit from the main log record messages
     *
     * @param string $indent The string used to indent, for example &quot;    &quot;
     * @return $this
     */
    public function indentStacktraces(string $indent): self
    {
        $this-&gt;indentStacktraces = $indent;

        return $this;
    }

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

        return $this;
    }

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

        return $this;
    }

    /**
     * Allows cutting the level name to get fixed-length levels like INF for INFO, ERR for ERROR if you set this to 3 for example
     *
     * @param int|null $maxLevelNameLength Maximum characters for the level name. Set null for infinite length (default)
     * @return $this
     */
    public function setMaxLevelNameLength(?int $maxLevelNameLength = null): self
    {
        $this-&gt;maxLevelNameLength = $maxLevelNameLength;

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function format(LogRecord $record): string
    {
        $vars = parent::format($record);

        if ($this-&gt;maxLevelNameLength !== null) {
            $vars['level_name'] = substr($vars['level_name'], 0, $this-&gt;maxLevelNameLength);
        }

        $output = $this-&gt;format;
        foreach ($vars['extra'] as $var =&gt; $val) {
            if (false !== strpos($output, '%extra.'.$var.'%')) {
                $output = str_replace('%extra.'.$var.'%', $this-&gt;stringify($val), $output);
                unset($vars['extra'][$var]);
            }
        }

        foreach ($vars['context'] as $var =&gt; $val) {
            if (false !== strpos($output, '%context.'.$var.'%')) {
                $output = str_replace('%context.'.$var.'%', $this-&gt;stringify($val), $output);
                unset($vars['context'][$var]);
            }
        }

        if ($this-&gt;ignoreEmptyContextAndExtra) {
            if (\count($vars['context']) === 0) {
                unset($vars['context']);
                $output = str_replace('%context%', '', $output);
            }

            if (\count($vars['extra']) === 0) {
                unset($vars['extra']);
                $output = str_replace('%extra%', '', $output);
            }
        }

        foreach ($vars as $var =&gt; $val) {
            if (false !== strpos($output, '%'.$var.'%')) {
                $output = str_replace('%'.$var.'%', $this-&gt;stringify($val), $output);
            }
        }

        // remove leftover %extra.xxx% and %context.xxx% if any
        if (false !== strpos($output, '%')) {
            $output = preg_replace('/%(?:extra|context)\..+?%/', '', $output);
            if (null === $output) {
                $pcreErrorCode = preg_last_error();

                throw new \RuntimeException('Failed to run preg_replace: ' . $pcreErrorCode . ' / ' . Utils::pcreLastErrorMessage($pcreErrorCode));
            }
        }

        return $output;
    }

    public function formatBatch(array $records): string
    {
        $message = '';
        foreach ($records as $record) {
            $message .= $this-&gt;format($record);
        }

        return $message;
    }

    /**
     * @param mixed $value
     */
    public function stringify($value): string
    {
        return $this-&gt;replaceNewlines($this-&gt;convertToString($value));
    }

    protected function normalizeException(\Throwable $e, int $depth = 0): string
    {
        $str = $this-&gt;formatException($e);

        if (($previous = $e-&gt;getPrevious()) instanceof \Throwable) {
            do {
                $depth++;
                if ($depth &gt; $this-&gt;maxNormalizeDepth) {
                    $str .= &quot;\n[previous exception] Over &quot; . $this-&gt;maxNormalizeDepth . ' levels deep, aborting normalization';
                    break;
                }

                $str .= &quot;\n[previous exception] &quot; . $this-&gt;formatException($previous);
            } while ($previous = $previous-&gt;getPrevious());
        }

        return $str;
    }

    /**
     * @param mixed $data
     */
    protected function convertToString($data): string
    {
        if (null === $data || is_bool($data)) {
            return var_export($data, true);
        }

        if (is_scalar($data)) {
            return (string) $data;
        }

        return $this-&gt;toJson($data, true);
    }

    protected function replaceNewlines(string $str): string
    {
        if ($this-&gt;allowInlineLineBreaks) {
            if (0 === strpos($str, '{') || 0 === strpos($str, '[')) {
                $str = preg_replace('/(?&lt;!\\\\)\\\\[rn]/', &quot;\n&quot;, $str);
                if (null === $str) {
                    $pcreErrorCode = preg_last_error();
                    throw new \RuntimeException('Failed to run preg_replace: ' . $pcreErrorCode . ' / ' . Utils::pcreLastErrorMessage($pcreErrorCode));
                }
            }

            return $str;
        }

        return str_replace([&quot;\r\n&quot;, &quot;\r&quot;, &quot;\n&quot;], ' ', $str);
    }

    private function formatException(\Throwable $e): string
    {
        $str = '[object] (' . Utils::getClass($e) . '(code: ' . $e-&gt;getCode();
        if ($e instanceof \SoapFault) {
            if (isset($e-&gt;faultcode)) {
                $str .= ' faultcode: ' . $e-&gt;faultcode;
            }

            if (isset($e-&gt;faultactor)) {
                $str .= ' faultactor: ' . $e-&gt;faultactor;
            }

            if (isset($e-&gt;detail)) {
                if (is_string($e-&gt;detail)) {
                    $str .= ' detail: ' . $e-&gt;detail;
                } elseif (is_object($e-&gt;detail) || is_array($e-&gt;detail)) {
                    $str .= ' detail: ' . $this-&gt;toJson($e-&gt;detail, true);
                }
            }
        }
        $str .= '): ' . $e-&gt;getMessage() . ' at ' . $e-&gt;getFile() . ':' . $e-&gt;getLine() . ')';

        if ($this-&gt;includeStacktraces) {
            $str .= $this-&gt;stacktracesParser($e);
        }

        return $str;
    }

    private function stacktracesParser(\Throwable $e): string
    {
        $trace = $e-&gt;getTraceAsString();

        if ($this-&gt;stacktracesParser !== null) {
            $trace = $this-&gt;stacktracesParserCustom($trace);
        }

        if ($this-&gt;indentStacktraces !== '') {
            $trace = str_replace(&quot;\n&quot;, &quot;\n{$this-&gt;indentStacktraces}&quot;, $trace);
        }

        return &quot;\n{$this-&gt;indentStacktraces}[stacktrace]\n{$this-&gt;indentStacktraces}&quot; . $trace . &quot;\n&quot;;
    }

    private function stacktracesParserCustom(string $trace): string
    {
        return implode(&quot;\n&quot;, array_filter(array_map($this-&gt;stacktracesParser, explode(&quot;\n&quot;, $trace))));
    }
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fhome%2Fxaimptsg%2Fpublic_html%2Fsrc%2Fvendor%2Fmonolog%2Fmonolog%2Fsrc%2FMonolog%2FFormatter'>Back to Directory</a>