Subversion-Projekte lars-tiefland.laravel_shop

<?php declare(strict_types=1);

/*

 * This file is part of the Monolog package.

 *

 * (c) Jordi Boggiano <j.boggiano@seld.be>

 *

 * For the full copyright and license information, please view the LICENSE

 * file that was distributed with this source code.

 */

namespace Monolog\Formatter;

use Monolog\Utils;

/**

 * Formats incoming records into a one-line string

 *

 * This is especially useful for logging to files

 *

 * @author Jordi Boggiano <j.boggiano@seld.be>

 * @author Christophe Coevoet <stof@notk.org>

 */

class LineFormatter extends NormalizerFormatter

{

    public const SIMPLE_FORMAT = "[%datetime%] %channel%.%level_name%: %message% %context% %extra%\n";

    /** @var string */

    protected $format;

    /** @var bool */

    protected $allowInlineLineBreaks;

    /** @var bool */

    protected $ignoreEmptyContextAndExtra;

    /** @var bool */

    protected $includeStacktraces;

    /** @var ?callable */

    protected $stacktracesParser;

    /**

     * @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

     * @param bool        $ignoreEmptyContextAndExtra

     */

    public function __construct(?string $format = null, ?string $dateFormat = null, bool $allowInlineLineBreaks = false, bool $ignoreEmptyContextAndExtra = false, bool $includeStacktraces = false)

    {

        $this->format = $format === null ? static::SIMPLE_FORMAT : $format;

        $this->allowInlineLineBreaks = $allowInlineLineBreaks;

        $this->ignoreEmptyContextAndExtra = $ignoreEmptyContextAndExtra;

        $this->includeStacktraces($includeStacktraces);

        parent::__construct($dateFormat);

    }

    public function includeStacktraces(bool $include = true, ?callable $parser = null): self

    {

        $this->includeStacktraces = $include;

        if ($this->includeStacktraces) {

            $this->allowInlineLineBreaks = true;

            $this->stacktracesParser = $parser;

        }

        return $this;

    }

    public function allowInlineLineBreaks(bool $allow = true): self

    {

        $this->allowInlineLineBreaks = $allow;

        return $this;

    }

    public function ignoreEmptyContextAndExtra(bool $ignore = true): self

    {

        $this->ignoreEmptyContextAndExtra = $ignore;

        return $this;

    }

    /**

     * {@inheritDoc}

     */

    public function format(array $record): string

    {

        $vars = parent::format($record);

        $output = $this->format;

        foreach ($vars['extra'] as $var => $val) {

            if (false !== strpos($output, '%extra.'.$var.'%')) {

                $output = str_replace('%extra.'.$var.'%', $this->stringify($val), $output);

                unset($vars['extra'][$var]);

            }

        }

        foreach ($vars['context'] as $var => $val) {

            if (false !== strpos($output, '%context.'.$var.'%')) {

                $output = str_replace('%context.'.$var.'%', $this->stringify($val), $output);

                unset($vars['context'][$var]);

            }

        }

        if ($this->ignoreEmptyContextAndExtra) {

            if (empty($vars['context'])) {

                unset($vars['context']);

                $output = str_replace('%context%', '', $output);

            }

            if (empty($vars['extra'])) {

                unset($vars['extra']);

                $output = str_replace('%extra%', '', $output);

            }

        }

        foreach ($vars as $var => $val) {

            if (false !== strpos($output, '%'.$var.'%')) {

                $output = str_replace('%'.$var.'%', $this->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->format($record);

        }

        return $message;

    }

    /**

     * @param mixed $value

     */

    public function stringify($value): string

    {

        return $this->replaceNewlines($this->convertToString($value));

    }

    protected function normalizeException(\Throwable $e, int $depth = 0): string

    {

        $str = $this->formatException($e);

        if ($previous = $e->getPrevious()) {

            do {

                $depth++;

                if ($depth > $this->maxNormalizeDepth) {

                    $str .= '\n[previous exception] Over ' . $this->maxNormalizeDepth . ' levels deep, aborting normalization';

                    break;

                }

                $str .= "\n[previous exception] " . $this->formatException($previous);

            } while ($previous = $previous->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->toJson($data, true);

    }

    protected function replaceNewlines(string $str): string

    {

        if ($this->allowInlineLineBreaks) {

            if (0 === strpos($str, '{')) {

                $str = preg_replace('/(?<!\\\\)\\\\[rn]/', "\n", $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(["\r\n", "\r", "\n"], ' ', $str);

    }

    private function formatException(\Throwable $e): string

    {

        $str = '[object] (' . Utils::getClass($e) . '(code: ' . $e->getCode();

        if ($e instanceof \SoapFault) {

            if (isset($e->faultcode)) {

                $str .= ' faultcode: ' . $e->faultcode;

            }

            if (isset($e->faultactor)) {

                $str .= ' faultactor: ' . $e->faultactor;

            }

            if (isset($e->detail)) {

                if (is_string($e->detail)) {

                    $str .= ' detail: ' . $e->detail;

                } elseif (is_object($e->detail) || is_array($e->detail)) {

                    $str .= ' detail: ' . $this->toJson($e->detail, true);

                }

            }

        }

        $str .= '): ' . $e->getMessage() . ' at ' . $e->getFile() . ':' . $e->getLine() . ')';

        if ($this->includeStacktraces) {

            $str .= $this->stacktracesParser($e);

        }

        return $str;

    }

    private function stacktracesParser(\Throwable $e): string

    {

        $trace = $e->getTraceAsString();

        if ($this->stacktracesParser) {

            $trace = $this->stacktracesParserCustom($trace);

        }

        return "\n[stacktrace]\n" . $trace . "\n";

    }

    private function stacktracesParserCustom(string $trace): string

    {

        return implode("\n", array_filter(array_map($this->stacktracesParser, explode("\n", $trace))));

    }

}