Msschl\Monolog\Formatter\SeqCompactJsonFormatter

Complexity

Total Complexity

36

Size/Duplication

Total Lines	207
Duplicated Lines	0 %

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	getContentType()	0	2	1
A	getExtractExtras()	0	3	1
A	__construct()	0	6	1
A	setExtractExtras()	0	5	1
A	setExtractContent()	0	5	1
A	getExtractContent()	0	3	1
A	normalizeArray()	0	15	3
A	normalize()	0	11	4
B	processLogRecord()	0	15	8
A	processExtras()	0	11	4
A	processDateTime()	0	8	2
A	processMessage()	0	8	2
A	processContextArray()	0	7	3
A	processContext()	0	9	2
A	processContextException()	0	10	2

<?php

namespace Msschl\Monolog\Formatter;

use DateTime;
use Monolog\Formatter\FormatterInterface;
use Monolog\Formatter\JsonFormatter;
use Throwable;

/**
 * This file is part of the msschl\monolog-seq-handler package.
 *
 * Copyright (c) 2018 Markus Schlotbohm
 *
 * For the full copyright and license information, please view the LICENSE.md
 * file that was distributed with this source code.
 */
class SeqCompactJsonFormatter extends SeqBaseFormatter
{

    /**
     * The extract context flag.
     * Whether to extract the context array to the root or not.
     *
     * @var bool
     */
    protected $extractContext;

    /**
     * The extract extras flag.
     * Whether to extract the extras array to the root or not.
     *
     * @var bool
     */
    protected $extractExtras;

    /**
     * Initializes a new instance of the {@see SeqCompactJsonFormatter} class.
     *
     * @param  bool $extractContext Flag that indicates whether to extract the extras array
     *                              to the root or not.
     * @param  bool $extractExtras  Flag that indicates whether to extract the context array
     *                              to the root or not.
     */
	public function __construct(bool $extractContext = true, bool $extractExtras = true)
	{
        $this->appendNewline = false;
        $this->batchMode = JsonFormatter::BATCH_MODE_NEWLINES;
        $this->extractContext = $extractContext;
        $this->extractExtras = $extractExtras;
	}

    /**
     * Returns a string with the content type for the seq-formatter.
     *
     * @return string
     */
    public function getContentType() : string {
        return 'application/vnd.serilog.clef';
    }

    /**
     * Gets whether the flag extract content is set or not.
     *
     * @return bool
     */
    public function getExtractContent() : bool
    {
        return $this->extractContext;
    }

    /**
     * Sets the flag extract content.
     *
     * @param  bool $value The flag.
     * @return self
     */
    public function setExtractContent(bool $value)
    {
        $this->extractContext = $value;

        return $this;
    }

    /**
     * Gets whether the flag extract extras is set or not.
     *
     * @return bool
     */
    public function getExtractExtras()
    {
        return $this->extractExtras;
    }

    /**
     * Sets the flag extract extras.
     *
     * @param  bool $value The flag.
     * @return self
     */
    public function setExtractExtras(bool $value)
    {
        $this->extractExtras = $value;

        return $this;
    }

    /**
     * Normalizes given $data.
     *
     * @param mixed $data The data to normalize.
     * @return mixed
     */
    protected function normalize($data)
    {
        if (is_array($data) || $data instanceof \Traversable) {
            return $this->normalizeArray($data);
        }

        if ($data instanceof \Throwable) {
            return $this->normalizeException($data);
        }

        return $data;
    }

    private function normalizeArray($array)
    {
        $normalized = array();

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

            $normalized = $this->processLogRecord($normalized, $key, $value, $count);
        }

        return $normalized;
    }

    private function processLogRecord($array, $key, $value, /** @scrutinizer ignore-unused */ $count)
    {
        switch ($key) {
            case 'message': return $this->processMessage($array, $value);
            case 'datetime': return $this->processDateTime($array, $value);
            case 'level':
                $array['@l'] = $this->logLevelMap[$value];
                $array['LogLevelCode'] = $value;
                return $array;
            case 'level_name': return $array;
            case 'extra': return $this->processExtras($array, $value);
            case 'context': return $this->processContext($array, $value);
            default:
                $array[is_int($key) ? $key : SeqCompactJsonFormatter::ConvertSnakeCaseToPascalCase($key)] = $this->normalize($value);
                return $array;
        }
    }

    private function processMessage($array, $value)
    {
        $array['@m'] = $value;
        if (!(strpos($value, '{') === false)) {
            $array['@mt'] = $value;
        }

        return $array;
    }

    private function processDateTime($array, $value)
    {
        if ($value instanceof \DateTime) {
            $value = $value->format(DateTime::ISO8601);
        }
        $array['@t'] = $value;

        return $array;
    }

    private function processExtras($array, $value)
    {
        if (is_array($value) && is_array($normalizedArray = $this->normalize($value))) {
            if ($this->extractExtras) {
                $array = array_merge($normalizedArray, $array);
            } else {
                $array['Extra'] = $normalizedArray;
            }
        }

        return $array;
    }

    private function processContext($array, $value)
    {
        if (!is_array($value)) {
            return $array;
        }

        $array = $this->processContextArray($array, $value);

        return $this->processContextException($array, $value);
    }

    private function processContextArray(array $array, array $value) : array
    {
        if (is_array($normalizedArray = $this->normalize($value))) {
            return $this->extractContext ? array_merge($normalizedArray, $array) : $normalizedArray;
        }

        return $array;
    }

    private function processContextException(array $array, array $value) : array
    {
        $exception = $this->extractException($value);
        if ($exception === null) {
            return $array;
        }

        $array['@x'] = $this->normalizeException($exception);

        return $array;
    }
}