Configure Azure Monitor OpenTelemetry

Use one of the following three ways to configure the connection string:

• Add UseAzureMonitor() to your program.cs file:

    var builder = WebApplication.CreateBuilder(args);

    // Add the OpenTelemetry telemetry service to the application.
    // This service will collect and send telemetry data to Azure Monitor.
    builder.Services.AddOpenTelemetry().UseAzureMonitor(options => {
        options.ConnectionString = "<Your Connection String>";
    });

    var app = builder.Build();

    app.Run();

• Set an environment variable.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

• Add the following section to your appsettings.json config file.

  {
    "AzureMonitor": {
        "ConnectionString": "<Your Connection String>"
    }
  }

Use one of the following two ways to configure the connection string:

• Add the Azure Monitor Exporter to each OpenTelemetry signal in application startup.

    // Create a new OpenTelemetry tracer provider.
    // It is important to keep the TracerProvider instance active throughout the process lifetime.
    var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddAzureMonitorTraceExporter(options =>
        {
            options.ConnectionString = "<Your Connection String>";
        })
        .Build();

    // Create a new OpenTelemetry meter provider.
    // It is important to keep the MetricsProvider instance active throughout the process lifetime.
    var metricsProvider = Sdk.CreateMeterProviderBuilder()
        .AddAzureMonitorMetricExporter(options =>
        {
            options.ConnectionString = "<Your Connection String>";
        })
        .Build();

    // Create a new logger factory.
    // It is important to keep the LoggerFactory instance active throughout the process lifetime.
    var loggerFactory = LoggerFactory.Create(builder =>
    {
        builder.AddOpenTelemetry(logging =>
        {
            logging.AddAzureMonitorLogExporter(options =>
            {
                options.ConnectionString = "<Your Connection String>";
            });
        });
    });

• Set an environment variable.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

To set the connection string, see Connection string.

Use one of the following two ways to configure the connection string:

• Set an environment variable.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

• Set a property.

    applicationinsights.connection.string=<Your Connection String>

Use one of the following two ways to configure the connection string:

• Set an environment variable.

APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

• Use a configuration object.

export class BasicConnectionSample {
  static async run() {
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const options = {
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<your-connection-string>",
      },
    };
    const monitor = useAzureMonitor(options);
    console.log("Azure Monitor initialized");
  }
}

Use one of the following two ways to configure the connection string:

• Set an environment variable.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

• Use the configure_azure_monitorfunction.

# Import the `configure_azure_monitor()` function from the `azure.monitor.opentelemetry` package.
from azure.monitor.opentelemetry import configure_azure_monitor

# Configure OpenTelemetry to use Azure Monitor with the specified connection string.
# Replace `<your-connection-string>` with the connection string of your Azure Monitor Application Insights resource.
configure_azure_monitor(
    connection_string="<your-connection-string>",
)

Set the Cloud Role Name and the Cloud Role Instance via Resource attributes. Cloud Role Name uses service.namespace and service.name attributes, although it falls back to service.name if service.namespace isn't set. Cloud Role Instance uses the service.instance.id attribute value. For information on standard attributes for resources, see OpenTelemetry Semantic Conventions.

// Setting role name and role instance

// Create a dictionary of resource attributes.
var resourceAttributes = new Dictionary<string, object> {
    { "service.name", "my-service" },
    { "service.namespace", "my-namespace" },
    { "service.instance.id", "my-instance" }};

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Add the OpenTelemetry telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry()
    .UseAzureMonitor()
    // Configure the ResourceBuilder to add the custom resource attributes to all signals.
    // Custom resource attributes should be added AFTER AzureMonitor to override the default ResourceDetectors.
    .ConfigureResource(resourceBuilder => resourceBuilder.AddAttributes(resourceAttributes));

// Build the ASP.NET Core web application.
var app = builder.Build();

// Start the ASP.NET Core web application.
app.Run();

Set the Cloud Role Name and the Cloud Role Instance via Resource attributes. Cloud Role Name uses service.namespace and service.name attributes, although it falls back to service.name if service.namespace isn't set. Cloud Role Instance uses the service.instance.id attribute value. For information on standard attributes for resources, see OpenTelemetry Semantic Conventions.

// Setting role name and role instance

// Create a dictionary of resource attributes.
var resourceAttributes = new Dictionary<string, object> {
    { "service.name", "my-service" },
    { "service.namespace", "my-namespace" },
    { "service.instance.id", "my-instance" }};

// Create a resource builder.
var resourceBuilder = ResourceBuilder.CreateDefault().AddAttributes(resourceAttributes);

// Create a new OpenTelemetry tracer provider and set the resource builder.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
    // Set ResourceBuilder on the TracerProvider.
    .SetResourceBuilder(resourceBuilder)
    .AddAzureMonitorTraceExporter()
    .Build();

// Create a new OpenTelemetry meter provider and set the resource builder.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
    // Set ResourceBuilder on the MeterProvider.
    .SetResourceBuilder(resourceBuilder)
    .AddAzureMonitorMetricExporter()
    .Build();

// Create a new logger factory and add the OpenTelemetry logger provider with the resource builder.
// It is important to keep the LoggerFactory instance active throughout the process lifetime.
var loggerFactory = LoggerFactory.Create(builder =>
{
    builder.AddOpenTelemetry(logging =>
    {
        // Set ResourceBuilder on the Logging config.
        logging.SetResourceBuilder(resourceBuilder);
        logging.AddAzureMonitorLogExporter();
    });
});

To set the cloud role name, see cloud role name.

To set the cloud role instance, see cloud role instance.

To set the cloud role name:

• Use the spring.application.name for Spring Boot native image applications
• Use the quarkus.application.name for Quarkus native image applications

Set the Cloud Role Name and the Cloud Role Instance via Resource attributes. Cloud Role Name uses service.namespace and service.name attributes, although it falls back to service.name if service.namespace isn't set. Cloud Role Instance uses the service.instance.id attribute value. For information on standard attributes for resources, see OpenTelemetry Semantic Conventions.

export class CloudRoleSample {
  static async run() {
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const { resourceFromAttributes } = await import("@opentelemetry/resources");
    const { ATTR_SERVICE_NAME } = await import("@opentelemetry/semantic-conventions");
    const { ATTR_SERVICE_NAMESPACE, ATTR_SERVICE_INSTANCE_ID } =
      await import("@opentelemetry/semantic-conventions/incubating");

    const customResource = resourceFromAttributes({
      [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME || "my-service",
      [ATTR_SERVICE_NAMESPACE]: process.env.OTEL_SERVICE_NAMESPACE || "my-namespace",
      [ATTR_SERVICE_INSTANCE_ID]: process.env.OTEL_SERVICE_INSTANCE_ID || "my-instance",
    });

    const options = {
      resource: customResource,
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<your-connection-string>",
      },
    };

    const monitor = useAzureMonitor(options);
    console.log("Azure Monitor initialized (custom resource)");
  }
}

Set the Cloud Role Name and the Cloud Role Instance via Resource attributes. Cloud Role Name uses service.namespace and service.name attributes, although it falls back to service.name if service.namespace isn't set. Cloud Role Instance uses the service.instance.id attribute value. For information on standard attributes for resources, see OpenTelemetry Semantic Conventions.

Set Resource attributes using the OTEL_RESOURCE_ATTRIBUTES and/or OTEL_SERVICE_NAME environment variables. OTEL_RESOURCE_ATTRIBUTES takes series of comma-separated key-value pairs. For example, to set the Cloud Role Name to my-namespace.my-helloworld-service and set Cloud Role Instance to my-instance, you can set OTEL_RESOURCE_ATTRIBUTES and OTEL_SERVICE_NAME as such:

export OTEL_RESOURCE_ATTRIBUTES="service.namespace=my-namespace,service.instance.id=my-instance"
export OTEL_SERVICE_NAME="my-helloworld-service"

If you don't set the service.namespace Resource attribute, you can alternatively set the Cloud Role Name with only the OTEL_SERVICE_NAME environment variable or the service.name Resource attribute. For example, to set the Cloud Role Name to my-helloworld-service and set Cloud Role Instance to my-instance, you can set OTEL_RESOURCE_ATTRIBUTES and OTEL_SERVICE_NAME as such:

export OTEL_RESOURCE_ATTRIBUTES="service.instance.id=my-instance"
export OTEL_SERVICE_NAME="my-helloworld-service"

You can configure sampling in code or by using the environment variables shown above.

Configure in code

Fixed percentage

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
    o.SamplingRatio = 0.1F; // ~10%
});
var app = builder.Build();
app.Run();

Rate-limited

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
    o.TracesPerSecond = 1.5; // ~1.5 traces/sec
});
var app = builder.Build();
app.Run();

Trace‑based sampling for logs

builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
    o.EnableTraceBasedLogsSampler = true;
});

You can configure sampling in code or by using the environment variables shown above.

Configure in code

Fixed percentage

var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddAzureMonitorTraceExporter(o => o.SamplingRatio = 0.1F)
    .Build();

Rate-limited

var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddAzureMonitorTraceExporter(o => o.TracesPerSecond = 1.5F)
    .Build();

Trace‑based sampling for logs

var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddAzureMonitorTraceExporter(o => o.EnableTraceBasedLogsSampler = true)
    .Build();

Starting from 3.4.0, rate‑limited sampling is the default. For configuration options and examples, see Java sampling.

For Spring Boot native applications, the sampling configurations of the OpenTelemetry Java SDK are applicable.

For Quarkus native applications, configure sampling using the Quarkus OpenTelemetry guide, then use the Quarkus OpenTelemetry Exporter to send telemetry to Application Insights.

Configure sampling in code or by using the environment variables shown above.

Configure in code

Fixed percentage

const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const monitor = useAzureMonitor({
  samplingRatio: 0.1, // ~10%
  azureMonitorExporterOptions: {
    connectionString:
      process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<your-connection-string>",
  },
});

Rate-limited

const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const monitor = useAzureMonitor({
  tracesPerSecond: 1.5, // ~1.5 traces/sec
  azureMonitorExporterOptions: {
    connectionString:
      process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<your-connection-string>",
  },
});

Trace‑based sampling for logs

const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const monitor = useAzureMonitor({
  enableTraceBasedSamplingForLogs: true,
  azureMonitorExporterOptions: {
    connectionString:
      process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<your-connection-string>",
  },
});

Configure sampling in code or by using the environment variables shown above.

Configure in code

Fixed percentage

from azure.monitor.opentelemetry import configure_azure_monitor

configure_azure_monitor(
    connection_string="<your-connection-string>",
    sampling_ratio=0.1,  # 0.1 = 10% of traces sampled
)

Rate-limited

from azure.monitor.opentelemetry import configure_azure_monitor

configure_azure_monitor(
    connection_string="<your-connection-string>",
    traces_per_second=1.5,  # ~1.5 traces/sec
)

Trace‑based sampling for logs

from azure.monitor.opentelemetry import configure_azure_monitor

configure_azure_monitor(
    connection_string="<your-connection-string>",
    enable_trace_based_sampling_for_logs=True,
)

This feature is enabled by default.

Users can disable Live Metrics when configuring the Distro.

builder.Services.AddOpenTelemetry().UseAzureMonitor(options => {
	// Disable the Live Metrics feature.
    options.EnableLiveMetrics = false;
});

This feature isn't available in the Azure Monitor .NET Exporter.

The Live Metrics experience is enabled by default.

For more information on Java configuration, see Configuration options: Azure Monitor Application Insights for Java.

The Live Metrics aren't available today for GraalVM native applications.

Users can enable/disable Live Metrics when configuring the Distro using the enableLiveMetrics property.

export class LiveMetricsSample {
  static async run() {
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const options = {
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<your-connection-string>",
      },
      enableLiveMetrics: true, // set to false to disable
    };
    const monitor = useAzureMonitor(options);
    console.log("Azure Monitor initialized (live metrics enabled)");
  }
}

You can enable live metrics using the Azure monitor OpenTelemetry Distro for Python as follows:

...
configure_azure_monitor(
	enable_live_metrics=True
)
...

For information on configuring Entra ID authentication, see Microsoft Entra authentication for Application Insights

For information on configuring Entra ID authentication, see Microsoft Entra authentication for Application Insights

For information on configuring Entra ID authentication, see Microsoft Entra authentication for Application Insights

Microsoft Entra ID authentication isn't available for GraalVM Native applications.

For information on configuring Entra ID authentication, see Microsoft Entra authentication for Application Insights

For information on configuring Entra ID authentication, see Microsoft Entra authentication for Application Insights

The Distro package includes the AzureMonitorExporter, which by default uses one of the following locations for offline storage (listed in order of precedence):

• Windows
  • %LOCALAPPDATA%\Microsoft\AzureMonitor
  • %TEMP%\Microsoft\AzureMonitor
• Non-Windows
  • %TMPDIR%/Microsoft/AzureMonitor
  • /var/tmp/Microsoft/AzureMonitor
  • /tmp/Microsoft/AzureMonitor

To override the default directory, you should set AzureMonitorOptions.StorageDirectory.

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Add the OpenTelemetry telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor(options =>
{
    // Set the Azure Monitor storage directory to "C:\\SomeDirectory".
    // This is the directory where the OpenTelemetry SDK will store any telemetry data that cannot be sent to Azure Monitor immediately.
    options.StorageDirectory = "C:\\SomeDirectory";
});

// Build the ASP.NET Core web application.
var app = builder.Build();

// Start the ASP.NET Core web application.
app.Run();

To disable this feature, you should set AzureMonitorOptions.DisableOfflineStorage = true.

By default, the AzureMonitorExporter uses one of the following locations for offline storage (listed in order of precedence):

• Windows
  • %LOCALAPPDATA%\Microsoft\AzureMonitor
  • %TEMP%\Microsoft\AzureMonitor
• Non-Windows
  • %TMPDIR%/Microsoft/AzureMonitor
  • /var/tmp/Microsoft/AzureMonitor
  • /tmp/Microsoft/AzureMonitor

To override the default directory, you should set AzureMonitorExporterOptions.StorageDirectory.

// Create a new OpenTelemetry tracer provider and set the storage directory.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddAzureMonitorTraceExporter(options =>
    {
        // Set the Azure Monitor storage directory to "C:\\SomeDirectory".
        // This is the directory where the OpenTelemetry SDK will store any trace data that cannot be sent to Azure Monitor immediately.
        options.StorageDirectory = "C:\\SomeDirectory";
        })
        .Build();

// Create a new OpenTelemetry meter provider and set the storage directory.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
    .AddAzureMonitorMetricExporter(options =>
    {
        // Set the Azure Monitor storage directory to "C:\\SomeDirectory".
        // This is the directory where the OpenTelemetry SDK will store any metric data that cannot be sent to Azure Monitor immediately.
        options.StorageDirectory = "C:\\SomeDirectory";
        })
        .Build();

// Create a new logger factory and add the OpenTelemetry logger provider with the storage directory.
// It is important to keep the LoggerFactory instance active throughout the process lifetime.
var loggerFactory = LoggerFactory.Create(builder =>
{
    builder.AddOpenTelemetry(logging =>
    {
        logging.AddAzureMonitorLogExporter(options =>
        {
            // Set the Azure Monitor storage directory to "C:\\SomeDirectory".
            // This is the directory where the OpenTelemetry SDK will store any log data that cannot be sent to Azure Monitor immediately.
            options.StorageDirectory = "C:\\SomeDirectory";
        });
    });
});

To disable this feature, you should set AzureMonitorExporterOptions.DisableOfflineStorage = true.

When the agent can't send telemetry to Azure Monitor, it stores telemetry files on disk. The files are saved in a telemetry folder under the directory specified by the java.io.tmpdir system property. Each file name starts with a timestamp and ends with the .trn extension. This offline storage mechanism helps ensure telemetry is retained during temporary network outages or ingestion failures.

The agent stores up to 50 MB of telemetry data by default and allows configuration of the storage limit. Attempts to send stored telemetry are made periodically. Telemetry files older than 48 hours are deleted and the oldest events are discarded when the storage limit is reached.

For a full list of available configurations, see Configuration options.

When the agent can't send telemetry to Azure Monitor, it stores telemetry files on disk. The files are saved in a telemetry folder under the directory specified by the java.io.tmpdir system property. Each file name starts with a timestamp and ends with the .trn extension. This offline storage mechanism helps ensure telemetry is retained during temporary network outages or ingestion failures.

The agent stores up to 50 MB of telemetry data by default. Attempts to send stored telemetry are made periodically. Telemetry files older than 48 hours are deleted and the oldest events are discarded when the storage limit is reached.

By default, the AzureMonitorExporter uses one of the following locations for offline storage.

• Windows
  • %TEMP%\Microsoft\AzureMonitor
• Non-Windows
  • %TMPDIR%/Microsoft/AzureMonitor
  • /var/tmp/Microsoft/AzureMonitor

To override the default directory, you should set storageDirectory.

For example:

export class OfflineStorageSample {
  static async run() {
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const options = {
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<Your Connection String>",
        storageDirectory: "C:\\\\SomeDirectory",
        disableOfflineStorage: false, // set to true to disable
      },
    };
    const monitor = useAzureMonitor(options);
    console.log("Azure Monitor initialized (offline storage configured)");
  }
}

To disable this feature, you should set disableOfflineStorage = true.

By default, Azure Monitor exporters use the following path:

<tempfile.gettempdir()>/Microsoft/AzureMonitor/opentelemetry-python-<your-instrumentation-key>

To override the default directory, you should set storage_directory to the directory you want.

For example:

...
# Configure OpenTelemetry to use Azure Monitor with the specified connection string and storage directory.
# Replace `your-connection-string` with the connection string to your Azure Monitor Application Insights resource.
# Replace `C:\\SomeDirectory` with the directory where you want to store the telemetry data before it is sent to Azure Monitor.
configure_azure_monitor(
    connection_string="your-connection-string",
    storage_directory="C:\\SomeDirectory",
)
...

To disable this feature, you should set disable_offline_storage to True. Defaults to False.

For example:

...
# Configure OpenTelemetry to use Azure Monitor with the specified connection string and disable offline storage.
# Replace `your-connection-string` with the connection string to your Azure Monitor Application Insights resource.
configure_azure_monitor(
    connection_string="your-connection-string",
    disable_offline_storage=True,
)
...

1. Install the OpenTelemetry.Exporter.OpenTelemetryProtocol package in your project.

    dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol

1. Add the following code snippet. This example assumes you have an OpenTelemetry Collector with an OTLP receiver running. For details, see the example on GitHub.

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Add the OpenTelemetry telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();
    
// Add the OpenTelemetry OTLP exporter to the application.
// This exporter will send telemetry data to an OTLP receiver, such as Prometheus
builder.Services.AddOpenTelemetry().WithTracing(builder => builder.AddOtlpExporter());
builder.Services.AddOpenTelemetry().WithMetrics(builder => builder.AddOtlpExporter());

// Build the ASP.NET Core web application.
var app = builder.Build();

// Start the ASP.NET Core web application.
app.Run();

1. Install the OpenTelemetry.Exporter.OpenTelemetryProtocol package in your project.

    dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol

1. Add the following code snippet. This example assumes you have an OpenTelemetry Collector with an OTLP receiver running. For details, see the example on GitHub.

    // Create a new OpenTelemetry tracer provider and add the Azure Monitor trace exporter and the OTLP trace exporter.
    // It is important to keep the TracerProvider instance active throughout the process lifetime.
    var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddAzureMonitorTraceExporter()
        .AddOtlpExporter()
        .Build();

    // Create a new OpenTelemetry meter provider and add the Azure Monitor metric exporter and the OTLP metric exporter.
    // It is important to keep the MetricsProvider instance active throughout the process lifetime.
    var metricsProvider = Sdk.CreateMeterProviderBuilder()
        .AddAzureMonitorMetricExporter()
        .AddOtlpExporter()
        .Build();

The Application Insights Java Agent doesn't support OTLP. For more information about supported configurations, see the Java supplemental documentation.

You can't enable the OpenTelemetry Protocol (OTLP) Exporter alongside the Azure Monitor Exporter to send your telemetry to two locations.

1. Install the OpenTelemetry Collector Trace Exporter and other OpenTelemetry packages in your project.

npm install @opentelemetry/api
npm install @opentelemetry/exporter-trace-otlp-http
npm install @opentelemetry/sdk-trace-base
npm install @opentelemetry/sdk-trace-node

1. Add the following code snippet. This example assumes you have an OpenTelemetry Collector with an OTLP receiver running. For details, see the example on GitHub.

export class OtlpExporterSample {
  static async run() {
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const { BatchSpanProcessor } = await import("@opentelemetry/sdk-trace-base");
    const { OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-http");

    // Create an OTLP trace exporter (set 'url' if your collector isn't on the default endpoint).
    const otlpExporter = new OTLPTraceExporter({
      // url: "http://localhost:4318/v1/traces",
    });

    // Configure Azure Monitor and add the OTLP exporter as an additional span processor.
    const options = {
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<your-connection-string>",
      },
      spanProcessors: [new BatchSpanProcessor(otlpExporter)],
    };

    const monitor = useAzureMonitor(options);
    console.log("Azure Monitor initialized (OTLP exporter added)");
  }
}

1. Install the opentelemetry-exporter-otlp package.

2. Add the following code snippet. This example assumes you have an OpenTelemetry Collector with an OTLP receiver running. For details, see this README.

    # Import the `configure_azure_monitor()`, `trace`, `OTLPSpanExporter`, and `BatchSpanProcessor` classes from the appropriate packages.    
    from azure.monitor.opentelemetry import configure_azure_monitor
    from opentelemetry import trace
    from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
    from opentelemetry.sdk.trace.export import BatchSpanProcessor

    # Configure OpenTelemetry to use Azure Monitor with the specified connection string.
    # Replace `<your-connection-string>` with the connection string to your Azure Monitor Application Insights resource.
    configure_azure_monitor(
        connection_string="<your-connection-string>",
    )
    
    # Get the tracer for the current module.
    tracer = trace.get_tracer(__name__) 
    
    # Create an OTLP span exporter that sends spans to the specified endpoint.
    # Replace `http://localhost:4317` with the endpoint of your OTLP collector.
    otlp_exporter = OTLPSpanExporter(endpoint="http://localhost:4317")
    
    # Create a batch span processor that uses the OTLP span exporter.
    span_processor = BatchSpanProcessor(otlp_exporter)
    
    # Add the batch span processor to the tracer provider.
    trace.get_tracer_provider().add_span_processor(span_processor)
    
    # Start a new span with the name "test".
    with tracer.start_as_current_span("test"):
        print("Hello world!")

For more information about Java, see the Java supplemental documentation.

For Spring Boot native applications, the OpenTelemetry Java SDK configurations are available.

For Quarkus native applications, review the Quarkus OpenTelemetry documentation.

For more information about OpenTelemetry SDK configuration, see the OpenTelemetry documentation.

For more information about OpenTelemetry SDK configuration, see the OpenTelemetry documentation and Azure monitor Distro Usage.

When you're using the Azure.Monitor.OpenTelemetry.AspNetCore distro package, both the ASP.NET Core and HttpClient Instrumentation libraries are included. Our distro package sets Query String Redaction off by default.

To change this behavior, you must set an environment variable to either true or false.

• ASP.NET Core Instrumentation: OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION Query String Redaction is disabled by default. To enable, set this environment variable to false.
• Http Client Instrumentation: OTEL_DOTNET_EXPERIMENTAL_HTTPCLIENT_DISABLE_URL_QUERY_REDACTION Query String Redaction is disabled by default. To enable, set this environment variable to false.

When using the Azure.Monitor.OpenTelemetry.Exporter, you must manually include either the ASP.NET Core or HttpClient Instrumentation libraries in your OpenTelemetry configuration. These Instrumentation libraries have QueryString Redaction enabled by default.

To change this behavior, you must set an environment variable to either true or false.

• ASP.NET Core Instrumentation: OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION Query String Redaction is enabled by default. To disable, set this environment variable to true.
• Http Client Instrumentation: OTEL_DOTNET_EXPERIMENTAL_HTTPCLIENT_DISABLE_URL_QUERY_REDACTION Query String Redaction is enabled by default. To disable, set this environment variable to true.

Add the following to the applicationinsights.json configuration file:

{
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "actions": [
          {
            "key": "url.query",
            "pattern": "^.*$",
            "replace": "REDACTED",
            "action": "mask"
          }
        ]
      },
      {
        "type": "attribute",
        "actions": [
          {
            "key": "url.full",
            "pattern": "[?].*$",
            "replace": "?REDACTED",
            "action": "mask"
          }
        ]
      }
    ]
  }
}

We're actively working in the OpenTelemetry community to support redaction.

When you're using the Azure Monitor OpenTelemetry distro package, query strings can be redacted via creating and applying a span processor to the distro configuration.

export class RedactQueryStringsSample {
  static async run() {
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const { SEMATTRS_HTTP_ROUTE, SEMATTRS_HTTP_TARGET, SEMATTRS_HTTP_URL } =
      await import("@opentelemetry/semantic-conventions");

    class RedactQueryStringProcessor {
      forceFlush() { return Promise.resolve(); }
      onStart() {}
      shutdown() { return Promise.resolve(); }
      onEnd(span: any) {
        const route = String(span.attributes[SEMATTRS_HTTP_ROUTE] ?? "");
        const url = String(span.attributes[SEMATTRS_HTTP_URL] ?? "");
        const target = String(span.attributes[SEMATTRS_HTTP_TARGET] ?? "");

        const strip = (s: string) => {
          const i = s.indexOf("?");
          return i === -1 ? s : s.substring(0, i);
        };

        if (route) span.attributes[SEMATTRS_HTTP_ROUTE] = strip(route);
        if (url) span.attributes[SEMATTRS_HTTP_URL] = strip(url);
        if (target) span.attributes[SEMATTRS_HTTP_TARGET] = strip(target);
      }
    }

    const options = {
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<your-connection-string>",
      },
      spanProcessors: [new RedactQueryStringProcessor()],
    };

    const monitor = useAzureMonitor(options);
    console.log("Azure Monitor initialized (query strings redacted)");
  }
}

We're actively working in the OpenTelemetry community to support redaction.