Psr7Middlewares\Middleware\AccessLog

Complexity

Total Complexity

13

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	4
Bugs	3	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	logger()	0	6	1
A	combined()	0	6	1
B	__invoke()	0	20	6
A	commonFormat()	0	14	2
A	combinedFormat()	0	8	1

<?php

namespace Psr7Middlewares\Middleware;

use Psr7Middlewares\Middleware;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Log\LoggerInterface;
use RuntimeException;

class AccessLog
{
    /**
     * @var LoggerInterface|null The router container
     */
    private $logger;

    /**
     * @var bool
     */
    private $combined = false;

    /**
     * Constructor.Set the LoggerInterface instance.
     *
     * @param LoggerInterface $logger
     */
    public function __construct(LoggerInterface $logger = null)
    {
        if ($logger !== null) {
            $this->logger($logger);
        }
    }

    /**
     * Set the LoggerInterface instance.
     *
     * @param LoggerInterface $logger
     *
     * @return self
     */
    public function logger(LoggerInterface $logger)
    {
        $this->logger = $logger;

        return $this;
    }

    /**
     * Whether use the combined log format instead the common log format.
     *
     * @param bool $combined
     *
     * @return self
     */
    public function combined($combined = true)
    {
        $this->combined = $combined;

        return $this;
    }

    /**
     * Execute the middleware.
     *
     * @param ServerRequestInterface $request
     * @param ResponseInterface      $response
     * @param callable               $next
     *
     * @return ResponseInterface
     */
    public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next)
    {
        if (empty($this->logger)) {
            throw new RuntimeException('No PSR-4 logger instance has been provided');
        }

        if (!Middleware::hasAttribute($request, ClientIp::KEY)) {
            throw new RuntimeException('AccessLog middleware needs ClientIp executed before');
        }

        $message = $this->combined ? self::combinedFormat($request, $response) : self::commonFormat($request, $response);

        if ($response->getStatusCode() >= 400 && $response->getStatusCode() < 600) {
            $this->logger->addError($message);

It seems like you code against a concrete implementation and not the interface Psr\Log\LoggerInterface as the method addError() does only exist in the following implementations of said interface: Monolog\Logger.

        } else {
            $this->logger->addInfo($message);

It seems like you code against a concrete implementation and not the interface Psr\Log\LoggerInterface as the method addInfo() does only exist in the following implementations of said interface: Monolog\Logger.

        }

        return $next($request, $response);
    }

    /**
     * Generates a message using the Apache's Common Log format
     * https://httpd.apache.org/docs/2.4/logs.html#accesslog.
     * 
     * Note: The user identifier (identd) is ommited intentionally
     * 
     * @param ServerRequestInterface $request
     * @param ResponseInterface      $response
     * 
     * @return string
     */
    private static function commonFormat(ServerRequestInterface $request, ResponseInterface $response)
    {
        return sprintf('%s %s [%s] "%s %s %s/%s" %d %d',
            ClientIp::getIp($request),
            $request->getUri()->getUserInfo() ?: '-',
            strftime('%d/%b/%Y:%H:%M:%S %z'),
            strtoupper($request->getMethod()),
            $request->getUri()->getPath(),
            strtoupper($request->getUri()->getScheme()),
            $request->getProtocolVersion(),
            $response->getStatusCode(),
            $response->getBody()->getSize()
        );
    }

    /**
     * Generates a message using the Apache's Combined Log format
     * This is exactly the same than Common Log, with the addition of two more fields: Referer and User-Agent headers.
     * 
     * @param ServerRequestInterface $request
     * @param ResponseInterface      $response
     * 
     * @return string
     */
    private static function combinedFormat(ServerRequestInterface $request, ResponseInterface $response)
    {
        return sprintf('%s "%s" "%s"',
            self::commonFormat($request, $response),
            $request->getHeaderLine('Referer'),
            $request->getHeaderLine('User-Agent')
        );
    }
}