nvidia-nat-opentelemetry 1.1.0a20251020__py3-none-any.whl

nat/plugins/opentelemetry/otel_span_exporter.py

@@ -0,0 +1,165 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+from abc import abstractmethod
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version
+
+from nat.builder.context import ContextState
+from nat.data_models.span import Span
+from nat.observability.exporter.span_exporter import SpanExporter
+from nat.observability.processor.batching_processor import BatchingProcessor
+from nat.observability.processor.processor import Processor
+from nat.plugins.opentelemetry.otel_span import OtelSpan
+from nat.plugins.opentelemetry.span_converter import convert_span_to_otel
+from opentelemetry.sdk.resources import Resource
+
+logger = logging.getLogger(__name__)
+
+
+def get_opentelemetry_sdk_version() -> str:
+    """Get the OpenTelemetry SDK version dynamically.
+
+    Returns:
+        The version of the opentelemetry-sdk package, or 'unknown' if not found.
+    """
+    try:
+        return version("opentelemetry-sdk")
+    except PackageNotFoundError:
+        logger.warning("Could not determine opentelemetry-sdk version")
+        return "unknown"
+
+
+class SpanToOtelProcessor(Processor[Span, OtelSpan]):
+    """Processor that converts a Span to an OtelSpan."""
+
+    async def process(self, item: Span) -> OtelSpan:
+        return convert_span_to_otel(item)  # type: ignore
+
+
+class OtelSpanBatchProcessor(BatchingProcessor[OtelSpan]):
+    """Processor that batches OtelSpans with explicit type information.
+
+    This class provides explicit type information for the TypeIntrospectionMixin
+    by overriding the type properties directly.
+    """
+    pass
+
+
+class OtelSpanExporter(SpanExporter[Span, OtelSpan]):
+    """Abstract base class for OpenTelemetry exporters.
+
+    This class provides a specialized implementation for OpenTelemetry exporters.
+    It builds upon SpanExporter's span construction logic and automatically adds
+    a SpanToOtelProcessor to transform Span objects into OtelSpan objects.
+
+    The processing flow is:
+    IntermediateStep → Span → OtelSpan → Export
+
+    Key Features:
+    - Automatic span construction from IntermediateStep events (via SpanExporter)
+    - Built-in Span to OtelSpan conversion (via SpanToOtelProcessor)
+    - Support for additional processing steps if needed
+    - Type-safe processing pipeline with enhanced TypeVar compatibility
+    - Batching support for efficient export
+
+    Inheritance Hierarchy:
+    - BaseExporter: Core functionality + TypeIntrospectionMixin
+    - ProcessingExporter: Processor pipeline support
+    - SpanExporter: Span creation and lifecycle management
+    - OtelExporter: OpenTelemetry-specific span transformation
+
+    Generic Types:
+    - InputSpanT: Always Span (from IntermediateStep conversion)
+    - OutputSpanT: Always OtelSpan (for OpenTelemetry compatibility)
+    """
+
+    def __init__(self,
+                 context_state: ContextState | None = None,
+                 batch_size: int = 100,
+                 flush_interval: float = 5.0,
+                 max_queue_size: int = 1000,
+                 drop_on_overflow: bool = False,
+                 shutdown_timeout: float = 10.0,
+                 resource_attributes: dict[str, str] | None = None):
+        """Initialize the OpenTelemetry exporter.
+
+        Args:
+            context_state: The context state to use for the exporter.
+            batch_size: The batch size for exporting spans.
+            flush_interval: The flush interval in seconds for exporting spans.
+            max_queue_size: The maximum queue size for exporting spans.
+            drop_on_overflow: Whether to drop spans on overflow.
+            shutdown_timeout: The shutdown timeout in seconds.
+            resource_attributes: Additional resource attributes for spans.
+        """
+        super().__init__(context_state)
+
+        # Initialize resource for span attribution
+        if resource_attributes is None:
+            resource_attributes = {}
+        self._resource = Resource(attributes=resource_attributes)
+
+        self.add_processor(SpanToOtelProcessor())
+        self.add_processor(
+            OtelSpanBatchProcessor(batch_size=batch_size,
+                                   flush_interval=flush_interval,
+                                   max_queue_size=max_queue_size,
+                                   drop_on_overflow=drop_on_overflow,
+                                   shutdown_timeout=shutdown_timeout))
+
+    async def export_processed(self, item: OtelSpan | list[OtelSpan]) -> None:
+        """Export the processed span(s).
+
+        This method handles the common logic for all OTEL exporters:
+        - Normalizes single spans vs. batches
+        - Sets resource attributes on spans
+        - Delegates to the abstract export_otel_spans method
+
+        Args:
+            item (OtelSpan | list[OtelSpan]): The processed span(s) to export.
+                Can be a single span or a batch of spans from BatchingProcessor.
+        """
+        try:
+            if isinstance(item, OtelSpan):
+                spans = [item]
+            elif isinstance(item, list):
+                spans = item
+            else:
+                logger.warning("Unexpected item type: %s", type(item))
+                return
+
+            # Set resource attributes on all spans
+            for span in spans:
+                span.set_resource(self._resource)
+
+            # Delegate to concrete implementation
+            await self.export_otel_spans(spans)
+
+        except Exception as e:
+            logger.error("Error exporting spans: %s", e, exc_info=True)
+
+    @abstractmethod
+    async def export_otel_spans(self, spans: list[OtelSpan]) -> None:
+        """Export a list of OpenTelemetry spans.
+
+        This method must be implemented by concrete exporters to handle
+        the actual export logic (e.g., HTTP requests, file writes, etc.).
+
+        Args:
+            spans (list[OtelSpan]): The list of spans to export.
+        """
+        pass

nat/plugins/opentelemetry/otlp_span_adapter_exporter.py

@@ -0,0 +1,94 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+from nat.builder.context import ContextState
+from nat.plugins.opentelemetry.mixin.otlp_span_exporter_mixin import OTLPSpanExporterMixin
+from nat.plugins.opentelemetry.otel_span_exporter import OtelSpanExporter
+
+logger = logging.getLogger(__name__)
+
+
+class OTLPSpanAdapterExporter(OTLPSpanExporterMixin, OtelSpanExporter):
+    """An OpenTelemetry OTLP span exporter for sending traces to OTLP-compatible services.
+
+    This class combines the OtelSpanExporter base functionality with OTLP-specific
+    export capabilities to provide a complete solution for sending telemetry traces
+    to any OTLP-compatible collector or service via HTTP.
+
+    Key Features:
+    - Complete span processing pipeline (IntermediateStep → Span → OtelSpan → Export)
+    - Batching support for efficient transmission
+    - OTLP HTTP protocol for maximum compatibility
+    - Configurable authentication via headers
+    - Resource attribute management
+    - Error handling and retry logic
+
+    This exporter is commonly used with services like:
+    - OpenTelemetry Collector
+    - Jaeger (OTLP endpoint)
+    - Grafana Tempo
+    - Custom OTLP-compatible backends
+
+    Example::
+
+        exporter = OTLPSpanAdapterExporter(
+            endpoint="https://api.service.com/v1/traces",
+            headers={"Authorization": "Bearer your-token"},
+            batch_size=50,
+            flush_interval=10.0
+        )
+    """
+
+    def __init__(
+            self,
+            *,
+            # OtelSpanExporter args
+            context_state: ContextState | None = None,
+            batch_size: int = 100,
+            flush_interval: float = 5.0,
+            max_queue_size: int = 1000,
+            drop_on_overflow: bool = False,
+            shutdown_timeout: float = 10.0,
+            resource_attributes: dict[str, str] | None = None,
+            # OTLPSpanExporterMixin args
+            endpoint: str,
+            headers: dict[str, str] | None = None,
+            **otlp_kwargs):
+        """Initialize the OTLP span exporter.
+
+        Args:
+            context_state: The context state for the exporter.
+            batch_size: Number of spans to batch before exporting.
+            flush_interval: Time in seconds between automatic batch flushes.
+            max_queue_size: Maximum number of spans to queue.
+            drop_on_overflow: Whether to drop spans when queue is full.
+            shutdown_timeout: Maximum time to wait for export completion during shutdown.
+            resource_attributes: Additional resource attributes for spans.
+            endpoint: The endpoint for the OTLP service.
+            headers: The headers for the OTLP service.
+            otlp_kwargs: Additional keyword arguments for the OTLP service.
+        """
+        super().__init__(context_state=context_state,
+                         batch_size=batch_size,
+                         flush_interval=flush_interval,
+                         max_queue_size=max_queue_size,
+                         drop_on_overflow=drop_on_overflow,
+                         shutdown_timeout=shutdown_timeout,
+                         resource_attributes=resource_attributes,
+                         endpoint=endpoint,
+                         headers=headers,
+                         **otlp_kwargs)

nat/plugins/opentelemetry/otlp_span_redaction_adapter_exporter.py

@@ -0,0 +1,144 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+from collections.abc import Callable
+from collections.abc import Mapping
+from enum import Enum
+from typing import Any
+
+from nat.builder.context import ContextState
+from nat.observability.processor.redaction import SpanHeaderRedactionProcessor
+from nat.observability.processor.span_tagging_processor import SpanTaggingProcessor
+from nat.plugins.opentelemetry.otlp_span_adapter_exporter import OTLPSpanAdapterExporter
+
+logger = logging.getLogger(__name__)
+
+
+class OTLPSpanHeaderRedactionAdapterExporter(OTLPSpanAdapterExporter):
+    """An OpenTelemetry OTLP span exporter with built-in redaction and privacy tagging.
+
+    This class extends OTLPSpanAdapterExporter to provide automatic span redaction
+    and privacy tagging capabilities. It automatically adds header-based redaction
+    and span tagging processors to the processing pipeline.
+
+    Key Features:
+    - Header-based span redaction with configurable callback logic
+    - Privacy level tagging for compliance and governance
+    - Complete span processing pipeline (IntermediateStep → Span → Redaction → Tagging → OtelSpan → Batching → Export)
+    - Batching support for efficient transmission
+    - OTLP HTTP protocol for maximum compatibility
+    - Configurable authentication via headers
+    - Resource attribute management
+    - Error handling and retry logic
+
+    The redaction processor allows conditional redaction based on authentication headers,
+    while the tagging processor adds privacy-level metadata to spans for downstream
+    processing and compliance tracking.
+
+    This exporter is commonly used with services like:
+    - OpenTelemetry Collector
+    - DataDog (OTLP endpoint)
+    - Jaeger (OTLP endpoint)
+    - Grafana Tempo
+    - Custom OTLP-compatible backends
+
+    Example::
+
+        def should_redact(auth_key: str) -> bool:
+            return auth_key in ["sensitive_user", "test_user"]
+
+        exporter = OTLPSpanRedactionAdapterExporter(
+            endpoint="https://api.service.com/v1/traces",
+            headers={"Authorization": "Bearer your-token"},
+            redaction_attributes=["user.email", "request.body"],
+            redaction_headers=["x-user-id"],
+            redaction_callback=should_redact,
+            redaction_value="REDACTED",
+            tags={"privacy.level": PrivacyLevel.HIGH, "service.type": "sensitive"},
+            batch_size=50,
+            flush_interval=10.0
+        )
+    """
+
+    def __init__(
+            self,
+            *,
+            # OtelSpanExporter args
+            context_state: ContextState | None = None,
+            batch_size: int = 100,
+            flush_interval: float = 5.0,
+            max_queue_size: int = 1000,
+            drop_on_overflow: bool = False,
+            shutdown_timeout: float = 10.0,
+            resource_attributes: dict[str, str] | None = None,
+            # Redaction args
+            redaction_attributes: list[str] | None = None,
+            redaction_headers: list[str] | None = None,
+            redaction_callback: Callable[..., Any] | None = None,
+            redaction_enabled: bool = False,
+            force_redaction: bool = False,
+            redaction_value: str = "[REDACTED]",
+            redaction_tag: str | None = None,
+            tags: Mapping[str, Enum | str] | None = None,
+            # OTLPSpanExporterMixin args
+            endpoint: str,
+            headers: dict[str, str] | None = None,
+            **otlp_kwargs):
+        """Initialize the OTLP span exporter with redaction and tagging capabilities.
+
+        Args:
+            context_state: The context state for the exporter.
+            batch_size: Number of spans to batch before exporting, default is 100.
+            flush_interval: Time in seconds between automatic batch flushes, default is 5.0.
+            max_queue_size: Maximum number of spans to queue, default is 1000.
+            drop_on_overflow: Whether to drop spans when queue is full, default is False.
+            shutdown_timeout: Maximum time to wait for export completion during shutdown, default is 10.0.
+            resource_attributes: Additional resource attributes for spans.
+            redaction_attributes: List of span attribute keys to redact when conditions are met.
+            redaction_headers: List of header keys to check for authentication/user identification.
+            redaction_callback: Function that returns true to redact spans based on header value, false otherwise.
+            redaction_enabled: Whether the redaction processor is enabled, default is False.
+            force_redaction: If True, always redact regardless of header checks, default is False.
+            redaction_value: Value to replace redacted attributes with, default is "[REDACTED]".
+            tags: Mapping of tag keys to their values (enums or strings) to add to spans.
+            redaction_tag: Tag to add to spans when redaction occurs.
+            endpoint: The endpoint for the OTLP service.
+            headers: The headers for the OTLP service.
+            otlp_kwargs: Additional keyword arguments for the OTLP service.
+        """
+        super().__init__(context_state=context_state,
+                         batch_size=batch_size,
+                         flush_interval=flush_interval,
+                         max_queue_size=max_queue_size,
+                         drop_on_overflow=drop_on_overflow,
+                         shutdown_timeout=shutdown_timeout,
+                         resource_attributes=resource_attributes,
+                         endpoint=endpoint,
+                         headers=headers,
+                         **otlp_kwargs)
+
+        # Insert redaction and tagging processors to the front of the processing pipeline
+        self.add_processor(SpanHeaderRedactionProcessor(attributes=redaction_attributes or [],
+                                                        headers=redaction_headers or [],
+                                                        callback=redaction_callback or (lambda _: False),
+                                                        enabled=redaction_enabled,
+                                                        force_redact=force_redaction,
+                                                        redaction_value=redaction_value,
+                                                        redaction_tag=redaction_tag),
+                           name="header_redaction",
+                           position=0)
+
+        self.add_processor(SpanTaggingProcessor(tags=tags), name="span_sensitivity_tagging", position=1)

nat/plugins/opentelemetry/register.py

@@ -0,0 +1,194 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import os
+
+from pydantic import Field
+
+from nat.builder.builder import Builder
+from nat.cli.register_workflow import register_telemetry_exporter
+from nat.data_models.telemetry_exporter import TelemetryExporterBaseConfig
+from nat.observability.mixin.batch_config_mixin import BatchConfigMixin
+from nat.observability.mixin.collector_config_mixin import CollectorConfigMixin
+
+logger = logging.getLogger(__name__)
+
+
+class LangfuseTelemetryExporter(BatchConfigMixin, TelemetryExporterBaseConfig, name="langfuse"):
+    """A telemetry exporter to transmit traces to externally hosted langfuse service."""
+
+    endpoint: str = Field(description="The langfuse OTEL endpoint (/api/public/otel/v1/traces)")
+    public_key: str = Field(description="The Langfuse public key", default="")
+    secret_key: str = Field(description="The Langfuse secret key", default="")
+    resource_attributes: dict[str, str] = Field(default_factory=dict,
+                                                description="The resource attributes to add to the span")
+
+
+@register_telemetry_exporter(config_type=LangfuseTelemetryExporter)
+async def langfuse_telemetry_exporter(config: LangfuseTelemetryExporter, builder: Builder):
+
+    import base64
+
+    from nat.plugins.opentelemetry import OTLPSpanAdapterExporter
+
+    secret_key = config.secret_key or os.environ.get("LANGFUSE_SECRET_KEY")
+    public_key = config.public_key or os.environ.get("LANGFUSE_PUBLIC_KEY")
+    if not secret_key or not public_key:
+        raise ValueError("secret and public keys are required for langfuse")
+
+    credentials = f"{public_key}:{secret_key}".encode()
+    auth_header = base64.b64encode(credentials).decode("utf-8")
+    headers = {"Authorization": f"Basic {auth_header}"}
+
+    yield OTLPSpanAdapterExporter(endpoint=config.endpoint,
+                                  headers=headers,
+                                  batch_size=config.batch_size,
+                                  flush_interval=config.flush_interval,
+                                  max_queue_size=config.max_queue_size,
+                                  drop_on_overflow=config.drop_on_overflow,
+                                  shutdown_timeout=config.shutdown_timeout)
+
+
+class LangsmithTelemetryExporter(BatchConfigMixin, CollectorConfigMixin, TelemetryExporterBaseConfig, name="langsmith"):
+    """A telemetry exporter to transmit traces to externally hosted langsmith service."""
+
+    endpoint: str = Field(
+        description="The langsmith OTEL endpoint",
+        default="https://api.smith.langchain.com/otel/v1/traces",
+    )
+    api_key: str = Field(description="The Langsmith API key", default="")
+    resource_attributes: dict[str, str] = Field(default_factory=dict,
+                                                description="The resource attributes to add to the span")
+
+
+@register_telemetry_exporter(config_type=LangsmithTelemetryExporter)
+async def langsmith_telemetry_exporter(config: LangsmithTelemetryExporter, builder: Builder):
+    """Create a Langsmith telemetry exporter."""
+
+    from nat.plugins.opentelemetry import OTLPSpanAdapterExporter
+
+    api_key = config.api_key or os.environ.get("LANGSMITH_API_KEY")
+    if not api_key:
+        raise ValueError("API key is required for langsmith")
+
+    headers = {"x-api-key": api_key, "Langsmith-Project": config.project}
+    yield OTLPSpanAdapterExporter(endpoint=config.endpoint,
+                                  headers=headers,
+                                  batch_size=config.batch_size,
+                                  flush_interval=config.flush_interval,
+                                  max_queue_size=config.max_queue_size,
+                                  drop_on_overflow=config.drop_on_overflow,
+                                  shutdown_timeout=config.shutdown_timeout)
+
+
+class OtelCollectorTelemetryExporter(BatchConfigMixin,
+                                     CollectorConfigMixin,
+                                     TelemetryExporterBaseConfig,
+                                     name="otelcollector"):
+    """A telemetry exporter to transmit traces to externally hosted otel collector service."""
+
+    resource_attributes: dict[str, str] = Field(default_factory=dict,
+                                                description="The resource attributes to add to the span")
+
+
+@register_telemetry_exporter(config_type=OtelCollectorTelemetryExporter)
+async def otel_telemetry_exporter(config: OtelCollectorTelemetryExporter, builder: Builder):
+    """Create an OpenTelemetry telemetry exporter."""
+
+    from nat.plugins.opentelemetry import OTLPSpanAdapterExporter
+    from nat.plugins.opentelemetry.otel_span_exporter import get_opentelemetry_sdk_version
+
+    # Default resource attributes
+    default_resource_attributes = {
+        "telemetry.sdk.language": "python",
+        "telemetry.sdk.name": "opentelemetry",
+        "telemetry.sdk.version": get_opentelemetry_sdk_version(),
+        "service.name": config.project,
+    }
+
+    # Merge defaults with config, giving precedence to config
+    merged_resource_attributes = {**default_resource_attributes, **config.resource_attributes}
+
+    yield OTLPSpanAdapterExporter(endpoint=config.endpoint,
+                                  resource_attributes=merged_resource_attributes,
+                                  batch_size=config.batch_size,
+                                  flush_interval=config.flush_interval,
+                                  max_queue_size=config.max_queue_size,
+                                  drop_on_overflow=config.drop_on_overflow,
+                                  shutdown_timeout=config.shutdown_timeout)
+
+
+class PatronusTelemetryExporter(BatchConfigMixin, CollectorConfigMixin, TelemetryExporterBaseConfig, name="patronus"):
+    """A telemetry exporter to transmit traces to Patronus service."""
+
+    api_key: str = Field(description="The Patronus API key", default="")
+    resource_attributes: dict[str, str] = Field(default_factory=dict,
+                                                description="The resource attributes to add to the span")
+
+
+@register_telemetry_exporter(config_type=PatronusTelemetryExporter)
+async def patronus_telemetry_exporter(config: PatronusTelemetryExporter, builder: Builder):
+    """Create a Patronus telemetry exporter."""
+
+    from nat.plugins.opentelemetry import OTLPSpanAdapterExporter
+
+    api_key = config.api_key or os.environ.get("PATRONUS_API_KEY")
+    if not api_key:
+        raise ValueError("API key is required for Patronus")
+
+    headers = {
+        "x-api-key": api_key,
+        "pat-project-name": config.project,
+    }
+    yield OTLPSpanAdapterExporter(endpoint=config.endpoint,
+                                  headers=headers,
+                                  batch_size=config.batch_size,
+                                  flush_interval=config.flush_interval,
+                                  max_queue_size=config.max_queue_size,
+                                  drop_on_overflow=config.drop_on_overflow,
+                                  shutdown_timeout=config.shutdown_timeout)
+
+
+class GalileoTelemetryExporter(BatchConfigMixin, CollectorConfigMixin, TelemetryExporterBaseConfig, name="galileo"):
+    """A telemetry exporter to transmit traces to externally hosted galileo service."""
+
+    endpoint: str = Field(description="The galileo endpoint to export telemetry traces.",
+                          default="https://app.galileo.ai/api/galileo/otel/traces")
+    logstream: str = Field(description="The logstream name to group the telemetry traces.")
+    api_key: str = Field(description="The api key to authenticate with the galileo service.")
+
+
+@register_telemetry_exporter(config_type=GalileoTelemetryExporter)
+async def galileo_telemetry_exporter(config: GalileoTelemetryExporter, builder: Builder):
+    """Create a Galileo telemetry exporter."""
+
+    from nat.plugins.opentelemetry import OTLPSpanAdapterExporter
+
+    headers = {
+        "Galileo-API-Key": config.api_key,
+        "logstream": config.logstream,
+        "project": config.project,
+    }
+
+    yield OTLPSpanAdapterExporter(
+        endpoint=config.endpoint,
+        headers=headers,
+        batch_size=config.batch_size,
+        flush_interval=config.flush_interval,
+        max_queue_size=config.max_queue_size,
+        drop_on_overflow=config.drop_on_overflow,
+        shutdown_timeout=config.shutdown_timeout,
+    )