add sessionid for downstream event processors

Author: modethirteen

composer.json

@@ -17,7 +17,8 @@
     "php": "^7.2.0",
     "psr/event-dispatcher": "^1.0.0",
     "psr/simple-cache": "^1.0.1",
-    "symfony/event-dispatcher-contracts": "^2.2.0"
+    "symfony/event-dispatcher-contracts": "^2.2.0",
+    "ramsey/uuid": "~4.1.1"
   },
   "require-dev": {
     "phpstan/phpstan": "~0.12.0",

src/CacheBuilder.php

@@ -21,6 +21,8 @@
 use Psr\EventDispatcher\EventDispatcherInterface;
 use Psr\SimpleCache\CacheException;
 use Psr\SimpleCache\CacheInterface;
+use Ramsey\Uuid\UuidFactory;
+use Ramsey\Uuid\UuidFactoryInterface;
 
 class CacheBuilder implements ICacheBuilder {
 
@@ -74,12 +76,23 @@ class CacheBuilder implements ICacheBuilder {
      */
     private $lazyDispatcher;
 
+    /**
+     * @var UuidFactoryInterface
+     */
+    private $uuidFactory;
+
+    /**
+     * @var string|null
+     */
+    private $sessionId = null;
+
     /**
      * Creates an instance with a simple build/cache validators that check results for null
      *
      * @note it is intended that references in this instance are maintained when the instance is cloned
+     * @param UuidFactoryInterface|null $uuidFactory - an optional uuid generation override to control automatic session ids
      */
-    public function __construct() {
+    public function __construct(?UuidFactoryInterface $uuidFactory = null) {
         $this->buildValidator = function($result) : bool {
             return $result !== null;
         };
@@ -99,59 +112,64 @@ public function dispatch(object $event) : object {
                 }
             };
         };
+        $this->uuidFactory = $uuidFactory ?? new UuidFactory();
+    }
+
+    public function __clone() {
+        $this->sessionId = null;
     }
 
     public function get() {
         if($this->getCache() !== null) {
-            $this->dispatch(new Event(Event::CACHE_GET_START));
+            $this->dispatch($this->newEvent(Event::CACHE_GET_START));
             $key = $this->getCacheKey();
             try {
                 $result = $key !== null ? $this->cache->get($key) : null;
             } catch(CacheException $e) {
-                $this->dispatch((new Event(Event::CACHE_GET_ERROR))->withCacheException($e));
+                $this->dispatch($this->newEvent(Event::CACHE_GET_ERROR)->withCacheException($e));
                 $result = null;
             }
             $cacheValidator = $this->cacheValidator;
             if($cacheValidator($result) === true) {
-                $this->dispatch(new Event(Event::CACHE_GET_HIT));
+                $this->dispatch($this->newEvent(Event::CACHE_GET_HIT));
                 return $result;
             }
-            $this->dispatch(new Event(Event::CACHE_GET_MISS));
+            $this->dispatch($this->newEvent(Event::CACHE_GET_MISS));
         }
         if($this->builder === null) {
             return null;
         }
-        $this->dispatch(new Event(Event::BUILD_START));
+        $this->dispatch($this->newEvent(Event::BUILD_START));
         $builder = $this->builder;
         try {
             $result = $builder();
         } catch(Exception $e) {
-            $this->dispatch((new Event(Event::BUILD_ERROR))->withBuildException($e));
+            $this->dispatch($this->newEvent(Event::BUILD_ERROR)->withBuildException($e));
             $result = null;
         }
         $buildValidator = $this->buildValidator;
         if($buildValidator($result) === true) {
-            $this->dispatch(new Event(Event::BUILD_SUCCESS));
+            $this->dispatch($this->newEvent(Event::BUILD_SUCCESS));
 
             // the cache key used for setting a value may be different than the key used to get a value if upstream
             // ...dependencies and state have changed - to be safe, we regenerate the key
             $this->isCacheKeyStale = true;
             $key = $this->getCacheKey();
             if($this->getCache() !== null && $key !== null) {
                 $cacheLifespanBuilder = $this->cacheLifespanBuilder;
-                $this->dispatch(new Event(Event::CACHE_SET_START));
+                $this->dispatch($this->newEvent(Event::CACHE_SET_START));
                 try {
                     if($this->cache->set($key, $result, $cacheLifespanBuilder($result))) {
-                        $this->dispatch(new Event(Event::CACHE_SET_SUCCESS));
+                        $this->dispatch($this->newEvent(Event::CACHE_SET_SUCCESS));
                     } else {
-                        $this->dispatch(new Event(Event::CACHE_SET_FAIL));
+                        $this->dispatch($this->newEvent(Event::CACHE_SET_FAIL));
                     }
                 } catch(CacheException $e) {
-                    $this->dispatch((new Event(Event::CACHE_SET_ERROR))->withCacheException($e));
+                    $this->dispatch($this->newEvent(Event::CACHE_SET_ERROR)->withCacheException($e));
                 }
             }
         } else {
-            $this->dispatch(new Event(Event::BUILD_FAIL));
+            $this->dispatch($this->newEvent(Event::BUILD_FAIL));
         }
         return $result;
     }
@@ -169,6 +187,13 @@ public function getCacheKey() : ?string {
         return $this->cacheKey;
     }
 
+    public function getSessionId() : string {
+        if($this->sessionId === null) {
+            $this->sessionId = $this->uuidFactory->uuid4()->toString();
+        }
+        return $this->sessionId;
+    }
+
     public function withBuildValidator(Closure $validator) : ICacheBuilder {
         $instance = clone $this;
         $instance->buildValidator = $validator;
@@ -213,6 +238,12 @@ public function withLazyEventDispatcher(Closure $dispatcher) : ICacheBuilder {
         return $instance;
     }
 
+    public function withSessionId(string $sessionId) : ICacheBuilder {
+        $instance = clone $this;
+        $instance->sessionId = $sessionId;
+        return $instance;
+    }
+
     /**
      * @param Event $event
      */
@@ -226,4 +257,12 @@ private function dispatch(Event $event) : void {
         }
         $this->dispatcher->dispatch($event);
     }
+
+    /**
+     * @param string $message
+     * @return Event
+     */
+    private function newEvent(string $message) : Event {
+        return new Event($message, $this->getSessionId());
+    }
 }

src/Event.php

@@ -60,11 +60,18 @@ class Event extends \Symfony\Contracts\EventDispatcher\Event implements Stoppabl
      */
     private $message;
 
+    /**
+     * @var string
+     */
+    private $sessionId;
+
     /**
      * @param string $message
+     * @param string $sessionId
      */
-    public function __construct(string $message) {
+    public function __construct(string $message, string $sessionId) {
         $this->message = $message;
+        $this->sessionId = $sessionId;
     }
 
     /**
@@ -102,6 +109,13 @@ public function getMessage() : string {
         return $this->message;
     }
 
+    /**
+     * @return string
+     */
+    public function getSessionId() : string {
+        return $this->sessionId;
+    }
+
     /**
      * @param Exception $e
      * @return static

src/ICacheBuilder.php

@@ -37,6 +37,13 @@ function getCache() : ?CacheInterface;
      */
     function getCacheKey() : ?string;
 
+    /**
+     * Return the user defined session id or fallback to a random UUID v4
+     *
+     * @return string
+     */
+    function getSessionId() : string;
+
     /**
      * @param Closure $builder - <$builder() : mixed> : returns result to set in cache and return
      * @return ICacheBuilder
@@ -79,4 +86,10 @@ function withEventDispatcher(EventDispatcherInterface $dispatcher) : ICacheBuild
      * @return ICacheBuilder
      */
     function withLazyEventDispatcher(Closure $dispatcher) : ICacheBuilder;
+
+    /**
+     * @param string $sessionId - a user defined token to identify events in downstream processing
+     * @return ICacheBuilder
+     */
+    function withSessionId(string $sessionId) : ICacheBuilder;
 }