bytic / logger

src/Manager/MonologWrappers.php

<?php

namespace Nip\Logger\Manager;

use League\Container\Exception\NotFoundException;
use Monolog\Formatter\LineFormatter;
use Monolog\Handler\FormattableHandlerInterface;
use Monolog\Handler\HandlerInterface;
use Monolog\Logger as Monolog;
use Nip\Config\Config;
use Nip\Container\Container;
use Psr\Log\InvalidArgumentException;

/**
 * Class MonologWrappers
 * @package Nip\Logger\Manager
 *
 * @method Container getContainer()
 */
trait MonologWrappers
{
    /**
     * Create an instance of any handler available in Monolog.
     *
     * @param array $config
     * @return \Psr\Log\LoggerInterface
     *
     * @throws \InvalidArgumentException
     */
    protected function createMonologDriver($config)
    {
        $config = $config instanceof Config ? $config->toArray() : $config;

$config is never a sub-type of Nip\Config\Config.

        if (!is_a($config['handler'], HandlerInterface::class, true)) {
            throw new InvalidArgumentException(
                $config['handler'].' must be an instance of '.HandlerInterface::class
            );
        }

        $with = array_merge(
            ['level' => $this->level($config)],

It seems like level() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $config['with'] ?? [],
            $config['handler_with'] ?? []
        );

        $handler = $this->getContainer()->make($config['handler'], $with);

        return new Monolog(
            $this->parseChannel($config),

It seems like parseChannel() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            [$this->prepareHandler($handler, $config)]
        );
    }

    /**
     * Prepare the handlers for usage by Monolog.
     *
     * @param array $handlers
     * @return array
     */
    protected function prepareHandlers(array $handlers)
    {
        foreach ($handlers as $key => $handler) {
            $handlers[$key] = $this->prepareHandler($handler);
        }

        return $handlers;
    }

    /**
     * Prepare the handler for usage by Monolog.
     *
     * @param \Monolog\Handler\HandlerInterface $handler
     * @param array $config
     * @return \Monolog\Handler\HandlerInterface
     */
    protected function prepareHandler(HandlerInterface $handler, array $config = [])
    {
        $isHandlerFormattable = false;

        if (Monolog::API === 1) {

The condition Monolog\Logger::API === 1 is always false.

            $isHandlerFormattable = true;
        } elseif (Monolog::API === 2 && $handler instanceof FormattableHandlerInterface) {
            $isHandlerFormattable = true;
        }

        if ($isHandlerFormattable && !isset($config['formatter'])) {
            $handler->setFormatter($this->formatter());

The method setFormatter() does not exist on Monolog\Handler\HandlerInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Monolog\Handler\Handler or Monolog\Handler\AbstractHandler or Monolog\Handler\NullHandler or Monolog\Handler\NoopHandler. Are you sure you never get one of those?

        } elseif ($isHandlerFormattable && $config['formatter'] !== 'default') {
            $handler->setFormatter($this->app->make($config['formatter'], $config['formatter_with'] ?? []));
        }

        return $handler;
    }

    /**
     * Get a Monolog formatter instance.
     *
     * @return \Monolog\Formatter\FormatterInterface
     */
    protected function formatter()
    {
        $formatter = new LineFormatter(null, $this->dateFormat, true, true);
        $formatter->includeStacktraces();

        return $formatter;
    }
}