PhraseanetSDK\Profiler\PhraseanetSDKDataCollector

Complexity

Total Complexity

28

Size/Duplication

Total Lines	193
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

5.26%

Importance

Changes	10
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getCalls()	0	4	2
A	countErrors()	0	4	2
A	getMethods()	0	4	2
A	getTotalTime()	0	4	2
A	getName()	0	4	1
A	getCacheHitRatio()	0	10	3
B	collect()	0	60	7
A	sanitizeRequest()	0	16	2
A	sanitizeResponse()	0	8	1
B	parsePhraseanetResponse()	0	26	5

<?php

namespace PhraseanetSDK\Profiler;

use Guzzle\Plugin\History\HistoryPlugin;
use Guzzle\Http\Message\RequestInterface;
use Guzzle\Http\Message\Response as GuzzleResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\DataCollector\DataCollector;
use Guzzle\Http\Message\EntityEnclosingRequestInterface;

/**
 * GuzzleDataCollector.
 *
 * @author Ludovic Fleury <ludo.flery@gmail.com>
 */
class PhraseanetSDKDataCollector extends DataCollector
{
    /**
     * @var HistoryPlugin
     */
    private $profiler;

    public function __construct(HistoryPlugin $profiler)
    {
        $this->profiler = $profiler;
    }

    /**
     * {@inheritdoc}
     */
    public function collect(Request $request, Response $response, \Exception $exception = null)
    {
        $this->data = array(
            'calls'       => array(),
            'cache_hits'  => 0,
            'error_count' => 0,
            'methods'     => array(),
            'total_time'  => 0,
        );

        foreach ($this->profiler as $call) {
            $error = false;
            $request = $call;
            $response = $request->getResponse();

            $requestContent = null;
            if ($request instanceof EntityEnclosingRequestInterface) {
                $requestContent = (string) $request->getBody();
            }

            $time = array(
                'total' => $response->getInfo('total_time'),
                'connection' => $response->getInfo('connect_time'),
            );


            $this->data['total_time'] += $response->getInfo('total_time');

            if (!isset($this->data['methods'][$request->getMethod()])) {
                $this->data['methods'][$request->getMethod()] = 0;
            }

            $this->data['methods'][$request->getMethod()]++;

            if ($response->isError()) {
                $this->data['error_count']++;
                $error = true;
            }

            if (substr($response->getHeaders()->get('X-Cache', ''), 0, 3) == 'HIT') {
                $this->data['cache_hits'] += 1;
            }

            $decodedBody = json_decode($response->getBody(true));

            if (! $decodedBody) {
                $decodedBody = $response->getBody('true');
            }

            $this->data['calls'][] = array(
                'request' => $this->sanitizeRequest($request),
                'requestContent' => $requestContent,
                'response' => $this->sanitizeResponse($response),
                'responseContent' => $decodedBody,
                'time' => $time,
                'error' => $error,
                'phraseanet' => $this->parsePhraseanetResponse($decodedBody, $response)
            );
        }
    }

    /**
     * @return array
     */
    public function getCalls()
    {
        return isset($this->data['calls']) ? $this->data['calls'] : array();
    }

    /**
     * @return int
     */
    public function countErrors()
    {
        return isset($this->data['error_count']) ? $this->data['error_count'] : 0;
    }

    /**
     * @return array
     */
    public function getMethods()
    {
        return isset($this->data['methods']) ? $this->data['methods'] : array();
    }

    /**
     * @return int
     */
    public function getTotalTime()
    {
        return isset($this->data['total_time']) ? $this->data['total_time'] : 0;
    }

    /**
     * @return int|void
     */
    public function getCacheHitRatio()
    {
        $totalCalls = count($this->getCalls());

        if (! isset($this->data['cache_hits']) || $totalCalls == 0) {
            return 0;
        }

        return $this->data['cache_hits'] * 100 / $totalCalls;
    }

    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return 'phrasea-sdk';
    }

    /**
     * @param RequestInterface $request
     *
     * @return array
     */
    private function sanitizeRequest(RequestInterface $request)
    {
        $postParameters = $request instanceof EntityEnclosingRequestInterface ? $request->getPostFields() : null;

        return array(
            'method'           => $request->getMethod(),
            'protocol_version' => $request->getProtocolVersion(),
            'path'             => $request->getPath(),
            'scheme'           => $request->getScheme(),
            'host'             => $request->getHost(),
            'query'            => $request->getQuery(),
            'headers'          => $request->getHeaders()->toArray(),
            'query_parameters' => $request->getUrl(true)->getQuery(),
            'post_parameters'  => $postParameters,
        );
    }

    /**
     * @param GuzzleResponse $response
     *
     * @return array
     */
    private function sanitizeResponse($response)
    {
        return array(
            'statusCode'   => $response->getStatusCode(),
            'reasonPhrase' => $response->getReasonPhrase(),
            'headers'      => $response->getHeaders()->toArray(),

The method toArray cannot be called on $response->getHeaders() (of type array).

        );
    }

    private function parsePhraseanetResponse($data, $response)
    {
        if ($response->getStatusCode() !== 200) {
            return array();
        }

        $parsed = array(
            'metadata' => $data->meta
        );

        if (isset($data->response->offset_start)) {
            $pageMaxSize = isset($data->response->available_results) ? $data->response->available_results : '-';
            $totalResults = isset($data->response->total_results) ? $data->response->total_results : '-';

            $pagination = array(
                'Offset' => $data->response->offset_start,
                'Page size' => $data->response->per_page,
                'Page max size' => $pageMaxSize,
                'Total results' => $totalResults
            );

            $parsed['pagination'] = $pagination;
        }

        return $parsed;
    }
}