nvidia-nat-opentelemetry 1.2.1rc1__py3-none-any.whl → 1.3.0__py3-none-any.whl

nat/plugins/opentelemetry/__init__.py

@@ -12,3 +12,15 @@
 # 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.
+
+from nat.plugins.opentelemetry.mixin.otlp_span_exporter_mixin import OTLPProtocol
+from nat.plugins.opentelemetry.otel_span_exporter import OtelSpanExporter
+from nat.plugins.opentelemetry.otlp_span_adapter_exporter import OTLPSpanAdapterExporter
+from nat.plugins.opentelemetry.otlp_span_redaction_adapter_exporter import OTLPSpanHeaderRedactionAdapterExporter
+
+__all__ = [
+    "OTLPProtocol",
+    "OTLPSpanHeaderRedactionAdapterExporter",
+    "OTLPSpanAdapterExporter",
+    "OtelSpanExporter",
+]

nat/plugins/opentelemetry/mixin/otlp_span_exporter_mixin.py

@@ -14,44 +14,61 @@
 # limitations under the License.
 
 import logging
-
-from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from typing import Literal
 
 from nat.plugins.opentelemetry.otel_span import OtelSpan
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter as OTLPSpanExporterGRPC
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter as OTLPSpanExporterHTTP
 
 logger = logging.getLogger(__name__)
 
+OTLPProtocol = Literal['http', 'grpc']
+
 
 class OTLPSpanExporterMixin:
     """Mixin for OTLP span exporters.
 
     This mixin provides OTLP-specific functionality for OpenTelemetry span exporters.
-    It handles OTLP protocol transmission using the standard OpenTelemetry OTLP HTTP exporter.
+    It handles OTLP protocol transmission using the standard OpenTelemetry OTLP exporters.
 
     Key Features:
-    - Standard OTLP HTTP protocol support for span export
+    - Standard OTLP HTTP and gRPC protocol support for span export
     - Configurable endpoint and headers for authentication/routing
     - Integration with OpenTelemetry's OTLPSpanExporter for reliable transmission
     - Works with any OTLP-compatible collector or service
 
     This mixin is designed to be used with OtelSpanExporter as a base class:
 
-    Example:
+    Example::
+
         class MyOTLPExporter(OtelSpanExporter, OTLPSpanExporterMixin):
             def __init__(self, endpoint, headers, **kwargs):
                 super().__init__(endpoint=endpoint, headers=headers, **kwargs)
     """
 
-    def __init__(self, *args, endpoint: str, headers: dict[str, str] | None = None, **kwargs):
+    def __init__(self,
+                 *args,
+                 endpoint: str,
+                 headers: dict[str, str] | None = None,
+                 protocol: OTLPProtocol = 'http',
+                 **kwargs):
         """Initialize the OTLP span exporter.
 
         Args:
             endpoint: OTLP service endpoint URL.
             headers: HTTP headers for authentication and metadata.
+            protocol: Transport protocol to use ('http' or 'grpc'). Defaults to 'http'.
         """
         # Initialize exporter before super().__init__() to ensure it's available
         # if parent class initialization potentially calls export_otel_spans()
-        self._exporter = OTLPSpanExporter(endpoint=endpoint, headers=headers)
+
+        if protocol == 'http':
+            self._exporter = OTLPSpanExporterHTTP(endpoint=endpoint, headers=headers)
+        elif protocol == 'grpc':
+            self._exporter = OTLPSpanExporterGRPC(endpoint=endpoint, headers=headers)
+        else:
+            raise ValueError(f"Invalid protocol: {protocol}")
+
         super().__init__(*args, **kwargs)
 
     async def export_otel_spans(self, spans: list[OtelSpan]) -> None:

nat/plugins/opentelemetry/otel_span.py

@@ -46,7 +46,7 @@ class MimeTypes(Enum):
     JSON = "application/json"
 
 
-class OtelSpan(Span):  # pylint: disable=too-many-public-methods
+class OtelSpan(Span):
     """A manually created OpenTelemetry span.
 
     This class is a wrapper around the OpenTelemetry Span class.
@@ -86,8 +86,9 @@ class OtelSpan(Span):  # pylint: disable=too-many-public-methods
         self._name = name
         # Create a new SpanContext if none provided or if Context is provided
         if context is None or isinstance(context, Context):
-            trace_id = uuid.uuid4().int & ((1 << 128) - 1)
-            span_id = uuid.uuid4().int & ((1 << 64) - 1)
+            # Generate non-zero IDs per OTel spec (uuid4 is automatically non-zero)
+            trace_id = uuid.uuid4().int
+            span_id = uuid.uuid4().int >> 64
             self._context = SpanContext(
                 trace_id=trace_id,
                 span_id=span_id,

nat/plugins/opentelemetry/otel_span_exporter.py

@@ -18,8 +18,6 @@ from abc import abstractmethod
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version
 
-from opentelemetry.sdk.resources import Resource
-
 from nat.builder.context import ContextState
 from nat.data_models.span import Span
 from nat.observability.exporter.span_exporter import SpanExporter
@@ -27,6 +25,7 @@ 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__)
 
@@ -60,7 +59,7 @@ class OtelSpanBatchProcessor(BatchingProcessor[OtelSpan]):
     pass
 
 
-class OtelSpanExporter(SpanExporter[Span, OtelSpan]):  # pylint: disable=R0901
+class OtelSpanExporter(SpanExporter[Span, OtelSpan]):
     """Abstract base class for OpenTelemetry exporters.
 
     This class provides a specialized implementation for OpenTelemetry exporters.

nat/plugins/opentelemetry/otlp_span_adapter_exporter.py

@@ -16,13 +16,14 @@
 import logging
 
 from nat.builder.context import ContextState
+from nat.plugins.opentelemetry.mixin.otlp_span_exporter_mixin import OTLPProtocol
 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):  # pylint: disable=R0901
+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
@@ -32,7 +33,7 @@ class OTLPSpanAdapterExporter(OTLPSpanExporterMixin, OtelSpanExporter):  # pylin
     Key Features:
     - Complete span processing pipeline (IntermediateStep → Span → OtelSpan → Export)
     - Batching support for efficient transmission
-    - OTLP HTTP protocol for maximum compatibility
+    - OTLP HTTP and gRPC protocol for maximum compatibility
     - Configurable authentication via headers
     - Resource attribute management
     - Error handling and retry logic
@@ -43,10 +44,12 @@ class OTLPSpanAdapterExporter(OTLPSpanExporterMixin, OtelSpanExporter):  # pylin
     - Grafana Tempo
     - Custom OTLP-compatible backends
 
-    Example:
+    Example::
+
         exporter = OTLPSpanAdapterExporter(
             endpoint="https://api.service.com/v1/traces",
             headers={"Authorization": "Bearer your-token"},
+            protocol='http',
             batch_size=50,
             flush_interval=10.0
         )
@@ -66,6 +69,7 @@ class OTLPSpanAdapterExporter(OTLPSpanExporterMixin, OtelSpanExporter):  # pylin
             # OTLPSpanExporterMixin args
             endpoint: str,
             headers: dict[str, str] | None = None,
+            protocol: OTLPProtocol = 'http',
             **otlp_kwargs):
         """Initialize the OTLP span exporter.
 
@@ -79,7 +83,8 @@ class OTLPSpanAdapterExporter(OTLPSpanExporterMixin, OtelSpanExporter):  # pylin
             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.
+            protocol: The protocol to use for the OTLP service, default is 'http'.
+            otlp_kwargs: Additional keyword arguments for the OTLP service.
         """
         super().__init__(context_state=context_state,
                          batch_size=batch_size,
@@ -90,4 +95,5 @@ class OTLPSpanAdapterExporter(OTLPSpanExporterMixin, OtelSpanExporter):  # pylin
                          resource_attributes=resource_attributes,
                          endpoint=endpoint,
                          headers=headers,
+                         protocol=protocol,
                          **otlp_kwargs)

nat/plugins/opentelemetry/otlp_span_redaction_adapter_exporter.py

@@ -0,0 +1,149 @@
+# 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.mixin.otlp_span_exporter_mixin import OTLPProtocol
+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 and gRPC 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"},
+            protocol='http',
+            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,
+            protocol: OTLPProtocol = 'http',
+            **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.
+            protocol: The protocol to use for the OTLP service, default is 'http'.
+            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,
+                         protocol=protocol,
+                         **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

@@ -38,18 +38,18 @@ class LangfuseTelemetryExporter(BatchConfigMixin, TelemetryExporterBaseConfig, n
 
 
 @register_telemetry_exporter(config_type=LangfuseTelemetryExporter)
-async def langfuse_telemetry_exporter(config: LangfuseTelemetryExporter, builder: Builder):  # pylint: disable=W0613
+async def langfuse_telemetry_exporter(config: LangfuseTelemetryExporter, builder: Builder):
 
     import base64
 
-    from nat.plugins.opentelemetry.otlp_span_adapter_exporter import OTLPSpanAdapterExporter
+    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("utf-8")
+    credentials = f"{public_key}:{secret_key}".encode()
     auth_header = base64.b64encode(credentials).decode("utf-8")
     headers = {"Authorization": f"Basic {auth_header}"}
 
@@ -75,10 +75,10 @@ class LangsmithTelemetryExporter(BatchConfigMixin, CollectorConfigMixin, Telemet
 
 
 @register_telemetry_exporter(config_type=LangsmithTelemetryExporter)
-async def langsmith_telemetry_exporter(config: LangsmithTelemetryExporter, builder: Builder):  # pylint: disable=W0613
+async def langsmith_telemetry_exporter(config: LangsmithTelemetryExporter, builder: Builder):
     """Create a Langsmith telemetry exporter."""
 
-    from nat.plugins.opentelemetry.otlp_span_adapter_exporter import OTLPSpanAdapterExporter
+    from nat.plugins.opentelemetry import OTLPSpanAdapterExporter
 
     api_key = config.api_key or os.environ.get("LANGSMITH_API_KEY")
     if not api_key:
@@ -105,11 +105,11 @@ class OtelCollectorTelemetryExporter(BatchConfigMixin,
 
 
 @register_telemetry_exporter(config_type=OtelCollectorTelemetryExporter)
-async def otel_telemetry_exporter(config: OtelCollectorTelemetryExporter, builder: Builder):  # pylint: disable=W0613
+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
-    from nat.plugins.opentelemetry.otlp_span_adapter_exporter import OTLPSpanAdapterExporter
 
     # Default resource attributes
     default_resource_attributes = {
@@ -140,10 +140,10 @@ class PatronusTelemetryExporter(BatchConfigMixin, CollectorConfigMixin, Telemetr
 
 
 @register_telemetry_exporter(config_type=PatronusTelemetryExporter)
-async def patronus_telemetry_exporter(config: PatronusTelemetryExporter, builder: Builder):  # pylint: disable=W0613
+async def patronus_telemetry_exporter(config: PatronusTelemetryExporter, builder: Builder):
     """Create a Patronus telemetry exporter."""
 
-    from nat.plugins.opentelemetry.otlp_span_adapter_exporter import OTLPSpanAdapterExporter
+    from nat.plugins.opentelemetry import OTLPSpanAdapterExporter
 
     api_key = config.api_key or os.environ.get("PATRONUS_API_KEY")
     if not api_key:
@@ -159,10 +159,10 @@ async def patronus_telemetry_exporter(config: PatronusTelemetryExporter, builder
                                   flush_interval=config.flush_interval,
                                   max_queue_size=config.max_queue_size,
                                   drop_on_overflow=config.drop_on_overflow,
-                                  shutdown_timeout=config.shutdown_timeout)
+                                  shutdown_timeout=config.shutdown_timeout,
+                                  protocol="grpc")
 
 
-# pylint: disable=W0613
 class GalileoTelemetryExporter(BatchConfigMixin, CollectorConfigMixin, TelemetryExporterBaseConfig, name="galileo"):
     """A telemetry exporter to transmit traces to externally hosted galileo service."""
 
@@ -173,10 +173,10 @@ class GalileoTelemetryExporter(BatchConfigMixin, CollectorConfigMixin, Telemetry
 
 
 @register_telemetry_exporter(config_type=GalileoTelemetryExporter)
-async def galileo_telemetry_exporter(config: GalileoTelemetryExporter, builder: Builder):  # pylint: disable=W0613
+async def galileo_telemetry_exporter(config: GalileoTelemetryExporter, builder: Builder):
     """Create a Galileo telemetry exporter."""
 
-    from nat.plugins.opentelemetry.otlp_span_adapter_exporter import OTLPSpanAdapterExporter
+    from nat.plugins.opentelemetry import OTLPSpanAdapterExporter
 
     headers = {
         "Galileo-API-Key": config.api_key,

nat/plugins/opentelemetry/span_converter.py

@@ -18,16 +18,16 @@ import time
 
 from openinference.semconv.trace import OpenInferenceSpanKindValues
 from openinference.semconv.trace import SpanAttributes
+
+from nat.data_models.span import Span
+from nat.data_models.span import SpanStatusCode
+from nat.plugins.opentelemetry.otel_span import OtelSpan
 from opentelemetry.trace import SpanContext
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace import Status
 from opentelemetry.trace import StatusCode
 from opentelemetry.trace import TraceFlags
 
-from nat.data_models.span import Span
-from nat.data_models.span import SpanStatusCode
-from nat.plugins.opentelemetry.otel_span import OtelSpan
-
 logger = logging.getLogger(__name__)
 
 SPAN_EVENT_TYPE_TO_SPAN_KIND_MAP = {

{nvidia_nat_opentelemetry-1.2.1rc1.dist-info → nvidia_nat_opentelemetry-1.3.0.dist-info}/METADATA

@@ -1,15 +1,26 @@
 Metadata-Version: 2.4
 Name: nvidia-nat-opentelemetry
-Version: 1.2.1rc1
+Version: 1.3.0
 Summary: Subpackage for OpenTelemetry integration in NeMo Agent toolkit
+Author: NVIDIA Corporation
+Maintainer: NVIDIA Corporation
+License: Apache-2.0
+Project-URL: documentation, https://docs.nvidia.com/nemo/agent-toolkit/latest/
+Project-URL: source, https://github.com/NVIDIA/NeMo-Agent-Toolkit
 Keywords: ai,observability,opentelemetry
 Classifier: Programming Language :: Python
-Requires-Python: <3.13,>=3.11
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: nvidia-nat==v1.2.1-rc1
+License-File: LICENSE-3rd-party.txt
+License-File: LICENSE.md
+Requires-Dist: nvidia-nat==v1.3.0
 Requires-Dist: opentelemetry-api~=1.2
 Requires-Dist: opentelemetry-exporter-otlp~=1.3
 Requires-Dist: opentelemetry-sdk~=1.3
+Dynamic: license-file
 
 <!--
 SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.

nvidia_nat_opentelemetry-1.3.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+nat/meta/pypi.md,sha256=_o1o1BLPY1pvjCkklWxlm7LlIDMPCk-2Rho85NUuN8U,1109
+nat/plugins/opentelemetry/__init__.py,sha256=6RYrwlYGss4SzyAwjcbgFTLKaLk9jEIHTGEAF8XiC5E,1181
+nat/plugins/opentelemetry/otel_span.py,sha256=MC_ROZ8gSTu0gxRaaz77UDbn1ouZTZP3N_-0PcN140U,16564
+nat/plugins/opentelemetry/otel_span_exporter.py,sha256=YO7JsQgi8Cf2OQBJ_s78HwJjrWx9SdqMvPen3Pa2_bI,6533
+nat/plugins/opentelemetry/otlp_span_adapter_exporter.py,sha256=cWBfPKHET7U1oRMs1QMXvg-z1c1DaqYrLzHIyUUbfGM,4237
+nat/plugins/opentelemetry/otlp_span_redaction_adapter_exporter.py,sha256=YnoQlktT6EJRM7o8bhvYQcdGrAdOXNEk8wOimK_Wy88,7509
+nat/plugins/opentelemetry/register.py,sha256=cgYbX1xuUl3FOYe6yXFV7dFogV5KBCi0_ZrQKXLz3a8,9114
+nat/plugins/opentelemetry/span_converter.py,sha256=Gz3KvRNQeEBBlpaPO8YRAJkw4fmzV7m9bT6dGX0IV2E,8846
+nat/plugins/opentelemetry/mixin/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
+nat/plugins/opentelemetry/mixin/otlp_span_exporter_mixin.py,sha256=BN8fRHHEHEWZyrYoudl9lSeH--I2RY2dJVPyWIgDB0I,3454
+nvidia_nat_opentelemetry-1.3.0.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
+nvidia_nat_opentelemetry-1.3.0.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+nvidia_nat_opentelemetry-1.3.0.dist-info/METADATA,sha256=xlaL46W0ZP6FRzXjOyEwQpxS3jOhIcSJKb0-8OwmmZQ,2021
+nvidia_nat_opentelemetry-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_nat_opentelemetry-1.3.0.dist-info/entry_points.txt,sha256=gmEKhCafyibUJLGxbn8luTK0UTgIvV2vAtr4uZ8M85I,72
+nvidia_nat_opentelemetry-1.3.0.dist-info/top_level.txt,sha256=8-CJ2cP6-f0ZReXe5Hzqp-5pvzzHz-5Ds5H2bGqh1-U,4
+nvidia_nat_opentelemetry-1.3.0.dist-info/RECORD,,