TimerLogger::logger() - Code Metrics - shrikeh/guzzle-middleware-responsetimer - Measure and Improve Code Quality continuously with Scrutinizer

TimerLogger::logger() A
last analyzed 2018-11-05 11:19 UTC

↳ Parent: TimerLogger

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	3
rs	10
c	0
b	0
f	0
cc	1
eloc	1
nc	1
nop	1

<?php
/**
 * @codingStandardsIgnoreStart
 *
 * @author       Barney Hanlon <[email protected]>
 * @copyright    Barney Hanlon 2017
 * @license      https://opensource.org/licenses/MIT
 *
 * @codingStandardsIgnoreEnd
 */

namespace Shrikeh\GuzzleMiddleware\TimerLogger\ServiceProvider;

use Pimple\Container;
use Pimple\Psr11\ServiceLocator;
use Pimple\ServiceProviderInterface;
use Psr\Container\ContainerInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\LogLevel;
use Shrikeh\GuzzleMiddleware\TimerLogger\Formatter\Message\DefaultStartMessage;
use Shrikeh\GuzzleMiddleware\TimerLogger\Formatter\Message\DefaultStopMessage;
use Shrikeh\GuzzleMiddleware\TimerLogger\Formatter\StartFormatter;
use Shrikeh\GuzzleMiddleware\TimerLogger\Formatter\StopFormatter;
use Shrikeh\GuzzleMiddleware\TimerLogger\Formatter\Verbose;
use Shrikeh\GuzzleMiddleware\TimerLogger\Handler\ExceptionHandler\TriggerErrorHandler;
use Shrikeh\GuzzleMiddleware\TimerLogger\Handler\StartTimer;
use Shrikeh\GuzzleMiddleware\TimerLogger\Handler\StopTimer;
use Shrikeh\GuzzleMiddleware\TimerLogger\Middleware;
use Shrikeh\GuzzleMiddleware\TimerLogger\RequestTimers\RequestTimers;
use Shrikeh\GuzzleMiddleware\TimerLogger\ResponseLogger\ResponseLogger;
use Shrikeh\GuzzleMiddleware\TimerLogger\ResponseTimeLogger\ResponseTimeLogger;

/**
 * Class TimerLogger.
 */
final class TimerLogger implements ServiceProviderInterface, TimerLoggerInterface
{
    /**
     * @var callable
     */
    private $logger;

    /**
     * @param callable $logger A callable that unwraps to a PSR-3 LoggerInterface
     *
     * @return ServiceLocator
     */
    public static function serviceLocator(callable $logger)
    {
        $pimple = new Container();
        $pimple->register(new self($logger));

        return new ServiceLocator(
            $pimple,
            [self::MIDDLEWARE]
        );
    }

    /**
     * @param ContainerInterface $container A PSR-11 Container to use to build the Logger
     * @param string             $loggerKey The key to use in the PSR-11 container to provide the logger
     *
     * @return TimerLogger
     */
    public static function fromContainer(
        ContainerInterface $container,
        $loggerKey
    ) {
        $logger = function () use ($container, $loggerKey) {
            return $container->get($loggerKey);
        };

        return new self($logger);
    }

    /**
     * @param LoggerInterface $logger A PSR-3 LoggerInterface to log the response times
     *
     * @return TimerLogger
     */
    public static function fromLogger(LoggerInterface $logger)
    {
        $callable = function () use ($logger) {
            return $logger;
        };

        return new self($callable);
    }

    /**
     * @param callable $loggerCallable A callable that unwraps to a PSR-3 LoggerInterface
     *
     * @return TimerLogger
     */
    public static function fromCallable(callable $loggerCallable)
    {
        return new self($loggerCallable);
    }

    /**
     * TimerLogger constructor.
     *
     * @param callable $logger A callable that unwraps to a PSR-3 Logger
     */
    private function __construct(callable $logger)
    {
        $this->logger = $logger;
    }

    /**
     * Registers services on the given container.
     *
     * This method should only be used to configure services and parameters.
     * It should not get services.
     *
     * @param Container $pimple A container instance
     */
    public function register(Container $pimple)
    {
        $this->logger($pimple);
        $this->exceptionHandler($pimple);
        $this->formatter($pimple);
        $this->middlewareHandler($pimple);
        $this->responseTimer($pimple);
    }

    /**
     * @param \Pimple\Container $pimple A Pimple Container to register middleware with
     */
    private function responseTimer(Container $pimple)
    {
        $pimple[self::TIMERS] = function () {
            return new RequestTimers();
        };

        $pimple[self::RESPONSE_LOGGER] = function (Container $con) {
            return new ResponseLogger(
                $con[self::LOGGER],
                $con[self::FORMATTER]
            );
        };

        $pimple[self::RESPONSE_TIME_LOGGER] = function (Container $con) {
            return new ResponseTimeLogger(
                $con[self::TIMERS],
                $con[self::RESPONSE_LOGGER]
            );
        };
    }

    /**
     * @param Container $pimple A Pimple Container
     */
    private function logger(Container $pimple)
    {
        $pimple[self::LOGGER] = $this->logger;
    }

    /**
     * @param \Pimple\Container $pimple A Pimple Container to register middleware with
     */
    private function exceptionHandler(Container $pimple)
    {
        $pimple[self::EXCEPTION_HANDLER] = function () {
            return new TriggerErrorHandler();
        };

        $pimple[self::EXCEPTION_HANDLER_START] = function (Container $con) {
            return $con[self::EXCEPTION_HANDLER];
        };

        $pimple[self::EXCEPTION_HANDLER_STOP] = function (Container $con) {
            return $con[self::EXCEPTION_HANDLER];
        };
    }

    /**
     * @param \Pimple\Container $pimple A Pimple Container to register middleware with
     */
    private function formatter(Container $pimple)
    {
        $pimple[self::FORMATTER_DEFAULT_LOG_LEVEL] = function () {
            return LogLevel::DEBUG;
        };

        $pimple[self::FORMATTER_STOP_LOG_LEVEL] = function () {
            return LogLevel::DEBUG;
        };

        $pimple[self::FORMATTER_START_LOG_LEVEL] = function () {
            return LogLevel::DEBUG;
        };

        $pimple[self::FORMATTER_START_MSG] = function () {
            return new DefaultStartMessage();
        };

        $pimple[self::FORMATTER_STOP_MSG] = function () {
            return new DefaultStopMessage();
        };

        $pimple[self::FORMATTER_START] = function (Container $con) {
            return StartFormatter::create(
                $con[self::FORMATTER_START_MSG],
                $con[self::FORMATTER_START_LOG_LEVEL]
            );
        };

        $pimple[self::FORMATTER_STOP] = function (Container $con) {
            return StopFormatter::create(
                $con[self::FORMATTER_STOP_MSG],
                $con[self::FORMATTER_STOP_LOG_LEVEL]
            );
        };

        $pimple[self::FORMATTER] = function (Container $con) {
            return new Verbose(
                $con[self::FORMATTER_START],
                $con[self::FORMATTER_STOP]
            );
        };
    }

    /**
     * @param \Pimple\Container $pimple A Pimple Container to register middleware with
     */
    private function middlewareHandler(Container $pimple)
    {
        $pimple[self::START_HANDLER] = function (Container $con) {
            return new StartTimer(
                $con[self::RESPONSE_TIME_LOGGER],
                $con[self::EXCEPTION_HANDLER_STOP]
            );
        };

        $pimple[self::STOP_HANDLER] = function (Container $con) {
            return new StopTimer(
                $con[self::RESPONSE_TIME_LOGGER],
                $con[self::EXCEPTION_HANDLER_START]
            );
        };

        $pimple[self::MIDDLEWARE] = function (Container $con) {
            return new Middleware(
                $con[self::START_HANDLER],
                $con[self::STOP_HANDLER]
            );
        };
    }
}


1			<?php
2			/**
3			* @codingStandardsIgnoreStart
4			*
5			* @author Barney Hanlon <[email protected]>
6			* @copyright Barney Hanlon 2017
7			* @license https://opensource.org/licenses/MIT
8			*
9			* @codingStandardsIgnoreEnd
10			*/
11
12			namespace Shrikeh\GuzzleMiddleware\TimerLogger\ServiceProvider;
13
14			use Pimple\Container;
15			use Pimple\Psr11\ServiceLocator;
16			use Pimple\ServiceProviderInterface;
17			use Psr\Container\ContainerInterface;
18			use Psr\Log\LoggerInterface;
19			use Psr\Log\LogLevel;
20			use Shrikeh\GuzzleMiddleware\TimerLogger\Formatter\Message\DefaultStartMessage;
21			use Shrikeh\GuzzleMiddleware\TimerLogger\Formatter\Message\DefaultStopMessage;
22			use Shrikeh\GuzzleMiddleware\TimerLogger\Formatter\StartFormatter;
23			use Shrikeh\GuzzleMiddleware\TimerLogger\Formatter\StopFormatter;
24			use Shrikeh\GuzzleMiddleware\TimerLogger\Formatter\Verbose;
25			use Shrikeh\GuzzleMiddleware\TimerLogger\Handler\ExceptionHandler\TriggerErrorHandler;
26			use Shrikeh\GuzzleMiddleware\TimerLogger\Handler\StartTimer;
27			use Shrikeh\GuzzleMiddleware\TimerLogger\Handler\StopTimer;
28			use Shrikeh\GuzzleMiddleware\TimerLogger\Middleware;
29			use Shrikeh\GuzzleMiddleware\TimerLogger\RequestTimers\RequestTimers;
30			use Shrikeh\GuzzleMiddleware\TimerLogger\ResponseLogger\ResponseLogger;
31			use Shrikeh\GuzzleMiddleware\TimerLogger\ResponseTimeLogger\ResponseTimeLogger;
32
33			/**
34			* Class TimerLogger.
35			*/
36			final class TimerLogger implements ServiceProviderInterface, TimerLoggerInterface
37			{
38			/**
39			* @var callable
40			*/
41			private $logger;
42
43			/**
44			* @param callable $logger A callable that unwraps to a PSR-3 LoggerInterface
45			*
46			* @return ServiceLocator
47			*/
48			public static function serviceLocator(callable $logger)
49			{
50			$pimple = new Container();
51			$pimple->register(new self($logger));
52
53			return new ServiceLocator(
54			$pimple,
55			[self::MIDDLEWARE]
56			);
57			}
58
59			/**
60			* @param ContainerInterface $container A PSR-11 Container to use to build the Logger
61			* @param string $loggerKey The key to use in the PSR-11 container to provide the logger
62			*
63			* @return TimerLogger
64			*/
65			public static function fromContainer(
66			ContainerInterface $container,
67			$loggerKey
68			) {
69			$logger = function () use ($container, $loggerKey) {
70			return $container->get($loggerKey);
71			};
72
73			return new self($logger);
74			}
75
76			/**
77			* @param LoggerInterface $logger A PSR-3 LoggerInterface to log the response times
78			*
79			* @return TimerLogger
80			*/
81			public static function fromLogger(LoggerInterface $logger)
82			{
83			$callable = function () use ($logger) {
84			return $logger;
85			};
86
87			return new self($callable);
88			}
89
90			/**
91			* @param callable $loggerCallable A callable that unwraps to a PSR-3 LoggerInterface
92			*
93			* @return TimerLogger
94			*/
95			public static function fromCallable(callable $loggerCallable)
96			{
97			return new self($loggerCallable);
98			}
99
100			/**
101			* TimerLogger constructor.
102			*
103			* @param callable $logger A callable that unwraps to a PSR-3 Logger
104			*/
105			private function __construct(callable $logger)
106			{
107			$this->logger = $logger;
108			}
109
110			/**
111			* Registers services on the given container.
112			*
113			* This method should only be used to configure services and parameters.
114			* It should not get services.
115			*
116			* @param Container $pimple A container instance
117			*/
118			public function register(Container $pimple)
119			{
120			$this->logger($pimple);
121			$this->exceptionHandler($pimple);
122			$this->formatter($pimple);
123			$this->middlewareHandler($pimple);
124			$this->responseTimer($pimple);
125			}
126
127			/**
128			* @param \Pimple\Container $pimple A Pimple Container to register middleware with
129			*/
130			private function responseTimer(Container $pimple)
131			{
132			$pimple[self::TIMERS] = function () {
133			return new RequestTimers();
134			};
135
136			$pimple[self::RESPONSE_LOGGER] = function (Container $con) {
137			return new ResponseLogger(
138			$con[self::LOGGER],
139			$con[self::FORMATTER]
140			);
141			};
142
143			$pimple[self::RESPONSE_TIME_LOGGER] = function (Container $con) {
144			return new ResponseTimeLogger(
145			$con[self::TIMERS],
146			$con[self::RESPONSE_LOGGER]
147			);
148			};
149			}
150
151			/**
152			* @param Container $pimple A Pimple Container
153			*/
154			private function logger(Container $pimple)
155			{
156			$pimple[self::LOGGER] = $this->logger;
157			}
158
159			/**
160			* @param \Pimple\Container $pimple A Pimple Container to register middleware with
161			*/
162			private function exceptionHandler(Container $pimple)
163			{
164			$pimple[self::EXCEPTION_HANDLER] = function () {
165			return new TriggerErrorHandler();
166			};
167
168			$pimple[self::EXCEPTION_HANDLER_START] = function (Container $con) {
169			return $con[self::EXCEPTION_HANDLER];
170			};
171
172			$pimple[self::EXCEPTION_HANDLER_STOP] = function (Container $con) {
173			return $con[self::EXCEPTION_HANDLER];
174			};
175			}
176
177			/**
178			* @param \Pimple\Container $pimple A Pimple Container to register middleware with
179			*/
180			private function formatter(Container $pimple)
181			{
182			$pimple[self::FORMATTER_DEFAULT_LOG_LEVEL] = function () {
183			return LogLevel::DEBUG;
184			};
185
186			$pimple[self::FORMATTER_STOP_LOG_LEVEL] = function () {
187			return LogLevel::DEBUG;
188			};
189
190			$pimple[self::FORMATTER_START_LOG_LEVEL] = function () {
191			return LogLevel::DEBUG;
192			};
193
194			$pimple[self::FORMATTER_START_MSG] = function () {
195			return new DefaultStartMessage();
196			};
197
198			$pimple[self::FORMATTER_STOP_MSG] = function () {
199			return new DefaultStopMessage();
200			};
201
202			$pimple[self::FORMATTER_START] = function (Container $con) {
203			return StartFormatter::create(
204			$con[self::FORMATTER_START_MSG],
205			$con[self::FORMATTER_START_LOG_LEVEL]
206			);
207			};
208
209			$pimple[self::FORMATTER_STOP] = function (Container $con) {
210			return StopFormatter::create(
211			$con[self::FORMATTER_STOP_MSG],
212			$con[self::FORMATTER_STOP_LOG_LEVEL]
213			);
214			};
215
216			$pimple[self::FORMATTER] = function (Container $con) {
217			return new Verbose(
218			$con[self::FORMATTER_START],
219			$con[self::FORMATTER_STOP]
220			);
221			};
222			}
223
224			/**
225			* @param \Pimple\Container $pimple A Pimple Container to register middleware with
226			*/
227			private function middlewareHandler(Container $pimple)
228			{
229			$pimple[self::START_HANDLER] = function (Container $con) {
230			return new StartTimer(
231			$con[self::RESPONSE_TIME_LOGGER],
232			$con[self::EXCEPTION_HANDLER_STOP]
233			);
234			};
235
236			$pimple[self::STOP_HANDLER] = function (Container $con) {
237			return new StopTimer(
238			$con[self::RESPONSE_TIME_LOGGER],
239			$con[self::EXCEPTION_HANDLER_START]
240			);
241			};
242
243			$pimple[self::MIDDLEWARE] = function (Container $con) {
244			return new Middleware(
245			$con[self::START_HANDLER],
246			$con[self::STOP_HANDLER]
247			);
248			};
249			}
250			}
251

shrikeh / guzzle-middleware-responsetimer

TimerLogger::logger() A last analyzed 2018-11-05 11:19 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

TimerLogger::logger() A
last analyzed 2018-11-05 11:19 UTC