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)
	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 21 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 30 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 282 of file NormalizerFormatter.php.

References $data, $m, and array.

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 41 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 49 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 214 of file NormalizerFormatter.php.

References $code, $data, array, 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 192 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 )

protected

Definition at line 58 of file NormalizerFormatter.php.

References $data, $key, array, 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 (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) || $data instanceof \Traversable) {
            $normalized = array();

            $count = 1;
            foreach ($data as $key => $value) {
                if ($count++ >= 1000) {
                    $normalized['...'] = 'Over 1000 items, aborting normalization';
                    break;
                }
                $normalized[$key] = $this->normalize($value);
            }

            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)", get_class($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 116 of file NormalizerFormatter.php.

References $data, array, 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).' / '.get_class($e));
        }

        $data = array(
            '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), 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 244 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 172 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\GelfMessageFormatter\format(), Monolog\Formatter\JsonFormatter\format(), Monolog\Formatter\LogstashFormatter\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 25 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 23 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