<?php

namespace OpenTelemetry\Context {

/**

* @see https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/context/README.md#context

*/

final class Context implements \OpenTelemetry\Context\ContextInterface

{

public static function createKey(string $key): \OpenTelemetry\Context\ContextKeyInterface

{

}

/**

* @param ContextStorageInterface&ExecutionContextAwareInterface $storage

*/

public static function setStorage(\OpenTelemetry\Context\ContextStorageInterface $storage): void

{

}

/**

* @return ContextStorageInterface&ExecutionContextAwareInterface

*/

public static function storage(): \OpenTelemetry\Context\ContextStorageInterface

{

}

/**

* @param ContextInterface|false|null $context

*

* @internal OpenTelemetry

*/

public static function resolve($context, ?\OpenTelemetry\Context\ContextStorageInterface $contextStorage = null): \OpenTelemetry\Context\ContextInterface

{

}

/**

* @internal

*/

public static function getRoot(): \OpenTelemetry\Context\ContextInterface

{

}

public static function getCurrent(): \OpenTelemetry\Context\ContextInterface

{

}

public function activate(): \OpenTelemetry\Context\ScopeInterface

{

}

public function withContextValue(\OpenTelemetry\Context\ImplicitContextKeyedInterface $value): \OpenTelemetry\Context\ContextInterface

{

}

public function with(\OpenTelemetry\Context\ContextKeyInterface $key, $value): self

{

}

public function get(\OpenTelemetry\Context\ContextKeyInterface $key)

{

}

}

}

namespace DDTrace\OpenTelemetry {

// Operation Name Conventions

class Convention

{

public static function defaultOperationName(\DDTrace\SpanData $span): string

{

}

}

}

namespace OpenTelemetry\SDK\Trace {

final class Span extends \OpenTelemetry\API\Trace\Span implements \OpenTelemetry\SDK\Trace\ReadWriteSpanInterface

{

/**

* This method _MUST_ not be used directly.

* End users should use a {@see API\TracerInterface} in order to create spans.

*

* @param non-empty-string $name

* @psalm-param API\SpanKind::KIND_* $kind

* @param list<LinkInterface> $links

*

* @internal

* @psalm-internal OpenTelemetry

*/

public static function startSpan(\DDTrace\SpanData $span, \OpenTelemetry\API\Trace\SpanContextInterface $context, \OpenTelemetry\SDK\Common\Instrumentation\InstrumentationScopeInterface $instrumentationScope, int $kind, \OpenTelemetry\API\Trace\SpanInterface $parentSpan, \OpenTelemetry\Context\ContextInterface $parentContext, \OpenTelemetry\SDK\Trace\SpanProcessorInterface $spanProcessor, \OpenTelemetry\SDK\Resource\ResourceInfo $resource, array $attributes, array $links, int $totalRecordedLinks, array $events, bool $isRemapped = true): self

{

}

public function getName(): string

{

}

/**

* @inheritDoc

*/

public function getContext(): \OpenTelemetry\API\Trace\SpanContextInterface

{

}

public function getParentContext(): \OpenTelemetry\API\Trace\SpanContextInterface

{

}

public function getInstrumentationScope(): \OpenTelemetry\SDK\Common\Instrumentation\InstrumentationScopeInterface

{

}

public function hasEnded(): bool

{

}

/**

* @inheritDoc

*/

public function toSpanData(): \OpenTelemetry\SDK\Trace\SpanDataInterface

{

}

/**

* @inheritDoc

*/

public function getDuration(): int

{

}

/**

* @inheritDoc

*/

public function getKind(): int

{

}

/**

* @inheritDoc

*/

public function getAttribute(string $key)

{

}

public function getStartEpochNanos(): int

{

}

public function getTotalRecordedLinks(): int

{

}

public function getTotalRecordedEvents(): int

{

}

/**

* @inheritDoc

*/

public function isRecording(): bool

{

}

/**

* @inheritDoc

*/

public function setAttribute(string $key, $value): \OpenTelemetry\API\Trace\SpanInterface

{

}

/**

* @inheritDoc

*/

public function setAttributes(iterable $attributes): \OpenTelemetry\API\Trace\SpanInterface

{

}

/**

* @inheritDoc

*/

public function addLink(\OpenTelemetry\API\Trace\SpanContextInterface $context, iterable $attributes = []): \OpenTelemetry\API\Trace\SpanInterface

{

}

/**

* @inheritDoc

*/

public function addEvent(string $name, iterable $attributes = [], $timestamp = null): \OpenTelemetry\API\Trace\SpanInterface

{

}

/**

* @inheritDoc

*/

public function recordException(\Throwable $exception, iterable $attributes = []): \OpenTelemetry\API\Trace\SpanInterface

{

}

/**

* @inheritDoc

*/

public function updateName(string $name): \OpenTelemetry\API\Trace\SpanInterface

{

}

/**

* @inheritDoc

*/

public function setStatus(string $code, ?string $description = null): \OpenTelemetry\API\Trace\SpanInterface

{

}

/**

* @inheritDoc

*/

public function end(?int $endEpochNanos = null): void

{

}

public function endOTelSpan(?int $endEpochNanos = null): void

{

}

public function getResource(): \OpenTelemetry\SDK\Resource\ResourceInfo

{

}

/**

* @internal

* @return SpanData

*/

public function getDDSpan(): \DDTrace\SpanData

{

}

}

final class SpanBuilder implements \OpenTelemetry\API\Trace\SpanBuilderInterface

{

/** @param non-empty-string $spanName */

public function __construct(string $spanName, \OpenTelemetry\SDK\Common\Instrumentation\InstrumentationScopeInterface $instrumentationScope, \OpenTelemetry\SDK\Trace\TracerSharedState $tracerSharedState)

{

}

/**

* @inheritDoc

*/

public function setParent($context): \OpenTelemetry\API\Trace\SpanBuilderInterface

{

}

public function addLink(\OpenTelemetry\API\Trace\SpanContextInterface $context, iterable $attributes = []): \OpenTelemetry\API\Trace\SpanBuilderInterface

{

}

public function addEvent(string $name, iterable $attributes = [], ?int $timestamp = null): \OpenTelemetry\API\Trace\SpanBuilderInterface

{

}

public function recordException(\Throwable $exception, iterable $attributes = []): \OpenTelemetry\API\Trace\SpanBuilderInterface

{

}

/** @inheritDoc */

public function setAttribute(string $key, $value): \OpenTelemetry\API\Trace\SpanBuilderInterface

{

}

/** @inheritDoc */

public function setAttributes(iterable $attributes): \OpenTelemetry\API\Trace\SpanBuilderInterface

{

}

/**

* @inheritDoc

*/

public function setStartTimestamp(int $timestampNanos): \OpenTelemetry\API\Trace\SpanBuilderInterface

{

}

/**

* @inheritDoc

*/

public function setSpanKind(int $spanKind): \OpenTelemetry\API\Trace\SpanBuilderInterface

{

}

/**

* @inheritDoc

*/

public function startSpan(): \OpenTelemetry\API\Trace\SpanInterface

{

}

}

}

namespace DDTrace\OpenTelemetry\API\Trace {

final class SpanContext implements \OpenTelemetry\API\Trace\SpanContextInterface

{

/**

* @inheritDoc

*/

public function getTraceId(): string

{

}

public function getTraceIdBinary(): string

{

}

/**

* @inheritDoc

*/

public function getSpanId(): string

{

}

public function getSpanIdBinary(): string

{

}

public function getTraceState(): ?\OpenTelemetry\API\Trace\TraceStateInterface

{

}

public function isSampled(): bool

{

}

public function isValid(): bool

{

}

public function isRemote(): bool

{

}

public function getTraceFlags(): int

{

}

/** @inheritDoc */

public static function createFromRemoteParent(string $traceId, string $spanId, int $traceFlags = \OpenTelemetry\API\Trace\TraceFlags::DEFAULT, ?\OpenTelemetry\API\Trace\TraceStateInterface $traceState = null): \OpenTelemetry\API\Trace\SpanContextInterface

{

}

/** @inheritDoc */

public static function create(string $traceId, string $spanId, int $traceFlags = \OpenTelemetry\API\Trace\TraceFlags::DEFAULT, ?\OpenTelemetry\API\Trace\TraceStateInterface $traceState = null): \OpenTelemetry\API\Trace\SpanContextInterface

{

}

/** @inheritDoc */

public static function getInvalid(): \OpenTelemetry\API\Trace\SpanContextInterface

{

}

public static function createFromLocalSpan(\DDTrace\SpanData $span, bool $sampled, ?string $traceId = null, ?string $spanId = null)

{

}

}

}

namespace DDTrace\Processing {

/**

* A span processor in charge of adding the trace analytics client config metric when appropriate.

*

* NOTE: this may be transformer into a filter for consistency with other tracers, but for now we did not implement

* any filtering functionality so giving it such name as of now might be misleading.

*/

final class TraceAnalyticsProcessor

{

/**

* @param array $metrics

* @param bool|float $value

*/

public static function normalizeAnalyticsValue(&$metrics, $value)

{

}

}

}

namespace DDTrace {

/**

* Propagator implementations should be able to inject and extract

* SpanContexts into an implementation specific carrier.

*/

interface Propagator

{

const DEFAULT_BAGGAGE_HEADER_PREFIX = 'ot-baggage-';

const DEFAULT_TRACE_ID_HEADER = 'x-datadog-trace-id';

const DEFAULT_PARENT_ID_HEADER = 'x-datadog-parent-id';

const DEFAULT_SAMPLING_PRIORITY_HEADER = 'x-datadog-sampling-priority';

const DEFAULT_ORIGIN_HEADER = 'x-datadog-origin';

/**

* Inject takes the SpanContext and injects it into the carrier using

* an implementation specific method.

*

* @param SpanContextInterface $spanContext

* @param array|\ArrayAccess $carrier

* @return void

*/

public function inject(\DDTrace\Contracts\SpanContext $spanContext, &$carrier);

/**

* Extract returns the SpanContext from the given carrier using an

* implementation specific method.

*

* @param array|\ArrayAccess $carrier

* @return SpanContextInterface

*/

public function extract($carrier);

}

}

namespace DDTrace\Log {

trait LoggingTrait

{

/**

* Emits a log message at debug level.

*

* @param string $message

* @param array $context

*/

protected static function logDebug($message, array $context = [])

{

}

/**

* Emits a log message at warning level.

*

* @param string $message

* @param array $context

*/

protected static function logWarning($message, array $context = [])

{

}

/**

* Emits a log message at error level.

*

* @param string $message

* @param array $context

*/

protected static function logError($message, array $context = [])

{

}

/**

* @return bool

*/

protected static function isLogDebugActive()

{

}

}

}

namespace DDTrace\Propagators {

final class TextMap implements \DDTrace\Propagator

{

use \DDTrace\Log\LoggingTrait;

/**

* @param Tracer $tracer

*/

public function __construct(\DDTrace\Contracts\Tracer $tracer)

{

}

/**

* {@inheritdoc}

*/

public function inject(\DDTrace\Contracts\SpanContext $spanContext, &$carrier)

{

}

/**

* {@inheritdoc}

*/

public function extract($carrier)

{

}

}

}

namespace DDTrace\Contracts {

/**

* Ported from opentracing/opentracing

* @see https://github.com/opentracing/opentracing-php/blob/master/src/OpenTracing/Scope.php

*/

/**

* A {@link Scope} formalizes the activation and deactivation of a {@link Span}, usually from a CPU standpoint.

*

* Many times a {@link Span} will be extant (in that {@link Span#finish()} has not been called) despite being in a

* non-runnable state from a CPU/scheduler standpoint. For instance, a {@link Span} representing the client side of an

* RPC will be unfinished but blocked on IO while the RPC is still outstanding. A {@link Scope} defines when a given

* {@link Span} <em>is</em> scheduled and on the path.

*/

interface Scope

{

/**

* Mark the end of the active period for the current thread and {@link Scope},

* updating the {@link ScopeManager#active()} in the process.

*

* NOTE: Calling {@link #close} more than once on a single {@link Scope} instance leads to undefined

* behavior.

*/

public function close();

/**

* @return Span the {@link Span} that's been scoped by this {@link Scope}

*/

public function getSpan();

}

}

namespace DDTrace {

final class Scope implements \DDTrace\Contracts\Scope

{

public function __construct(\DDTrace\ScopeManager $scopeManager, \DDTrace\Contracts\Span $span, $finishSpanOnClose)

{

}

/**

* {@inheritdoc}

*/

public function close()

{

}

/**

* {@inheritdoc}

*

* @return SpanInterface

*/

public function getSpan()

{

}

}

}

namespace DDTrace\Contracts {

/**

* Ported from opentracing/opentracing

* @see https://github.com/opentracing/opentracing-php/blob/master/src/OpenTracing/ScopeManager.php

*/

/**

* Keeps track of the current active `Span`.

*/

interface ScopeManager

{

const DEFAULT_FINISH_SPAN_ON_CLOSE = true;

/**

* Activates an `Span`, so that it is used as a parent when creating new spans.

* The implementation must keep track of the active spans sequence, so

* that previous spans can be resumed after a deactivation.

*

* @param Span $span the {@link Span} that should become the {@link #active()}

* @param bool $finishSpanOnClose whether span should automatically be finished

* when {@link Scope#close()} is called. Its default value is true.

*

* @return Scope instance to control the end of the active period for the {@link Span}. It is a

* programming error to neglect to call {@link Scope#close()} on the returned instance.

*/

public function activate(\DDTrace\Contracts\Span $span, $finishSpanOnClose = self::DEFAULT_FINISH_SPAN_ON_CLOSE);

/**

* Return the currently active {@link Scope} which can be used to access the

* currently active {@link Scope#getSpan()}.

*

* If there is an {@link Scope non-null scope}, its wrapped {@link Span} becomes an implicit parent

* (as {@link References#CHILD_OF} reference) of any

* newly-created {@link Span} at {@link Tracer.SpanBuilder#startActive(boolean)} or {@link SpanBuilder#start()}

* time rather than at {@link Tracer#buildSpan(String)} time.

*

* @return Scope|null

*/

public function getActive();

/**

* Closes all the current request root spans. Typically there only will be one.

*/

public function close();

}

}

namespace DDTrace {

final class ScopeManager implements \DDTrace\Contracts\ScopeManager

{

public function __construct($rootContext = null)

{

}

/**

* {@inheritdoc}

* @param Span|SpanInterface $span

*/

public function activate(\DDTrace\Contracts\Span $span, $finishSpanOnClose = self::DEFAULT_FINISH_SPAN_ON_CLOSE)

{

}

/**

* {@inheritdoc}

*/

public function getActive()

{

}

public function deactivate(\DDTrace\Scope $scope)

{

}

/** @internal */

public function getPrimaryRoot()

{

}

/** @internal */

public function getTopScope()

{

}

/**

* Closes all the current request root spans. Typically there only will be one.

*/

public function close()

{

}

}

}

namespace DDTrace\Contracts {

/**

* Ported from opentracing/opentracing

* @see https://github.com/opentracing/opentracing-php/blob/master/src/OpenTracing/Span.php

*/

interface Span

{

/**

* @return string

*/

public function getOperationName();

/**

* Yields the SpanContext for this Span. Note that the return value of

* Span::getContext() is still valid after a call to Span::finish(), as is

* a call to Span::getContext() after a call to Span::finish().

*

* @return SpanContext

*/

public function getContext();

/**

* Sets the end timestamp and finalizes Span state.

*

* With the exception of calls to getContext() (which are always allowed),

* finish() must be the last call made to any span instance, and to do

* otherwise leads to undefined behavior but not returning an exception.

*

* As an implementor, make sure you call {@see Tracer::deactivate()}

* otherwise new spans might try to be child of this one.

*

* If the span is already finished, a warning should be logged.

*

* @param float|int|\DateTimeInterface|null $finishTime if passing float or int

* it should represent the timestamp (including as many decimal places as you need)

* @return void

*/

public function finish($finishTime = null);

/**

* If the span is already finished, a warning should be logged.

*

* @param string $newOperationName

*/

public function overwriteOperationName($newOperationName);

/**

* Sets the span's resource name.

*

* @param string $resource

*/

public function setResource($resource);

/**

* Adds a tag to the span.

*

* If there is a pre-existing tag set for key, it is overwritten.

*

* As an implementor, consider using "standard tags" listed in {@see \DDTrace\Tags}

*

* If the span is already finished, a warning should be logged.

*

* @param string $key

* @param mixed $value

* @param boolean $setIfFinished

* @return void

*/

public function setTag($key, $value, $setIfFinished = false);

/**

* @param string $key

* @return string|null

*/

public function getTag($key);

/**

* Adds a log record to the span in key => value format, key must be a string and tag must be either

* a string, a boolean value, or a numeric type.

*

* If the span is already finished, a warning should be logged.

*

* @param array $fields

* @param int|float|\DateTimeInterface $timestamp

* @return void

*/

public function log(array $fields = [], $timestamp = null);

/**

* Adds a baggage item to the SpanContext which is immutable so it is required to use

* SpanContext::withBaggageItem to get a new one.

*

* If the span is already finished, a warning should be logged.

*

* @param string $key

* @param string $value

* @return void

*/

public function addBaggageItem($key, $value);

/**

* @param string $key

* @return string|null returns null when there is not a item under the provided key

*/

public function getBaggageItem($key);

/**

* @return array

*/

public function getAllBaggageItems();

/**

* Stores a Throwable object within the span tags. The error status is

* updated and the error.Error() string is included with a default tag key.

* If the Span has been finished, it will not be modified by this method.

*

* @param \Throwable|\Exception|bool|null $error

* @throws \InvalidArgumentException

*/

public function setError($error);

/**

* Stores an error message and type in the Span.

*

* @param string $message

* @param string $type

*/

public function setRawError($message, $type);

/**

* Tells whether or not this Span contains errors.

*

* @return bool

*/

public function hasError();

/**

* @return int

*/

public function getStartTime();

/**

* @return int

*/

public function getDuration();

/**

* @return string

*/

public function getTraceId();

/**

* @return string

*/

public function getSpanId();

/**

* @return null|string

*/

public function getParentId();

/**

* @return string

*/

public function getResource();

/**

* @return string

*/

public function getService();

/**

* @return string|null

*/

public function getType();

/**

* @return bool

*/

public function isFinished();

/**

* @return array

*/

public function getAllTags();

/**

* Tells whether or not the span has the provided tag. Note that there are no guarantees that the tag value is

* not empty.

*

* @param string $name

* @return bool

*/

public function hasTag($name);

/**

* Set a DD metric.

*

* @param string $key

* @param mixed $value

*/

public function setMetric($key, $value);

/**

* @return array All the currently set metrics.

*/

public function getMetrics();

}

}

namespace DDTrace\Data {

/**

* Class Span

* @property string $operationName

* @property string $resource

* @property string $service

* @property string $type

* @property int $startTime

* @property int $duration

* @property array $tags

* @property array $metrics

* @property array $baggage

*/

abstract class Span implements \DDTrace\Contracts\Span

{

/**

* @var SpanContextData

*/

public $context;

/**

* @var bool

*/

public $hasError = false;

/**

* @var \DDTrace\SpanData

*/

protected $internalSpan;

public function &__get($name)

{

}

public function __set($name, $value)

{

}

public function __isset($name)

{

}

}

}

namespace DDTrace {

class Span extends \DDTrace\Data\Span

{

use \DDTrace\Log\LoggingTrait;

public $internalSpan;

/**

* Span constructor.

* @param SpanData $internalSpan

* @param SpanContext $context

*/

public function __construct(\DDTrace\SpanData $internalSpan, \DDTrace\SpanContext $context)

{

}

/**

* {@inheritdoc}

*/

public function getTraceId()

{

}

/**

* {@inheritdoc}

*/

public function getSpanId()

{

}

/**

* {@inheritdoc}

*/

public function getParentId()

{

}

/**

* {@inheritdoc}

*/

public function overwriteOperationName($operationName)

{

}

/**

* {@inheritdoc}

*/

public function getResource()

{

}

/**

* {@inheritdoc}

*/

public function getService()

{

}

/**

* {@inheritdoc}

*/

public function getType()

{

}

/**

* {@inheritdoc}

*/

public function getStartTime()

{

}

/**

* {@inheritdoc}

*/

public function getDuration()

{

}

/**

* {@inheritdoc}

*/

public function setTag($key, $value, $setIfFinished = false)

{

}

/**

* {@inheritdoc}

*/

public function getTag($key)

{

}

/**

* {@inheritdoc}

*/

public function getAllTags()

{

}

/**

* {@inheritdoc}

*/

public function hasTag($name)

{

}

/**

* @param string $key

* @param mixed $value

*/

public function setMetric($key, $value)

{

}

/**

* @return array

*/

public function getMetrics()

{

}

/**

* {@inheritdoc}

*/

public function setResource($resource)

{

}

/**

* Stores a Throwable object within the span tags. The error status is

* updated and the error.Error() string is included with a default tag key.

* If the Span has been finished, it will not be modified by this method.

*

* @param Throwable|Exception|bool|null $error

* @throws InvalidArgumentException

*/

public function setError($error)

{

}

/**

* @param string $message

* @param string $type

*/

public function setRawError($message, $type)

{

}

public function hasError()

{

}

/**

* {@inheritdoc}

*/

public function finish($finishTime = null)

{

}

/**

* {@inheritdoc}

*/

public function isFinished()

{

}

/**

* {@inheritdoc}

*/

public function getOperationName()

{

}

/**

* {@inheritdoc}

*/

public function getContext()

{

}

/**

* {@inheritdoc}

*/

public function log(array $fields = [], $timestamp = null)

{

}

/**

* {@inheritdoc}

*/

public function addBaggageItem($key, $value)

{

}

/**

* {@inheritdoc}

*/

public function getBaggageItem($key)

{

}

/**

* {@inheritdoc}

*/

public function getAllBaggageItems()

{

}

/**

* {@inheritdoc}

*/

public function removeBaggageItem($key)

{

}

/**

* {@inheritdoc}

*/

public function removeAllBaggageItems()

{

}

public function __destruct()

{

}

}

}

namespace DDTrace\Contracts {

/**

* SpanContext must be immutable in order to avoid complicated lifetime

* issues around Span finish and references.

*

* Baggage items are key => value string pairs that apply to the given Span,

* its SpanContext, and all Spans which directly or transitively reference

* the local Span. That is, baggage items propagate in-band along with the

* trace itself.

*/

interface SpanContext extends \IteratorAggregate

{

/**

* Returns the value of a baggage item based on its key. If there is no

* value with such key it will return null.

*

* @param string $key

* @return string|null

*/

public function getBaggageItem($key);

/**

* Creates a new SpanContext out of the existing one and the new key => value pair.

*

* @param string $key

* @param string $value

* @return SpanContext

*/

public function withBaggageItem($key, $value);

/**

* @return array

*/

public function getAllBaggageItems();

/**

* Gets initial priority sampling, upon span creation

*

* @return int

*/

public function getPropagatedPrioritySampling();

/**

* Sets initial priority sampling, to be consumed upon span creation

*