├── .gitignore
├── src
    └── OpenTracing
    │   ├── Exception.php
    │   ├── Exception
    │       ├── OpenTracingException.php
    │       ├── EmptyCarrierException.php
    │       ├── InvalidFormatException.php
    │       ├── InvalidCarrierException.php
    │       └── CorruptedCarrierException.php
    │   ├── Propagation.php
    │   ├── Format.php
    │   ├── Tag.php
    │   ├── SplitBinaryCarrier.php
    │   ├── SplitTextCarrier.php
    │   ├── Stub
    │       ├── Tracer.php
    │       └── Span.php
    │   ├── Tracer.php
    │   └── Span.php
├── README.md
├── composer.json
└── LICENSE.md


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | vendor/
3 | composer.phar
4 | composer.lock
5 | 


--------------------------------------------------------------------------------
/src/OpenTracing/Exception.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace OpenTracing;
4 | 
5 | 
6 | class Exception extends \Exception
7 | {
8 | 
9 | }


--------------------------------------------------------------------------------
/src/OpenTracing/Exception/OpenTracingException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace OpenTracing\Exception;
4 | 
5 | class OpenTracingException extends \Exception
6 | {
7 | 
8 | }


--------------------------------------------------------------------------------
/src/OpenTracing/Exception/EmptyCarrierException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace OpenTracing\Exception;
4 | 
5 | class EmptyCarrierException extends OpenTracingException
6 | {
7 | 
8 | }


--------------------------------------------------------------------------------
/src/OpenTracing/Exception/InvalidFormatException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace OpenTracing\Exception;
4 | 
5 | class InvalidFormatException extends OpenTracingException
6 | {
7 | 
8 | }


--------------------------------------------------------------------------------
/src/OpenTracing/Exception/InvalidCarrierException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace OpenTracing\Exception;
4 | 
5 | class InvalidCarrierException extends OpenTracingException
6 | {
7 | 
8 | }


--------------------------------------------------------------------------------
/src/OpenTracing/Exception/CorruptedCarrierException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace OpenTracing\Exception;
4 | 
5 | class CorruptedCarrierException extends OpenTracingException
6 | {
7 | 
8 | }


--------------------------------------------------------------------------------
/src/OpenTracing/Propagation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace OpenTracing;
 4 | 
 5 | 
 6 | class Propagation
 7 | {
 8 | 
 9 |     const SPLIT_TEXT = 'split_text';
10 |     const SPLIT_BINARY = 'split_binary';
11 | 
12 | }


--------------------------------------------------------------------------------
/src/OpenTracing/Format.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace OpenTracing;
 4 | 
 5 | class Format
 6 | {
 7 | 
 8 |     // @todo: add more info about supported carriers for the builtin formats
 9 | 
10 |     const SPLIT_TEXT = 'split_text';
11 |     const SPLIT_BINARY = 'split_binary';
12 | 
13 | }


--------------------------------------------------------------------------------
/src/OpenTracing/Tag.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace OpenTracing;
 4 | 
 5 | class Tag
 6 | {
 7 | 
 8 |     const PEER_SERVICE = "peer.service";
 9 |     const PEER_HOSTNAME = "peer.hostname";
10 |     const PEER_HOST_IPV4 = "peer.ipv4";
11 |     const PEER_HOST_IPV6 = "peer.ipv6";
12 |     const PEER_PORT = "peer.port";
13 | 
14 |     const SAMPLING_PRIORITY = "sampling.priority";
15 | 
16 |     const SPAN_KIND = 'span.kind';
17 |     const SPAN_KIND_RPC_SERVER = 's';
18 |     const SPAN_KIND_RPC_CLIENT = 'c';
19 | 
20 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | OpenTracing API for PHP
 2 | =======================
 3 | 
 4 | This package is an unofficial PHP platform API for OpenTracing.
 5 | 
 6 | ## Required Reading
 7 | 
 8 | In order to understand the Go platform API, one must first be familiar with the
 9 | [OpenTracing project](http://opentracing.io) and
10 | [terminology](http://opentracing.io/spec/) more generally.
11 | 
12 | ## Status
13 | 
14 | Current version: API unstable
15 | 
16 | In the current version, opentracing-php provides only the API and a
17 | basic no-op implementation that can be used by instrumentation libraries to
18 | collect and propagate distributed tracing context.
19 | 
20 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "wikia/opentracing-php",
 3 |   "description": "Unofficial implementation of http://opentracing.io/",
 4 |   "keywords": [
 5 |     "opentracing",
 6 |     "opentracing.io",
 7 |     "tracer",
 8 |     "span",
 9 |     "tracing",
10 |     "soa"
11 |   ],
12 |   "homepage": "https://github.com/Wikia/opentracing-php",
13 |   "type": "library",
14 |   "license": "MIT",
15 |   "authors": [
16 |     {
17 |       "name": "Władysław Bodzek",
18 |       "email": "wbodzek@o2.pl",
19 |       "homepage": "https://www.linkedin.com/in/w%C5%82adys%C5%82aw-bodzek-6b229b2",
20 |       "role": "Developer"
21 |     }
22 |   ],
23 |   "autoload": {
24 |     "psr-4": {
25 |       "OpenTracing\\": "src/OpenTracing/"
26 |     }
27 |   },
28 |   "extra": {
29 |     "branch-alias": {
30 |       "dev-master": "master"
31 |     }
32 |   }
33 | }


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | Copyright 2016: The OpenTracing Authors
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining
 4 | a copy of this software and associated documentation files (the
 5 | "Software"), to deal in the Software without restriction, including
 6 | without limitation the rights to use, copy, modify, merge, publish,
 7 | distribute, sublicense, and/or sell copies of the Software, and to
 8 | permit persons to whom the Software is furnished to do so, subject to
 9 | the following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/src/OpenTracing/SplitBinaryCarrier.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace OpenTracing;
 4 | 
 5 | class SplitBinaryCarrier
 6 | {
 7 | 
 8 |     /**
 9 |      * @var string
10 |      */
11 |     private $state = null;
12 |     /**
13 |      * @var string
14 |      */
15 |     private $baggage = null;
16 | 
17 |     /**
18 |      * Create new SplitBinaryCarrier and optionally initialize it
19 |      *
20 |      * @param string|null $state
21 |      * @param string|null $baggage
22 |      */
23 |     public function __construct($state = null, $baggage = null)
24 |     {
25 |         $this->state = $state;
26 |         $this->baggage = $baggage;
27 |     }
28 | 
29 |     /**
30 |      * @return string
31 |      */
32 |     public function getState()
33 |     {
34 |         return $this->state;
35 |     }
36 | 
37 |     /**
38 |      * @param string $state
39 |      * @return SplitBinaryCarrier
40 |      */
41 |     public function setState($state)
42 |     {
43 |         $this->state = $state;
44 | 
45 |         return $this;
46 |     }
47 | 
48 |     /**
49 |      * @return string
50 |      */
51 |     public function getBaggage()
52 |     {
53 |         return $this->baggage;
54 |     }
55 | 
56 |     /**
57 |      * @param string $baggage
58 |      * @return SplitBinaryCarrier
59 |      */
60 |     public function setBaggage($baggage)
61 |     {
62 |         $this->baggage = $baggage;
63 | 
64 |         return $this;
65 |     }
66 | 
67 | }


--------------------------------------------------------------------------------
/src/OpenTracing/SplitTextCarrier.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace OpenTracing;
 4 | 
 5 | class SplitTextCarrier
 6 | {
 7 |     /**
 8 |      * @var array
 9 |      */
10 |     private $state = null;
11 |     /**
12 |      * @var array
13 |      */
14 |     private $baggage = null;
15 | 
16 |     /**
17 |      * Create new SplitTextCarrier and optionally initialize it
18 |      *
19 |      * @param array|null $state
20 |      * @param array|null $baggage
21 |      */
22 |     public function __construct(array $state = null, array $baggage = null)
23 |     {
24 |         $this->state = $state;
25 |         $this->baggage = $baggage;
26 |     }
27 | 
28 |     /**
29 |      * @return array
30 |      */
31 |     public function getState()
32 |     {
33 |         return $this->state;
34 |     }
35 | 
36 |     /**
37 |      * @param array $state
38 |      * @return SplitTextCarrier
39 |      */
40 |     public function setState(array $state)
41 |     {
42 |         $this->state = $state;
43 | 
44 |         return $this;
45 |     }
46 | 
47 |     /**
48 |      * @return array
49 |      */
50 |     public function getBaggage()
51 |     {
52 |         return $this->baggage;
53 |     }
54 | 
55 |     /**
56 |      * @param array $baggage
57 |      * @return SplitTextCarrier
58 |      */
59 |     public function setBaggage(array $baggage)
60 |     {
61 |         $this->baggage = $baggage;
62 | 
63 |         return $this;
64 |     }
65 | 
66 | }


--------------------------------------------------------------------------------
/src/OpenTracing/Stub/Tracer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace OpenTracing\Stub;
 4 | 
 5 | use OpenTracing;
 6 | 
 7 | /**
 8 |  * Tracer is the entry point API between instrumentation code and the
 9 |  * tracing implementation.
10 |  *
11 |  * This implementation both defines the public Tracer API, and provides
12 |  * a default no-op behavior.
13 |  *
14 |  * @package OpenTracing
15 |  */
16 | class Tracer extends OpenTracing\Tracer
17 | {
18 |     private $noopSpan = null;
19 | 
20 |     public function __construct()
21 |     {
22 |         $this->noopSpan = new Span($this);
23 |     }
24 | 
25 |     /**
26 |      * Starts and returns a new Span representing a unit of work.
27 |      *
28 |      * @param string $operationName
29 |      * @param Span $parent
30 |      * @param array $tags
31 |      * @param float $startTime
32 |      * @return Span
33 |      */
34 |     public function startSpan($operationName = null, $parent = null, $tags = null, $startTime = null)
35 |     {
36 |         return $this->noopSpan;
37 |     }
38 | 
39 | 
40 |     /**
41 |      * Takes $span and injects it into $carrier.
42 |      *
43 |      * The actual type of $carrier depends on the $format.
44 |      *
45 |      * Implementations may raise implementation-specific exception
46 |      * if injection fails.
47 |      *
48 |      * @param OpenTracing\Span $span
49 |      * @param string $format
50 |      * @param mixed $carrier
51 |      * @throws \OpenTracing\Exception
52 |      */
53 |     public function inject(OpenTracing\Span $span, $format, &$carrier) {
54 |         // noop
55 |     }
56 | 
57 |     /**
58 |      * Returns a Span instance with operation name $operationName
59 |      * that's joined to the trace state embedded within $carrier, or null if
60 |      * no such trace state could be found.
61 |      *
62 |      * Implementations may raise implementation-specific errors
63 |      * if there are more fundamental problems with `carrier`.
64 |      *
65 |      * Upon success, the returned Span instance is already started.
66 |      *
67 |      * @param string $operationName
68 |      * @param string $format
69 |      * @param mixed $carrier
70 |      * @throws \OpenTracing\Exception
71 |      * @return OpenTracing\Span
72 |      */
73 |     public function join($operationName, $format, $carrier) {
74 |         return $this->noopSpan;
75 |     }
76 | 
77 | 
78 |     /**
79 |      * Flushes any trace data that may be buffered in memory, presumably
80 |      * out of the process.
81 |      *
82 |      * @return void
83 |      */
84 |     public function flush()
85 |     {
86 |         // noop
87 |     }
88 | }


--------------------------------------------------------------------------------
/src/OpenTracing/Tracer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace OpenTracing;
 4 | 
 5 | /**
 6 |  * Tracer is the entry point API between instrumentation code and the
 7 |  * tracing implementation.
 8 |  *
 9 |  * This implementation both defines the public Tracer API, and provides
10 |  * a default no-op behavior.
11 |  *
12 |  * @package OpenTracing
13 |  */
14 | abstract class Tracer
15 | {
16 |     /**
17 |      * @var Tracer
18 |      */
19 |     private static $globalTracerInstance = null;
20 | 
21 |     /**
22 |      * Starts and returns a new Span representing a unit of work.
23 |      *
24 |      * @param string $operationName
25 |      * @param Span $parent
26 |      * @param array $tags
27 |      * @param float $startTime
28 |      * @return Span
29 |      */
30 |     abstract public function startSpan($operationName = null, $parent = null, $tags = null, $startTime = null);
31 | 
32 |     /**
33 |      * Takes $span and injects it into $carrier.
34 |      *
35 |      * The actual type of $carrier depends on the $format.
36 |      *
37 |      * Implementations may raise implementation-specific exception
38 |      * if injection fails.
39 |      *
40 |      * @param Span $span
41 |      * @param string $format
42 |      * @param mixed $carrier
43 |      * @throws \OpenTracing\Exception
44 |      */
45 |     abstract public function inject(Span $span, $format, &$carrier);
46 | 
47 |     /**
48 |      * Returns a Span instance with operation name $operationName
49 |      * that's joined to the trace state embedded within $carrier, or null if
50 |      * no such trace state could be found.
51 |      *
52 |      * Implementations may raise implementation-specific errors
53 |      * if there are more fundamental problems with `carrier`.
54 |      *
55 |      * Upon success, the returned Span instance is already started.
56 |      *
57 |      * @param string $operationName
58 |      * @param string $format
59 |      * @param mixed $carrier
60 |      * @throws \OpenTracing\Exception
61 |      * @return Span
62 |      */
63 |     abstract public function join($operationName, $format, $carrier);
64 | 
65 |     /**
66 |      * Flushes any trace data that may be buffered in memory, presumably
67 |      * out of the process.
68 |      *
69 |      * @return void
70 |      */
71 |     abstract public function flush();
72 | 
73 |     /**
74 |      * Initialize the GlobalTracer singleton with the provided Tracer instance
75 |      *
76 |      * @param Tracer $tracer
77 |      */
78 |     public static final function setGlobalTracer(Tracer $tracer)
79 |     {
80 |         self::$globalTracerInstance = $tracer;
81 |     }
82 | 
83 |     /**
84 |      * Gets current GlobalTracer singleton.
85 |      *
86 |      * Returns stub tracer if not initialized yet.
87 |      *
88 |      * @return Tracer|null
89 |      */
90 |     public static final function getGlobalTracer()
91 |     {
92 |         if ( self::$globalTracerInstance === null ) {
93 |             self::$globalTracerInstance = new Stub\Tracer();
94 |         }
95 | 
96 |         return self::$globalTracerInstance;
97 |     }
98 | 
99 | }


--------------------------------------------------------------------------------
/src/OpenTracing/Span.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace OpenTracing;
  4 | 
  5 | /**
  6 |  * Span represents a unit of work executed on behalf of a trace. Examples of
  7 |  * spans include a remote procedure call, or a in-process method call to a
  8 |  * sub-component. A trace is required to have a single, top level "root"
  9 |  * span, and zero or more children spans, which in turns can have their own
 10 |  * children spans, thus forming a tree structure.
 11 |  *
 12 |  * @package OpenTracing
 13 |  */
 14 | abstract class Span
 15 | {
 16 |     /**
 17 |      * Sets or changes the operation name.
 18 |      *
 19 |      * @param string $operationName
 20 |      * @return $this
 21 |      */
 22 |     abstract public function setOperationName($operationName);
 23 | 
 24 |     /**
 25 |      * Indicates that the work represented by this span has been completed
 26 |      * or terminated, and is ready to be sent to the Reporter.
 27 |      *
 28 |      * If any tags / logs need to be added to the span, it should be done
 29 |      * before calling finish(), otherwise they may be ignored.
 30 |      *
 31 |      * @param float $finishTime
 32 |      */
 33 |     abstract public function finish($finishTime = null);
 34 | 
 35 |     /**
 36 |      * Attaches a key/value pair to the span.
 37 |      *
 38 |      * The set of supported value types is implementation specific. It is the
 39 |      * responsibility of the actual tracing system to know how to serialize
 40 |      * and record the values.
 41 |      *
 42 |      * If the user calls set_tag multiple times for the same key,
 43 |      * the behavior of the tracer is undefined, i.e. it is implementation
 44 |      * specific whether the tracer will retain the first value, or the last
 45 |      * value, or pick one randomly, or even keep all of them.
 46 |      *
 47 |      * @param string $key
 48 |      * @param mixed $value
 49 |      * @return $this
 50 |      */
 51 |     abstract public function setTag($key, $value);
 52 | 
 53 |     /**
 54 |      * Logs an event against the span, with the current timestamp.
 55 |      *
 56 |      * @param string $event
 57 |      * @param array $payload
 58 |      * @return $this
 59 |      */
 60 |     abstract public function logEvent($event, $payload = null);
 61 | 
 62 |     /**
 63 |      * Records a generic Log event at an arbitrary timestamp.
 64 |      *
 65 |      * @param float $timestamp
 66 |      * @param string $event
 67 |      * @param array $payload
 68 |      * @return $this
 69 |      */
 70 |     abstract public function log($timestamp, $event, $payload = null);
 71 | 
 72 |     /**
 73 |      * Stores Baggage Item in the span as a key/value pair.
 74 |      *
 75 |      * Enables powerful distributed context propagation functionality where
 76 |      * arbitrary application data can be carried along the full path of
 77 |      * request execution throughout the system.
 78 |      *
 79 |      * Note 1: baggage is only propagated to the future (recursive)
 80 |      * children of this Span.
 81 |      *
 82 |      * Note 2: baggage is sent in-band with every subsequent local and
 83 |      * remote calls, so this feature must be used with care.
 84 |      *
 85 |      * Note 3: keys are case-insensitive, to allow propagation via HTTP
 86 |      * headers. Keys must match regexp `(?i:[a-z0-9][-a-z0-9]*)`
 87 |      *
 88 |      * @param string $key
 89 |      * @param mixed $value
 90 |      * @return $this
 91 |      */
 92 |     abstract public function setBaggageItem($key, $value);
 93 | 
 94 |     /**
 95 |      * Retrieves value of the Baggage Item with the given key.
 96 |      *
 97 |      * Returns null if key doesn't exist.
 98 |      *
 99 |      * Key is case-insensitive.
100 |      *
101 |      * @param string $key
102 |      * @return mixed
103 |      */
104 |     abstract public function getBaggageItem($key);
105 | 
106 |     /**
107 |      * Provides access to the Tracer that created this Span.
108 |      *
109 |      * @return Tracer
110 |      */
111 |     abstract public function getTracer();
112 | 
113 |     /**
114 |      * A shorthand method that starts a child span given a parent span.
115 |      *
116 |      * @param string $operationName
117 |      * @param array $tags
118 |      * @param float $startTime
119 |      * @return Span
120 |      */
121 |     public final function startChild($operationName, $tags = null, $startTime = null)
122 |     {
123 |         return $this->getTracer()->startSpan($operationName, $this, $tags, $startTime);
124 |     }
125 | 
126 | }


--------------------------------------------------------------------------------
/src/OpenTracing/Stub/Span.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace OpenTracing\Stub;
  4 | 
  5 | use OpenTracing;
  6 | 
  7 | /**
  8 |  * Span represents a unit of work executed on behalf of a trace. Examples of
  9 |  * spans include a remote procedure call, or a in-process method call to a
 10 |  * sub-component. A trace is required to have a single, top level "root"
 11 |  * span, and zero or more children spans, which in turns can have their own
 12 |  * children spans, thus forming a tree structure.
 13 |  *
 14 |  * @package OpenTracing
 15 |  */
 16 | class Span extends OpenTracing\Span
 17 | {
 18 |     public function __construct(Tracer $tracer)
 19 |     {
 20 |         $this->tracer = $tracer;
 21 |     }
 22 | 
 23 |     /**
 24 |      * Sets or changes the operation name.
 25 |      *
 26 |      * @param string $operationName
 27 |      * @return $this
 28 |      */
 29 |     public function setOperationName($operationName)
 30 |     {
 31 |         return $this;
 32 |     }
 33 | 
 34 |     /**
 35 |      * Indicates that the work represented by this span has been completed
 36 |      * or terminated, and is ready to be sent to the Reporter.
 37 |      *
 38 |      * If any tags / logs need to be added to the span, it should be done
 39 |      * before calling finish(), otherwise they may be ignored.
 40 |      *
 41 |      * @param float $finishTime
 42 |      */
 43 |     public function finish($finishTime = null)
 44 |     {
 45 |         // noop
 46 |     }
 47 | 
 48 |     /**
 49 |      * Attaches a key/value pair to the span.
 50 |      *
 51 |      * The set of supported value types is implementation specific. It is the
 52 |      * responsibility of the actual tracing system to know how to serialize
 53 |      * and record the values.
 54 |      *
 55 |      * If the user calls set_tag multiple times for the same key,
 56 |      * the behavior of the tracer is undefined, i.e. it is implementation
 57 |      * specific whether the tracer will retain the first value, or the last
 58 |      * value, or pick one randomly, or even keep all of them.
 59 |      *
 60 |      * @param string $key
 61 |      * @param mixed $value
 62 |      * @return $this
 63 |      */
 64 |     public function setTag($key, $value)
 65 |     {
 66 |         return $this;
 67 |     }
 68 | 
 69 |     /**
 70 |      * Logs an event against the span, with the current timestamp.
 71 |      *
 72 |      * @param string $event
 73 |      * @param array $payload
 74 |      * @return $this
 75 |      */
 76 |     public function logEvent($event, $payload = null)
 77 |     {
 78 |         $this->log(null, $event, $payload);
 79 | 
 80 |         return $this;
 81 |     }
 82 | 
 83 |     /**
 84 |      * Records a generic Log event at an arbitrary timestamp.
 85 |      *
 86 |      * @param float $timestamp
 87 |      * @param string $event
 88 |      * @param array $payload
 89 |      * @return $this
 90 |      */
 91 |     public function log($timestamp, $event, $payload = null)
 92 |     {
 93 |         return $this;
 94 |     }
 95 | 
 96 |     /**
 97 |      * Stores Baggage Item in the span as a key/value pair.
 98 |      *
 99 |      * Enables powerful distributed context propagation functionality where
100 |      * arbitrary application data can be carried along the full path of
101 |      * request execution throughout the system.
102 |      *
103 |      * Note 1: baggage is only propagated to the future (recursive)
104 |      * children of this Span.
105 |      *
106 |      * Note 2: baggage is sent in-band with every subsequent local and
107 |      * remote calls, so this feature must be used with care.
108 |      *
109 |      * Note 3: keys are case-insensitive, to allow propagation via HTTP
110 |      * headers. Keys must match regexp `(?i:[a-z0-9][-a-z0-9]*)`
111 |      *
112 |      * @param string $key
113 |      * @param mixed $value
114 |      * @return $this
115 |      */
116 |     public function setBaggageItem($key, $value)
117 |     {
118 |         return $this;
119 |     }
120 | 
121 |     /**
122 |      * Retrieves value of the Baggage Item with the given key.
123 |      *
124 |      * Returns null if key doesn't exist.
125 |      *
126 |      * Key is case-insensitive.
127 |      *
128 |      * @param string $key
129 |      * @return mixed
130 |      */
131 |     public function getBaggageItem($key)
132 |     {
133 |         return null;
134 |     }
135 | 
136 |     /**
137 |      * Provides access to the Tracer that created this Span.
138 |      *
139 |      * @return Tracer
140 |      */
141 |     public function getTracer()
142 |     {
143 |         return $this->tracer;
144 |     }
145 | }


--------------------------------------------------------------------------------