QueryCountMiddleware now counts 4 different types

* initiated
* successful
* errored
* slow (configurable)

Author: WyriHaximus

composer.json

@@ -21,11 +21,13 @@
     "react/dns": "^0.4.17 || ^1.0.0",
     "roave/better-reflection": "^3.5",
     "voryx/pgasync": "^2.0",
+    "wyrihaximus/constants": "^1.1",
     "wyrihaximus/doctrine-annotation-autoloader": "^1.0",
     "wyrihaximus/iterator-or-array-to-array": "^1.1"
   },
   "require-dev": {
     "robmorgan/phinx": "^0.10.7 || ^0.11.0",
+    "thecodingmachine/safe": "^0.1.16",
     "vlucas/phpdotenv": "^3.3",
     "wyrihaximus/async-test-utilities": "^1.1"
   },

composer.lock

@@ -33,6 +33,11 @@
                  "WyriHaximus\\React\\SimpleORM\\Repository::translateFieldName"
              ]
          },
+         "Increment": {
+             "ignore": [
+                 "WyriHaximus\\React\\SimpleORM\\Middleware\\QueryCountMiddleware::query"
+             ]
+         },
          "OneZeroInteger": {
              "ignore": [
                  "WyriHaximus\\React\\SimpleORM\\Repository::count",

infection.json.dist

@@ -5,30 +5,74 @@
 use PgAsync\Client as PgClient;
 use Plasma\SQL\QueryBuilder;
 use React\Promise\PromiseInterface;
+use Rx\Observable;
+use Throwable;
 use WyriHaximus\React\SimpleORM\MiddlewareInterface;
+use function React\Promise\reject;
 use function React\Promise\resolve;
 
 final class QueryCountMiddleware implements MiddlewareInterface
 {
     private const ZERO = 0;
 
     /** @var int */
-    private $count = self::ZERO;
+    private $initiatedCount = self::ZERO;
+
+    /** @var int */
+    private $successfulCount = self::ZERO;
+
+    /** @var int */
+    private $erroredCount = self::ZERO;
+
+    /** @var int */
+    private $slowCount = self::ZERO;
+
+    /** @var int */
+    private $slowQueryTime;
+
+    public function __construct(int $slowQueryTime)
+    {
+        $this->slowQueryTime = $slowQueryTime;
+    }
 
     public function query(QueryBuilder $query, callable $next): PromiseInterface
     {
-        $this->count++;
+        $this->initiatedCount++;
+
+        $startTime = hrtime()[0];
+
+        return resolve($next($query))->then(function (Observable $observable) use ($startTime): PromiseInterface {
+            $this->successfulCount++;
+
+            if (hrtime()[0] - $startTime > $this->slowQueryTime) {
+                $this->slowCount++;
+            }
+
+            return resolve($observable);
+        }, function (Throwable $throwable) use ($startTime): PromiseInterface {
+            $this->erroredCount++;
+
+            if (hrtime()[0] - $startTime > $this->slowQueryTime) {
+                $this->slowCount++;
+            }
 
-        return resolve($next($query))->then();
+            return reject($throwable);
+        });
     }
 
-    public function getCount(): int
+    public function getCounters(): iterable
     {
-        return $this->count;
+        yield 'initiated' => $this->initiatedCount;
+        yield 'successful' => $this->successfulCount;
+        yield 'errored' => $this->erroredCount;
+        yield 'slow' => $this->slowCount;
     }
 
-    public function resetCount(): void
+    public function resetCounters(): void
     {
-        $this->count = 0;
+        $this->initiatedCount = self::ZERO;
+        $this->successfulCount = self::ZERO;
+        $this->erroredCount = self::ZERO;
+        $this->slowCount = self::ZERO;
     }
 }

src/Middleware/QueryCountMiddleware.php

@@ -5,6 +5,8 @@
 use Plasma\SQL\QueryBuilder;
 use Psr\Http\Message\ServerRequestInterface;
 use React\Promise\PromiseInterface;
+use const WyriHaximus\Constants\Numeric\ONE;
+use const WyriHaximus\Constants\Numeric\ZERO;
 
 /**
  * @internal
@@ -25,18 +27,18 @@ public function __construct(MiddlewareInterface ...$middleware)
 
     public function query(QueryBuilder $query, callable $last): PromiseInterface
     {
-        return $this->call($query, 0, $last);
+        return $this->call($query, ZERO, $last);
     }
 
     private function call(QueryBuilder $query, int $position, callable $last): PromiseInterface
     {
         // final request handler will be invoked without hooking into the promise
-        if (!array_key_exists($position + 1, $this->middleware)) {
+        if (!array_key_exists($position + ONE, $this->middleware)) {
             return $this->middleware[$position]->query($query, $last);
         }
 
         return $this->middleware[$position]->query($query, function (QueryBuilder $query) use ($position, $last) {
-            return $this->call($query, $position + 1, $last);
+            return $this->call($query, $position + ONE, $last);
         });
     }
 }