Add span manager, rework interaction with tracer

Author: allflame

src/Span/Span.php

@@ -8,7 +8,7 @@
 use Jaeger\Tag\OutOfScopeTag;
 use Jaeger\Thrift\Log;
 use Jaeger\Thrift\Tag;
-use Jaeger\Tracer\TracerInterface;
+use Jaeger\Tracer\FinishableInterface;
 
 class Span extends \Jaeger\Thrift\Span implements SpanInterface
 {
@@ -17,7 +17,7 @@ class Span extends \Jaeger\Thrift\Span implements SpanInterface
     private $context;
 
     public function __construct(
-        TracerInterface $tracer,
+        FinishableInterface $tracer,
         SpanContext $context,
         string $operationName,
         int $startTime,
@@ -67,12 +67,9 @@ public function start(int $startTimeUsec): SpanInterface
 
     public function finish(int $durationUsec = 0): SpanInterface
     {
-        if (0 === $durationUsec) {
-            $durationUsec = (int)(microtime(true) * 1000000) - $this->startTime;
-        }
-        $this->duration = $durationUsec;
+        $this->duration = $durationUsec ?: (microtime(true) * 1000000) - $this->startTime;
 
-        return $this;
+        return $this->tracer->finish($this, -1);
     }
 
     public function addTag(Tag $tag): SpanInterface

src/Span/SpanManager.php

@@ -0,0 +1,81 @@
+<?php
+declare(strict_types=1);
+
+namespace Jaeger\Span;
+
+use Jaeger\Span\Context\ContextAwareInterface;
+use Jaeger\Span\Context\SpanContext;
+use Jaeger\Tracer\InjectableInterface;
+use Jaeger\Tracer\ResettableInterface;
+
+class SpanManager implements InjectableInterface, ContextAwareInterface, ResettableInterface
+{
+    private $stack;
+
+    private $context;
+
+    public function __construct()
+    {
+        $this->stack = new \SplStack();
+    }
+
+    /**
+     * @return self
+     */
+    public function reset(): ResettableInterface
+    {
+        $this->stack = new \SplStack();
+
+        return $this;
+    }
+
+    /**
+     * @param SpanContext $context
+     *
+     * @return self
+     */
+    public function assign(SpanContext $context): InjectableInterface
+    {
+        $this->context = $context;
+
+        return $this->reset();
+    }
+
+    /**
+     * @param SpanContext $context
+     *
+     * @return self
+     */
+    public function remove(SpanContext $context): InjectableInterface
+    {
+        while ($this->stack->valid()) {
+            if (spl_object_hash($this->stack->top()) !== spl_object_hash($context)) {
+                $this->stack->pop();
+                continue;
+            }
+            break;
+        }
+
+        return $this;
+    }
+
+    public function getSpan(): ?SpanInterface
+    {
+        return $this->stack->count() ? $this->stack->top() : null;
+    }
+
+    public function push(SpanInterface $span): void
+    {
+        $this->stack->push($span);
+    }
+
+    public function pop(): ?SpanInterface
+    {
+        return $this->stack->count() ? $this->stack->pop() : null;
+    }
+
+    public function getContext(): ?SpanContext
+    {
+        return ($span = $this->getSpan()) ? $span->getContext() : $this->context;
+    }
+}

src/Tracer/FinishableInterface.php

@@ -0,0 +1,21 @@
+<?php
+declare(strict_types=1);
+
+namespace Jaeger\Tracer;
+
+use Jaeger\Span\SpanInterface;
+
+/**
+ * Interface FinishableInterface
+ * @internal use SpanInterface::finish(int $duration = 0)
+ */
+interface FinishableInterface
+{
+    /**
+     * @param SpanInterface $span
+     * @param int           $duration
+     *
+     * @return mixed
+     */
+    public function finish(SpanInterface $span, int $duration = 0): void;
+}

src/Tracer/Tracer.php

@@ -8,25 +8,27 @@
 use Jaeger\Span\Context\SpanContext;
 use Jaeger\Span\Factory\SpanFactoryInterface;
 use Jaeger\Span\SpanInterface;
-
-class Tracer implements TracerInterface,
-                        ContextAwareInterface,
-                        InjectableInterface,
-                        FlushableInterface,
-                        ResettableInterface,
-                        DebuggableInterface
+use Jaeger\Span\SpanManager;
+
+class Tracer implements
+    TracerInterface,
+    ContextAwareInterface,
+    InjectableInterface,
+    FlushableInterface,
+    ResettableInterface,
+    DebuggableInterface
 {
-    private $stack;
+    private $manager;
 
     private $debugId = '';
 
     private $factory;
 
     private $client;
 
-    public function __construct(\SplStack $stack, SpanFactoryInterface $factory, ClientInterface $client)
+    public function __construct(SpanManager $manager, SpanFactoryInterface $factory, ClientInterface $client)
     {
-        $this->stack = $stack;
+        $this->manager = $manager;
         $this->factory = $factory;
         $this->client = $client;
     }
@@ -54,27 +56,21 @@ public function flush(): FlushableInterface
 
     public function assign(SpanContext $context): InjectableInterface
     {
-        $this->stack->push($context);
+        $this->manager->assign($context);
 
         return $this;
     }
 
     public function reset(): ResettableInterface
     {
-        $this->stack = new \SplStack();
+        $this->manager->reset();
 
         return $this;
     }
 
     public function remove(SpanContext $context): InjectableInterface
     {
-        while ($this->stack->valid()) {
-            if (spl_object_hash($this->stack->top()) !== spl_object_hash($context)) {
-                $this->stack->pop();
-                continue;
-            }
-            break;
-        }
+        $this->manager->remove($context);
 
         return $this;
     }
@@ -87,45 +83,39 @@ public function getClient(): ClientInterface
     public function debug(string $operationName, array $tags = []): SpanInterface
     {
         $span = $this->factory->parent($this, $operationName, str_shuffle('01234567890abcdef'), $tags);
-        $this->stack->push($span->getContext());
+        $this->manager->push($span);
 
         return $span;
     }
 
     public function start(string $operationName, array $tags = [], SpanContext $userContext = null): SpanInterface
     {
-        if (null === ($context = $this->getContext($userContext))) {
+        if (null === ($context = $userContext ?: $this->manager->getContext())) {
             $span = $this->factory->parent($this, $operationName, $this->debugId, $tags);
         } else {
             $span = $this->factory->child($this, $operationName, $context, $tags);
         }
-        $this->stack->push($span->getContext());
+        $this->manager->push($span);
 
         return $span;
     }
 
     public function getContext(SpanContext $userContext = null): ?SpanContext
     {
-        if (null !== $userContext) {
-            return $userContext;
-        }
-        if (0 !== $this->stack->count()) {
-            return $this->stack->top();
-        }
-
-        return null;
+        return $this->manager->getContext();
     }
 
-    public function finish(SpanInterface $span, int $duration = 0): TracerInterface
+    public function finish(SpanInterface $span, int $duration = 0): void
     {
-        if (0 !== $this->stack->count()) {
-            $this->stack->pop();
+        if (-1 !== $duration) {
+            $span->finish($duration);
+
+            return;
         }
-        if (false === $span->finish($duration)->isSampled()) {
-            return $this;
+        $this->manager->pop();
+        if (false === $span->isSampled()) {
+            return;
         }
         $this->client->add($span);
-
-        return $this;
     }
 }

src/Tracer/TracerInterface.php

@@ -6,9 +6,7 @@
 use Jaeger\Span\Context\SpanContext;
 use Jaeger\Span\SpanInterface;
 
-interface TracerInterface
+interface TracerInterface extends FinishableInterface
 {
     public function start(string $operationName, array $tags = [], SpanContext $context = null): SpanInterface;
-
-    public function finish(SpanInterface $span, int $duration = 0);
 }