All Classes and Interfaces

Class
Description
 
 
A thread-safe map with weak keys.
 
A circle-buffer-backed exponential counter.
An integer array that automatically expands its memory consumption (via copy/allocation) when reaching limits.
Possible sizes of backing arrays.
This class is internal and is hence not for public use.
This class is internal and is hence not for public use.
This class is internal and is hence not for public use.
 
Configures how instrument measurements are combined into metrics.
 
 
Describes the time period over which measurements are aggregated.
A functional interface that selects AggregationTemporality based on InstrumentType.
This class is internal and is hence not for public use.
Aggregator represents the abstract class for all the available aggregations that can be computed during the collection phase for all the instruments.
An internal interface for returning an Aggregator from an Aggregation.
Aggregator represents the abstract class that is used for synchronous instruments.
A filter which makes no measurements eligible for being an exemplar.
 
A filter which makes all measurements eligible for being an exemplar.
 
A utility for returning wall times anchored to a given point in time.
RandomSupplier instance that doesn't use ThreadLocalRandom, which is broken on most versions of Android (it uses the same seed everytime it starts up).
 
Utility methods for obtaining AnyValue marshaler.
A Marshaler of key value pairs.
Helper for API misuse logging.
 
 
A Marshaler of key value pairs.
 
 
 
Array-based Stack.
 
 
 
Stores aggregated MetricData for asynchronous instruments.
 
 
This interface provides a handle for setting the values of Attributes.
A Marshaler of key value pairs.
 
An immutable container for attributes.
A builder of Attributes supporting an arbitrary number of key-value pairs.
A map with a fixed capacity that drops attributes when the map gets full, and which truncates string and array string attribute values to the AttributesMap.lengthLimit.
An AttributesProcessor is used to define the actual set of attributes that will be used in a Metric vs.
Processor which appends a static set of Attributes.
Processor which filters attributes according to a AttributeKey.getKey() Predicate.
Processor which appends entries from Baggage with keys that match a predicate.
A AttributesProcessor that runs a sequence of processors.
Predicate which tests if the set includes the input.
An enum that represents all the possible value types for an AttributeKey and hence the types of values that are allowed for Attributes.
 
This class is internal and is hence not for public use.
This class is internal and is hence not for public use.
A builder for customizing OpenTelemetry auto-configuration.
A service provider interface (SPI) for customizing auto-configuration.
An auto-configured OpenTelemetry SDK.
A builder for configuring auto-configuration of the OpenTelemetry SDK.
Interface to be extended by SPIs that require access to the autoconfigured OpenTelemetrySdk instance.
This class is internal and is hence not for public use.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Deprecated.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A map from String to BaggageEntry that can be used to label anything that is associated with a specific operation.
A builder of Baggage.
Note: This class is based on code from Apache Commons Codec.
Util class to hold on to the key for storing Baggage in the Context.
An entry in a set of baggage.
Metadata associated with an BaggageEntry.
Exponential bucket histogram aggregation configuration.
 
Implementation of the LogRecordProcessor that batches logs exported by the SDK then pushes them to the exporter pipeline.
 
Builder class for BatchLogRecordProcessor.
Implementation of the SpanProcessor that batches spans exported by the SDK then pushes them to the exporter pipeline.
 
Builder class for BatchSpanProcessor.
Deprecated.
Deprecated.
 
 
 
A registered callback.
Customize the MetricReader cardinality limit as a function of InstrumentType.
 
Interface for getting the current time.
Minimal copy of protobuf-java's CodedInputStream, currently only used in GrpcStatusUtil.
Protobuf wire encoder.
Abstract base class for buffered encoders.
An CodedOutputStream that decorates an OutputStream.
A CollectionRegistration is passed to each MetricReader registered with SdkMeterProvider, and provides readers the ability to trigger metric collections.
This class models JDK 8's CompletableFuture to afford migration should Open Telemetry's SDK select JDK 8 or greater as a baseline, and also to offer familiarity to developers.
A loader for components that are discovered via SPI.
Provides configured instances of SDK extension components.
Component (tracer, meter, etc) registry class for all the provider classes (TracerProvider, MeterProvider, etc.).
An abstraction for compressing messages.
A service provider interface (SPI) for providing Compressors.
Utilities for resolving SPI Compressors.
A resource provider that is only applied if the ConditionalResourceProvider.shouldApply(ConfigProperties, Resource) method returns true.
Properties used for auto-configuration of the OpenTelemetry SDK components.
A service provider interface (SPI) for providing additional exporters that can be used with the autoconfigured SDK.
A service provider interface (SPI) for providing additional exporters that can be used with the autoconfigured SDK.
A service provider interface (SPI) for providing additional metric readers that can be used with the autoconfigured SDK.
A service provider interface (SPI) for providing additional propagators that can be used with the autoconfigured SDK.
A service provider interface (SPI) for providing additional samplers that can be used with the autoconfigured SDK.
A service provider interface (SPI) for providing additional exporters that can be used with the autoconfigured SDK.
An exception that is thrown if the user-provided configuration is invalid.
Configuration utilities.
A context propagation mechanism which can carry scoped-values across API boundaries and between threads.
 
Key for indexing values of type ContextKey stored in a Context.
A container of the registered propagators for every supported format.
 
The storage for storing and retrieving the current Context.
A Java SPI (Service Provider Interface) to allow replacing the default ContextStorage.
Holder of functions to wrap the used ContextStorage.
Specifies some aspects of the method behavior depending on the arguments.
 
 
 
A ThreadFactory that delegates to Executors.defaultThreadFactory() and marks all threads as daemon.
A collection of metric PointData.
Determines if the SDK is in debugging mode (captures stack traces) or not.
Utilities for logging metric diagnostic issues.
Aggregation that selects the specified default based on instrument.
A functional interface that selects default Aggregation based on InstrumentType.
Properties are normalized to The properties for both of these will be normalized to be all lower case, dashses are replaces with periods, and environment variable underscores are replaces with periods.
 
DefaultContextPropagators is the default, built-in implementation of ContextPropagators.
 
 
 
 
 
 
 
 
No-op implementation of Meter.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A MeterProvider that does nothing.
 
The default OpenTelemetry API, which tries to find API implementations via SPI or otherwise falls back to no-op default implementations.
Stores aggregated MetricData for synchronous instruments.
 
No-op implementation of Tracer.
 
 
 
A SpanData which delegates all methods to another SpanData.
Interface mirroring the DoubleAdder API, with implementation that varies based on availability of DoubleAdder.
 
Aggregator that generates base2 exponential histograms.
 
This class handles the operations for recording, scaling, and exposing data related to the base2 exponential histogram.
A Counter instrument that records double values.
Builder class for DoubleCounter.
Exemplar data for double measurements.
Aggregator that generates explicit bucket histograms.
 
A gauge instrument that synchronously records double values.
A builder for Gauge metric types.
A Histogram instrument that records double values.
Builder class for DoubleHistogram.
Aggregator that aggregates recorded values by storing the last recorded value.
 
Point data with a double aggregation value.
Sum aggregator that keeps values as doubles.
 
An UpDownCounter instrument that records double values.
Builder class for DoubleUpDownCounter.
Configuration representing no aggregation.
A "null object" Aggregator which denotes no aggregation should occur.
A resizable list for storing primitive `long` values.
Represents single element of a W3C baggage header (key or value).
 
This class is internal and is hence not for public use.
 
Empty instance of StructuredConfigProperties.
The EventBuilder is used to EventBuilder.emit() events.
Data representation of an event.
A EventLogger is the entry point into an event pipeline.
Builder class for creating EventLogger instances.
A registry for creating scoped EventLoggers.
Data representation of an event for a recorded exception.
 
An example measurement.
Exemplar filters are used to pre-filter measurements before attempting to store them in a reservoir.
 
An interface for an exemplar reservoir of samples.
Explicit bucket histogram aggregation configuration.
Utilities for interacting with explicit bucket histograms.
 
ExponentialHistogramBuckets represents either the positive or negative measurements taken for a ExponentialHistogramPointData.
This class is internal and is hence not for public use.
A base-2 exponential histogram metric point, as defined by the OpenTelemetry Exponential Histogram specification.
 
 
This class is internal and is hence not for public use.
This class is internal and is hence not for public use.
ExponentialHistogramPointData represents an approximate distribution of measurements across exponentially increasing bucket boundaries, taken for a ExponentialHistogramData.
Utilities for exporter builders.
Helper for recording metrics from exporters.
 
 
 
 
 
 
 
Utility class to simplify context propagation.
 
 
 
 
No-op implementation of Meter.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A MeterProvider that does nothing.
 
No-op implementation of ExtendedTracer.
 
 
 
Extended DoubleCounter with experimental APIs.
Extended DoubleCounterBuilder with experimental APIs.
Extended DoubleGauge with experimental APIs.
Extended DoubleGaugeBuilder with experimental APIs.
Extended DoubleHistogram with experimental APIs.
Extended DoubleHistogramBuilder with experimental APIs.
Extended DoubleUpDownCounter with experimental APIs.
Extended DoubleUpDownCounterBuilder with experimental APIs.
Extended Logger with experimental APIs.
Extended LogRecordBuilder with experimental APIs.
Extended DoubleCounter with experimental APIs.
Extended LongCounterBuilder with experimental APIs.
Extended LongGauge with experimental APIs.
Extended LongGaugeBuilder with experimental APIs.
Extended LongHistogram with experimental APIs.
Extended LongHistogramBuilder with experimental APIs.
Extended LongUpDownCounter with experimental APIs.
Extended LongUpDownCounterBuilder with experimental APIs.
Extended SpanBuilder with experimental APIs.
Extended SpanProcessor with experimental APIs.
Extended Tracer with experimental APIs.
Represents the failure of a gRPC or HTTP exporter.
Represents the failure of a gRPC exporter.
Represents the failure of an HTTP exporter.
Filtered attributes is a filtered view of a ImmutableKeyValuePairs backed Attributes instance.
Implementation that can handle attributes of arbitrary size by storing filter status in a BitSet.
Implementation that relies on the source having less than FilteredAttributes.SmallFilteredAttributes.BITS_PER_INTEGER attributes, and storing entry filter status in the bits of an integer.
A reservoir that has a pre-filter on measurements.
Base for fixed-size reservoir sampling of Exemplars.
A ExecutorService that implements methods that don't need Context.
 
 
 
This class provides a temporary global accessor for EventLoggerProvider until the event API is marked stable.
A global singleton for the entrypoint to telemetry functionality for tracing, metrics and baggage.
Static global instances are obfuscated when they are returned from the API to prevent users from casting them to their SDK-specific implementation.
Utilities for glob pattern matching.
Generic gRPC exporter.
A builder for GrpcExporter.
This class is internal and is hence not for public use.
This class is internal and is hence not for public use.
An exporter of a messages encoded by Marshaler using the gRPC wire format.
A service provider interface (SPI) for providing GrpcSenders backed by different client libraries.
The field or method to which this annotation is applied can only be accessed when holding a particular lock, which may be a built-in (synchronization) lock, or may be an explicit Lock.
 
Data for a MetricDataType.HISTOGRAM metric.
 
 
A reservoir that records the latest measurement for each histogram bucket.
 
 
Point data for HistogramData.
Validations for HistogramPointData.
An exporter for http/protobuf or http/json using a signal-specific Marshaler.
A builder for HttpExporter.
An abstraction for sending HTTP requests and handling responses.
The HTTP response.
A service provider interface (SPI) for providing HttpSenders backed by different HTTP client libraries.
Interface used by the SdkTracer to generate new SpanIds and TraceIds.
 
 
An ExemplarData with double measurements.
DoublePoint is a single data point in a timeseries that describes the time-varying value of a double metric.
String-String key-value pair, along with ImmutableEntryMetadata.
 
An immutable implementation of the EventData.
An effectively immutable implementation of ExceptionEventData.
Auto value implementation of ExponentialHistogramBuckets.
Auto value implementation of ExponentialHistogramData.
Auto value implementation of ExponentialHistogramPointData.
GaugeData recorded uses doubles.
A histogram metric point.
An approximate representation of the distribution of measurements.
An immutable set of key-value pairs.
An immutable implementation of LinkData.
An ExemplarData with long measurements.
LongPoint is a single data point in a timeseries that describes the time-varying values of a int64 metric.
A long or double measurement recorded from ObservableLongMeasurement or ObservableDoubleMeasurement.
A container of metrics.
 
This class is internal and is hence not for public use.
Defines the status of a Span by providing a standard StatusCode in conjunction with an optional descriptive message.
SumData recorded uses doubles.
A summary metric point.
A single data point that summarizes the values in a time series of numeric values.
 
A summary metric value.
A value that can be stored inside Context.
Incubating utilities.
Deprecated.
 
Holds information about instrumentation scope.
 
A Marshaler of InstrumentationScopeInfo.
 
 
 
This class is internal and is hence not for public use.
This class is internal and is hence not for public use.
Deprecated.
use InstrumentationUtil instead.
Helper to make implementing builders easier.
 
 
Describes an instrument that was registered to record data.
Instrument selection criteria for applying Views registered via SdkMeterProviderBuilder.registerView(InstrumentSelector, View).
Builder for InstrumentSelector.
All possible instrument types.
All possible measurement value types.
 
Default AttributeKey implementation which preencodes to UTF8 for OTLP export.
Contains APIs that are implemented differently based on the version of Java being run.
Internal accessor of JCTools package for fast queues.
 
 
 
Key-value pair of String key and Value value.
 
 
 
 
 
 
A Marshaler of key value pairs.
A Marshaler of key value pairs.
A Marshaler of key value pairs.
 
Last-value aggregation configuration.
 
 
 
Data representation of a link.
 
A Logger is the entry point into a log pipeline.
Builder class for creating Logger instances.
A collection of configuration options which define the behavior of a Logger.
A registry for creating scoped Loggers.
 
Represents shared state and config between all SdkLoggers created by the same SdkLoggerProvider.
Class that holds limits enforced during log recording.
Builder for LogLimits.
 
 
Used to construct and emit log records from a Logger.
Log definition as described in OpenTelemetry Log Data Model.
An exporter is responsible for taking a collection of LogRecordDatas and transmitting them to their ultimate destination.
 
LogRecordProcessor is the interface to allow synchronous hooks for log records emitted by Loggers.
This class is internal and is hence not for public use.
Marshaler to convert SDK LogRecordData to OTLP ExportLogsServiceRequest.
Interface mirroring the LongAdder API, with implementation that varies based on availability of LongAdder.
A Counter instrument that records long values.
Builder class for LongCounter.
Exemplar data for long measurements.
A gauge instrument that synchronously records long values.
A builder for Gauge metric types.
A Histogram instrument that records long values.
Builder class for LongHistogram.
Aggregator that aggregates recorded values by storing the last recorded value.
 
A point data with a double aggregation value.
Sum aggregator that keeps values as longs.
 
 
An UpDownCounter instrument that records long values.
Builder class for LongUpDownCounter.
Marshaler to convert SDK LogRecordData to OTLP ExportLogsServiceRequest.
Marshaler to convert SDK MetricData to OTLP ExportMetricsServiceRequest.
Marshaler to convert SDK SpanData to OTLP ExportTraceServiceRequest.
Utilities for working with gRPC channels.
 
Marshaler from an SDK structure to protobuf wire format.
Class for keeping marshaling state.
 
This class is internal and is hence not for public use.
 
Adapter from Marshaler to gRPC types.
 
 
 
 
A gRPC stub that uses a Marshaler.
 
 
Marshaler utilities.
A Marshaler which returns a memoized size.
A long or double measurement recorded from ObservableLongMeasurement or ObservableDoubleMeasurement.
The memory semantics of the SDK.
Provides instruments used to record measurements which are aggregated to metrics.
Builder class for creating Meter instances.
A collection of configuration options which define the behavior of a Meter.
A registry for creating named Meters.
 
State for a SdkMeterProvider.
 
Metric data represents the aggregated measurements of an instrument.
The type of metric PointData.
Describes a metric that will be output.
A Metric Exporter is a push based interface for exporting MetricData out of SdkMeterProvider.
 
 
MetricProducer is the interface that is used to make metric data available to the MetricReaders.
A metric reader reads metrics from an SdkMeterProvider.
This class is internal and is hence not for public use.
 
Marshaler to convert SDK MetricData to OTLP ExportMetricsServiceRequest.
Stores collected MetricData.
Responsible for storing metrics by MetricDescriptor and returning access to input pipeline for instrument measurements.
LogRecordExporter that forwards all received logs to a list of LogRecordExporter.
Implementation of LogRecordProcessor that forwards all logs to a list of LogRecordProcessors.
SpanExporter that forwards all received spans to a list of SpanExporter.
Implementation of the SpanProcessor that simply forwards all received events to a list of SpanProcessors.
 
A mutable DoublePointData
A mutable Measurement implementation
This class is internal and is hence not for public use.
 
A reservoir that keeps no exemplars.
 
 
 
 
 
 
 
 
 
A pool of objects of type T.
A reference to an observable instrument registered with DoubleCounterBuilder.buildWithCallback(Consumer).
A reference to an observable instrument registered with DoubleGaugeBuilder.buildWithCallback(Consumer).
An interface for observing measurements with double values.
A reference to an observable instrument registered with DoubleUpDownCounterBuilder.buildWithCallback(Consumer).
A reference to an observable instrument registered with LongCounterBuilder.buildWithCallback(Consumer).
A reference to an observable instrument registered with LongGaugeBuilder.buildWithCallback(Consumer).
An interface for observing measurements with long values.
A reference to an observable metric registered with LongUpDownCounterBuilder.buildWithCallback(Consumer).
Super interface for observing measurements.
The entrypoint to telemetry functionality for tracing, metrics and baggage.
The SDK implementation of OpenTelemetry.
This class allows the SDK to unobfuscate an obfuscated static global provider.
This class allows the SDK to unobfuscate an obfuscated static global provider.
This class allows the SDK to unobfuscate an obfuscated static global provider.
A builder for configuring an OpenTelemetrySdk.
Interface to be extended by SPIs that need to guarantee ordering during loading.
This class is internal and is hence not for public use.
 
 
This class is internal and is hence not for public use.
Exports logs using OTLP via gRPC, using OpenTelemetry's protobuf model.
Exports metrics using OTLP via gRPC, using OpenTelemetry's protobuf model.
Builder utility for this exporter.
Exports spans using OTLP via gRPC, using OpenTelemetry's protobuf model.
Builder utility for this exporter.
Exports logs using OTLP via HTTP, using OpenTelemetry's protobuf model.
Builder utility for OtlpHttpLogRecordExporter.
Exports metrics using OTLP via HTTP, using OpenTelemetry's protobuf model.
Builder utility for OtlpHttpMetricExporter.
Exports spans using OTLP via HTTP, using OpenTelemetry's protobuf model.
Builder utility for OtlpHttpSpanExporter.
Declarative configuration SPI implementation for OtlpHttpLogRecordExporter and OtlpGrpcLogRecordExporter.
Declarative configuration SPI implementation for OtlpHttpMetricExporter and OtlpGrpcMetricExporter.
Declarative configuration SPI implementation for OtlpHttpSpanExporter and OtlpGrpcSpanExporter.
This class is internal and is hence not for public use.
A Sampler that uses the sampled flag of the parent Span, if present.
A builder for creating ParentBased sampler instances.
Implements single-pass Baggage parsing in accordance with https://w3c.github.io/baggage/ Key / value are restricted in accordance with https://www.ietf.org/rfc/rfc2616.txt.
 
A TextMapPropagator which can be configured with a set of fields, which will be extracted and stored in Context.
Note: This class is based on code from guava.
A MetricReader which wraps a MetricExporter and automatically reads and exports the metrics every export interval.
A point in the metric data model.
A bucket-based hash map with an internal re-usable map entry objects pool
 
A list of longs backed by, and exposing, an array of primitives.
 
 
 
The default Span that is used when no Span implementation is available.
 
Information about a field in a proto definition.
Information about a field in a proto definition.
Serializer for the protobuf binary wire format.
Configuration for proxy settings.
 
A FixedSizeExemplarReservoir which uses an un-unweighted/naive algorithm for sampler where the probability of sampling decrease as the number of observations continue.
 
 
Provides random number generater constructor utilities.
This class was taken from Jaeger java client.
SDK representation of a Span that can be read.
A read-only view of an array of key-value pairs.
A log record that can be read from and written to.
A combination of the write methods from the Span interface and the read methods from the ReadableSpan interface.
Represents a MetricReader registered with SdkMeterProvider.
Internal representation of a View and InstrumentSelector.
A Reservoir cell pre-allocated memories for Exemplar data.
Selects which FixedSizeExemplarReservoir ReservoirCell receives measurements.
 
Resource represents a resource, which capture identifying information about the entities for which signals (stats or traces) are reported.
A builder of Resource that allows to add key-value pairs and copy attributes from other Attributes or Resource.
Auto-configuration for the OpenTelemetry Resource.
 
A Marshaler of ResourceLogs.
A Marshaler of ResourceLogs.
A Marshaler of Resource.
 
 
A Marshaler of ResourceMetrics.
A Marshaler of ResourceMetrics.
 
A service provider interface (SPI) for providing a Resource that is merged into the default resource.
 
A Marshaler of ResourceSpans.
A Marshaler of ResourceSpans.
Configuration for exporter exponential retry policy.
Builder for RetryPolicy.
This class is internal and is hence not for public use.
 
A Sampler is used to make decisions on Span sampling.
A decision on whether a span should be recorded, recorded and sampled or dropped.
An AutoCloseable that represents a mounted context for a block of code.
A ScopeConfigurator computes configuration for a given InstrumentationScopeInfo.
Builder for ScopeConfigurator.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
SDK implementation for EventLoggerProvider.
 
 
SDK implementation of Logger.
 
SDK implementation for LoggerProvider.
Builder class for SdkLoggerProvider instances.
A collection of methods that allow use of experimental features prior to availability in public APIs.
SDK implementation of LogRecordBuilder.
 
 
 
 
 
 
 
 
 
SdkMeter is SDK implementation of Meter.
 
 
SDK implementation for MeterProvider.
Helper class to expose registered metric exports.
 
Builder class for the SdkMeterProvider.
A collection of methods that allow use of experimental features prior to availability in public APIs.
 
Records values from asynchronous instruments to associated AsynchronousMetricStorage.
 
Implementation for the Span class that records trace events.
 
SdkSpanBuilder is SDK implementation of SpanBuilder.
SdkTracer is SDK implementation of Tracer.
 
SDK implementation for TracerProvider.
Builder of SdkTracerProvider.
A collection of methods that allow use of experimental features prior to availability in public APIs.
Serializer to use when converting from an SDK data object into a protobuf output format.
 
 
Log record severity options.
 
An implementation of the LogRecordProcessor that passes LogRecordData directly to the configured exporter.
An implementation of the SpanProcessor that converts the ReadableSpan to SpanData and passes it directly to the configured exporter.
Builder class for SimpleSpanProcessor.
An interface that can be used to record the (runtime) source of registered metrics in the sdk.
An interface that represents a span.
 
 
 
 
SpanBuilder is used to construct Span instances which define arbitrary scopes of code that are sampled for distributed tracing as a single atomic unit.
An interface for creating a lambda that is wrapped in a span, returns a value, and that may throw.
A class that represents a span context.
Util class to hold on to the key for storing a Span in the Context.
Immutable representation of all data collected by the Span class.
 
An interface that allows different tracing services to export recorded data for sampled spans in their own format.
 
Represents the 32 bit span flags as specified in the proto definition.
Helper methods for dealing with a span identifier.
Type of Span.
Class that holds limits enforced during span recording.
 
Builder for SpanLimits.
 
 
SpanProcessor is the interface SdkTracer uses to allow synchronous hooks for when a Span is started or when a Span is ended.
This class is internal and is hence not for public use.
An interface for creating a lambda that is wrapped in a span and that may throw.
 
Immutable class that stores SpanData based on a SdkSpan.
This class is internal and is hence not for public use.
 
Diagnostic information derived from stack traces.
Marshaler from an SDK structure to protobuf wire format.
Marshaler from an SDK structure to protobuf wire format.
Marshaler utilities.
 
 
 
 
 
The set of canonical status codes.
Defines the status of a Span by providing a standard StatusCode in conjunction with an optional descriptive message.
A ContextStorage which keeps track of opened and closed Scopes, reporting caller information if a Scope is closed incorrectly or not at all.
 
 
A Marshaler of string-valued AnyValue.
A Marshaler of string-valued AnyValue.
 
Re-usable string predicates.
Utilities for working with strings.
An interface for accessing structured configuration data.
 
A sum aggregation configuration.
 
 
Data for a MetricDataType.SUMMARY metric.
 
 
 
 
Point data for SummaryData.
Stores aggregated MetricData for synchronous instruments.
ThreadLocal buffers for use when creating new derived objects such as Strings.
Interface that allows a TextMapPropagator to read propagated fields from a carrier.
Injects and extracts a value as text into carriers that travel in-band across process boundaries.
Class that allows a TextMapPropagator to set propagated fields into a carrier.
 
 
Will limit the number of log messages emitted, so as not to spam when problems are happening.
This class is internal and is hence not for public use.
Utility class to help with management of TLS related components.
Utilities for working with TLS.
Exemplar sampler that only samples measurements with associated sampled traces.
A valid trace flags is a byte or 2 character lowercase hex (base16) String.
Helper methods for dealing with a trace identifier.
We assume the lower 64 bits of the traceId's are randomly distributed around the whole (long) range.
Tracer is the interface for Span creation and interaction with the in-process context.
Builder class for creating Tracer instances.
A collection of configuration options which define the behavior of a Tracer.
Marshaler to convert SDK SpanData to OTLP ExportTraceServiceRequest.
A registry for creating named Tracers.
 
 
Carries tracing-system specific context in a list of key-value pairs.
A builder of TraceState.
 
 
 
General internal utility methods.
Value mirrors the proto AnyValue message type, and is used to model any type.
 
A quantile value within a SummaryPointData.
 
 
 
 
 
 
AnyValue type options, mirroring AnyValue#value options.
 
A view configures how measurements are aggregated and exported as metrics.
A builder for View.
Central location for Views to be registered.
TextMapPropagator that implements the W3C specification for baggage header propagation.
Implementation of the tracestate header encoding and decoding as defined by the W3C Trace Context recommendation.
Implementation of the W3C TraceContext propagation protocol.
A thread-safe map with weak keys.
 
A WeakConcurrentMap where stale entries are removed as a side effect of interacting with this map.
 
Stores MetricData and allows synchronous writes of measurements.