OpenTelemetry PHP

Application

Table of Contents

Interfaces

BaggageBuilderInterface

BaggageInterface

Represents a value that can be stored within {@see ContextInterface}.

MetadataInterface

LogWriterInterface

ClockInterface

ConfigProperties

ConfigProviderInterface

GeneralInstrumentationConfiguration

HookManagerInterface

Instrumentation

InstrumentationConfiguration

ConfigurationResolverInterface

InstrumentationInterface

EventLoggerInterface

EventLoggerProviderInterface

LoggerInterface

LoggerProviderInterface

AsynchronousInstrument

Marker interface for asynchronous instruments.

CounterInterface

Marker interface for synchronous instruments.

GaugeInterface

A synchronous instrument which can be used to record non-additive values.

HistogramInterface

Marker interface for synchronous instruments.

Instrument

MeterInterface

MeterProviderInterface

ObservableCallbackInterface

An observed callback.

ObservableCounterInterface

Marker interface for asynchronous instruments.

ObservableGaugeInterface

Marker interface for asynchronous instruments.

ObservableUpDownCounterInterface

Marker interface for asynchronous instruments.

ObserverInterface

SynchronousInstrument

Marker interface for synchronous instruments.

UpDownCounterInterface

Marker interface for synchronous instruments.

Signals

SpanBuilderInterface

Obtained from a {@see TracerInterface} and used to construct a {@see SpanInterface}.

SpanContextInterface

SpanInterface

Represents a value that can be stored within {@see ContextInterface}.

SpanKind

StatusCode

TraceFlags

TracerInterface

TracerProviderInterface

TraceStateInterface

TraceState parses and stores the tracestate header as an immutable list of string key/value pairs. It provides the following operations following the rules described in the W3C Trace Context specification: - Get value for a given key - Add a new key/value pair - Update an existing value for a given key - Delete a key/value pair

ComponentPlugin

A component plugin that can be used to create a component.

ComponentProvider

A component provider is responsible for interpreting configuration and returning an implementation of a particular type.

ComponentProviderRegistry

A registry of component providers.

EnvReader

EnvSource

ResourceTrackable

ConfigurationLoader

ResourceCollection

ContextInterface

Immutable execution scoped propagation mechanism.

ContextKeyInterface

ContextStorageInterface

ContextStorageScopeInterface

ExecutionContextAwareInterface

ImplicitContextKeyedInterface

Represents a value that can be stored within {@see ContextInterface}.

PropagationGetterInterface

PropagationSetterInterface

TextMapPropagatorInterface

ScopeInterface

ContentTypes

HttpEndpointResolverInterface

AttributesBuilderInterface

AttributesFactoryInterface

AttributesInterface

AttributeValidatorInterface

Defaults

Default values for environment variables defined by the OpenTelemetry specification and language specific variables for the PHP SDK.

KnownValues

"Known values" for OpenTelemetry configurataion variables.

ResolverInterface

ValueTypes

Environment variables defined by the OpenTelemetry specification and language specific variables for the PHP SDK.

Variables

Environment variables defined by the OpenTelemetry specification and language specific variables for the PHP SDK.

VariableTypes

TransportFactoryInterface

TransportInterface

CancellationInterface

FutureInterface

DependencyResolverInterface

ResolverInterface

DiscoveryInterface

ResolverInterface

FactoryResolverInterface

MessageFactoryInterface

InstrumentationScopeFactoryInterface

InstrumentationScopeInterface

Configurable

ClockInterface

EventLoggerProviderInterface

LoggerProviderInterface

LogRecordExporterFactoryInterface

LogRecordExporterInterface

LogRecordProcessorInterface

PsrSeverityMapperInterface

AggregationInterface

AggregationTemporalitySelectorInterface

DataInterface

DefaultAggregationProviderInterface

ExemplarFilterInterface

The exemplar spec is not yet stable, and can change at any time.

ExemplarReservoirInterface

MeterProviderInterface

MetricExporterFactoryInterface

MetricExporterInterface

MetricMetadataInterface

MetricReaderInterface

MetricSourceInterface

MetricSourceProviderInterface

MetricSourceRegistryInterface

PushMetricExporterInterface

StalenessHandlerFactoryInterface

StalenessHandlerInterface

SelectionCriteriaInterface

ViewRegistryInterface

ResourceDetectorInterface

EventInterface

IdGeneratorInterface

LinkInterface

ReadableSpanInterface

ReadWriteSpanInterface

Represents a value that can be stored within {@see ContextInterface}.

SamplerInterface

This interface is used to organize sampling logic.

SpanConverterInterface

SpanDataInterface

Represents an immutable snapshot of a {@see API\SpanInterface}.

SpanExporterFactoryInterface

SpanExporterInterface

SpanProcessorInterface

StatusDataInterface

TracerProviderInterface

ResourceAttributes

ResourceAttributeValues

TraceAttributes

TraceAttributeValues

MetricReaderSourceRegistryInterface

MeterMetricReaderInterface

DefaultAggregationProviderExporterInterface

MetricExporterWithTemporalityInterface

Classes

Example

ExampleConfig

ExampleConfigProvider

ExampleInstrumentation

ExampleMetricsGenerator

ExportLogsPartialSuccess

Generated from protobuf message <code>opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess</code>

ExportLogsServiceRequest

Generated from protobuf message <code>opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest</code>

ExportLogsServiceResponse

Generated from protobuf message <code>opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse</code>

LogsServiceClient

Service that can be used to push logs between one Application instrumented with OpenTelemetry and an collector, or between an collector and a central collector (in this case logs are sent/received to/from multiple Applications).

ExportMetricsPartialSuccess

Generated from protobuf message <code>opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess</code>

ExportMetricsServiceRequest

Generated from protobuf message <code>opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest</code>

ExportMetricsServiceResponse

Generated from protobuf message <code>opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse</code>

MetricsServiceClient

Service that can be used to push metrics between one Application instrumented with OpenTelemetry and a collector, or between a collector and a central collector.

ExportTracePartialSuccess

Generated from protobuf message <code>opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess</code>

ExportTraceServiceRequest

Generated from protobuf message <code>opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest</code>

ExportTraceServiceResponse

Generated from protobuf message <code>opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse</code>

TraceServiceClient

Service that can be used to push spans between one Application instrumented with OpenTelemetry and a collector, or between a collector and a central collector (in this case spans are sent/received to/from multiple Applications).

AnyValue

AnyValue is used to represent any type of attribute value. AnyValue may contain a primitive value such as a string or integer or it may contain an arbitrary nested object containing arrays, key-value lists and primitives.

ArrayValue

ArrayValue is a list of AnyValue messages. We need ArrayValue as a message since oneof in AnyValue does not allow repeated fields.

InstrumentationLibrary

InstrumentationLibrary is a message representing the instrumentation library information such as the fully qualified name and version.

InstrumentationScope

InstrumentationScope is a message representing the instrumentation scope information such as the fully qualified name and version.

KeyValue

KeyValue is a key-value pair that is used to store Span attributes, Link attributes, etc.

KeyValueList

KeyValueList is a list of KeyValue messages. We need KeyValueList as a message since `oneof` in AnyValue does not allow repeated fields. Everywhere else where we need a list of KeyValue messages (e.g. in Span) we use `repeated KeyValue` directly to avoid unnecessary extra wrapping (which slows down the protocol). The 2 approaches are semantically equivalent.

StringKeyValue

StringKeyValue is a pair of key/value strings. This is the simpler (and faster) version of KeyValue that only supports string values.

InstrumentationLibraryLogs

A collection of Logs produced by an InstrumentationLibrary.

LogRecord

A log record according to OpenTelemetry Log Data Model: https://github.com/open-telemetry/oteps/blob/main/text/logs/0097-log-data-model.md

LogRecordFlags

LogRecordFlags represents constants used to interpret the LogRecord.flags field, which is protobuf 'fixed32' type and is to be used as bit-fields. Each non-zero value defined in this enum is a bit-mask. To extract the bit-field, for example, use an expression like: (logRecord.flags & LOG_RECORD_FLAGS_TRACE_FLAGS_MASK)

LogsData

LogsData represents the logs data that can be stored in a persistent storage, OR can be embedded by other protocols that transfer OTLP logs data but do not implement the OTLP protocol.

ResourceLogs

A collection of ScopeLogs from a Resource.

ScopeLogs

A collection of Logs produced by a Scope.

SeverityNumber

Possible values for LogRecord.SeverityNumber.

MetricConfigRequest

Generated from protobuf message <code>opentelemetry.proto.metrics.experimental.MetricConfigRequest</code>

Pattern

A light-weight pattern that can match 1 or more metrics, for which this schedule will apply. The string is used to match against metric names. It should not exceed 100k characters.

Schedule

A Schedule is used to apply a particular scheduling configuration to a metric. If a metric name matches a schedule's patterns, then the metric adopts the configuration specified by the schedule.

MetricConfigResponse

Generated from protobuf message <code>opentelemetry.proto.metrics.experimental.MetricConfigResponse</code>

MetricConfigResponse_Schedule

This class is deprecated. Use Opentelemetry\Proto\Metrics\Experimental\MetricConfigResponse\Schedule instead.

MetricConfigResponse_Schedule_Pattern

This class is deprecated. Use Opentelemetry\Proto\Metrics\Experimental\MetricConfigResponse\Schedule\Pattern instead.

AggregationTemporality

AggregationTemporality defines how a metric aggregator reports aggregated values. It describes how those values relate to the time interval over which they are aggregated.

DataPointFlags

DataPointFlags is defined as a protobuf 'uint32' type and is to be used as a bit-field representing 32 distinct boolean flags. Each flag defined in this enum is a bit-mask. To test the presence of a single flag in the flags of a data point, for example, use an expression like: (point.flags & DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK) == DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK

Exemplar

A representation of an exemplar, which is a sample input measurement.

ExponentialHistogram

ExponentialHistogram represents the type of a metric that is calculated by aggregating as a ExponentialHistogram of all reported double measurements over a time interval.

Buckets

Buckets are a set of bucket counts, encoded in a contiguous array of counts.

ExponentialHistogramDataPoint

ExponentialHistogramDataPoint is a single data point in a timeseries that describes the time-varying values of a ExponentialHistogram of double values. A ExponentialHistogram contains summary statistics for a population of values, it may optionally contain the distribution of those values across a set of buckets.

ExponentialHistogramDataPoint_Buckets

This class is deprecated. Use Opentelemetry\Proto\Metrics\V1\ExponentialHistogramDataPoint\Buckets instead.

Gauge

Gauge represents the type of a scalar metric that always exports the "current value" for every data point. It should be used for an "unknown" aggregation.

Histogram

Histogram represents the type of a metric that is calculated by aggregating as a Histogram of all reported measurements over a time interval.

HistogramDataPoint

HistogramDataPoint is a single data point in a timeseries that describes the time-varying values of a Histogram. A Histogram contains summary statistics for a population of values, it may optionally contain the distribution of those values across a set of buckets.

InstrumentationLibraryMetrics

A collection of Metrics produced by an InstrumentationLibrary.

IntDataPoint

IntDataPoint is deprecated. Use integer value in NumberDataPoint.

IntExemplar

IntExemplar is deprecated. Use Exemplar with as_int for value

IntGauge

IntGauge is deprecated. Use Gauge with an integer value in NumberDataPoint.

IntHistogram

IntHistogram is deprecated, replaced by Histogram points using double- valued exemplars.

IntHistogramDataPoint

IntHistogramDataPoint is deprecated; use HistogramDataPoint.

IntSum

IntSum is deprecated. Use Sum with an integer value in NumberDataPoint.

Metric

Defines a Metric which has one or more timeseries. The following is a brief summary of the Metric data model. For more details, see: https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/data-model.md The data model and relation between entities is shown in the diagram below. Here, "DataPoint" is the term used to refer to any one of the specific data point value types, and "points" is the term used to refer to any one of the lists of points contained in the Metric.

MetricsData

MetricsData represents the metrics data that can be stored in a persistent storage, OR can be embedded by other protocols that transfer OTLP metrics data but do not implement the OTLP protocol.

NumberDataPoint

NumberDataPoint is a single data point in a timeseries that describes the time-varying scalar value of a metric.

ResourceMetrics

A collection of ScopeMetrics from a Resource.

ScopeMetrics

A collection of Metrics produced by an Scope.

Sum

Sum represents the type of a scalar metric that is calculated as a sum of all reported measurements over a time interval.

Summary

Summary metric data are used to convey quantile summaries, a Prometheus (see: https://prometheus.io/docs/concepts/metric_types/#summary) and OpenMetrics (see: https://github.com/OpenObservability/OpenMetrics/blob/4dbf6075567ab43296eed941037c12951faafb92/protos/prometheus.proto#L45) data type. These data points cannot always be merged in a meaningful way.

ValueAtQuantile

Represents the value at a given quantile of a distribution.

SummaryDataPoint

SummaryDataPoint is a single data point in a timeseries that describes the time-varying values of a Summary metric.

SummaryDataPoint_ValueAtQuantile

This class is deprecated. Use Opentelemetry\Proto\Metrics\V1\SummaryDataPoint\ValueAtQuantile instead.

Resource

Resource information.

ConstantDecision

How spans should be sampled: - Always off - Always on - Always follow the parent Span's decision (off if no parent).

ConstantSampler

Sampler that always makes a constant decision on span sampling.

ConstantSampler_ConstantDecision

This class is deprecated. Use Opentelemetry\Proto\Trace\V1\ConstantSampler\ConstantDecision instead.

InstrumentationLibrarySpans

A collection of Spans produced by an InstrumentationLibrary.

RateLimitingSampler

Sampler that tries to sample with a rate per time window.

ResourceSpans

A collection of ScopeSpans from a Resource.

ScopeSpans

A collection of Spans produced by an InstrumentationScope.

Event

Event is a time-stamped annotation of the span, consisting of user-supplied text description and key-value pairs.

Link

A pointer from the current span to another span in the same trace or in a different trace. For example, this can be used in batching operations, where a single batch handler processes multiple requests from different traces or when the handler receives a request from a different project.

SpanKind

SpanKind is the type of span. Can be used to specify additional relationships between spans in addition to a parent/child relationship.

Span

A Span represents a single operation performed by a single component of the system.

Span_Event

This class is deprecated. Use Opentelemetry\Proto\Trace\V1\Span\Event instead.

Span_Link

This class is deprecated. Use Opentelemetry\Proto\Trace\V1\Span\Link instead.

Span_SpanKind

This class is deprecated. Use Opentelemetry\Proto\Trace\V1\Span\SpanKind instead.

SpanFlags

SpanFlags represents constants used to interpret the Span.flags field, which is protobuf 'fixed32' type and is to be used as bit-fields. Each non-zero value defined in this enum is a bit-mask. To extract the bit-field, for example, use an expression like: (span.flags & SPAN_FLAGS_TRACE_FLAGS_MASK) See https://www.w3.org/TR/trace-context-2/#trace-flags for the flag definitions.

DeprecatedStatusCode

Protobuf type <code>opentelemetry.proto.trace.v1.Status.DeprecatedStatusCode</code>

StatusCode

For the semantics of status codes see https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#set-status

Status

The Status type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs.

Status_DeprecatedStatusCode

This class is deprecated. Use Opentelemetry\Proto\Trace\V1\Status\DeprecatedStatusCode instead.

Status_StatusCode

This class is deprecated. Use Opentelemetry\Proto\Trace\V1\Status\StatusCode instead.

TraceConfig

Global configuration of the trace service. All fields must be specified, or the default (zero) values will be used for each type.

TraceIdRatioBased

Sampler that tries to uniformly sample traces with a given ratio.

TracesData

TracesData represents the traces data that can be stored in a persistent storage, OR can be embedded by other protocols that transfer OTLP traces data but do not implement the OTLP protocol.

Baggage

BaggageBuilder

Entry

Metadata

BaggagePropagator

Parser

Logging

Logging utility functions for internal logging (of OpenTelemetry errors/warnings etc).

ErrorLogWriter

Formatter

NoopLogWriter

Psr3LogWriter

StreamLogWriter

LogWriterFactory

Clock

NoopConfigProperties

NoopConfigProvider

Globals

Provides access to the globally configured instrumentation instances.

ConfigurationRegistry

Context

Context used for component creation.

ExtensionHookManager

HookManager

NoopHookManager

CachedInstrumentation

Provides access to cached {@link TracerInterface} and {@link MeterInterface} instances.

HttpConfig

PeerConfig

ConfigurationResolver

Configurator

Configures the global (context scoped) instrumentation instances.

SpanAttribute

For function and methods that have the {@link WithSpan} attribute, adding this attribute to an argument will add the argument as a span attribute.

WithSpan

Functions and methods with this attribute will be auto-instrumented by the OpenTelemetry extension.

WithSpanHandler

Generic pre-hook and post-hook handlers for attribute-based auto instrumentation

LoggerHolder

LateBindingLogger

LateBindingLoggerProvider

LogRecord

Psr3

NoopEventLogger

NoopEventLoggerProvider

NoopLogger

NoopLoggerProvider

LateBindingMeter

LateBindingMeterProvider

NoopMeter

NoopMeterProvider

LateBindingTracer

LateBindingTracerProvider

Late binding providers are designed to be used by Instrumentation, while we do not have control over when all components (propagators, etc) which are registered through composer.autoload.files are actually loaded. It means that tracers etc are not fetched from Globals until the last possible instant (ie, when they try to create a span, get an instrument, etc).

LocalRootSpan

NonRecordingSpan

NoopSpanBuilder

NoopTracer

NoopTracerProvider

TraceContextPropagator

TraceContext is a propagator that supports the W3C Trace Context format (https://www.w3.org/TR/trace-context/)

TraceContextValidator

Span

SpanContext

SpanContextValidator

TraceState

HttpConfigProvider

PeerConfigProvider

LogRecordExporterConsole

LogRecordExporterOtlp

LogRecordProcessorBatch

LogRecordProcessorSimple

AggregationResolverDefault

MetricExporterConsole

MetricExporterOtlp

MetricReaderPeriodic

TextMapPropagatorB3

TextMapPropagatorB3Multi

TextMapPropagatorBaggage

TextMapPropagatorComposite

TextMapPropagatorJaeger

TextMapPropagatorTraceContext

SamplerAlwaysOff

SamplerAlwaysOn

SamplerParentBased

SamplerTraceIdRatioBased

SpanExporterConsole

SpanExporterOtlp

SpanExporterZipkin

SpanProcessorBatch

SpanProcessorSimple

ConfigurationFactory

Context

Context used for component creation.

ArrayEnvSource

EnvResource

EnvResourceChecker

EnvSourceReader

PhpIniEnvSource

ServerEnvSource

YamlExtensionFileLoader

YamlSymfonyFileLoader

Validation

Provides validation closures for {@see NodeDefinition}s.

Configuration

Instrumentation

Context

ContextKeys

ArrayAccessGetterSetter

MultiTextMapPropagator

NoopTextMapPropagator

SanitizeCombinedHeadersPropagationGetter

Some servers concatenate multiple headers with ';' -- we need to replace these with ',' This is still a workaround and doesn't get around the problem fully, specifically it doesn't handle edge cases where the header has a trailing ';' or an empty trace state.

GrpcTransportFactory

AttributesConverter

HttpEndpointResolver

Resolves non-signal-specific OTLP HTTP endpoints to signal-specific ones according to the specification.

LogsConverter

LogsExporter

LogsExporterFactory

MetricConverter

MetricExporter

MetricExporterFactory

OtlpHttpTransportFactory

OtlpUtil

Protocols

SpanConverter

SpanExporter

SpanExporterFactory

SpanConverter

SpanExporterFactory

SpanKind

B3DebugFlagContextKey

B3MultiPropagator

B3Multi is a propagator that supports the specification for multiple "b3" http headers used for trace context propagation across service boundaries.

B3Propagator

B3 is a propagator that supports the specification for the header "b3" used for trace context propagation across service boundaries.

B3SinglePropagator

B3 is a propagator that supports the specification for the B3 single header "b3" used for trace context propagation across service boundaries.

CloudTraceFormatter

This format using a human readable string encoding to propagate SpanContext.

CloudTracePropagator

CloudTracePropagator is a propagator that supports the specification for the X-Cloud-Trace-Context header used for trace context propagation across service boundaries.

Utils

This class contains utilities that are used by the CloudTracePropagator.

JaegerBaggagePropagator

JaegerBaggagePropagator is a baggage propagator that supports the specification for the header "uberctx" used for baggage propagation.

JaegerDebugFlagContextKey

JaegerPropagator

JaegerPropagator is a propagator that supports the specification for the header "uber-trace-id" used for trace context propagation across service boundaries.

DependencyResolver

HttpPlugClientResolver

MessageFactoryResolver

PsrClientResolver

Attributes

AttributeValidator

LogRecordAttributeValidator

Configuration

Configuration can come from one or more of the following sources (from highest to lowest priority): - values defined in php.ini - environment variable ($_SERVER) - configuration file (todo)

BooleanParser

ListParser

MapParser

RatioParser

PhpIniAccessor

Util

StackTraceFormatter

PsrTransport

PsrTransportFactory

StreamTransportFactory

CompletedFuture

ErrorFuture

NullCancellation

Buzz

CurlClient

Guzzle

Symfony

Discovery

MessageFactory

InstrumentationScope

Represents the instrumentation scope information associated with the Tracer or Meter

InstrumentationScopeFactory

Configurator

ClockFactory

ClassConstantAccessor

ShutdownHandler

EventLogger

EventLoggerProvider

EventLoggerProviderFactory

ConsoleExporter

A JSON console exporter for LogRecords. This is only useful for testing; the output is human-readable, and is not compatible with the OTLP format.

ConsoleExporterFactory

InMemoryExporter

InMemoryExporterFactory

NoopExporter

ExporterFactory

Logger

Note that this logger class is deliberately NOT psr-3 compatible, per spec: "Note: this document defines a log backend API. The API is not intended to be called by application developers directly."

LoggerConfig

LoggerProvider

LoggerProviderBuilder

LoggerProviderFactory

LoggerSharedState

LogRecordLimits

LogRecordLimitsBuilder

LogRecordProcessorFactory

NoopEventLoggerProvider

NoopLoggerProvider

BatchLogRecordProcessor

MultiLogRecordProcessor

NoopLogRecordProcessor

SimpleLogRecordProcessor

ReadableLogRecord

ReadWriteLogRecord

SimplePsrFileLogger

ExplicitBucketHistogramAggregation

ExplicitBucketHistogramSummary

LastValueAggregation

LastValueSummary

SumAggregation

SumSummary

Exemplar

Gauge

Histogram

HistogramDataPoint

Metric

NumberDataPoint

Sum

Temporality

Metric aggregation temporality.

AllExemplarFilter

The exemplar spec is not yet stable, and can change at any time.

NoneExemplarFilter

The exemplar spec is not yet stable, and can change at any time.

WithSampledTraceExemplarFilter

The exemplar spec is not yet stable, and can change at any time.

FilteredReservoir

The exemplar spec is not yet stable, and can change at any time.

FixedSizeReservoir

HistogramBucketReservoir

NoopReservoir

Instrument

InstrumentType

Instrument type.

MeterConfig

MeterProvider

MeterProviderBuilder

MeterProviderFactory

ConsoleMetricExporter

Console metrics exporter.

ConsoleMetricExporterFactory

InMemoryExporter

InMemoryExporterFactory

NoopMetricExporter

NoopMetricExporterFactory

ExportingReader

NoopMeterProvider

DelayedStalenessHandlerFactory

ImmediateStalenessHandlerFactory

NoopStalenessHandlerFactory

CriteriaViewRegistry

AllCriteria

InstrumentationScopeNameCriteria

InstrumentationScopeSchemaUrlCriteria

InstrumentationScopeVersionCriteria

InstrumentNameCriteria

InstrumentTypeCriteria

ViewTemplate

ViewProjection

PropagatorFactory

Registry

A registry to enable central registration of components that the SDK requires but which may be provided by non-SDK modules, such as contrib and extension.

Composer

Composite

Constant

Environment

Host

OperatingSystem

Process

ProcessRuntime

Sdk

SdkProvided

Service

ResourceInfo

A Resource is an immutable representation of the entity producing telemetry. For example, a process producing telemetry that is running in a container on Kubernetes has a Pod name, it is in a namespace and possibly is part of a Deployment which also has a name. All three of these attributes can be included in the Resource.

ResourceInfoFactory

Sdk

SdkAutoloader

SdkBuilder

AutoRootSpan

Event

ExporterFactory

ImmutableSpan

Link

NoopTracerProvider

RandomIdGenerator

AlwaysOffSampler

This implementation of the SamplerInterface always skips record.

AlwaysOnSampler

This implementation of the SamplerInterface always records.

ParentBased

This implementation of the SamplerInterface that respects parent context's sampling decision and delegates for the root span.

TraceIdRatioBasedSampler

This implementation of the SamplerInterface records with given probability.

SamplerFactory

SamplingResult

Span

SpanBuilder

AbstractDecorator

ConsoleSpanExporter

ConsoleSpanExporterFactory

FriendlySpanConverter

InMemoryExporter

InMemorySpanExporterFactory

LoggerDecorator

LoggerExporter

NullSpanConverter

SpanLimits

SpanLimitsBuilder

BatchSpanProcessor

BatchSpanProcessorBuilder

MultiSpanProcessor

Class SpanMultiProcessor is a SpanProcessor that forwards all events to an array of SpanProcessors.

NoopSpanProcessor

SimpleSpanProcessor

SpanProcessorFactory

StatusData

Tracer

TracerConfig

TracerProvider

TracerProviderBuilder

TracerProviderFactory

TracerSharedState

Stores shared state/config between all {@see API\TracerInterface} created via the same {@see API\TracerProviderInterface}.

BaggageParsingBench

MetricBench

OtlpBench

TODO https://github.com/open-telemetry/opentelemetry-go/blob/051227c9edded2c772a07a4d4e60dda27c3e4b20/sdk/trace/benchmark_test.go

ResourceCreationBench

ConfigurationTest

AlwaysOffSamplerTest

AlwaysOnSamplerTest

SpanContextTest

LocalRootSpanTest

LoggerConfigTest

MeterProviderTest

MeterTest

MeterConfigTest

ParentBasedTest

ResourceInfoFactoryTest

ResourceInfoTest

SpanBuilderTest

SpanLimitsBuilderTest

SpanProcessorTest

TracerConfigTest

TraceIdRatioBasedSamplerTest

TracerTest

BaggageTest

BaggagePropagatorTest

ParserTest

FormatterTest

LogWriterFactoryTest

LogsMessagesTraitTest

ClockTest

SystemClockTest

NoopConfigPropertiesTest

NoopConfigProviderTest

ConfigurationRegistryTest

ContextTest

ExtensionHookManagerTest

HookManagerTest

LateBindingProviderTest

ConfigurationResolverTest

InstrumentationTest

InstrumentationTraitTest

ValidInstrumentation

InvalidInstrumentation

SpanAttributeTest

WithSpanHandlerTest

WithSpanTest

LoggerHolderTest

LogRecordTest

Psr3Test

NoopLoggerProviderTest

NoopLoggerTest

SeverityTest

LocalRootSpanTest

NonRecordingSpanTest

NoopSpanBuilderTest

NoopTracerTest

TraceContextPropagatorTest

TraceContextValidatorTest

SpanContextTest

SpanContextValidatorTest

TraceStateTest

TraceTest

ConfigurationFactoryTest

LogRecordExporterConsole

LogRecordExporterOtlp

LogRecordProcessorBatch

LogRecordProcessorSimple

AggregationResolverDefault

AggregationResolverDrop

AggregationResolverExplicitBucketHistogram

AggregationResolverLastValue

AggregationResolverSum

MetricExporterConsole

MetricExporterOtlp

MetricExporterPrometheus

MetricReaderPeriodic

MetricReaderPull

OpenTelemetryConfiguration

TextMapPropagatorB3

TextMapPropagatorB3Multi

TextMapPropagatorBaggage

TextMapPropagatorComposite

TextMapPropagatorJaeger

TextMapPropagatorOTTrace

TextMapPropagatorTraceContext

TextMapPropagatorXRay

SamplerAlwaysOff

SamplerAlwaysOn

SamplerParentBased

SamplerTraceIdRatioBased

SpanExporterConsole

SpanExporterOtlp

SpanExporterZipkin

SpanProcessorBatch

SpanProcessorSimple

ContextKeysTest

ContextKeyTest

ContextStorageTest

ContextTest

DebugScopeTest

FiberBoundContextStorageExecutionAwareBCTest

ArrayAccessGetterSetterTest

MultiTextMapPropagatorTest

NoopTextMapPropagatorTest

ScopeTest

GrpcTransportFactoryTest

GrpcTransportTest

AttributesConverterTest

HttpEndpointResolverTest

LogsConverterTest

LogsExporterFactoryTest

LogsExporterTest

MetricConverterTest

MetricExporterFactoryTest

MetricExporterTest

OtlpHttpTransportFactoryTest

OtlpUtilTest

ProtobufSerializerTest

SpanConverterTest

SpanExporterFactoryTest

SpanExporterTest

ZipkinExporterTest

ZipkinSpanConverterTest

B3DebugFlagContextKeyTest

B3MultiPropagatorTest

B3PropagatorTest

B3SinglePropagatorTest

CloudTraceFormatterTest

CloudTracePropagatorOneWayTest

CloudTracePropagatorTest

UtilsTest

JaegerBaggagePropagatorTest

JaegerDebugFlagContextKeyTest

JaegerPropagatorTest

DependencyResolverTest

HttpPlugClientResolverTest

MessageFactoryResolverTest

PsrClientResolverTest

AttributesTest

AttributeValidatorTest

FilteredAttributesTest

ConfigurationTest

BooleanParserTest

ListParserTest

MapParserTest

RatioParserTest

CompositeResolverTest

EnvironmentResolverTest

PhpIniResolverTest

UtilTest

PsrTransportTest

PsrUtilsTest

StreamTransportFactoryTest

FutureTest

AbstractDiscoveryTestCase

BuzzTest

CurlClientTest

GuzzleTest

SymfonyTest

DiscoveryTest

MessageFactoryTest

InstrumentationScopeTest

ConfigTest

ConfiguratorTest

ClassConstantAccessorTest

ClassConstantAccessorTestClass

ShutdownHandlerTest

WeakenTest

A

B

FactoryRegistryTest

EventLoggerProviderFactoryTest

EventLoggerProviderTest

EventLoggerTest

ConsoleExporterFactoryTest

ConsoleExporterTest

InMemoryExporterFactoryTest

InMemoryExporterTest

NoopExporterTest

ExporterFactoryTest

LoggerProviderBuilderTest

LoggerProviderFactoryTest

LoggerProviderTest

LoggerSharedStateTest

LoggerTest

LogRecordLimitsBuilderTest

LogRecordProcessorFactoryTest

NoopEventLoggerProviderTest

NoopLoggerProviderTest

BatchLogRecordProcessorTest

MultiLogRecordProcessorTest

NoopLogRecordProcessorTest

SimpleLogRecordProcessorTest

ReadableLogRecordTest

SimplePsrFileLoggerTest

ExplicitBucketHistogramAggregationTest

LastValueAggregationTest

SumAggregationTest

FilteredAttributeProcessorTest

IdentityAttributeProcessorTest

BucketStorageTest

FilteredReservoirTest

FixedSizeReservoirTest

HistogramBucketReservoirTest

NoopReservoirTest

InstrumentTest

MeterProviderFactoryTest

MeterProviderTest

MeterTest

ConsoleMetricExporterFactoryTest

InMemoryExporterFactoryTest

InMemoryExporterTest

NoopMetricExporterFactoryTest

StreamFactoryTest

CollectingSourceRegistry

ExportingReaderTest

MetricRegistryTest

DelayedStalenessHandlerTest

ImmediateStalenessHandlerTest

NoopStalenessHandlerTest

DeltaStorageTest

MetricStreamTest

CriteriaViewRegistryTest

SelectionCriteriaTest

ViewTemplateTest

PropagatorFactoryTest

ComposerTest

CompositeTest

ConstantTest

EnvironmentTest

HostTest

OperatingSystemTest

ProcessRuntimeTest

ProcessTest

SdkProvidedTest

SdkTest

ServiceTest

ResourceInfoFactoryTest

ResourceInfoTest

SdkAutoloaderTest

SdkBuilderTest

SdkTest

AutoRootSpanTest

UsesSpanConverterTraitTest

EventTest

ExporterFactoryTest

ImmutableSpanTest

LinkTest

NonRecordingSpanTest

RandomIdGeneratorTest

AlwaysOffSamplerTest

AlwaysOnSamplerTest

ParentBasedTest

TraceIdRatioBasedSamplerTest

SamplerFactoryTest

SamplingResultTest

SpanBuilderTest

AbstractExporterTestCase

AbstractLoggerAwareTestCase

ConsoleSpanExporterFactoryTest

ConsoleSpanExporterTest

FriendlySpanConverterTest

InMemoryExporterTest

InMemorySpanExporterFactoryTest

LoggerDecoratorTest

LoggerExporterTest

NullSpanConverterTest

SpanLimitsBuilderTest

BatchSpanProcessorBuilderTest

BatchSpanProcessorTest

MultiSpanProcessorTest

NoopSpanProcessorTest

SimpleSpanProcessorTest

SpanProcessorFactoryTest

SpanTest

StatusDataTest

TracerProviderFactoryTest

TracerProviderTest

TracerSharedStateTest

TracerTest

SpanData

VersionTest

Traits

LogsMessagesTrait

InstrumentationTrait

This trait in conjunction with the InstrumentationInterface is meant as a base for instrumentations for the OpenTelemetry API.

ConfigTrait

DefaultAggregationProviderTrait

LoggerAwareTrait

SpanExporterDecoratorTrait

SpanExporterTrait

UsesSpanConverterTrait

TestState

UsesHttpClientTrait

CreatesMockTrait

UsesRequestFactoryTrait

UsesResponseFactoryTrait

UsesServerRequestFactoryTrait

LoggerAwareTestTrait

Enums

Severity

Version

Functions

trace()  : R

Executes the given closure within the provided span.

main()  : void

parseRequestFromGlobals()  : RequestInterface

sendResponse()  : void

handleTraceContext()  : ResponseInterface