FM / Formatter

/home/techb158/dev.balacoffee.com/vendor/monolog/monolog/src/Monolog/Formatter/

/home/techb158/dev.balacoffee.com/vendor/monolog/monolog/src/Monolog/Formatter

Name	Size	Mode	Actions
ChromePHPFormatter.php	2144	0644	edit dl rm
ElasticaFormatter.php	2072	0644	edit dl rm
ElasticsearchFormatter.php	1861	0644	edit dl rm
FlowdockFormatter.php	2613	0644	edit dl rm
FluentdFormatter.php	2224	0644	edit dl rm
FormatterInterface.php	958	0644	edit dl rm
GelfMessageFormatter.php	5617	0644	edit dl rm
GoogleCloudLoggingFormatter.php	1130	0644	edit dl rm
HtmlFormatter.php	4513	0644	edit dl rm
JsonFormatter.php	6128	0644	edit dl rm
LineFormatter.php	7690	0644	edit dl rm
LogglyFormatter.php	1305	0644	edit dl rm
LogmaticFormatter.php	1484	0644	edit dl rm
LogstashFormatter.php	3402	0644	edit dl rm
MongoDBFormatter.php	4972	0644	edit dl rm
NormalizerFormatter.php	8239	0644	edit dl rm
ScalarFormatter.php	1160	0644	edit dl rm
WildfireFormatter.php	3937	0644	edit dl rm

Edit: /home/techb158/dev.balacoffee.com/vendor/monolog/monolog/src/Monolog/Formatter/LineFormatter.php (7690B)

<?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))));
    }
}

cmd: