OpenTelemetry

OpenTelemetry tracing for Flyte.

Every task becomes a span, every flyte.trace step becomes a child span inside it, and spans created by your own code or by any instrumentation library nest underneath without wiring. Export goes wherever OTLP goes.

Usage:

import flyte
from flyteplugins.otel import init

# At module scope, not inside a task: the task span opens before the task body runs.
init(service_name="my-service")

env = flyte.TaskEnvironment(name="my_env")

@env.task
async def main(n: int) -> int:
    ...

With no arguments init reads OTEL_EXPORTER_OTLP_ENDPOINT and OTEL_EXPORTER_OTLP_HEADERS, so pointing it at a vendor is a matter of setting those usually from a flyte.Secret. If you already configure OpenTelemetry yourself, pass tracer_provider and your setup is adopted unchanged.

Trace context travels in Flyte’s custom_context as a W3C carrier in both directions: a run submitted inside a caller’s span joins that trace, and a child task nests under the task that spawned it even though it runs in another pod.

Two things are specific to Flyte being durable. When no trace context arrives from outside, the trace id is derived from the run identity, so the several processes that make up a crashed-and-resumed run all record into one trace with no coordination. And steps that a resumed run served from its durable log, which never execute and so would otherwise be missing, are recorded as spans marked flyte.replayed.

Directory

Classes

Methods

Methods

format_trace_id()

def format_trace_id(
    trace_id: int,
) -> str

Render a trace id the way backends display it: 32 lowercase hex characters.

get_tracer()

def get_tracer()

The tracer init built for handing to another instrumentation library.

Libraries that create their own provider still nest correctly since parenting comes from the active context rather than the provider. Sharing the tracer just keeps everything on one export pipeline.

init()

def init(
    service_name: Optional[str] = None,
    endpoint: Optional[str] = None,
    headers: Union[Mapping[str, str], str, None] = None,
    protocol: Optional[str] = None,
    resource_attributes: Optional[Mapping[str, Any]] = None,
    exporter: Union[SpanExporter, Sequence[SpanExporter], None] = None,
    tracer_provider: Optional[trace_api.TracerProvider] = None,
    disable_batch: bool = False,
    set_global: bool = True,
) -> OtelObserver

Start recording Flyte tasks and trace steps as OpenTelemetry spans.

Call this once at module scope, not inside a task. The task span opens before the task body runs, so initializing from within the body means that task’s own span has already been missed. Module scope runs during import, which happens before any task starts.

With no arguments it reads the standard OTEL_EXPORTER_OTLP_ENDPOINT and OTEL_EXPORTER_OTLP_HEADERS variables, which is the shape most vendors document.

If you already configure OpenTelemetry yourself, pass tracer_provider and none of the exporter arguments. The provider is adopted as it stands, with its sampler, resource, and exporters untouched; only its id generator is wrapped, so run derived trace ids keep working without you giving up your own setup.

Returns

The registered observer, which can be passed to shutdown.

Raises

shutdown()

def shutdown()

Unregister the observer and flush pending spans.

trace_id_for_run()

def trace_id_for_run(
    action: 'ActionID',
) -> int

The trace id shared by every span in this run, across attempts and containers.

Derived from the fully qualified run identity rather than the run name alone, so two runs that happen to share a name in different projects or domains stay distinct.