Upgrades OpenTracing to 1.0.0-beta4.

composer.json

@@ -18,7 +18,7 @@
     "minimum-stability": "dev",
     "require": {
         "php": "^5.6||^7.0",
-        "opentracing/opentracing": "1.0.0-beta2",
+        "opentracing/opentracing": "1.0.0-beta4",
         "symfony/polyfill": "~1.7.0",
         "guzzlehttp/psr7": "^1.4@dev",
         "psr/log": "^1.0@dev"
@@ -43,7 +43,7 @@
         }
     },
     "provide": {
-        "opentracing/opentracing": "1.0.0-beta2"
+        "opentracing/opentracing": "1.0.0-beta4"
     },
     "scripts": {
         "test": [

src/DDTrace/Scope.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace DDTrace;
+
+use OpenTracing\Scope as OpenTracingScope;
+
+final class Scope implements OpenTracingScope
+{
+    /**
+     * @var Span
+     */
+    private $span;
+
+    /**
+     * @var ScopeManager
+     */
+    private $scopeManager;
+
+    public function __construct(ScopeManager $scopeManager, Span $span)
+    {
+        $this->scopeManager = $scopeManager;
+        $this->span = $span;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function close()
+    {
+        $this->scopeManager->deactivate($this);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSpan()
+    {
+        return $this->span;
+    }
+}

src/DDTrace/ScopeManager.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace DDTrace;
+
+use OpenTracing\Scope as OpenTracingScope;
+use OpenTracing\ScopeManager as OpenTracingScopeManager;
+use OpenTracing\Span as OpenTracingSpan;
+
+final class ScopeManager implements OpenTracingScopeManager
+{
+    /**
+     * @var array|OpenTracingScope[]
+     */
+    private $scopes = [];
+
+    /**
+     * {@inheritdoc}
+     * @param Span|OpenTracingSpan $span
+     */
+    public function activate(OpenTracingSpan $span)
+    {
+        $this->scopes[] = new Scope($this, $span);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getActive()
+    {
+        if (empty($this->scopes)) {
+            return null;
+        }
+
+        return $this->scopes[count($this->scopes) - 1];
+    }
+
+    /**
+     * {@inheritdoc}
+     * @param Span $span
+     */
+    public function getScope(OpenTracingSpan $span)
+    {
+        $scopeLength = count($this->scopes);
+
+        for ($i = 0; $i < $scopeLength; $i++) {
+            if ($span === $this->scopes[$i]->getSpan()) {
+                return $this->scopes[$i];
+            }
+        }
+
+        return null;
+    }
+
+    public function deactivate(Scope $scope)
+    {
+        $scopeLength = count($this->scopes);
+
+        for ($i = 0; $i < $scopeLength; $i++) {
+            if ($scope === $this->scopes[$i]) {
+                unset($this->scopes[$i]);
+            }
+        }
+    }
+}

src/DDTrace/Span.php

@@ -2,6 +2,7 @@
 
 namespace DDTrace;
 
+use BadMethodCallException;
 use DDTrace\Exceptions\InvalidSpanArgument;
 use Exception;
 use InvalidArgumentException;
@@ -174,34 +175,32 @@ public function getDuration()
     /**
      * {@inheritdoc}
      */
-    public function setTags(array $tags)
+    public function setTag($key, $value)
     {
         if ($this->isFinished()) {
             return;
         }
 
-        foreach ($tags as $key => $value) {
-            if ($key !== (string) $key) {
-                throw InvalidSpanArgument::forTagKey($key);
-            }
-
-            if ($key === Tags\SERVICE_NAME) {
-                $this->service = $value;
-                continue;
-            }
+        if ($key !== (string) $key) {
+            throw InvalidSpanArgument::forTagKey($key);
+        }
 
-            if ($key === Tags\RESOURCE_NAME) {
-                $this->resource = $value;
-                continue;
-            }
+        if ($key === Tags\SERVICE_NAME) {
+            $this->service = $value;
+            return;
+        }
 
-            if ($key === Tags\SPAN_TYPE) {
-                $this->type = $value;
-                continue;
-            }
+        if ($key === Tags\RESOURCE_NAME) {
+            $this->resource = $value;
+            return;
+        }
 
-            $this->tags[$key] = (string) $value;
+        if ($key === Tags\SPAN_TYPE) {
+            $this->type = $value;
+            return;
         }
+
+        $this->tags[$key] = (string) $value;
     }
 
     /**
@@ -246,11 +245,9 @@ public function setError($error)
 
         if (($error instanceof Exception) || ($error instanceof Throwable)) {
             $this->hasError = true;
-            $this->setTags([
-                Tags\ERROR_MSG => $error->getMessage(),
-                Tags\ERROR_TYPE => get_class($error),
-                Tags\ERROR_STACK => $error->getTraceAsString(),
-            ]);
+            $this->tags[Tags\ERROR_MSG] = $error->getMessage();
+            $this->tags[Tags\ERROR_TYPE] = get_class($error);
+            $this->tags[Tags\ERROR_STACK] = $error->getTraceAsString();
             return;
         }
 
@@ -265,7 +262,7 @@ public function hasError()
     /**
      * {@inheritdoc}
      */
-    public function finish($finishTime = null, array $logRecords = [])
+    public function finish($finishTime = null)
     {
         if ($this->isFinished()) {
             return;
@@ -313,7 +310,7 @@ public function getContext()
      */
     public function log(array $fields = [], $timestamp = null)
     {
-        throw new \BadMethodCallException('not implemented');
+        throw new BadMethodCallException('not implemented');
     }
 
     /**

src/DDTrace/Tracer.php

@@ -52,6 +52,11 @@ final class Tracer implements OpenTracingTracer
         'global_tags' => [],
     ];
 
+    /**
+     * @var ScopeManager
+     */
+    private $scopeManager;
+
     /**
      * Tracer constructor.
      * @param Transport $transport
@@ -64,6 +69,7 @@ public function __construct(Transport $transport = null, array $propagators = nu
         $this->propagators = $propagators ?: [
             Formats\TEXT_MAP => new TextMap(),
         ];
+        $this->scopeManager = new ScopeManager();
         $this->config = array_merge($this->config, $config);
     }
 
@@ -109,13 +115,37 @@ public function startSpan($operationName, $options = [])
             $options->getStartTime()
         );
 
-        $span->setTags($options->getTags() + $this->config['global_tags']);
+        $tags = $options->getTags() + $this->config['global_tags'];
+
+        foreach ($tags as $key => $value) {
+            $span->setTag($key, $value);
+        }
 
         $this->record($span);
 
         return $span;
     }
 
+    /**
+     * {@inheritdoc}
+     */
+    public function startActiveSpan($operationName, $options = [])
+    {
+        if (!($options instanceof SpanOptions)) {
+            $options = SpanOptions::create($options);
+        }
+
+        if (($activeSpan = $this->getActiveSpan()) !== null) {
+            $options = $options->withParent($activeSpan);
+        }
+
+        $span = $this->startSpan($operationName, $options);
+
+        $this->scopeManager->activate($span);
+
+        return $span;
+    }
+
     /**
      * @param array|Reference[] $references
      * @return null|Reference
@@ -173,7 +203,27 @@ public function flush()
 
         $this->transport->send($tracesToBeSent);
     }
-
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getScopeManager()
+    {
+        return $this->scopeManager;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getActiveSpan()
+    {
+        if (null !== ($activeScope = $this->scopeManager->getActive())) {
+            return $activeScope->getSpan();
+        }
+
+        return null;
+    }
+
     private function shiftFinishedTraces()
     {
         $tracesToBeSent = [];
@@ -196,7 +246,7 @@ private function shiftFinishedTraces()
             $tracesToBeSent[] = $traceToBeSent;
             unset($this->traces[$traceToBeSent[0]->getTraceId()]);
         }
-        
+
         return $tracesToBeSent;
     }
 

tests/Unit/ScopeManagerTest.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace DDTrace\Tests\Unit;
+
+use DDTrace\ScopeManager;
+use DDTrace\Tracer;
+use DDTrace\Transport\Noop as NoopTransport;
+use PHPUnit_Framework_TestCase;
+
+final class ScopeManagerTest extends PHPUnit_Framework_TestCase
+{
+    const OPERATION_NAME = 'test_name';
+
+    public function testGetActiveFailsWithNoActiveSpans()
+    {
+        $scopeManager = new ScopeManager();
+        $this->assertNull($scopeManager->getActive());
+    }
+
+    public function testActivateSuccess()
+    {
+        $tracer = new Tracer(new NoopTransport);
+        $span = $tracer->startSpan(self::OPERATION_NAME);
+        $scopeManager = new ScopeManager();
+        $scopeManager->activate($span);
+        $this->assertSame($span, $scopeManager->getActive()->getSpan());
+    }
+
+    public function testGetScopeReturnsNull()
+    {
+        $tracer = new Tracer(new NoopTransport);
+        $span = $tracer->startSpan(self::OPERATION_NAME);
+        $scopeManager = new ScopeManager();
+        $this->assertNull($scopeManager->getScope($span));
+    }
+
+    public function testGetScopeSuccess()
+    {
+        $tracer = new Tracer(new NoopTransport);
+        $span = $tracer->startSpan(self::OPERATION_NAME);
+        $scopeManager = new ScopeManager();
+        $scopeManager->activate($span);
+        $scope = $scopeManager->getScope($span);
+        $this->assertSame($span, $scope->getSpan());
+    }
+
+    public function testDeactivateSuccess()
+    {
+        $tracer = new Tracer(new NoopTransport);
+        $span = $tracer->startSpan(self::OPERATION_NAME);
+        $scopeManager = new ScopeManager();
+        $scopeManager->activate($span);
+        $scope = $scopeManager->getScope($span);
+        $scopeManager->deactivate($scope);
+        $this->assertNull($scopeManager->getActive());
+    }
+}