Merge 2a40bed into 93d6565

src/Handler/DefaultHandler.php

@@ -4,8 +4,20 @@
 
 class DefaultHandler implements Handler
 {
+    private $hasDistributedTracing;
+
+    public function __construct($hasDistributedTracing)
+    {
+        $this->hasDistributedTracing = $hasDistributedTracing;
+    }
+
     public function handle($functionName, array $arguments = array())
     {
         return call_user_func_array($functionName, $arguments);
     }
+
+    public function isDistributedTracingEnabled()
+    {
+        return $this->hasDistributedTracing;
+    }
 }

src/Handler/Handler.php

@@ -11,4 +11,9 @@ interface Handler
      * @return mixed
      */
     public function handle($functionName, array $arguments = array());
+
+    /**
+     * @return bool
+     */
+    public function isDistributedTracingEnabled();
 }

src/Handler/NullHandler.php

@@ -8,4 +8,9 @@ public function handle($functionName, array $arguments = array())
     {
         return false;
     }
+
+    public function isDistributedTracingEnabled()
+    {
+        return false;
+    }
 }

src/Newrelic.php

@@ -57,7 +57,7 @@ public function __construct($throw = false, Handler $handler = null)
         }
 
         if ($handler === null) {
-            $handler = $this->installed ? new DefaultHandler() : new NullHandler();
+            $handler = $this->installed ? new DefaultHandler(function_exists('newrelic_create_distributed_trace_payload')) : new NullHandler();
         }
 
         $this->handler = $handler;
@@ -377,6 +377,61 @@ public function recordCustomEvent($name, array $attributes)
         return $this->call('newrelic_record_custom_event', array($name, $attributes));
     }
 
+    /**
+     * Create a newrelic distributed trace payload.
+     * {@link https://docs.newrelic.com/docs/agents/php-agent/features/distributed-tracing-php#manual}
+     *
+     * @return newrelic\DistributedTracePayload|false
+     */
+    public function createDistributedTracePayload()
+    {
+        if ($this->handler->isDistributedTracingEnabled()) {
+            return $this->call('newrelic_create_distributed_trace_payload');
+        }
+
+        return false;
+    }
+
+    /**
+     * Accept a distributed trace payload.
+     *
+     * Generate a payload using:
+     * $payload = newrelic_create_distributed_trace_payload();
+     * $textPayload = $payload->Text();
+     *
+     * @param string $textPayload
+     *
+     * @return bool
+     */
+    public function acceptDistributedTracePayload($textPayload)
+    {
+        if ($this->handler->isDistributedTracingEnabled()) {
+            return $this->call('newrelic_accept_distributed_trace_payload', array($textPayload));
+        }
+
+        return false;
+    }
+
+    /**
+     * Accept a distributed trace http safe payload.
+     *
+     * Generate an http safe payload using:
+     * $payload = newrelic_create_distributed_trace_payload();
+     * $httpSafePayload = $payload->httpSafe();
+     *
+     * @param string $httpSafePayload
+     *
+     * @return bool
+     */
+    public function acceptDistributedTracePayloadHttpSafe($httpSafePayload)
+    {
+        if ($this->handler->isDistributedTracingEnabled()) {
+            return $this->call('newrelic_accept_distributed_trace_payload_httpsafe', array($httpSafePayload));
+        }
+
+        return false;
+    }
+
     /**
      * Call the named method with the given params.  Return false if the NewRelic PHP agent is not available.
      *

tests/Handler/DefaultHandlerTest.php

@@ -9,10 +9,11 @@ class DefaultHandlerTest extends TestCase
 {
     public function testImplementsInterface()
     {
-        $handler = new DefaultHandler();
+        $handler = new DefaultHandler(false);
 
         $this->assertInstanceOf('Intouch\Newrelic\Handler\Handler', $handler);
     }
+
     public function testHandleCallsFunctionWithArguments()
     {
         $functionName = 'strpos';
@@ -22,10 +23,24 @@ public function testHandleCallsFunctionWithArguments()
             0
         );
 
-        $handler = new DefaultHandler();
+        $handler = new DefaultHandler(false);
 
         $expected = call_user_func_array($functionName, $arguments);
 
         $this->assertSame($expected, $handler->handle($functionName, $arguments));
     }
+
+    public function testIsDistributedTracingEnabled()
+    {
+        $handler = new DefaultHandler(true);
+
+        $this->assertTrue($handler->isDistributedTracingEnabled());
+    }
+
+    public function testIsDistributedTracingEnabledFalse()
+    {
+        $handler = new DefaultHandler(false);
+
+        $this->assertFalse($handler->isDistributedTracingEnabled());
+    }
 }

tests/Handler/NullHandlerTest.php

@@ -27,4 +27,11 @@ public function testHandleReturnsFalse()
 
         $this->assertFalse($handler->handle($functionName, $arguments));
     }
+
+    public function testIsDistributedTracingEnabledReturnsFalse()
+    {
+        $handler = new NullHandler();
+
+        $this->assertFalse($handler->isDistributedTracingEnabled());
+    }
 }

tests/NewrelicTest.php

@@ -400,6 +400,106 @@ public function testStartTransaction()
         $this->assertSame($result, $agent->startTransaction($name, $licence));
     }
 
+    public function testCreateDistributedTracePayload()
+    {
+        $result = true;
+
+        $handler = $this->getHandlerSpy(
+            'newrelic_create_distributed_trace_payload',
+            array(),
+            $result
+        );
+        $handler->expects($this->once())
+            ->method('isDistributedTracingEnabled')
+            ->willReturn(true);
+
+        $agent = new Newrelic(false, $handler);
+
+        $this->assertSame($result, $agent->createDistributedTracePayload());
+    }
+
+    public function testCreateDistributedTracePayloadNotEnabled()
+    {
+        $handler = $this->getHandlerMock();
+        $handler->expects($this->once())
+            ->method('isDistributedTracingEnabled')
+            ->willReturn(false);
+
+        $agent = new Newrelic(false, $handler);
+
+        $this->assertFalse($agent->createDistributedTracePayload());
+    }
+
+    public function testAcceptDistributedTracePayload()
+    {
+        $payload = 'payload';
+        $result = true;
+
+        $handler = $this->getHandlerSpy(
+            'newrelic_accept_distributed_trace_payload',
+            array(
+                $payload,
+            ),
+            $result
+        );
+        $handler->expects($this->once())
+            ->method('isDistributedTracingEnabled')
+            ->willReturn(true);
+
+        $agent = new Newrelic(false, $handler);
+
+        $this->assertSame($result, $agent->acceptDistributedTracePayload($payload));
+    }
+
+    public function testAcceptDistributedTracePayloadNotEnabled()
+    {
+        $payload = 'payload';
+
+        $handler = $this->getHandlerMock();
+        $handler->expects($this->once())
+            ->method('isDistributedTracingEnabled')
+            ->willReturn(false);
+
+        $agent = new Newrelic(false, $handler);
+
+        $this->assertFalse($agent->acceptDistributedTracePayload($payload));
+    }
+
+    public function testAcceptDistributedTracePayloadHttpSafe()
+    {
+        $payload = 'payload';
+        $result = true;
+
+        $handler = $this->getHandlerSpy(
+            'newrelic_accept_distributed_trace_payload_httpsafe',
+            array(
+                $payload,
+            ),
+            $result
+        );
+        $handler->expects($this->once())
+            ->method('isDistributedTracingEnabled')
+            ->willReturn(true);
+
+        $agent = new Newrelic(false, $handler);
+
+        $this->assertSame($result, $agent->acceptDistributedTracePayloadHttpSafe($payload));
+    }
+
+    public function testAcceptDistributedTracePayloadHttpSafeNotEnabled()
+    {
+        $payload = 'payload';
+
+        $handler = $this->getHandlerMock();
+        $handler->expects($this->once())
+            ->method('isDistributedTracingEnabled')
+            ->willReturn(false);
+
+        $agent = new Newrelic(false, $handler);
+
+        $this->assertFalse($agent->acceptDistributedTracePayloadHttpSafe($payload));
+    }
+
     /**
      * @return bool
      */