mirror of
https://github.com/Seldaek/monolog.git
synced 2025-10-21 00:26:10 +02:00
318 lines
9.8 KiB
PHP
318 lines
9.8 KiB
PHP
<?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 Throwable;
|
||
use Monolog\DateTimeImmutable;
|
||
|
||
/**
|
||
* Normalizes incoming records to remove objects/resources so it's easier to dump to various targets
|
||
*
|
||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||
*/
|
||
class NormalizerFormatter implements FormatterInterface
|
||
{
|
||
const SIMPLE_DATE = "Y-m-d\TH:i:sP";
|
||
|
||
protected $dateFormat;
|
||
|
||
/**
|
||
* @param string $dateFormat The format of the timestamp: one supported by DateTime::format
|
||
*/
|
||
public function __construct(string $dateFormat = null)
|
||
{
|
||
$this->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}
|
||
*/
|
||
public function format(array $record): array
|
||
{
|
||
return $this->normalize($record);
|
||
}
|
||
|
||
/**
|
||
* {@inheritdoc}
|
||
*/
|
||
public function formatBatch(array $records): array
|
||
{
|
||
foreach ($records as $key => $record) {
|
||
$records[$key] = $this->format($record);
|
||
}
|
||
|
||
return $records;
|
||
}
|
||
|
||
/**
|
||
* @param mixed $data
|
||
* @return int|bool|string|null|array
|
||
*/
|
||
protected function normalize($data, int $depth = 0)
|
||
{
|
||
if ($depth > 9) {
|
||
return 'Over 9 levels deep, aborting normalization';
|
||
}
|
||
|
||
if (null === $data || is_scalar($data)) {
|
||
if (is_float($data)) {
|
||
if (is_infinite($data)) {
|
||
return ($data > 0 ? '' : '-') . 'INF';
|
||
}
|
||
if (is_nan($data)) {
|
||
return 'NaN';
|
||
}
|
||
}
|
||
|
||
return $data;
|
||
}
|
||
|
||
if (is_array($data)) {
|
||
$normalized = [];
|
||
|
||
$count = 1;
|
||
foreach ($data as $key => $value) {
|
||
if ($count++ >= 1000) {
|
||
$normalized['...'] = 'Over 1000 items ('.count($data).' total), aborting normalization';
|
||
break;
|
||
}
|
||
$normalized[$key] = $this->normalize($value, $depth + 1);
|
||
}
|
||
|
||
return $normalized;
|
||
}
|
||
|
||
if ($data instanceof \DateTimeInterface) {
|
||
return $this->formatDate($data);
|
||
}
|
||
|
||
if (is_object($data)) {
|
||
if ($data instanceof Throwable) {
|
||
return $this->normalizeException($data, $depth);
|
||
}
|
||
|
||
if ($data instanceof \JsonSerializable) {
|
||
$value = $data->jsonSerialize();
|
||
} elseif (method_exists($data, '__toString')) {
|
||
$value = $data->__toString();
|
||
} else {
|
||
// the rest is normalized by json encoding and decoding it
|
||
$encoded = $this->toJson($data, true);
|
||
if ($encoded === false) {
|
||
$value = 'JSON_ERROR';
|
||
} else {
|
||
$value = json_decode($encoded, true);
|
||
}
|
||
}
|
||
|
||
return [get_class($data) => $value];
|
||
}
|
||
|
||
if (is_resource($data)) {
|
||
return sprintf('[resource(%s)]', get_resource_type($data));
|
||
}
|
||
|
||
return '[unknown('.gettype($data).')]';
|
||
}
|
||
|
||
/**
|
||
* @return array
|
||
*/
|
||
protected function normalizeException(Throwable $e, int $depth = 0)
|
||
{
|
||
$data = [
|
||
'class' => get_class($e),
|
||
'message' => $e->getMessage(),
|
||
'code' => $e->getCode(),
|
||
'file' => $e->getFile().':'.$e->getLine(),
|
||
];
|
||
|
||
if ($e instanceof \SoapFault) {
|
||
if (isset($e->faultcode)) {
|
||
$data['faultcode'] = $e->faultcode;
|
||
}
|
||
|
||
if (isset($e->faultactor)) {
|
||
$data['faultactor'] = $e->faultactor;
|
||
}
|
||
|
||
if (isset($e->detail)) {
|
||
$data['detail'] = $e->detail;
|
||
}
|
||
}
|
||
|
||
$trace = $e->getTrace();
|
||
foreach ($trace as $frame) {
|
||
if (isset($frame['file'])) {
|
||
$data['trace'][] = $frame['file'].':'.$frame['line'];
|
||
} elseif (isset($frame['function']) && $frame['function'] === '{closure}') {
|
||
// We should again normalize the frames, because it might contain invalid items
|
||
$data['trace'][] = $frame['function'];
|
||
} else {
|
||
// We should again normalize the frames, because it might contain invalid items
|
||
$data['trace'][] = $this->toJson($this->normalize($frame, $depth + 1), true);
|
||
}
|
||
}
|
||
|
||
if ($previous = $e->getPrevious()) {
|
||
$data['previous'] = $this->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|bool
|
||
*/
|
||
protected function toJson($data, bool $ignoreErrors = false)
|
||
{
|
||
// suppress json_encode errors since it's twitchy with some inputs
|
||
if ($ignoreErrors) {
|
||
return @$this->jsonEncode($data);
|
||
}
|
||
|
||
$json = $this->jsonEncode($data);
|
||
|
||
if ($json === false) {
|
||
$json = $this->handleJsonError(json_last_error(), $data);
|
||
}
|
||
|
||
return $json;
|
||
}
|
||
|
||
/**
|
||
* @param mixed $data
|
||
* @return string|bool JSON encoded data or false on failure
|
||
*/
|
||
private function jsonEncode($data)
|
||
{
|
||
return json_encode($data, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE | JSON_PRESERVE_ZERO_FRACTION);
|
||
}
|
||
|
||
/**
|
||
* Handle a json_encode failure.
|
||
*
|
||
* If the failure is due to invalid string encoding, try to clean the
|
||
* input and encode again. If the second encoding attempt fails, the
|
||
* initial error is not encoding related or the input can't be cleaned then
|
||
* raise a descriptive exception.
|
||
*
|
||
* @param int $code return code of json_last_error function
|
||
* @param mixed $data data that was meant to be encoded
|
||
* @throws \RuntimeException if failure can't be corrected
|
||
* @return string JSON encoded data after error correction
|
||
*/
|
||
private function handleJsonError(int $code, $data): string
|
||
{
|
||
if ($code !== JSON_ERROR_UTF8) {
|
||
$this->throwEncodeError($code, $data);
|
||
}
|
||
|
||
if (is_string($data)) {
|
||
$this->detectAndCleanUtf8($data);
|
||
} elseif (is_array($data)) {
|
||
array_walk_recursive($data, [$this, 'detectAndCleanUtf8']);
|
||
} else {
|
||
$this->throwEncodeError($code, $data);
|
||
}
|
||
|
||
$json = $this->jsonEncode($data);
|
||
|
||
if ($json === false) {
|
||
$this->throwEncodeError(json_last_error(), $data);
|
||
}
|
||
|
||
return $json;
|
||
}
|
||
|
||
/**
|
||
* Throws an exception according to a given code with a customized message
|
||
*
|
||
* @param int $code return code of json_last_error function
|
||
* @param mixed $data data that was meant to be encoded
|
||
* @throws \RuntimeException
|
||
*/
|
||
private function throwEncodeError(int $code, $data)
|
||
{
|
||
switch ($code) {
|
||
case JSON_ERROR_DEPTH:
|
||
$msg = 'Maximum stack depth exceeded';
|
||
break;
|
||
case JSON_ERROR_STATE_MISMATCH:
|
||
$msg = 'Underflow or the modes mismatch';
|
||
break;
|
||
case JSON_ERROR_CTRL_CHAR:
|
||
$msg = 'Unexpected control character found';
|
||
break;
|
||
case JSON_ERROR_UTF8:
|
||
$msg = 'Malformed UTF-8 characters, possibly incorrectly encoded';
|
||
break;
|
||
default:
|
||
$msg = 'Unknown error';
|
||
}
|
||
|
||
throw new \RuntimeException('JSON encoding failed: '.$msg.'. Encoding: '.var_export($data, true));
|
||
}
|
||
|
||
/**
|
||
* Detect invalid UTF-8 string characters and convert to valid UTF-8.
|
||
*
|
||
* Valid UTF-8 input will be left unmodified, but strings containing
|
||
* invalid UTF-8 codepoints will be reencoded as UTF-8 with an assumed
|
||
* original encoding of ISO-8859-15. This conversion may result in
|
||
* incorrect output if the actual encoding was not ISO-8859-15, but it
|
||
* will be clean UTF-8 output and will not rely on expensive and fragile
|
||
* detection algorithms.
|
||
*
|
||
* Function converts the input in place in the passed variable so that it
|
||
* can be used as a callback for array_walk_recursive.
|
||
*
|
||
* @param mixed &$data Input to check and convert if needed
|
||
* @private
|
||
*/
|
||
public function detectAndCleanUtf8(&$data)
|
||
{
|
||
if (is_string($data) && !preg_match('//u', $data)) {
|
||
$data = preg_replace_callback(
|
||
'/[\x80-\xFF]+/',
|
||
function ($m) {
|
||
return utf8_encode($m[0]);
|
||
},
|
||
$data
|
||
);
|
||
$data = str_replace(
|
||
['¤', '¦', '¨', '´', '¸', '¼', '½', '¾'],
|
||
['€', 'Š', 'š', 'Ž', 'ž', 'Œ', 'œ', 'Ÿ'],
|
||
$data
|
||
);
|
||
}
|
||
}
|
||
|
||
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->dateFormat === self::SIMPLE_DATE && $date instanceof DateTimeImmutable) {
|
||
return (string) $date;
|
||
}
|
||
|
||
return $date->format($this->dateFormat);
|
||
}
|
||
}
|