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.

  // Import the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions class from the @azure/monitor-opentelemetry package.
  const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
  
  // Create a new AzureMonitorOpenTelemetryOptions object.
  const options: AzureMonitorOpenTelemetryOptions = {
    azureMonitorExporterOptions: {
      connectionString: "<your connection string>"
    }
  };
  
  // Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
  useAzureMonitor(options);
  

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(_testResourceAttributes));

// 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.

// Import the useAzureMonitor function, the AzureMonitorOpenTelemetryOptions class, the Resource class, and the SemanticResourceAttributes class from the @azure/monitor-opentelemetry, @opentelemetry/resources, and @opentelemetry/semantic-conventions packages, respectively.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
const { Resource } = require("@opentelemetry/resources");
const { SemanticResourceAttributes } = require("@opentelemetry/semantic-conventions");

// Create a new Resource object with the following custom resource attributes:
//
// * service_name: my-service
// * service_namespace: my-namespace
// * service_instance_id: my-instance
const customResource = new Resource({
  [SemanticResourceAttributes.SERVICE_NAME]: "my-service",
  [SemanticResourceAttributes.SERVICE_NAMESPACE]: "my-namespace",
  [SemanticResourceAttributes.SERVICE_INSTANCE_ID]: "my-instance",
});

// Create a new AzureMonitorOpenTelemetryOptions object and set the resource property to the customResource object.
const options: AzureMonitorOpenTelemetryOptions = {
  resource: customResource
};

// Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
useAzureMonitor(options);

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"

The sampler expects a sample rate of between 0 and 1 inclusive. A rate of 0.1 means approximately 10% of your traces are sent.

// 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 sampling ratio to 10%. This means that 10% of all traces will be sampled and sent to Azure Monitor.
    options.SamplingRatio = 0.1F;
});

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

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

The sampler expects a sample rate of between 0 and 1 inclusive. A rate of 0.1 means approximately 10% of your traces are sent.

// 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 =>
    {   
        // Set the sampling ratio to 10%. This means that 10% of all traces will be sampled and sent to Azure Monitor.
        options.SamplingRatio = 0.1F;
    })
    .Build();

Starting from 3.4.0, rate-limited sampling is available and is now the default. For more information about sampling, see Java sampling.

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

For Quarkus native applications, review the Quarkus OpenTelemetry documentation.

The sampler expects a sample rate of between 0 and 1 inclusive. A rate of 0.1 means approximately 10% of your traces are sent.

// Import the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions class from the @azure/monitor-opentelemetry package.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");

// Create a new AzureMonitorOpenTelemetryOptions object and set the samplingRatio property to 0.1.
const options: AzureMonitorOpenTelemetryOptions = {
  samplingRatio: 0.1
};

// Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
useAzureMonitor(options);

The configure_azure_monitor() function automatically utilizes ApplicationInsightsSampler for compatibility with Application Insights SDKs and to sample your telemetry. The OTEL_TRACES_SAMPLER_ARG environment variable can be used to specify the sampling rate, with a valid range of 0 to 1, where 0 is 0% and 1 is 100%. For example, a value of 0.1 means 10% of your traces are sent.

export OTEL_TRACES_SAMPLER_ARG=0.1

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.

const options: AzureMonitorOpenTelemetryOptions = {
    azureMonitorExporterOptions: {
        connectionString:
            process.env["APPLICATIONINSIGHTS_CONNECTION_STRING"] || "<your connection string>",
    },
    enableLiveMetrics: false
};

useAzureMonitor(options);

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

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

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.

Configuring Offline Storage and Automatic Retries isn't available in Java.

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

Configuring Offline Storage and Automatic Retries isn't available in Java native image applications.

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:

// Import the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions class from the @azure/monitor-opentelemetry package.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");

// Create a new AzureMonitorOpenTelemetryOptions object and set the azureMonitorExporterOptions property to an object with the following properties:
//
// * connectionString: The connection string for your Azure Monitor Application Insights resource.
// * storageDirectory: The directory where the Azure Monitor OpenTelemetry exporter will store telemetry data when it is offline.
// * disableOfflineStorage: A boolean value that specifies whether to disable offline storage.
const options: AzureMonitorOpenTelemetryOptions = {
  azureMonitorExporterOptions: {
    connectionString: "<Your Connection String>",
    storageDirectory: "C:\\SomeDirectory",
    disableOfflineStorage: false
  }
};

// Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
useAzureMonitor(options);

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
   

2. 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
   

2. 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();
   

For more information about Java, 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
   

2. 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.

   // Import the useAzureMonitor function, the AzureMonitorOpenTelemetryOptions class, the trace module, the ProxyTracerProvider class, the BatchSpanProcessor class, the NodeTracerProvider class, and the OTLPTraceExporter class from the @azure/monitor-opentelemetry, @opentelemetry/api, @opentelemetry/sdk-trace-base, @opentelemetry/sdk-trace-node, and @opentelemetry/exporter-trace-otlp-http packages, respectively.
   const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
   const { BatchSpanProcessor } = require('@opentelemetry/sdk-trace-base');
   const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
   
   // Create a new OTLPTraceExporter object.
   const otlpExporter = new OTLPTraceExporter();
   
   // Enable Azure Monitor integration.
   const options: AzureMonitorOpenTelemetryOptions = {
       // Add the SpanEnrichingProcessor
       spanProcessors: [new BatchSpanProcessor(otlpExporter)] 
   }
   useAzureMonitor(options);
   

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.

import { useAzureMonitor, AzureMonitorOpenTelemetryOptions } from "@azure/monitor-opentelemetry";
import { Context } from "@opentelemetry/api";
import { ReadableSpan, Span, SpanProcessor } from "@opentelemetry/sdk-trace-base";
import { SEMATTRS_HTTP_ROUTE, SEMATTRS_HTTP_TARGET, SEMATTRS_HTTP_URL } from "@opentelemetry/semantic-conventions";

class RedactQueryStringProcessor implements SpanProcessor {
  forceFlush(): Promise<void> {
	return Promise.resolve();
  }
  onStart(span: Span, parentContext: Context): void {
    return;
  }
  shutdown(): Promise<void> {
	return Promise.resolve();
  }
  onEnd(span: ReadableSpan) {
    const httpRouteIndex: number = String(span.attributes[SEMATTRS_HTTP_ROUTE]).indexOf('?');
    const httpUrlIndex: number = String(span.attributes[SEMATTRS_HTTP_URL]).indexOf('?');
    const httpTargetIndex: number = String(span.attributes[SEMATTRS_HTTP_TARGET]).indexOf('?');
    if (httpRouteIndex !== -1) {
      span.attributes[SEMATTRS_HTTP_ROUTE] = String(span.attributes[SEMATTRS_HTTP_ROUTE]).substring(0, httpRouteIndex);
    }
    if (httpUrlIndex !== -1) {
      span.attributes[SEMATTRS_HTTP_URL] = String(span.attributes[SEMATTRS_HTTP_URL]).substring(0, httpUrlIndex);
    }
    if (httpTargetIndex !== -1) {
      span.attributes[SEMATTRS_HTTP_TARGET] = String(span.attributes[SEMATTRS_HTTP_TARGET]).substring(0, httpTargetIndex);
    }
  }
}

const options: AzureMonitorOpenTelemetryOptions = {
  azureMonitorExporterOptions: {
      connectionString: <YOUR_CONNECTION_STRING>,
  },
  spanProcessors: [new RedactQueryStringProcessor()]
};

useAzureMonitor(options);

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