OpenTelemetry provides vendor-neutral instrumentation standards, and Azure Monitor offers powerful analytics capabilities for application telemetry. The Azure Monitor OpenTelemetry Exporter for Python enables Python applications instrumented with OpenTelemetry to send traces, metrics, and logs to Application Insights. This low-level exporter provides fine-grained control over telemetry pipelines, though most applications should use the azure-monitor-opentelemetry distro for simpler setup with automatic instrumentation.
What This Skill Does
The azure-monitor-opentelemetry-exporter-py skill provides low-level exporters for sending OpenTelemetry telemetry to Azure Monitor. It includes AzureMonitorTraceExporter for distributed tracing spans, AzureMonitorMetricExporter for custom metrics and performance counters, AzureMonitorLogExporter for application logs and events, ApplicationInsightsSampler for consistent sampling across services, and offline storage for retry during network failures.
This skill enables custom OpenTelemetry pipeline configuration with full control over processors and exporters, integration with existing OpenTelemetry instrumentation, sampling configuration for cost control, Azure AD authentication instead of instrumentation keys, and sovereign cloud support for Azure Government and other regions.
The exporter integrates with OpenTelemetry's SDK, requiring manual configuration of tracer providers, meter providers, and logger providers. This provides maximum flexibility but requires more setup code compared to the distro package.
Getting Started
Install the exporter package:
pip install azure-monitor-opentelemetry-exporterSet your Application Insights connection string:
export APPLICATIONINSIGHTS_CONNECTION_STRING="InstrumentationKey=xxx;IngestionEndpoint=https://xxx.in.applicationinsights.azure.com/"Configure trace export manually:
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter
exporter = AzureMonitorTraceExporter(
connection_string="InstrumentationKey=xxx;..."
)
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
BatchSpanProcessor(exporter)
)
tracer = trace.get_tracer(__name__)
with tracer.start_as_current_span("my-operation"):
print("Traced operation")Key Features
Separate Exporters: Three specialized exporters handle different telemetry types. AzureMonitorTraceExporter sends spans to Application Insights' requests, dependencies, and exceptions tables. AzureMonitorMetricExporter sends metrics to customMetrics and performanceCounters. AzureMonitorLogExporter sends logs to traces and customEvents tables.
Sampling Control: ApplicationInsightsSampler provides consistent sampling across distributed services. Set sampling ratios to reduce telemetry volume and costs while maintaining trace completeness. Sampling decisions propagate through distributed traces.
Offline Storage: Enable offline storage to queue telemetry during network outages or Azure Monitor downtime. The exporter automatically retries failed uploads from local storage, ensuring telemetry isn't lost during transient failures.
Azure AD Authentication: Use Azure managed identity or service principal authentication instead of instrumentation keys. AD authentication provides better security through token rotation and integration with Azure RBAC policies.
Custom Configuration: Full control over batch processors, export intervals, memory limits, and other OpenTelemetry SDK settings. This enables optimization for specific application patterns and performance requirements.
Usage Examples
Configuring metrics export:
from opentelemetry import metrics
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter
exporter = AzureMonitorMetricExporter()
reader = PeriodicExportingMetricReader(exporter, export_interval_millis=60000)
metrics.set_meter_provider(MeterProvider(metric_readers=[reader]))
meter = metrics.get_meter(__name__)
counter = meter.create_counter("requests_total")
counter.add(1, {"route": "/api/users", "status": "200"})Implementing log export:
import logging
from opentelemetry._logs import set_logger_provider
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter
exporter = AzureMonitorLogExporter()
logger_provider = LoggerProvider()
logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
set_logger_provider(logger_provider)
handler = LoggingHandler(level=logging.INFO, logger_provider=logger_provider)
logging.getLogger().addHandler(handler)
logger = logging.getLogger(__name__)
logger.info("This appears in Application Insights")Configuring sampling for cost control:
from opentelemetry.sdk.trace import TracerProvider
from azure.monitor.opentelemetry.exporter import ApplicationInsightsSampler
sampler = ApplicationInsightsSampler(sampling_ratio=0.1)
trace.set_tracer_provider(TracerProvider(sampler=sampler))Best Practices
Use the azure-monitor-opentelemetry distro for most applications instead of this low-level exporter. The distro provides one-line setup with automatic instrumentation for popular libraries. Reserve this exporter for scenarios requiring custom OpenTelemetry pipeline configuration.
Enable offline storage for production deployments to ensure telemetry reliability during network issues. Configure appropriate storage directories with sufficient disk space for queued telemetry.
Use BatchSpanProcessor instead of SimpleSpanProcessor for trace export. Batching dramatically improves performance by reducing network calls and API overhead.
Configure appropriate export intervals for metrics based on your monitoring needs. Longer intervals reduce API costs but increase metric staleness.
Use ApplicationInsightsSampler for consistent sampling across distributed services. Sampling at the root span ensures complete traces are sampled together, maintaining distributed tracing visibility.
Authenticate with Azure AD credentials instead of instrumentation keys when possible. Managed identity eliminates credential management and provides better security through automatic token rotation.
Set reasonable storage limits for offline storage to prevent disk exhaustion during extended outages. Monitor storage usage and implement alerting for queue backlog.
When to Use This Skill
Use this skill when building custom OpenTelemetry pipelines requiring specific processor configurations. Applications with unique telemetry requirements benefit from the flexibility of manual exporter configuration.
It's valuable for teams standardizing on OpenTelemetry instrumentation across multiple languages and backends. The low-level exporter integrates with existing OpenTelemetry instrumentation without requiring Azure-specific SDK changes.
The skill is ideal for applications requiring custom sampling logic or telemetry filtering. Manual pipeline configuration enables sophisticated sampling strategies based on span attributes, user segments, or business rules.
Use it when integrating Azure Monitor with existing OpenTelemetry collectors. The exporter can send telemetry through OpenTelemetry Collector for centralized processing before reaching Azure Monitor.
When Not to Use This Skill
Don't use this low-level exporter for standard Python web applications. The azure-monitor-opentelemetry distro provides simpler setup with automatic instrumentation for Flask, Django, FastAPI, and other frameworks.
If you're new to OpenTelemetry, start with the distro package. It provides better developer experience and handles common scenarios without requiring deep OpenTelemetry SDK knowledge.
Avoid it for simple monitoring scenarios without distributed tracing needs. Application Insights SDK provides adequate telemetry for single-service applications without OpenTelemetry overhead.
Don't use it when your team hasn't adopted OpenTelemetry standards. OpenTelemetry requires understanding of traces, spans, and context propagation that may not be necessary for simpler monitoring needs.
Related Skills
- azure-monitor-opentelemetry-py - Simplified OpenTelemetry setup with automatic instrumentation
- azure-monitor-ingestion-py - Send custom logs to Azure Monitor
- azure-monitor-query-py - Query exported telemetry data
Source
This skill is provided by Microsoft as part of the Azure SDK for Python. Learn more at the PyPI package page, explore the GitHub source code, and review OpenTelemetry Python documentation for comprehensive instrumentation guidance.