GuzzleCollector::collect() - Code Metrics - ozo2003/HelperBundle - Measure and Improve Code Quality continuously with Scrutinizer

GuzzleCollector::collect() B
last analyzed 2018-09-14 14:31 UTC

↳ Parent: GuzzleCollector

Complexity

Conditions	7
Paths	11

Size

Total Lines	59
Code Lines	35

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	7
eloc	35
nc	11
nop	3
dl	0
loc	59
rs	8.4266
c	0
b	0
f	0

How to fix Long Method

<?php

namespace Sludio\HelperBundle\Guzzle\DataCollector;

use GuzzleHttp\Exception\RequestException;
use Psr\Http\Message\StreamInterface;
use Sludio\HelperBundle\Guzzle\GuzzleHttp\History\History;
use Sludio\HelperBundle\Guzzle\GuzzleHttp\Middleware\CacheMiddleware;
use Sludio\HelperBundle\Guzzle\GuzzleHttp\Middleware\MockMiddleware;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\DataCollector\DataCollector;

class GuzzleCollector extends DataCollector
{
    const MAX_BODY_SIZE = 0x10000;

    private $maxBodySize;
    private $history;

    /**
     * Constructor.
     *
     * @param int          $maxBodySize The max body size to store in the profiler storage
     * @param History|null $history
     */
    public function __construct($maxBodySize = self::MAX_BODY_SIZE, History $history = null)
    {
        $this->maxBodySize = $maxBodySize;
        $this->history = $history ?: new History();

        $this->data = [];
    }

    /**
     * {@inheritdoc}
     */
    public function collect(Request $request, Response $response, \Exception $exception = null)
    {
        $data = [];

        foreach ($this->history as $historyRequest) {
            /* @var \Psr\Http\Message\RequestInterface $historyRequest */
            $transaction = $this->history[$historyRequest];
            /* @var \Psr\Http\Message\ResponseInterface $historyResponse */
            $historyResponse = $transaction['response'];
            /* @var \Exception $error */
            $error = $transaction['error'];
            /* @var array $info */
            $info = $transaction['info'];

            $req = [
                'request' => [
                    'method' => $historyRequest->getMethod(),
                    'version' => $historyRequest->getProtocolVersion(),
                    'headers' => $historyRequest->getHeaders(),
                    'body' => $this->cropContent($historyRequest->getBody()),
                ],
                'info' => $info,
                'uri' => urldecode($historyRequest->getUri()),
                'httpCode' => 0,
                'error' => null,
            ];

            if ($historyResponse) {
                $req['response'] = [
                    'reasonPhrase' => $historyResponse->getReasonPhrase(),
                    'headers' => $historyResponse->getHeaders(),
                    'body' => $this->cropContent($historyResponse->getBody()),
                ];

                $req['httpCode'] = $historyResponse->getStatusCode();

                if ($historyResponse->hasHeader(CacheMiddleware::DEBUG_HEADER)) {
                    $req['cache'] = $historyResponse->getHeaderLine(CacheMiddleware::DEBUG_HEADER);
                }

                if ($historyResponse->hasHeader(MockMiddleware::DEBUG_HEADER)) {
                    $req['mock'] = $historyResponse->getHeaderLine(MockMiddleware::DEBUG_HEADER);
                }
            }

            if ($error && $error instanceof RequestException) {
                $req['error'] = [
                    'message' => $error->getMessage(),
                    'line' => $error->getLine(),
                    'file' => $error->getFile(),
                    'code' => $error->getCode(),
                    'trace' => $error->getTraceAsString(),
                ];
            }

            $data[] = $req;
        }

        $this->data = $data;
    }

    private function cropContent(StreamInterface $stream = null)
    {
        if (null === $stream) {
            return '';
        }

        if ($stream->getSize() <= $this->maxBodySize) {
            return (string)$stream;
        }

        $stream->seek(0);

        return '(partial content)'.$stream->read($this->maxBodySize).'(...)';
    }

    public function getErrors()
    {
        return array_filter($this->data, function($call) {
            return 0 === $call['httpCode'] || $call['httpCode'] >= 400;
        });
    }

    public function getTotalTime()
    {
        return array_sum(array_map(function($call) {
            return isset($call['info']['total_time']) ? $call['info']['total_time'] : 0;
        }, $this->data));
    }

    public function getCalls()
    {
        return $this->data;
    }

    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return 'guzzle';
    }
}


1			<?php
2
3			namespace Sludio\HelperBundle\Guzzle\DataCollector;
4
5			use GuzzleHttp\Exception\RequestException;
6			use Psr\Http\Message\StreamInterface;
7			use Sludio\HelperBundle\Guzzle\GuzzleHttp\History\History;
8			use Sludio\HelperBundle\Guzzle\GuzzleHttp\Middleware\CacheMiddleware;
9			use Sludio\HelperBundle\Guzzle\GuzzleHttp\Middleware\MockMiddleware;
10			use Symfony\Component\HttpFoundation\Request;
11			use Symfony\Component\HttpFoundation\Response;
12			use Symfony\Component\HttpKernel\DataCollector\DataCollector;
13
14			class GuzzleCollector extends DataCollector
15			{
16			const MAX_BODY_SIZE = 0x10000;
17
18			private $maxBodySize;
19			private $history;
20
21			/**
22			* Constructor.
23			*
24			* @param int $maxBodySize The max body size to store in the profiler storage
25			* @param History\|null $history
26			*/
27			public function __construct($maxBodySize = self::MAX_BODY_SIZE, History $history = null)
28			{
29			$this->maxBodySize = $maxBodySize;
30			$this->history = $history ?: new History();
31
32			$this->data = [];
33			}
34
35			/**
36			* {@inheritdoc}
37			*/
38			public function collect(Request $request, Response $response, \Exception $exception = null)
39			{
40			$data = [];
41
42			foreach ($this->history as $historyRequest) {
43			/* @var \Psr\Http\Message\RequestInterface $historyRequest */
44			$transaction = $this->history[$historyRequest];
45			/* @var \Psr\Http\Message\ResponseInterface $historyResponse */
46			$historyResponse = $transaction['response'];
47			/* @var \Exception $error */
48			$error = $transaction['error'];
49			/* @var array $info */
50			$info = $transaction['info'];
51
52			$req = [
53			'request' => [
54			'method' => $historyRequest->getMethod(),
55			'version' => $historyRequest->getProtocolVersion(),
56			'headers' => $historyRequest->getHeaders(),
57			'body' => $this->cropContent($historyRequest->getBody()),
58			],
59			'info' => $info,
60			'uri' => urldecode($historyRequest->getUri()),
61			'httpCode' => 0,
62			'error' => null,
63			];
64
65			if ($historyResponse) {
66			$req['response'] = [
67			'reasonPhrase' => $historyResponse->getReasonPhrase(),
68			'headers' => $historyResponse->getHeaders(),
69			'body' => $this->cropContent($historyResponse->getBody()),
70			];
71
72			$req['httpCode'] = $historyResponse->getStatusCode();
73
74			if ($historyResponse->hasHeader(CacheMiddleware::DEBUG_HEADER)) {
75			$req['cache'] = $historyResponse->getHeaderLine(CacheMiddleware::DEBUG_HEADER);
76			}
77
78			if ($historyResponse->hasHeader(MockMiddleware::DEBUG_HEADER)) {
79			$req['mock'] = $historyResponse->getHeaderLine(MockMiddleware::DEBUG_HEADER);
80			}
81			}
82
83			if ($error && $error instanceof RequestException) {
84			$req['error'] = [
85			'message' => $error->getMessage(),
86			'line' => $error->getLine(),
87			'file' => $error->getFile(),
88			'code' => $error->getCode(),
89			'trace' => $error->getTraceAsString(),
90			];
91			}
92
93			$data[] = $req;
94			}
95
96			$this->data = $data;
97			}
98
99			private function cropContent(StreamInterface $stream = null)
100			{
101			if (null === $stream) {
102			return '';
103			}
104
105			if ($stream->getSize() <= $this->maxBodySize) {
106			return (string)$stream;
107			}
108
109			$stream->seek(0);
110
111			return '(partial content)'.$stream->read($this->maxBodySize).'(...)';
112			}
113
114			public function getErrors()
115			{
116			return array_filter($this->data, function($call) {
117			return 0 === $call['httpCode'] \|\| $call['httpCode'] >= 400;
118			});
119			}
120
121			public function getTotalTime()
122			{
123			return array_sum(array_map(function($call) {
124			return isset($call['info']['total_time']) ? $call['info']['total_time'] : 0;
125			}, $this->data));
126			}
127
128			public function getCalls()
129			{
130			return $this->data;
131			}
132
133			/**
134			* {@inheritdoc}
135			*/
136			public function getName()
137			{
138			return 'guzzle';
139			}
140			}
141

ozo2003 / HelperBundle

GuzzleCollector::collect() B last analyzed 2018-09-14 14:31 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

GuzzleCollector::collect() B
last analyzed 2018-09-14 14:31 UTC