Request::getBody() - Code Metrics - zoilomora/elastic-apm-agent-php - Measure and Improve Code Quality continuously with Scrutinizer

Request::getBody() A
last analyzed 2020-12-16 13:20 UTC

↳ Parent: Request

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	4
c	1
b	0
f	0
nc	2
nop	0
dl	0
loc	7
ccs	4
cts	4
cp	1
crap	2
rs	10

<?php

namespace ZoiloMora\ElasticAPM\Events\Common;

use ZoiloMora\ElasticAPM\Events\Common\Request\Socket;
use ZoiloMora\ElasticAPM\Events\Common\Request\Url;
use ZoiloMora\ElasticAPM\Helper\Encoding;
use ZoiloMora\ElasticAPM\Helper\HttpHeaderSanitizer;

/**
 * If a log record was generated as a result of a http request,
 * the http interface can be used to collect this information.
 */
class Request implements \JsonSerializable
{
    /**
     * Data should only contain the request body (not the query string).
     * It can either be a dictionary (for standard HTTP requests) or a raw request body.
     *
     * @var object|string|null
     */
    private $body;

    /**
     * The env variable is a compounded of environment information passed from the webserver.
     *
     * @var object|null
     */
    private $env;

    /**
     * Should include any headers sent by the requester. Cookies will be taken by headers if supplied.
     *
     * @var array|null
     */
    private $headers;

    /**
     * HTTP version.
     *
     * @var string|null
     */
    private $httpVersion;

    /**
     * HTTP method.
     *
     * @var string
     */
    private $method;

    /**
     * @var Socket|null
     */
    private $socket;

    /**
     * A complete Url, with scheme, host and path.
     *
     * @var Url
     */
    private $url;

    /**
     * A parsed key-value object of cookies
     *
     * @var array|null
     */
    private $cookies;

    /**
     * @param string $method
     * @param Url $url
     * @param object|string|null $body
     * @param object|null $env
     * @param array|null $headers
     * @param string|null $httpVersion
     * @param Socket|null $socket
     * @param array|null $cookies
     */
    public function __construct(
        $method,
        Url $url,
        $body = null,
        $env = null,
        array $headers = null,
        $httpVersion = null,
        Socket $socket = null,
        array $cookies = null
    ) {
        $this->body = $body;
        $this->env = $env;
        $this->headers = $headers;

        $this->httpVersion = $httpVersion;
        $this->method = $method;
        $this->socket = $socket;
        $this->url = $url;
        $this->cookies = $cookies;
    }

    /**
     * @return object|string|null
     */
    public function body()
    {
        return $this->body;
    }

    /**
     * @return object|null
     */
    public function env()
    {
        return $this->env;
    }

    /**
     * @return array|null
     */
    public function headers()
    {
        return $this->headers;
    }

    /**
     * @return string|null
     */
    public function httpVersion()
    {
        return $this->httpVersion;
    }

    /**
     * @return string
     */
    public function method()
    {
        return $this->method;
    }

    /**
     * @return Socket|null
     */
    public function socket()
    {
        return $this->socket;
    }

    /**
     * @return Url
     */
    public function url()
    {
        return $this->url;
    }

    /**
     * @return array|null
     */
    public function cookies()
    {
        return $this->cookies;
    }

    /**
     * @return Request|null
     */
    public static function discover()
    {
        if ('cli' === self::getMethod()) {
            return null;
        }

        return new self(
            self::getMethod(),
            Url::discover(),
            self::getBody(),
            null,
            self::getHeaders(),
            self::getHttpVersion(),
            Socket::discover()
        );
    }

    /**
     * @return string|null
     */
    private static function getBody()
    {
        $input = file_get_contents('php://input');

        return '' !== $input
            ? (string) $input
            : null;
    }

    /**
     * @return array|null
     */
    private static function getHeaders()
    {
        $headers = [];

        foreach ($_SERVER as $key => $value) {
            if ('HTTP_' !== substr($key, 0, 5)) {
                continue;
            }

            $header = str_replace(
                ' ',
                '-',
                ucwords(
                    str_replace(
                        '_',
                        ' ',
                        strtolower(
                            substr(
                                $key,
                                5
                            )
                        )
                    )
                )
            );

            $headers[$header] = $value;
        }

        $headers = HttpHeaderSanitizer::sanitize($headers);

        return 0 !== count($headers)
            ? $headers
            : null;
    }

    /**
     * @return string|null
     */
    private static function getHttpVersion()
    {
        if (false === array_key_exists('SERVER_PROTOCOL', $_SERVER)) {
            return null;
        }

        $position = strpos(
            $_SERVER['SERVER_PROTOCOL'],
            '/'
        );

        return substr(
            $_SERVER['SERVER_PROTOCOL'],
            $position + 1
        );
    }

    /**
     * @return string
     */
    private static function getMethod()
    {
        if (true === array_key_exists('REQUEST_METHOD', $_SERVER)) {
            return $_SERVER['REQUEST_METHOD'];
        }

        return 'cli';
    }

    /**
     * @return array
     */
    public function jsonSerialize()
    {
        return [
            'body' => $this->body,
            'env' => $this->env,
            'headers' => $this->headers,
            'http_version' => Encoding::keywordField($this->httpVersion),
            'method' => Encoding::keywordField($this->method),
            'socket' => $this->socket,
            'url' => $this->url,
            'cookies' => $this->cookies,
        ];
    }
}


1		<?php
2
3		namespace ZoiloMora\ElasticAPM\Events\Common;
4
5		use ZoiloMora\ElasticAPM\Events\Common\Request\Socket;
6		use ZoiloMora\ElasticAPM\Events\Common\Request\Url;
7		use ZoiloMora\ElasticAPM\Helper\Encoding;
8		use ZoiloMora\ElasticAPM\Helper\HttpHeaderSanitizer;
9
10		/**
11		* If a log record was generated as a result of a http request,
12		* the http interface can be used to collect this information.
13		*/
14		class Request implements \JsonSerializable
15		{
16		/**
17		* Data should only contain the request body (not the query string).
18		* It can either be a dictionary (for standard HTTP requests) or a raw request body.
19		*
20		* @var object\|string\|null
21		*/
22		private $body;
23
24		/**
25		* The env variable is a compounded of environment information passed from the webserver.
26		*
27		* @var object\|null
28		*/
29		private $env;
30
31		/**
32		* Should include any headers sent by the requester. Cookies will be taken by headers if supplied.
33		*
34		* @var array\|null
35		*/
36		private $headers;
37
38		/**
39		* HTTP version.
40		*
41		* @var string\|null
42		*/
43		private $httpVersion;
44
45		/**
46		* HTTP method.
47		*
48		* @var string
49		*/
50		private $method;
51
52		/**
53		* @var Socket\|null
54		*/
55		private $socket;
56
57		/**
58		* A complete Url, with scheme, host and path.
59		*
60		* @var Url
61		*/
62		private $url;
63
64		/**
65		* A parsed key-value object of cookies
66		*
67		* @var array\|null
68		*/
69		private $cookies;
70
71		/**
72		* @param string $method
73		* @param Url $url
74		* @param object\|string\|null $body
75		* @param object\|null $env
76		* @param array\|null $headers
77		* @param string\|null $httpVersion
78		* @param Socket\|null $socket
79		* @param array\|null $cookies
80		*/
81	6	public function __construct(
82		$method,
83		Url $url,
84		$body = null,
85		$env = null,
86		array $headers = null,
87		$httpVersion = null,
88		Socket $socket = null,
89		array $cookies = null
90		) {
91	6	$this->body = $body;
92	6	$this->env = $env;
93	6	$this->headers = $headers;
94
95	6	$this->httpVersion = $httpVersion;
96	6	$this->method = $method;
97	6	$this->socket = $socket;
98	6	$this->url = $url;
99	6	$this->cookies = $cookies;
100	6	}
101
102		/**
103		* @return object\|string\|null
104		*/
105	1	public function body()
106		{
107	1	return $this->body;
108		}
109
110		/**
111		* @return object\|null
112		*/
113	1	public function env()
114		{
115	1	return $this->env;
116		}
117
118		/**
119		* @return array\|null
120		*/
121	2	public function headers()
122		{
123	2	return $this->headers;
124		}
125
126		/**
127		* @return string\|null
128		*/
129	2	public function httpVersion()
130		{
131	2	return $this->httpVersion;
132		}
133
134		/**
135		* @return string
136		*/
137	1	public function method()
138		{
139	1	return $this->method;
140		}
141
142		/**
143		* @return Socket\|null
144		*/
145	1	public function socket()
146		{
147	1	return $this->socket;
148		}
149
150		/**
151		* @return Url
152		*/
153	1	public function url()
154		{
155	1	return $this->url;
156		}
157
158		/**
159		* @return array\|null
160		*/
161	1	public function cookies()
162		{
163	1	return $this->cookies;
164		}
165
166		/**
167		* @return Request\|null
168		*/
169	16	public static function discover()
170		{
171	16	if ('cli' === self::getMethod()) {
172	13	return null;
173		}
174
175	3	return new self(
176	3	self::getMethod(),
177	3	Url::discover(),
178	3	self::getBody(),
179	3	null,
180	3	self::getHeaders(),
181	3	self::getHttpVersion(),
182	3	Socket::discover()
183	3	);
184		}
185
186		/**
187		* @return string\|null
188		*/
189	3	private static function getBody()
190		{
191	3	$input = file_get_contents('php://input');
192
193		return '' !== $input
194	3	? (string) $input
195	3	: null;
196		}
197
198		/**
199		* @return array\|null
200		*/
201	3	private static function getHeaders()
202		{
203	3	$headers = [];
204
205	3	foreach ($_SERVER as $key => $value) {
206	3	if ('HTTP_' !== substr($key, 0, 5)) {
207	3	continue;
208		}
209
210	1	$header = str_replace(
211	1	' ',
212	1	'-',
213	1	ucwords(
214	1	str_replace(
215	1	'_',
216	1	' ',
217	1	strtolower(
218	1	substr(
219	1	$key,
220		5
221	1	)
222	1	)
223	1	)
224	1	)
225	1	);
226
227	1	$headers[$header] = $value;
228	3	}
229
230	3	$headers = HttpHeaderSanitizer::sanitize($headers);
231
232	3	return 0 !== count($headers)
233	3	? $headers
234	3	: null;
235		}
236
237		/**
238		* @return string\|null
239		*/
240	3	private static function getHttpVersion()
241		{
242	3	if (false === array_key_exists('SERVER_PROTOCOL', $_SERVER)) {
243	2	return null;
244		}
245
246	1	$position = strpos(
247	1	$_SERVER['SERVER_PROTOCOL'],
248		'/'
249	1	);
250
251	1	return substr(
252	1	$_SERVER['SERVER_PROTOCOL'],
253		$position + 1
254	1	);
255		}
256
257		/**
258		* @return string
259		*/
260	16	private static function getMethod()
261		{
262	16	if (true === array_key_exists('REQUEST_METHOD', $_SERVER)) {
263	3	return $_SERVER['REQUEST_METHOD'];
264		}
265
266	13	return 'cli';
267		}
268
269		/**
270		* @return array
271		*/
272	1	public function jsonSerialize()
273		{
274		return [
275	1	'body' => $this->body,
276	1	'env' => $this->env,
277	1	'headers' => $this->headers,
278	1	'http_version' => Encoding::keywordField($this->httpVersion),
279	1	'method' => Encoding::keywordField($this->method),
280	1	'socket' => $this->socket,
281	1	'url' => $this->url,
282	1	'cookies' => $this->cookies,
283	1	];
284		}
285		}
286

zoilomora / elastic-apm-agent-php

Request::getBody() A last analyzed 2020-12-16 13:20 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Request::getBody() A
last analyzed 2020-12-16 13:20 UTC