Custom Exporters

setup_telemetry supports injecting custom SpanExporter and MetricReader instances, which bypasses the configuration-based construction. This is the extension point for the following use cases:

• In-memory exporters for testing
• Custom exporters for proprietary backends
• Exporters that require fine-grained configuration that NeMo Lens does not expose

Signature

setup_telemetry(
    config,
    *,
    resource_attributes=None,
    span_exporter=None,        # optional custom SpanExporter
    metric_reader=None,         # optional custom MetricReader
)

When provided, these override the config’s exporter field for that signal. You can mix these options by passing a custom span_exporter and letting metrics use the config’s exporter.

Custom Span Exporter

from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
exporter = InMemorySpanExporter()
handle = setup_telemetry(
    config,
    span_exporter=exporter,
)
# ... do work ...
spans = exporter.get_finished_spans()

This is how the NeMo Lens test suite captures spans for assertions.

Custom Metric Reader

from opentelemetry.sdk.metrics.export import InMemoryMetricReader
reader = InMemoryMetricReader()
handle = setup_telemetry(
    config,
    metric_reader=reader,
)
# ... record metrics ...
data = reader.get_metrics_data()

Write a Custom Exporter

To route telemetry to a backend not supported by OTLP, subclass SpanExporter:

from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
class MyBackendExporter(SpanExporter):
    def __init__(self, client):
        self._client = client
    def export(self, spans) -> SpanExportResult:
        try:
            for span in spans:
                self._client.send(
                    name=span.name,
                    trace_id=span.context.trace_id,
                    attributes=dict(span.attributes),
                )
            return SpanExportResult.SUCCESS
        except Exception:
            return SpanExportResult.FAILURE
    def shutdown(self) -> None:
        self._client.close()
    def force_flush(self, timeout_millis=30000) -> bool:
        return True
handle = setup_telemetry(config, span_exporter=MyBackendExporter(my_client))

Use the same pattern for MetricReader (refer to the OpenTelemetry documentation).

Custom Exporters and Sampling

Custom exporters plug into the BatchSpanProcessor that NeMo Lens installs. NeMo Lens does no sampling of its own, so a custom exporter receives every span the process produces; configure the OTel SDK’s OTEL_TRACES_SAMPLER if you need to reduce that. If you want a parallel processor, install your own SpanProcessor as shown below:

from opentelemetry import trace
from opentelemetry.sdk.trace.export import BatchSpanProcessor
handle = setup_telemetry(config)
provider = trace.get_tracer_provider()
provider.add_span_processor(BatchSpanProcessor(MyArchiveExporter()))

NeMo Lens does not expose an extension point for custom processors, so if you need one, add it to the provider directly after setup_telemetry returns. This is a lower-level interface, but it is stable within the OpenTelemetry SDK.

Why This API

Before this extension point, connecting NeMo Lens to a non-OTLP backend required subclassing build_providers or monkey-patching internals. Now it is a supported extension point: pass your exporter, and NeMo Lens does the rest.

The design goal is to keep NeMo Lens’s core surface small (OTLP and console are plenty for most users) while letting power users plug in whatever they need without forking NeMo Lens.