OpenTelemetryAPI

Return the Context associated with the caller's current execution unit.

with_context(f, [context]; kv...)

Run function f in the context. If extra kv pairs are provided, they will be merged with the context to form a new context. When context is not provided, the current_context will be used.

TraceContextTextMapPropagator()

This propagator follows the W3C format

Each concrete span should have the following interfaces implemented.

• tracer
• span_context
• span_kind
• parent_span_context
• attributes
• is_recording
• start_time
• end_time
• end_span!
• span_status!
• span_status
• span_name!
• span_name
• span_links
• span_events

Tracer(;instrumentation_scope=InstrumentationScope(), provider=global_meter_provider())

attributes(s::AbstractSpan)

A BoundedAttributes is expected.

end_span!([s=current_span()], [t=UInt(time()*10^9)])

Set the end time of the span and trigger span processors. Note t is the nanoseconds.

global_tracer_provider(p)

Set the global tracer provider to p.

global_tracer_provider()

Get the global tracer provider.

is_recording([current_span()])

Returns true if this span s is recording information like Event operations, attribute modification using setindex!, etc.

parent_span_context(s::AbstractSpan)

Get the SpanContext from parent span.

provider(s::AbstractSpan)

Get the AbstractTracerProvider which generates the tracer that the span s resides in.

resource(s::AbstractSpan)

Get the associated resource of the span s. Fall back to resource(provider(::AbstractSpan))

span_context([s::AbstractSpan])

Get the SpanContext from a span s. If s is not specified, current_span() will be used. nothing is returned if no span context found.

span_events(s::AbstractSpan)

Get the recorded events in a span.

span_kind([current_span()])

Return SpanKind

span_links(s::AbstractSpan)

Get the recorded links in a span.

span_name!([current_span()], name::String)

span_name([current_span()])

span_status!([current_span()], code::SpanStatusCode, description=nothing)

Update the status of span s by following the original specification. description is only considered when the code is SPAN_STATUS_ERROR. Only valid when the span is not ended yet.

span_status([current_span()])

Get status of the span. A SpanStatusCode is returned.

tracer(s::AbstractSpan)

Get the Tracer which generates the span s.

with_span(f, name::String, [tracer=Tracer()]; kw...)

Call function f with the current span set a newly created one of name with tracer.

Keyword arguments

• end_on_exit=true, controls whether to call end_span! after f or not.
• record_exception=true, controls whether to record the exception.
• set_status_on_exception=true, decides whether to set status to SPAN_STATUS_ERROR automatically when an exception is caught.
• The rest keyword arguments are forwarded to create_span.

with_span(f, s::AbstractSpan; kw...)

Call function f with the provided span s.

Keyword arguments

• end_on_exit=true, controls whether to call end_span! after f or not.
• record_exception=true, controls whether to record the exception.
• set_status_on_exception=true, decides whether to set status to SPAN_STATUS_ERROR automatically when an exception is caught.

Meter(name::String;kw...)

Meter is responsible for creating instruments.

Keyword Arguments:

• provider::P = global_meter_provider()
• instrumentation_scope = InstrumentationScope()

global_meter_provider(p)

Set the global meter provider to p.

global_meter_provider()

Get the global meter provider.

Counter{T}(name, meter;unit="", description="") where T

Counter is a AbstractSyncInstrument which supports non-negative increments.

See more details from the specification.

Histogram{T}(name, meter; unit = "", description = "") where {T}

Histogram is an AbstractSyncInstrument which can be used to report arbitrary values that are likely to be statistically meaningful. It is intended for statistics such as histograms, summaries, and percentile.

See more details from the specification

Measurement(value, [attributes=BoundedAttributes()])

This is to follow the specification

See also BoundedAttributes

ObservableCounter{T}(callback, name, meter; unit = "", description = "") where {T}

ObservableCounter is an AbstractAsyncInstrument which reports monotonically increasing value(s) when the instrument is being observed.

See more details from the specification

ObservableGauge{T}(callback, name, meter; unit = "", description = "",) where {T}

ObservableGauge is an AbstractAsyncInstrument which reports non-additive value(s) (e.g. the room temperature - it makes no sense to report the temperature value from multiple rooms and sum them up) when the instrument is being observed.

See also the details from the specification

ObservableUpDownCounter{T}(callback, name, meter; unit = "", description = "") where {T}

ObservableUpDownCounter is an AbstractAsyncInstrument which reports additive value(s) (e.g. the process heap size - it makes sense to report the heap size from multiple processes and sum them up, so we get the total heap usage) when the instrument is being observed.

See more details from the specification.

UpDownCounter{T}(name, meter; unit = "", description = "") where {T}

UpDownCounter is a AbstractSyncInstrument which supports increments and decrements.

See also the details from the specification.

LogRecord(;kw...)

A Julia representation of the Log Data Model.

OtelLogTransformer(resource::Resource)

It can be used as a function f to the TransformerLogger. After applying this transformer, a LogRecord will be returned.

Valid type of attribute value.

Async instrument usually has a callback function (which is named Observable in OpenTelemetry) to get its measurement.

AbstractInstrumentis the super type of all instruments, which are used to report [Measurement`](@ref)s.

Each concrete subtype should at least have the following fields:

• name
• description
• unit
• meter, the associated Meter

See also the specification:

A meter provider defines how to collect and update Measurements. Each meter provider should have the following interfaces implemented:

• Base.push!(provider, m::Meter), register a meter.
• Base.push!(provider, ins::AbstractInstrument), register an instrument.
• Base.push!(provider, (ins::AbstractInstrument, m::Measurement)), update a measurement.

Sync instrument usually pass its measurement immediately.

A tracer provider is a part of an Tracer. For each concrete tracer provider, resource and OpenTelemetryAPI.create_span(name::String, tracer::Tracer{<:YourCustomProvider}) should also be implemented.

BoundedAttributes(attrs; count_limit=nothing, value_length_limit=nothing)

This provides a wrapper around attributes (typically AbstractDict or NamedTuple) to follow the specification of Attribute.

The following methods from Base are defined on BoundedAttributes which are then forwarded to the inner attrs by default. Feel free to create a PR if you find any method you need is missing:

• Base.getindex
• Base.setindex!
• Base.iterate
• Base.length
• Base.haskey
• Base.push!. Obviously, an error will be thrown when calling on immutable attrss like NamedTuple.

CompositePropagator(propagators::Vector)

Event(name, attributes; timestamp=time()*10^9)

timestamp is the nanoseconds.

InstrumentationScope(;name="OpenTelemetryAPI", version=<default>, schema_url="", attributes=BoundedAttributes())

Usually used in an instrumentation package.

LimitInfo(;kw...)

Used in TracerProvider to configure generated Tracer.

Link(span_context, attributes)

See more details at links between spans.

Resource(;attributes=nothing, schema_url="", default_attributes=OTEL_RESOURCE_ATTRIBUTES())

Quoted from the specification:

Resource captures information about the entity for which telemetry is recorded. For example, metrics exposed by a Kubernetes container can be linked to a resource that specifies the cluster, namespace, pod, and container name.

Resource may capture an entire hierarchy of entity identification. It may describe the host in the cloud and specific container or an application running in the process.

SpanContext(;span_id, trace_id, is_remote, trace_flag=TraceFlag(), trace_state=TraceState())

A SpanContext represents the portion of a Span which must be serialized and propagated along side of a distributed context. SpanContexts are immutable.

The OpenTelemetry SpanContext representation conforms to the W3C TraceContext specification. It contains two identifiers - a TraceId and a SpanId - along with a set of common TraceFlags and system-specific TraceState values.

TraceId A valid trace identifier is a 16-byte array with at least one non-zero byte.

SpanId A valid span identifier is an 8-byte array with at least one non-zero byte.

TraceFlags contain details about the trace. Unlike TraceState values, TraceFlags are present in all traces. The current version of the specification only supports a single flag called sampled.

TraceState carries vendor-specific trace identification data, represented as a list of key-value pairs. TraceState allows multiple tracing systems to participate in the same trace. It is fully described in the W3C Trace Context specification.

SpanStatus(code, description=nothing)

Possible codes are:

• SPAN_STATUS_UNSET
• SPAN_STATUS_ERROR
• SPAN_STATUS_OK

description is required when code is SPAN_STATUS_ERROR.

TraceState(entries::Pair{String,String}...)

TraceState carries vendor-specific trace identification data, represented as a list of key-value pairs. TraceState allows multiple tracing systems to participate in the same trace. It is fully described in the W3C Trace Context specification.

Base.getindex(s::AbstractSpan, key)

Look up key in the attributes of the span s.

Base.haskey(s::AbstractSpan, key)

Check if the span s has the key in its attributes.

Base.push!([s::AbstractSpan], event::Event)

Add an Event into the span s.

Base.push!([current_span()], link::Link)

Add a Link into the span s.

Base.push!(s::AbstractSpan, ex::Exception; is_rethrow_followed = false)

A specialized variant of Event to record exceptions. Usually used in a try... catch...end to capture the backtrace. If the ex is rethrowed in the catch...end, is_rethrow_followed should be set to true.

(s::AbstractSpan)[key] = val

Set the attributes in span s. Only valid when the span is not ended yet.

Maximum allowed span attribute count

Maximum allowed attribute value size

Maximum allowed time (in milliseconds) to export data

Maximum batch size Must be less than or equal to OTELBLRPMAXQUEUESIZE

Maximum queue size

Delay interval (in milliseconds) between two consecutive exports

Maximum allowed time (in milliseconds) to export data

Maximum batch size

Must be less than or equal to OTELBSPMAXQUEUESIZE

Maximum queue size

Delay interval (in milliseconds) between two consecutive exports

Maximum allowed attribute per span event count

Host used by the Prometheus exporter

Port used by the Prometheus exporter

Maximum allowed attribute per span link count

Maximum allowed log record attribute count

Maximum allowed attribute value size

Logs exporter to be used

Log level used by the SDK logger.

Filter for which measurements can become Exemplars.

Metrics exporter to be used

The time interval (in milliseconds) between the start of two export attempts.

Maximum allowed time (in milliseconds) to export data.

Propagators to be used as a comma-separated list .

Values MUST be deduplicated in order to register a Propagator only once.

Key-value pairs to be used as resource attributes.

See Resource SDK for more details.

Disable the SDK for all signals.

Boolean value. If "true", a no-op SDK implementation will be used for all telemetry signals. Any other value or absence of the variable will have no effect and the SDK will remain enabled. This setting has no effect on propagators configured through the OTEL_PROPAGATORS variable.

Sets the value of the service.name resource attribute.

If service.name is also provided in OTEL_RESOURCE_ATTRIBUTES, then OTEL_SERVICE_NAME takes precedence.

Maximum allowed span attribute count

Maximum allowed attribute value size

Maximum allowed span event count

Maximum allowed span link count

Trace exporter to be used

Sampler to be used for traces.

See Sampling

String value to be used as the sampler argument.

The specified value will only be used if OTELTRACESSAMPLER is set. Each Sampler type defines its own expected input, if any. Invalid or unrecognized input MUST be logged and MUST be otherwise ignored, i.e. the SDK MUST behave as if OTELTRACESSAMPLER_ARG is not set.

Follow the specification on Attribute Limits. The cleaned attributes and the number of dropped elements is returned.

Here we follow the Behavior of the API in the absence of an installed SDK.

current_span([current_context])

Get the span in the current context.

end_time(s::AbstractSpan)

Get the end time of span s in nanoseconds.

Turn "a=b,c=d" into a NamedTuple

extract_context(carrier, [global_propagator], [current_context])

Extracts the value from an incoming request. For example, from the headers of an HTTP request.

inject(carrier, [global_propagator], [current_context])

Injects the value into a carrier. For example, into the headers of an HTTP request.

n_dropped(x::BoundedAttributes)

Return the total number of dropped elements since creation.

start_time(s::AbstractSpan)

Get the start time of span s in nanoseconds.