TimerLogger::fromContainer() - Code Metrics - Inspection of "Fix Service Provider" - shrikeh/guzzle-middleware-responsetimer - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — feature/codeception (912e4f)

by Barney

created 2017-09-29 08:55 UTC

TimerLogger::fromContainer() A

↳ Parent: TimerLogger

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
cc	1
eloc	3
nc	1
nop	2

<?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);
    }

    /**
     * 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			* TimerLogger constructor.
92			*
93			* @param callable $logger A callable that unwraps to a PSR-3 Logger
94			*/
95			private function __construct(callable $logger)
96			{
97			$this->logger = $logger;
98			}
99
100			/**
101			* Registers services on the given container.
102			*
103			* This method should only be used to configure services and parameters.
104			* It should not get services.
105			*
106			* @param Container $pimple A container instance
107			*/
108			public function register(Container $pimple)
109			{
110			$this->logger($pimple);
111			$this->exceptionHandler($pimple);
112			$this->formatter($pimple);
113			$this->middlewareHandler($pimple);
114			$this->responseTimer($pimple);
115			}
116
117			/**
118			* @param \Pimple\Container $pimple A Pimple Container to register middleware with
119			*/
120			private function responseTimer(Container $pimple)
121			{
122			$pimple[self::TIMERS] = function () {
123			return new RequestTimers();
124			};
125
126			$pimple[self::RESPONSE_LOGGER] = function (Container $con) {
127			return new ResponseLogger(
128			$con[self::LOGGER],
129			$con[self::FORMATTER]
130			);
131			};
132
133			$pimple[self::RESPONSE_TIME_LOGGER] = function (Container $con) {
134			return new ResponseTimeLogger(
135			$con[self::TIMERS],
136			$con[self::RESPONSE_LOGGER]
137			);
138			};
139			}
140
141			/**
142			* @param Container $pimple A Pimple Container
143			*/
144			private function logger(Container $pimple)
145			{
146			$pimple[self::LOGGER] = $this->logger;
147			}
148
149			/**
150			* @param \Pimple\Container $pimple A Pimple Container to register middleware with
151			*/
152			private function exceptionHandler(Container $pimple)
153			{
154			$pimple[self::EXCEPTION_HANDLER] = function () {
155			return new TriggerErrorHandler();
156			};
157
158			$pimple[self::EXCEPTION_HANDLER_START] = function (Container $con) {
159			return $con[self::EXCEPTION_HANDLER];
160			};
161
162			$pimple[self::EXCEPTION_HANDLER_STOP] = function (Container $con) {
163			return $con[self::EXCEPTION_HANDLER];
164			};
165			}
166
167			/**
168			* @param \Pimple\Container $pimple A Pimple Container to register middleware with
169			*/
170			private function formatter(Container $pimple)
171			{
172			$pimple[self::FORMATTER_DEFAULT_LOG_LEVEL] = function () {
173			return LogLevel::DEBUG;
174			};
175
176			$pimple[self::FORMATTER_STOP_LOG_LEVEL] = function () {
177			return LogLevel::DEBUG;
178			};
179
180			$pimple[self::FORMATTER_START_LOG_LEVEL] = function () {
181			return LogLevel::DEBUG;
182			};
183
184			$pimple[self::FORMATTER_START_MSG] = function () {
185			return new DefaultStartMessage();
186			};
187
188			$pimple[self::FORMATTER_STOP_MSG] = function () {
189			return new DefaultStopMessage();
190			};
191
192			$pimple[self::FORMATTER_START] = function (Container $con) {
193			return StartFormatter::create(
194			$con[self::FORMATTER_START_MSG],
195			$con[self::FORMATTER_START_LOG_LEVEL]
196			);
197			};
198
199			$pimple[self::FORMATTER_STOP] = function (Container $con) {
200			return StopFormatter::create(
201			$con[self::FORMATTER_STOP_MSG],
202			$con[self::FORMATTER_STOP_LOG_LEVEL]
203			);
204			};
205
206			$pimple[self::FORMATTER] = function (Container $con) {
207			return new Verbose(
208			$con[self::FORMATTER_START],
209			$con[self::FORMATTER_STOP]
210			);
211			};
212			}
213
214			/**
215			* @param \Pimple\Container $pimple A Pimple Container to register middleware with
216			*/
217			private function middlewareHandler(Container $pimple)
218			{
219			$pimple[self::START_HANDLER] = function (Container $con) {
220			return new StartTimer(
221			$con[self::RESPONSE_TIME_LOGGER],
222			$con[self::EXCEPTION_HANDLER_STOP]
223			);
224			};
225
226			$pimple[self::STOP_HANDLER] = function (Container $con) {
227			return new StopTimer(
228			$con[self::RESPONSE_TIME_LOGGER],
229			$con[self::EXCEPTION_HANDLER_START]
230			);
231			};
232
233			$pimple[self::MIDDLEWARE] = function (Container $con) {
234			return new Middleware(
235			$con[self::START_HANDLER],
236			$con[self::STOP_HANDLER]
237			);
238			};
239			}
240			}
241

shrikeh / guzzle-middleware-responsetimer

Branch — feature/codeception (912e4f)

TimerLogger::fromContainer() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like