-
Notifications
You must be signed in to change notification settings - Fork 14
/
GuzzleLogMiddleware.php
547 lines (471 loc) · 18.1 KB
/
GuzzleLogMiddleware.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
<?php
/**
* Created by PhpStorm.
* User: Exodus 4D
* Date: 05.01.2019
* Time: 13:32
*/
namespace Exodus4D\ESI\Lib\Middleware;
use Exodus4D\ESI\Lib\Stream\JsonStream;
use Exodus4D\ESI\Lib\Stream\JsonStreamInterface;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\TransferStats;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
class GuzzleLogMiddleware {
/**
* default for: global enable this middleware
*/
const DEFAULT_LOG_ENABLED = true;
/**
* default for: log message format
*/
const DEFAULT_LOG_FORMAT = '{method} {target} HTTP/{version} → {code} {phrase} {res_header_content-length}';
/**
* default for: log errors, e.g. ConnectException or other errors where no response available
*/
const DEFAULT_LOG_ERROR = true;
/**
* default for: log statistics (if available)
*/
const DEFAULT_LOG_STATS = false;
/**
* default for: log cache info (if available)
*/
const DEFAULT_LOG_CACHE = false;
/**
* default for: cache info response Header (see GuzzleCacheMiddleware)
*/
const DEFAULT_LOG_CACHE_HEADER = 'X-Guzzle-Cache';
/**
* default for: log all requests HTTP headers
*/
const DEFAULT_LOG_REQUEST_HEADERS = false;
/**
* default for: log all response HTTP headers
*/
const DEFAULT_LOG_RESPONSE_HEADERS = false;
/**
* default for: log requests with HTTP 5xx response
*/
const DEFAULT_LOG_5XX = true;
/**
* default for: log requests with HTTP 4xx response
*/
const DEFAULT_LOG_4XX = true;
/**
* default for: log requests with HTTP 3xx response
*/
const DEFAULT_LOG_3XX = false;
/**
* default for: log requests with HTTP 2xx response
*/
const DEFAULT_LOG_2XX = false;
/**
* default for: log requests with HTTP 1xx response
*/
const DEFAULT_LOG_1XX = false;
/**
* default for: log all requests regardless of the HTTP status response code
*/
const DEFAULT_LOG_ALL_STATUS = false;
/**
* default for: log requests with specific HTTP status response
*/
const DEFAULT_LOG_ON_STATUS = [];
/**
* default for: exclude requests with specific HTTP status response.
* This overwrites all other configured status options set before
*/
const DEFAULT_LOG_OFF_STATUS = [];
/**
* default for: callback function that checks a $request
* -> can be used to "exclude" some requests from been logged (e.g. on expected downtime)
*/
const DEFAULT_LOG_LOGGABLE_CALLBACK = null;
/**
* default for: callback function for logging
*/
const DEFAULT_LOG_CALLBACK = null;
/**
* default for: name for log file
*/
const DEFAULT_LOG_FILE = 'requests';
/**
* default options can go here for middleware
* @var array
*/
private $defaultOptions = [
'log_enabled' => self::DEFAULT_LOG_ENABLED,
'log_format' => self::DEFAULT_LOG_FORMAT,
'log_error' => self::DEFAULT_LOG_ERROR,
'log_stats' => self::DEFAULT_LOG_STATS,
'log_cache' => self::DEFAULT_LOG_CACHE,
'log_cache_header' => self::DEFAULT_LOG_CACHE_HEADER,
'log_request_headers' => self::DEFAULT_LOG_REQUEST_HEADERS,
'log_response_headers' => self::DEFAULT_LOG_RESPONSE_HEADERS,
'log_5xx' => self::DEFAULT_LOG_5XX,
'log_4xx' => self::DEFAULT_LOG_4XX,
'log_3xx' => self::DEFAULT_LOG_3XX,
'log_2xx' => self::DEFAULT_LOG_2XX,
'log_1xx' => self::DEFAULT_LOG_1XX,
'log_all_status' => self::DEFAULT_LOG_ALL_STATUS,
'log_on_status' => self::DEFAULT_LOG_ON_STATUS,
'log_off_status' => self::DEFAULT_LOG_OFF_STATUS,
'log_loggable_callback' => self::DEFAULT_LOG_LOGGABLE_CALLBACK,
'log_callback' => self::DEFAULT_LOG_CALLBACK,
'log_file' => self::DEFAULT_LOG_FILE
];
/**
* @var callable
*/
private $nextHandler;
/**
* @var TransferStats|null
*/
private $stats = null;
/**
* GuzzleLogMiddleware constructor.
* @param callable $nextHandler
* @param array $defaultOptions
*/
public function __construct(callable $nextHandler, array $defaultOptions = []){
$this->nextHandler = $nextHandler;
$this->defaultOptions = $this->mergeOptions($this->defaultOptions, $defaultOptions);
}
/**
* log errors for requested URL
* @param RequestInterface $request
* @param array $options
* @return mixed
*/
public function __invoke(RequestInterface $request, array $options){
// Combine options with defaults specified by this middleware
$options = $this->mergeOptions($this->defaultOptions, $options);
// deactivate this middleware a callback function is provided with response false
if(
$options['log_enabled'] &&
is_callable($loggable = $options['log_loggable_callback'])
){
$options['log_enabled'] = $loggable($request);
}
$next = $this->nextHandler;
// reset TransferStats
$this->stats = null;
// TransferStats can only be accessed through a callback -> 'on_stats' Core Guzzle option
if($options['log_enabled'] && $options['log_stats'] && !isset($options['on_stats'])){
$options['on_stats'] = function(TransferStats $stats){
$this->stats = $stats;
};
}
return $next($request, $options)->then(
$this->onFulfilled($request, $options),
$this->onRejected($request, $options)
);
}
/**
* No exceptions were thrown during processing
* @param RequestInterface $request
* @param array $options
* @return \Closure
*/
protected function onFulfilled(RequestInterface $request, array $options) : \Closure {
return function (ResponseInterface $response) use ($request, $options) {
if($options['log_enabled']){
$this->log($options, $request, $response);
}
return $response;
};
}
/**
* An exception or error was thrown during processing
* @param RequestInterface $request
* @param array $options
* @return \Closure
*/
protected function onRejected(RequestInterface $request, array $options) : \Closure {
return function ($reason) use ($request, $options) {
if(
$options['log_enabled'] &&
$reason instanceof \Exception
){
$response = null;
if(($reason instanceof RequestException) && $reason->hasResponse()){
$response = $reason->getResponse();
}
$this->log($options, $request, $response, $reason);
}
return \GuzzleHttp\Promise\rejection_for($reason);
};
}
/**
* log request and response data based on $option flags
* @param array $options
* @param RequestInterface $request
* @param ResponseInterface|null $response
* @param \Exception|null $exception
*/
protected function log(array $options, RequestInterface $request, ?ResponseInterface $response, ?\Exception $exception = null) : void {
$logData = [];
$action = $options['log_file'];
$level = 'info';
$tag = 'information';
$logError = $options['log_error'] && $exception instanceof \Exception;
$logRequestData = false;
if($logError){
// Either Guzzle Exception -> ConnectException or RequestException
// of any other Exception
$reasonData = $this->logReason($exception);
$logData['reason'] = $reasonData;
$logRequestData = true;
$level = 'critical';
$tag = 'danger';
}
if(!is_null($response)){
$statusCode = $response->getStatusCode();
if($logError || $this->checkStatusCode($options, $statusCode)){
$logData['response'] = $this->logResponse($response, $options);
if($options['log_cache']){
$logData['cache'] = $this->logCache($response, $options);
}
$logRequestData = true;
// if Error -> do not change log $level and $tag
if(!$logError){
if($this->is2xx($statusCode)){
$level = 'info';
$tag = 'success';
}elseif($this->is4xx($statusCode)){
$level = 'error';
$tag = 'warning';
}elseif($this->is5xx($statusCode)){
$level = 'critical';
$tag = 'warning';
}
}
}
}
if($logRequestData){
$logData['request'] = $this->logRequest($request, $options);
}
// log stats in case other logData should be logged
if(!is_null($this->stats) && !empty($logData)){
$logData['stats'] = $this->logStats($this->stats);
}
if(!empty($logData) && is_callable($log = $options['log_callback'])){
$log($action, $level, $this->getLogMessage($options['log_format'], $logData), $logData, $tag);
}
}
/**
* log request
* @param RequestInterface $request
* @param array $options
* @return array
*/
protected function logRequest(RequestInterface $request, array $options) : array {
$logData = [
'method' => $request->getMethod(),
'url' => $request->getUri()->__toString(),
'host' => $request->getUri()->getHost(),
'path' => $request->getUri()->getPath(),
'target' => $request->getRequestTarget(),
'version' => $request->getProtocolVersion()
];
if($options['log_request_headers']){
$logData['requestHeaders'] = $request->getHeaders();
}
return $logData;
}
/**
* log response -> this might be a HTTP 1xx up to 5xx response
* @param ResponseInterface $response
* @param array $options
* @return array
*/
protected function logResponse(ResponseInterface $response, array $options) : array {
// response body might contain additional error message
$errorMessage = $this->getErrorMessageFromResponseBody($response);
$logData = [
'code' => $response->getStatusCode(),
'phrase' => $response->getReasonPhrase(),
'version' => $response->getProtocolVersion(),
'res_header_content-length' => $response->getHeaderLine('content-length'),
'error_msg' => $errorMessage
];
if($options['log_response_headers']){
$logData['responseHeaders'] = $response->getHeaders();
}
return $logData;
}
/**
* log reason -> rejected promise
* ConnectException or parent of type RequestException -> get error from HandlerContext
* any other Exception (no idea when this can happen) -> get error from Exception
* @param \Exception|null $exception
* @return array
*/
protected function logReason(?\Exception $exception) : array {
if(
($exception instanceof RequestException) &&
!empty($handlerContext = $exception->getHandlerContext())
){
return [
'errno' => $handlerContext['errno'],
'error' => $handlerContext['error']
];
}else{
// other Exception OR RequestException without handlerContext data
return [
'errno' => 'NULL',
'error' => $exception->getMessage()
];
}
}
/**
* log Cache information
* -> read from HTTP response headers -> set by GuzzleCacheMiddleware
* @param ResponseInterface $response
* @param array $options
* @return array
*/
protected function logCache(ResponseInterface $response, array $options) : array {
$cacheStatusHeader = 'NULL';
if($response->hasHeader($options['log_cache_header'])){
$cacheStatusHeader = $response->getHeaderLine($options['log_cache_header']);
}
return [
'status' => $cacheStatusHeader
];
}
/**
* log transfer stats
* For debugging purpose
* @param TransferStats $stats
* @return array
*/
protected function logStats(TransferStats $stats) : array {
return [
'time' => (string)$stats->getTransferTime()
];
}
/**
* Some APIs provide additional error information in response body
* E.g. is there is a HTTP 4xx/5xx $response, the body might have:
* -> A: JSON response: {"error":"Some error message"}
* -> B: TEXT response: 'Some error message'
* @param ResponseInterface $response
* @return string
*/
protected function getErrorMessageFromResponseBody(ResponseInterface $response) : string {
$error = '';
$body = $response->getBody();
if($body->isReadable()){
$contentTypeHeader = strtolower($response->getHeaderLine('Content-Type'));
if(strpos($contentTypeHeader, 'application/json') !== false){
// we expect json encoded content
// -> check if $body is already wrapped in JsonStream (e.g. from previous Middlewares,..)
if(!($body instanceof JsonStreamInterface)){
// ... create temp JsonStream
$jsonBody = new JsonStream($body);
$content = $jsonBody->getContents();
}else{
// ... already JsonStream -> get content
$content = $body->getContents();
}
// ... check if "error" key exists in content, with error message
if(is_string($content->error)){
$error = $content->error;
}
}else{
// no Json encoded content expected -> simple text
$error = $body->getContents();
}
// rewind $body for next access. !important!
$body->rewind();
}
return $error;
}
/**
* check response HTTP Status code for logging
* @param array $options
* @param int $statusCode
* @return bool
*/
protected function checkStatusCode(array $options, int $statusCode) : bool {
if($options['log_all_status']){
return true;
}
if(in_array($statusCode, (array)$options['log_off_status'])){
return false;
}
if(in_array($statusCode, (array)$options['log_on_status'])){
return true;
}
$statusLevel = (int)substr($statusCode, 0, 1);
return (bool)$options['log_' . $statusLevel . 'xx'];
}
/**
* check HTTP Status for 2xx response
* @param int $statusCode
* @return bool
*/
protected function is2xx(int $statusCode) : bool {
return (int)substr($statusCode, 0, 1) === 2;
}
/**
* check HTTP Status for 4xx response
* @param int $statusCode
* @return bool
*/
protected function is4xx(int $statusCode) : bool {
return (int)substr($statusCode, 0, 1) === 4;
}
/**
* check HTTP Status for 5xx response
* @param int $statusCode
* @return bool
*/
protected function is5xx(int $statusCode) : bool {
return (int)substr($statusCode, 0, 1) === 5;
}
/**
* get formatted log message from $logData
* @param string $message
* @param array $logData
* @return string
*/
protected function getLogMessage(string $message, array $logData = []) : string {
$replace = [
'{method}' => $logData['request']['method'],
'{url}' => $logData['request']['url'],
'{host}' => $logData['request']['host'],
'{path}' => $logData['request']['path'],
'{target}' => $logData['request']['target'],
'{version}' => $logData['request']['version'],
'{code}' => $logData['response']['code'] ? : 'NULL',
'{phrase}' => $logData['response']['phrase'] ? : '',
'{res_header_content-length}' => $logData['response']['res_header_content-length'] ? : 0
];
return str_replace(array_keys($replace), array_values($replace), $message);
}
/**
* merge middleware options
* @param array $options
* @param array $optionsNew
* @return array
*/
protected function mergeOptions(array $options = [], array $optionsNew = []) : array {
// array options must be merged rather than replaced
$optionsNew['log_on_status'] = array_unique(array_merge((array)$options['log_on_status'], (array)$optionsNew['log_on_status']));
$optionsNew['log_off_status'] = array_unique(array_merge((array)$options['log_off_status'], (array)$optionsNew['log_off_status']));
return array_replace($options, $optionsNew);
}
/**
* @param array $defaultOptions
* @return \Closure
*/
public static function factory(array $defaultOptions = []) : \Closure {
return function(callable $handler) use ($defaultOptions){
return new static($handler, $defaultOptions);
};
}
}