Monolog\Formatter\NormalizerFormatter Class Reference

Normalizes incoming records to remove objects/resources so it's easier to dump to various targets. More...

Inheritance diagram for Monolog\Formatter\NormalizerFormatter:

Collaboration diagram for Monolog\Formatter\NormalizerFormatter:

Public Member Functions
	__construct ($dateFormat=null)
	format (array $record)
	{Formats a log record. Parameters array $record A record to format Returns mixed The formatted record } More...
	formatBatch (array $records)
	{Formats a set of log records. Parameters array $records A set of records to format Returns mixed The formatted set of records } More...
	detectAndCleanUtf8 (&$data)
	Detect invalid UTF-8 string characters and convert to valid UTF-8. More...

Data Fields
const	SIMPLE_DATE = "Y-m-d H:i:s"

Protected Member Functions
	normalize ($data, $depth=0)
	normalizeException ($e)
	toJson ($data, $ignoreErrors=false)
	Return the JSON representation of a value. More...

Protected Attributes
	$dateFormat

Private Member Functions
	jsonEncode ($data)
	handleJsonError ($code, $data)
	Handle a json_encode failure. More...
	throwEncodeError ($code, $data)
	Throws an exception according to a given code with a customized message. More...

Detailed Description

Normalizes incoming records to remove objects/resources so it's easier to dump to various targets.

Author

Jordi Boggiano j.bog.nosp@m.gian.nosp@m.o@sel.nosp@m.d.be

Definition at line 22 of file NormalizerFormatter.php.

Constructor & Destructor Documentation

__construct()

Monolog\Formatter\NormalizerFormatter::__construct

(

$dateFormat = null

)

Parameters

string

$dateFormat

The format of the timestamp: one supported by DateTime::format

Definition at line 31 of file NormalizerFormatter.php.

References Monolog\Formatter\NormalizerFormatter\$dateFormat.

    {
        $this->dateFormat = $dateFormat ?: static::SIMPLE_DATE;
        if (!function_exists('json_encode')) {
            throw new \RuntimeException('PHP\'s json extension is required to use Monolog\'s NormalizerFormatter');
        }
    }

Member Function Documentation

detectAndCleanUtf8()

Monolog\Formatter\NormalizerFormatter::detectAndCleanUtf8

(

&

$data

)

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.

Parameters

mixed

&$data

Input to check and convert if needed

Definition at line 299 of file NormalizerFormatter.php.

References $data, and $m.

Referenced by Monolog\Formatter\NormalizerFormatter\handleJsonError().

    {
        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(
                array('¤', '¦', '¨', '´', '¸', '¼', '½', '¾'),
                array('€', 'Š', 'š', 'Ž', 'ž', 'Œ', 'œ', 'Ÿ'),
                $data
            );
        }
    }

Here is the caller graph for this function:

format()

Monolog\Formatter\NormalizerFormatter::format

(

array

$record

)

{Formats a log record.

Parameters

array

$record

A record to format

Returns

mixed The formatted record

}

Implements Monolog\Formatter\FormatterInterface.

Definition at line 42 of file NormalizerFormatter.php.

References Monolog\Formatter\NormalizerFormatter\normalize().

Referenced by Monolog\Formatter\NormalizerFormatter\formatBatch().

    {
        return $this->normalize($record);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

formatBatch()

Monolog\Formatter\NormalizerFormatter::formatBatch

(

array

$records

)

{Formats a set of log records.

Parameters

array

$records

A set of records to format

Returns

mixed The formatted set of records

}

Implements Monolog\Formatter\FormatterInterface.

Definition at line 50 of file NormalizerFormatter.php.

References $key, $records, and Monolog\Formatter\NormalizerFormatter\format().

    {
        foreach ($records as $key => $record) {
            $records[$key] = $this->format($record);
        }

        return $records;
    }

Here is the call graph for this function:

handleJsonError()

Monolog\Formatter\NormalizerFormatter::handleJsonError (   $code,   $data  )

private

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 inital error is not encoding related or the input can't be cleaned then raise a descriptive exception.

Parameters

int	$code	return code of json_last_error function
mixed	$data	data that was meant to be encoded

Exceptions

Definition at line 231 of file NormalizerFormatter.php.

References $code, $data, Monolog\Formatter\NormalizerFormatter\detectAndCleanUtf8(), Monolog\Formatter\NormalizerFormatter\jsonEncode(), and Monolog\Formatter\NormalizerFormatter\throwEncodeError().

Referenced by Monolog\Formatter\NormalizerFormatter\toJson().

    {
        if ($code !== JSON_ERROR_UTF8) {
            $this->throwEncodeError($code, $data);
        }

        if (is_string($data)) {
            $this->detectAndCleanUtf8($data);
        } elseif (is_array($data)) {
            array_walk_recursive($data, array($this, 'detectAndCleanUtf8'));
        } else {
            $this->throwEncodeError($code, $data);
        }

        $json = $this->jsonEncode($data);

        if ($json === false) {
            $this->throwEncodeError(json_last_error(), $data);
        }

        return $json;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

jsonEncode()

Monolog\Formatter\NormalizerFormatter::jsonEncode (   $data )

private

Parameters

mixed

$data

Returns

string JSON encoded data or null on failure

Definition at line 209 of file NormalizerFormatter.php.

References $data.

Referenced by Monolog\Formatter\NormalizerFormatter\handleJsonError(), and Monolog\Formatter\NormalizerFormatter\toJson().

    {
        if (version_compare(PHP_VERSION, '5.4.0', '>=')) {
            return json_encode($data, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
        }

        return json_encode($data);
    }

Here is the caller graph for this function:

normalize()

Monolog\Formatter\NormalizerFormatter::normalize (   $data,   $depth = 0  )

protected

Definition at line 59 of file NormalizerFormatter.php.

References $data, $key, Monolog\Utils\getClass(), Monolog\Formatter\NormalizerFormatter\normalizeException(), and Monolog\Formatter\NormalizerFormatter\toJson().

Referenced by Monolog\Formatter\HtmlFormatter\convertToString(), Monolog\Formatter\NormalizerFormatter\format(), Monolog\Formatter\NormalizerFormatter\normalizeException(), and Monolog\Formatter\ScalarFormatter\normalizeValue().

    {
        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 = array();

            $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 \DateTime) {
            return $data->format($this->dateFormat);
        }

        if (is_object($data)) {
            // TODO 2.0 only check for Throwable
            if ($data instanceof Exception || (PHP_VERSION_ID > 70000 && $data instanceof \Throwable)) {
                return $this->normalizeException($data);
            }

            // non-serializable objects that implement __toString stringified
            if (method_exists($data, '__toString') && !$data instanceof \JsonSerializable) {
                $value = $data->__toString();
            } else {
                // the rest is json-serialized in some way
                $value = $this->toJson($data, true);
            }

            return sprintf("[object] (%s: %s)", Utils::getClass($data), $value);
        }

        if (is_resource($data)) {
            return sprintf('[resource] (%s)', get_resource_type($data));
        }

        return '[unknown('.gettype($data).')]';
    }

Here is the call graph for this function:

Here is the caller graph for this function:

normalizeException()

Monolog\Formatter\NormalizerFormatter::normalizeException (   $e )

protected

Definition at line 122 of file NormalizerFormatter.php.

References $data, Monolog\Utils\getClass(), Monolog\Formatter\NormalizerFormatter\normalize(), and Monolog\Formatter\NormalizerFormatter\toJson().

Referenced by Monolog\Formatter\NormalizerFormatter\normalize().

    {
        // TODO 2.0 only check for Throwable
        if (!$e instanceof Exception && !$e instanceof \Throwable) {
            throw new \InvalidArgumentException('Exception/Throwable expected, got '.gettype($e).' / '.Utils::getClass($e));
        }

        $data = array(
            'class' => Utils::getClass($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}') {
                // Simplify closures handling
                $data['trace'][] = $frame['function'];
            } else {
                if (isset($frame['args'])) {
                    // Make sure that objects present as arguments are not serialized nicely but rather only
                    // as a class name to avoid any unexpected leak of sensitive information
                    $frame['args'] = array_map(function ($arg) {
                        if (is_object($arg) && !($arg instanceof \DateTime || $arg instanceof \DateTimeInterface)) {
                            return sprintf("[object] (%s)", Utils::getClass($arg));
                        }

                        return $arg;
                    }, $frame['args']);
                }
                // We should again normalize the frames, because it might contain invalid items
                $data['trace'][] = $this->toJson($this->normalize($frame), true);
            }
        }

        if ($previous = $e->getPrevious()) {
            $data['previous'] = $this->normalizeException($previous);
        }

        return $data;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

throwEncodeError()

Monolog\Formatter\NormalizerFormatter::throwEncodeError (   $code,   $data  )

private

Throws an exception according to a given code with a customized message.

Parameters

int	$code	return code of json_last_error function
mixed	$data	data that was meant to be encoded

Exceptions

Definition at line 261 of file NormalizerFormatter.php.

References $code, and $data.

Referenced by Monolog\Formatter\NormalizerFormatter\handleJsonError().

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

Here is the caller graph for this function:

toJson()

Monolog\Formatter\NormalizerFormatter::toJson (   $data,   $ignoreErrors = false  )

protected

Return the JSON representation of a value.

Parameters

mixed	$data
bool	$ignoreErrors

Exceptions

Definition at line 189 of file NormalizerFormatter.php.

References $data, Monolog\Formatter\NormalizerFormatter\handleJsonError(), and Monolog\Formatter\NormalizerFormatter\jsonEncode().

Referenced by Monolog\Formatter\LineFormatter\convertToString(), Monolog\Formatter\WildfireFormatter\format(), Monolog\Formatter\LogstashFormatter\format(), Monolog\Formatter\JsonFormatter\format(), Monolog\Formatter\GelfMessageFormatter\format(), Monolog\Formatter\JsonFormatter\formatBatchJson(), Monolog\Formatter\NormalizerFormatter\normalize(), Monolog\Formatter\NormalizerFormatter\normalizeException(), and Monolog\Formatter\ScalarFormatter\normalizeValue().

    {
        // 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;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

$dateFormat

Monolog\Formatter\NormalizerFormatter::$dateFormat

protected

Definition at line 26 of file NormalizerFormatter.php.

Referenced by Monolog\Formatter\NormalizerFormatter\__construct(), Monolog\Formatter\LineFormatter\__construct(), and Monolog\Formatter\HtmlFormatter\__construct().

SIMPLE_DATE

const Monolog\Formatter\NormalizerFormatter::SIMPLE_DATE = "Y-m-d H:i:s"

Definition at line 24 of file NormalizerFormatter.php.

---

The documentation for this class was generated from the following file:

• libs/composer/vendor/monolog/monolog/src/Monolog/Formatter/NormalizerFormatter.php