Merge pull request #25 from loveOSS/introduced-monitoring

Introduced Monitoring feature
loveOSS · Sep 20, 2019 · 411abb0 · 411abb0
2 parents ac71241 + 956ef4d
commit 411abb0
Show file tree

Hide file tree

Showing 27 changed files with 482 additions and 97 deletions.
diff --git a/.php_cs.dist b/.php_cs.dist
@@ -33,6 +33,7 @@ return PhpCsFixer\Config::create()
         'yoda_style' => null,
         'non_printable_character' => true,
         'phpdoc_no_empty_return' => false,
+        'php_unit_test_case_static_method_calls' => ['call_type' => 'self'],
     ])
     ->setFinder($finder)
     ->setCacheFile(__DIR__.'/.php_cs.cache')

diff --git a/README.md b/README.md
@@ -47,7 +47,7 @@ $mainSystem = MainSystem::createFromArray([
 
 $storage = new SimpleArray();
 
-// Any PSR-13 Event Dispatcher implementation.
+// Any PSR-14 Event Dispatcher implementation.
 $dispatcher = new Symfony\Component\EventDispatcher\EventDispatcher;
 
 $circuitBreaker = new MainCircuitBreaker(
@@ -75,6 +75,23 @@ $circuitBreaker->call(
 > For the Guzzle implementation, the Client options are described
 > in the [HttpGuzzle documentation](http://docs.guzzlephp.org/en/stable/index.html).
 
+### Monitoring
+
+This library is shipped with a minimalist system to help you monitor your circuits.
+
+```php
+$monitor = new SimpleMonitor();
+
+// on some circuit breaker events...
+function listener(Event $event) {
+    $monitor->add($event);
+};
+
+// retrieve a complete report for analysis or storage
+$report = $monitor->getReport();
+
+```
+
 ## Tests
 
 ```

diff --git a/src/Contracts/Monitoring/Monitor.php b/src/Contracts/Monitoring/Monitor.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace Resiliency\Contracts\Monitoring;
+
+use Resiliency\Contracts\Event;
+
+/**
+ * If you need to monitor and collect information about the circuit breaker
+ * use the monitor to collect the information when events are dispatched.
+ */
+interface Monitor
+{
+    /**
+     * @param Event $event the dispatched event
+     */
+    public function collect(Event $event): void;
+
+    /**
+     * @return Report the Monitor Report
+     */
+    public function getReport(): Report;
+}
diff --git a/src/Contracts/Monitoring/Report.php b/src/Contracts/Monitoring/Report.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Resiliency\Contracts\Monitoring;
+
+/**
+ * The Monitor report
+ */
+interface Report
+{
+    /**
+     * @var ReportEntry the report entry
+     *
+     * @return self
+     */
+    public function add(ReportEntry $reportEntry): self;
+
+    /**
+     * @return array the list of report entries
+     */
+    public function all(): array;
+}
diff --git a/src/Contracts/Monitoring/ReportEntry.php b/src/Contracts/Monitoring/ReportEntry.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace Resiliency\Contracts\Monitoring;
+
+use Resiliency\Contracts\CircuitBreaker;
+use Resiliency\Contracts\Service;
+
+/**
+ * A report entry store information used to generate a report
+ * about Circuit Breaker activity over time.
+ */
+interface ReportEntry
+{
+    /**
+     * @return Service the service called
+     */
+    public function getService(): Service;
+
+    /**
+     * @return CircuitBreaker the circuit breaker used
+     */
+    public function getCircuitBreaker(): CircuitBreaker;
+
+    /**
+     * @return string the current transition of the circuit breaker
+     */
+    public function getTransition(): string;
+}
diff --git a/src/Monitors/SimpleMonitor.php b/src/Monitors/SimpleMonitor.php
@@ -0,0 +1,42 @@
+<?php
+
+namespace Resiliency\Monitors;
+
+use Resiliency\Contracts\Monitoring\Monitor;
+use Resiliency\Contracts\Monitoring\Report;
+use Resiliency\Contracts\Event;
+
+final class SimpleMonitor implements Monitor
+{
+    /**
+     * @var Report the report
+     */
+    private $report;
+
+    public function __construct()
+    {
+        $this->report = new SimpleReport();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function collect(Event $event): void
+    {
+        $reportEntry = new SimpleReportEntry(
+            $event->getService(),
+            $event->getCircuitBreaker(),
+            get_class($event)
+        );
+
+        $this->report->add($reportEntry);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getReport(): Report
+    {
+        return $this->report;
+    }
+}
diff --git a/src/Monitors/SimpleReport.php b/src/Monitors/SimpleReport.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace Resiliency\Monitors;
+
+use Resiliency\Contracts\Monitoring\Report;
+use Resiliency\Contracts\Monitoring\ReportEntry;
+
+final class SimpleReport implements Report
+{
+    /**
+     * @var array the report entries
+     */
+    private $reportEntries;
+
+    public function __construct()
+    {
+        $this->reportEntries = [];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function add(ReportEntry $reportEntry): Report
+    {
+        $this->reportEntries[] = $reportEntry;
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function all(): array
+    {
+        return $this->reportEntries;
+    }
+}
diff --git a/src/Monitors/SimpleReportEntry.php b/src/Monitors/SimpleReportEntry.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace Resiliency\Monitors;
+
+use Resiliency\Contracts\CircuitBreaker;
+use Resiliency\Contracts\Monitoring\ReportEntry;
+use Resiliency\Contracts\Service;
+
+final class SimpleReportEntry implements ReportEntry
+{
+    /**
+     * @var Service the Service called
+     */
+    private $service;
+
+    /**
+     * @var CircuitBreaker the Circuit Breaker called
+     */
+    private $circuitBreaker;
+
+    /**
+     * @var string the Circuit Breaker transition
+     */
+    private $transition;
+
+    public function __construct(Service $service, CircuitBreaker $circuitBreaker, string $transition)
+    {
+        $this->service = $service;
+        $this->circuitBreaker = $circuitBreaker;
+        $this->transition = $transition;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getService(): Service
+    {
+        return $this->service;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getCircuitBreaker(): CircuitBreaker
+    {
+        return $this->circuitBreaker;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getTransition(): string
+    {
+        return $this->transition;
+    }
+}
diff --git a/tests/CircuitBreakerTestCase.php b/tests/CircuitBreakerTestCase.php
@@ -29,7 +29,8 @@ protected function getTestClient(): GuzzleClient
     {
         $mock = new MockHandler([
             new RequestException('Service unavailable', new Request('GET', 'test')),
-            new RequestException('Service unavailable', new Request('GET', 'test')),
+            new RequestException('Service unavailable', new Request('GET', 'test1')),
+            new RequestException('Service unavailable', new Request('GET', 'test2')),
             new Response(200, [], '{"hello": "world"}'),
         ]);
 

diff --git a/tests/CircuitBreakerWorkflowTest.php b/tests/CircuitBreakerWorkflowTest.php
@@ -32,9 +32,9 @@ class CircuitBreakerWorkflowTest extends CircuitBreakerTestCase
      */
     public function testCircuitBreakerIsInClosedStateAtStart(): void
     {
-        $this->assertInstanceOf(Closed::class, $this->circuitBreaker->getState());
+        self::assertInstanceOf(Closed::class, $this->circuitBreaker->getState());
 
-        $this->assertSame(
+        self::assertSame(
             '{"uri": https://httpbin.org/get/foo"}',
             $this->circuitBreaker->call(
                 'https://httpbin.org/get/foo',
@@ -52,13 +52,13 @@ public function testCircuitBreakerIsInClosedStateAtStart(): void
     public function testCircuitBreakerWillBeOpenInCaseOfFailures(): void
     {
         // CLOSED
-        $this->assertInstanceOf(Closed::class, $this->circuitBreaker->getState());
+        self::assertInstanceOf(Closed::class, $this->circuitBreaker->getState());
         $response = $this->circuitBreaker->call('https://httpbin.org/get/foo', $this->createFallbackResponse());
-        $this->assertSame('{"uri": https://httpbin.org/get/foo"}', $response);
+        self::assertSame('{"uri": https://httpbin.org/get/foo"}', $response);
 
         //After two failed calls switch to OPEN state
-        $this->assertInstanceOf(Opened::class, $this->circuitBreaker->getState());
-        $this->assertSame(
+        self::assertInstanceOf(Opened::class, $this->circuitBreaker->getState());
+        self::assertSame(
             '{"uri": https://httpbin.org/get/foo"}',
             $this->circuitBreaker->call(
                 'https://httpbin.org/get/foo',
@@ -79,26 +79,40 @@ public function testCircuitBreakerWillBeOpenInCaseOfFailures(): void
     public function testOnceInHalfOpenModeServiceIsFinallyReachable(): void
     {
         // CLOSED - first call fails (twice)
-        $this->assertInstanceOf(Closed::class, $this->circuitBreaker->getState());
+        self::assertInstanceOf(Closed::class, $this->circuitBreaker->getState());
         $response = $this->circuitBreaker->call('https://httpbin.org/get/foo', $this->createFallbackResponse());
-        $this->assertSame('{"uri": https://httpbin.org/get/foo"}', $response);
-        $this->assertInstanceOf(Opened::class, $this->circuitBreaker->getState());
+        self::assertSame('{"uri": https://httpbin.org/get/foo"}', $response);
+        self::assertInstanceOf(Opened::class, $this->circuitBreaker->getState());
 
         // OPEN - no call to client
         $response = $this->circuitBreaker->call('https://httpbin.org/get/foo', $this->createFallbackResponse());
-        $this->assertSame('{"uri": https://httpbin.org/get/foo"}', $response);
-        $this->assertInstanceOf(Opened::class, $this->circuitBreaker->getState());
+        self::assertSame('{"uri": https://httpbin.org/get/foo"}', $response);
+        self::assertInstanceOf(Opened::class, $this->circuitBreaker->getState());
         $this->waitFor(2 * self::OPEN_THRESHOLD);
 
         // SWITCH TO HALF OPEN and retry to call the service (still in failure)
-        $this->assertSame(
+        self::assertSame(
+            '{"uri": https://httpbin.org/get/foo"}',
+            $this->circuitBreaker->call(
+                'https://httpbin.org/get/foo',
+                $this->createFallbackResponse()
+            )
+        );
+
+        // SWITCH BACK TO OPENED
+        self::assertInstanceOf(Opened::class, $this->circuitBreaker->getState());
+
+        $this->waitFor(2 * self::OPEN_THRESHOLD);
+
+        // FINALLY, THE RESPONSE IS AVAILABLE
+        self::assertSame(
             '{"hello": "world"}',
             $this->circuitBreaker->call(
                 'https://httpbin.org/get/foo',
                 $this->createFallbackResponse()
             )
         );
-        $this->assertInstanceOf(Closed::class, $this->circuitBreaker->getState());
+        self::assertInstanceOf(Closed::class, $this->circuitBreaker->getState());
     }
 
     /**
@@ -114,20 +128,20 @@ public function testOnceCircuitBreakerIsIsolatedNoTrialsAreDone(): void
         $this->circuitBreaker->isolate($uri);
 
         $response = $this->circuitBreaker->call($uri, $this->createFallbackResponse());
-        $this->assertSame('{"uri": https://httpbin.org/get/foo"}', $response);
-        $this->assertInstanceOf(Isolated::class, $this->circuitBreaker->getState());
+        self::assertSame('{"uri": https://httpbin.org/get/foo"}', $response);
+        self::assertInstanceOf(Isolated::class, $this->circuitBreaker->getState());
 
         // Let's do 5 calls!
 
         for ($i = 0; $i < 5; ++$i) {
             $this->circuitBreaker->call($uri, $this->createFallbackResponse());
-            $this->assertSame('{"uri": https://httpbin.org/get/foo"}', $response);
-            $this->assertInstanceOf(Isolated::class, $this->circuitBreaker->getState());
+            self::assertSame('{"uri": https://httpbin.org/get/foo"}', $response);
+            self::assertInstanceOf(Isolated::class, $this->circuitBreaker->getState());
         }
 
         $this->circuitBreaker->reset($uri);
 
-        $this->assertInstanceOf(Closed::class, $this->circuitBreaker->getState());
+        self::assertInstanceOf(Closed::class, $this->circuitBreaker->getState());
     }
 
     /**

diff --git a/tests/Clients/GuzzleClientTest.php b/tests/Clients/GuzzleClientTest.php
@@ -14,7 +14,7 @@ public function testRequestWorksAsExpected()
         $client = new GuzzleClient();
         $service = $this->getService('https://www.google.com', ['method' => 'GET']);
 
-        $this->assertNotNull($client->request($service, $this->createMock(Place::class)));
+        self::assertNotNull($client->request($service, $this->createMock(Place::class)));
     }
 
     public function testWrongRequestThrowsAnException()
@@ -35,7 +35,7 @@ public function testTheClientAcceptsHttpMethodOverride()
 
         $service = $this->getService('https://www.google.fr');
 
-        $this->assertEmpty(
+        self::assertEmpty(
             $client->request(
                 $service,
                 $this->createMock(Place::class)

diff --git a/tests/Events/TransitionEventTestCase.php b/tests/Events/TransitionEventTestCase.php
@@ -16,9 +16,9 @@ public function checkEventIsValid($className)
             $this->createService('bar', [])
         );
 
-        $this->assertInstanceOf(Event::class, $event);
-        $this->assertInstanceOf(Service::class, $event->getService());
-        $this->assertInstanceOf(CircuitBreaker::class, $event->getCircuitBreaker());
+        self::assertInstanceOf(Event::class, $event);
+        self::assertInstanceOf(Service::class, $event->getService());
+        self::assertInstanceOf(CircuitBreaker::class, $event->getCircuitBreaker());
     }
 
     /**