or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

index.md
tile.json

tessl/pypi-opentelemetry-exporter-jaeger

Convenience meta-package for OpenTelemetry Jaeger exporters that installs both gRPC and Thrift-based trace exporters.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
pypipkg:pypi/opentelemetry-exporter-jaeger@1.21.x

To install, run

npx @tessl/cli install tessl/pypi-opentelemetry-exporter-jaeger@1.21.0

index.mddocs/

OpenTelemetry Jaeger Exporter

A convenience meta-package that provides unified access to OpenTelemetry Jaeger trace exporters. This package automatically installs both gRPC Protocol Buffer and Thrift-based Jaeger exporters, allowing users to export OpenTelemetry traces to Jaeger tracing systems with multiple serialization methods.

Important: This package is deprecated. Since Jaeger v1.35+, Jaeger supports OTLP natively. New implementations should use the OTLP exporter instead.

Package Information

  • Package Name: opentelemetry-exporter-jaeger
  • Package Type: pypi
  • Language: Python
  • Installation: pip install opentelemetry-exporter-jaeger
  • Status: Deprecated (support ends July 2023)

Core Imports

Access the gRPC-based exporter (recommended):

from opentelemetry.exporter.jaeger.proto.grpc import JaegerExporter

Access the Thrift-based exporter:

from opentelemetry.exporter.jaeger.thrift import JaegerExporter

Access package version:

from opentelemetry.exporter.jaeger.version import __version__

Access default constants:

# gRPC exporter constants
from opentelemetry.exporter.jaeger.proto.grpc import (
    DEFAULT_GRPC_COLLECTOR_ENDPOINT,
    DEFAULT_EXPORT_TIMEOUT
)

# Thrift exporter constants
from opentelemetry.exporter.jaeger.thrift import (
    DEFAULT_AGENT_HOST_NAME,
    DEFAULT_AGENT_PORT,
    DEFAULT_EXPORT_TIMEOUT
)

Architecture

This meta-package provides a unified interface to OpenTelemetry's Jaeger exporters by automatically installing both supported implementations:

  • gRPC Protocol Buffer Exporter: Uses Protocol Buffers over gRPC for efficient binary communication
  • Thrift Protocol Exporter: Uses Thrift protocol over UDP (agent) or HTTP (collector) for legacy compatibility

The package registers a default entry point (jaeger) that references the gRPC implementation, while both exporters remain available for direct use based on specific deployment requirements.

Basic Usage

Using the gRPC Exporter (Default)

from opentelemetry import trace
from opentelemetry.exporter.jaeger.proto.grpc import JaegerExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

# Set up the tracer provider
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)

# Create a Jaeger exporter (gRPC)
jaeger_exporter = JaegerExporter(
    collector_endpoint='localhost:14250',
    insecure=True
)

# Create a batch span processor and add the exporter
span_processor = BatchSpanProcessor(jaeger_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

# Create and export spans
with tracer.start_as_current_span('example-span'):
    print('Hello from OpenTelemetry!')

Using the Thrift Exporter

from opentelemetry import trace
from opentelemetry.exporter.jaeger.thrift import JaegerExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

# Set up the tracer provider
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)

# Create a Jaeger exporter (Thrift)
jaeger_exporter = JaegerExporter(
    agent_host_name='localhost',
    agent_port=6831
)

# Create a batch span processor and add the exporter
span_processor = BatchSpanProcessor(jaeger_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

# Create and export spans
with tracer.start_as_current_span('example-span'):
    print('Hello from OpenTelemetry!')

Capabilities

gRPC Protocol Buffer Exporter

Exports OpenTelemetry traces to Jaeger using Protocol Buffers over gRPC. This is the default exporter referenced by the package's entry point.

class JaegerExporter(SpanExporter):
    def __init__(
        self,
        collector_endpoint: Optional[str] = None,
        insecure: Optional[bool] = None,
        credentials: Optional[ChannelCredentials] = None,
        max_tag_value_length: Optional[int] = None,
        timeout: Optional[int] = None,
    ):
        """
        Initialize the Jaeger gRPC exporter.

        Args:
            collector_endpoint: Jaeger collector endpoint (default: "localhost:14250")
            insecure: Whether to use insecure connection (default: False)
            credentials: gRPC channel credentials for secure connections
            max_tag_value_length: Maximum length for string attribute values
            timeout: Export timeout in seconds (default: 10)
        """

    def export(self, spans) -> SpanExportResult:
        """
        Export a batch of spans to Jaeger.

        Args:
            spans: List of spans to export

        Returns:
            SpanExportResult: SUCCESS or FAILURE
        """

    def shutdown(self):
        """Shutdown the exporter."""

    def force_flush(self, timeout_millis: int = 30000) -> bool:
        """
        Force flush pending data.

        Args:
            timeout_millis: Timeout in milliseconds

        Returns:
            bool: True if successful
        """

Thrift Protocol Exporter

Exports OpenTelemetry traces to Jaeger using Thrift protocol over UDP or HTTP. Supports both agent-based (UDP) and collector-based (HTTP) configurations.

class JaegerExporter(SpanExporter):
    def __init__(
        self,
        agent_host_name: Optional[str] = None,
        agent_port: Optional[int] = None,
        collector_endpoint: Optional[str] = None,
        username: Optional[str] = None,
        password: Optional[str] = None,
        max_tag_value_length: Optional[int] = None,
        udp_split_oversized_batches: bool = None,
        timeout: Optional[int] = None,
    ):
        """
        Initialize the Jaeger Thrift exporter.

        Args:
            agent_host_name: Jaeger agent hostname (default: "localhost")
            agent_port: Jaeger agent port (default: 6831)
            collector_endpoint: Jaeger collector HTTP endpoint
            username: Basic authentication username
            password: Basic authentication password
            max_tag_value_length: Maximum length for string attribute values
            udp_split_oversized_batches: Split oversized UDP batches
            timeout: Export timeout in seconds (default: 10)
        """

    def export(self, spans) -> SpanExportResult:
        """
        Export a batch of spans to Jaeger.

        Args:
            spans: List of spans to export

        Returns:
            SpanExportResult: SUCCESS or FAILURE
        """

    def shutdown(self):
        """Shutdown the exporter."""

    def force_flush(self, timeout_millis: int = 30000) -> bool:
        """
        Force flush pending data.

        Args:
            timeout_millis: Timeout in milliseconds

        Returns:
            bool: True if successful
        """

Package Version

Access to the package version string.

__version__: str = "1.21.0"

Environment Variables

Both exporters support configuration via environment variables:

Common Environment Variables

  • OTEL_EXPORTER_JAEGER_ENDPOINT: Jaeger collector endpoint
  • OTEL_EXPORTER_JAEGER_TIMEOUT: Export timeout in seconds

gRPC-Specific Environment Variables

  • OTEL_EXPORTER_JAEGER_CERTIFICATE: Path to TLS certificate file
  • OTEL_EXPORTER_JAEGER_GRPC_INSECURE: Use insecure gRPC connection ("true"/"false")

Thrift-Specific Environment Variables

  • OTEL_EXPORTER_JAEGER_AGENT_HOST: Jaeger agent hostname
  • OTEL_EXPORTER_JAEGER_AGENT_PORT: Jaeger agent port number
  • OTEL_EXPORTER_JAEGER_AGENT_SPLIT_OVERSIZED_BATCHES: Split large UDP batches
  • OTEL_EXPORTER_JAEGER_USER: Basic authentication username
  • OTEL_EXPORTER_JAEGER_PASSWORD: Basic authentication password

Types

from typing import Optional
from grpc import ChannelCredentials
from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult

# SpanExportResult is an enum with values:
# - SpanExportResult.SUCCESS
# - SpanExportResult.FAILURE

Constants

gRPC Exporter Constants

DEFAULT_GRPC_COLLECTOR_ENDPOINT: str = "localhost:14250"
DEFAULT_EXPORT_TIMEOUT: int = 10

Thrift Exporter Constants

DEFAULT_AGENT_HOST_NAME: str = "localhost"
DEFAULT_AGENT_PORT: int = 6831
DEFAULT_EXPORT_TIMEOUT: int = 10

Entry Point Configuration

This package registers a trace exporter entry point that can be used with OpenTelemetry's auto-configuration:

  • Entry point name: jaeger
  • Target: opentelemetry.exporter.jaeger.proto.grpc:JaegerExporter (gRPC implementation)

Package Dependencies

This meta-package automatically installs:

  • opentelemetry-exporter-jaeger-proto-grpc==1.21.0: gRPC/Protocol Buffer implementation
  • opentelemetry-exporter-jaeger-thrift==1.21.0: Thrift/UDP implementation

Users can install specific exporters individually to avoid unnecessary dependencies if only one protocol is needed.

Migration Notice

Deprecation: This package is deprecated as of version 1.16.0. Support will end in July 2023.

Recommended Migration: Use the OTLP exporter instead:

from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter

# Replace Jaeger exporters with OTLP
otlp_exporter = OTLPSpanExporter(
    endpoint="http://localhost:4317",  # Jaeger's OTLP endpoint
    insecure=True
)