For hyperf 3.0

Author: gokure

CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 3.0.0 (2023-09-11)
+
+* Support Hyperf 3.0 only.
+* Remove Logger class, uses instance of `Hyperf` to logging request log.
+* Remove deprecated logics.
+* Remove slow requests time behaviors.

README.md

@@ -27,24 +27,6 @@ To allow HTTP Logger in your application, add the `HttpLoggerMiddleware` middlew
 ],
 ```
 
-Also, to allow HTTP Logger for exception responses, you need add the `HttpLoggerExceptionHandler` handler at the bottom of the property of `config/autoload/exceptions.php` file:
-
-```php
-'handler' => [
-    'http' => [
-        ...
-        Gokure\HttpLogger\HttpLoggerExceptionHandler::class,
-    ],
-],
-```
-
-> **Note:** No response logged, if `$this->stopPropagation()` is used in the previous exception handlers.
-
-## TODO
-
-- [ ] To filter secret body of requests and responses.
-- [ ] Add test cases.
-
 ## License
 
 Released under the MIT License, see [LICENSE](LICENSE).

composer.json

@@ -11,22 +11,16 @@
         }
     ],
     "require": {
-        "php": ">= 7.2",
-        "ext-swoole": ">= 4.4",
-        "psr/log": "^1.0",
-        "psr/container": "^1.0",
-        "hyperf/contract": "^1.0|^2.0",
-        "hyperf/di": "^1.0|^2.0",
-        "hyperf/http-server": "^1.0|^2.0",
-        "hyperf/utils": "^1.0|^2.0",
-        "monolog/monolog": "^2.0"
+        "php": ">= 8.0",
+        "hyperf/di": "~3.0.0",
+        "hyperf/http-server": "~3.0.0",
+        "hyperf/logger": "~3.0.0",
+        "monolog/monolog": "^2.7|^3.1"
     },
     "require-dev": {
-        "mockery/mockery": "^1.0",
-        "phpunit/phpunit": "^7.0.0",
-        "hyperf/testing": "^1.0|^2.0",
-        "roave/security-advisories": "dev-master",
-        "swoole/ide-helper": "^4.5"
+        "mockery/mockery": "^1.4",
+        "phpunit/phpunit": "^9.5",
+        "hyperf/testing": "~3.0.0"
     },
     "autoload": {
         "psr-4": {
@@ -35,7 +29,7 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "1.0-dev"
+            "dev-master": "3.0-dev"
         },
         "hyperf": {
             "config": "Gokure\\HttpLogger\\ConfigProvider"

publish/http_logger.php

@@ -1,38 +1,33 @@
 <?php
 
+declare(strict_types=1);
+
 return [
     /**
      * Matches the log request method. `['*']` allows all methods.
      */
-    'allowed_methods' => ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
+    'allowed_methods' => ['*'],
 
     /**
      * Matches the log context of request method. `['*']` allows all methods.
      */
     'allowed_context_methods' => ['POST', 'PUT', 'PATCH', 'DELETE'],
 
     /**
-     * Sets the slow requests when > 0
+     * Determine bypass logging when the true returned.
+     * For example, you can ignore logging for given user agent.
+     *
+     *     function ($response, $request) {
+     *         return $request->getHeaderLine('user-agent') === 'SLBHealthCheck';
+     *     }
      */
-    'long_request_time' => (float)env('HTTP_LOGGER_LONG_REQUEST_TIME', 3.0),
+    'bypass_function' => function ($response, $request) {},
 
     /**
-     * Sets the logger instance, same as the logger.php file in hyperf.
+     * Sets the logger instance.
      */
     'logger' => [
-        'handler' => [
-            'class' => Monolog\Handler\StreamHandler::class,
-            'constructor' => [
-                'stream' => BASE_PATH . '/runtime/logs/hyperf.log',
-            ],
-        ],
-        'formatter' => [
-            'class' => Monolog\Formatter\LineFormatter::class,
-            'constructor' => [
-                'format' => null,
-                'dateFormat' => 'Y-m-d H:i:s',
-                'allowInlineLineBreaks' => false,
-            ],
-        ],
+        'name' => 'hyperf',
+        'group' => 'default',
     ],
 ];

src/HttpLogger.php

@@ -5,40 +5,30 @@
 namespace Gokure\HttpLogger;
 
 use Hyperf\Contract\ConfigInterface;
-use Hyperf\Utils\Context;
-use Psr\Container\ContainerInterface;
+use Hyperf\Logger\LoggerFactory;
+use Monolog\Level;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Log\LoggerInterface;
+use function \Hyperf\Collection\collect;
 
 class HttpLogger
 {
-    protected const HYPERF_START = __CLASS__ . '.HYPERF_START';
+    protected LoggerInterface $logger;
 
-    /**
-     * @var ContainerInterface
-     */
-    protected $container;
+    protected array $options;
 
-    /**
-     * @var array
-     */
-    protected $options;
-
-    public function __construct(ContainerInterface $container)
-    {
-        $this->container = $container;
-        $options = $this->container->get(ConfigInterface::class)->get('http_logger', []);
-        $this->options = $this->normalizeOptions($options);
-    }
-
-    public function setUp(): void
+    public function __construct(LoggerFactory $factory, ConfigInterface $config)
     {
-        Context::set(static::HYPERF_START, microtime(true));
+        $this->options = $this->normalizeOptions($config->get('http_logger', []));
+        $name = $this->options['logger']['name'] ?? 'hyperf';
+        $group = $this->options['logger']['group'] ?? 'default';
+        $this->logger = $factory->get($name, $group);
     }
 
-    public function record(ResponseInterface $response, ServerRequestInterface $request, $level = Logger::INFO): void
+    public function record(\Throwable|ResponseInterface $response, ServerRequestInterface $request): void
     {
-        if (!$this->shouldRecord($response, $request)) {
+        if (! $this->shouldRecord($response, $request)) {
             return;
         }
 
@@ -58,43 +48,56 @@ public function record(ResponseInterface $response, ServerRequestInterface $requ
                     })->toArray(),
             ]);
 
-            $context['response'] = array_filter([
-                'body' => (string)$response->getBody(),
-            ]);
+            if ($response instanceof \Throwable) {
+                $context['exception'] = [
+                    'message' => $response->getMessage(),
+                    'trace' => $response->getTraceAsString(),
+                ];
+            } else {
+                $context['response'] = array_filter([
+                    'body' => (string)$response->getBody(),
+                ]);
+            }
         }
 
-        $requestTime = microtime(true) - Context::get(static::HYPERF_START, microtime(true));
-        Context::destroy(static::HYPERF_START);
+        $server = $request->getServerParams();
+        if (isset($server['request_time_float'])) {
+            $startTime = $server['request_time_float'];
+            $executeTime = number_format(microtime(true) - $startTime, 3);
+        } else {
+            $executeTime = '-';
+        }
 
         // "GET /path HTTP/1.1" 200 0.026 "User-Agent"
         $message = sprintf('"%s %s HTTP/%s" %s %s "%s"',
             $request->getMethod(),
             $request->getRequestTarget(),
             $request->getProtocolVersion(),
-            $response->getStatusCode(),
-            number_format($requestTime, 3),
-            $request->getHeaderLine('User-Agent')
+            $response instanceof ResponseInterface ? $response->getStatusCode() : '-',
+            $executeTime,
+            $request->getHeaderLine('user-agent')
         );
 
-        if ($this->options['long_request_time'] > 0 && $requestTime >= $this->options['long_request_time']) {
-            $logger = $this->container->get(LoggerFactory::class)->get('http-slow');
-        } else {
-            $logger = $this->container->get(LoggerFactory::class)->get('http');
-        }
-
-        $logger->log($level, $message, $context);
+        $level = $response instanceof \Throwable ? Level::Error : Level::Info;
+        $this->logger->log($level, $message, $context);
     }
 
-    protected function shouldRecord(ResponseInterface $response, ServerRequestInterface $request): bool
+    protected function shouldRecord(\Throwable|ResponseInterface $response, ServerRequestInterface $request): bool
     {
-        return !$this->isSuccessful($response) ||
-            $this->options['allowed_methods'] === true ||
-            in_array(strtoupper($request->getMethod()), $this->options['allowed_methods'], true);
+        return $response instanceof \Throwable ||
+            ! $this->isSuccessful($response) ||
+            (
+                (
+                    $this->options['allowed_methods'] === true ||
+                    in_array(strtoupper($request->getMethod()), $this->options['allowed_methods'], true)
+                ) && $this->options['bypass_function']($response, $request) !== true
+            );
     }
 
-    protected function shouldRecordContext(ResponseInterface $response, ServerRequestInterface $request): bool
+    protected function shouldRecordContext(\Throwable|ResponseInterface $response, ServerRequestInterface $request): bool
     {
-        return !$this->isSuccessful($response) ||
+        return $response instanceof \Throwable ||
+            ! $this->isSuccessful($response) ||
             $this->options['allowed_context_methods'] === true ||
             in_array(strtoupper($request->getMethod()), $this->options['allowed_context_methods'], true);
     }
@@ -109,28 +112,18 @@ protected function normalizeOptions(array $options = []): array
         $options += [
             'allowed_methods' => ['*'],
             'allowed_context_methods' => ['POST', 'PUT', 'PATCH', 'DELETE'],
-            'slow_request_log' => false,
-            'long_request_time' => 3.0,
             'logger' => [
-                'handler' => [
-                    'class' => \Monolog\Handler\StreamHandler::class,
-                    'constructor' => [
-                        'stream' => BASE_PATH . '/runtime/logs/hyperf.log',
-                    ],
-                ],
-                'formatter' => [
-                    'class' => \Monolog\Formatter\LineFormatter::class,
-                    'constructor' => [
-                        'format' => null,
-                        'dateFormat' => 'Y-m-d H:i:s',
-                        'allowInlineLineBreaks' => false,
-                    ],
-                ],
+                'name' => 'hyperf',
+                'group' => 'default',
             ],
         ];
 
+        if (! isset($options['bypass_function'])) {
+            $options['bypass_function'] = function () {};
+        }
+
         foreach (['allowed_methods', 'allowed_context_methods'] as $key) {
-            if (!is_array($options[$key])) {
+            if (! is_array($options[$key])) {
                 throw new \RuntimeException('Http Logger config `' . $key . '` should be an array.');
             }
         }

src/HttpLoggerExceptionHandler.php

@@ -11,22 +11,19 @@
 
 class HttpLoggerMiddleware implements MiddlewareInterface
 {
-    /**
-     * @var HttpLogger
-     */
-    protected $httpLogger;
-
-    public function __construct(HttpLogger $httpLogger)
+    public function __construct(protected HttpLogger $logger)
     {
-        $this->httpLogger = $httpLogger;
     }
 
     public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
     {
-        $this->httpLogger->setUp();
-        $response = $handler->handle($request);
-        $this->httpLogger->record($response, $request);
-
-        return $response;
+        try {
+            $response = $handler->handle($request);
+            $this->logger->record($response, $request);
+            return $response;
+        } catch (\Throwable $e) {
+            $this->logger->record($e, $request);
+            throw $e;
+        }
     }
 }