Filter Azure Monitor OpenTelemetry for .NET, Java, Node.js, and Python applications

Many instrumentation libraries provide a filter option. For guidance, review the corresponding readme files:

• ASP.NET Core
• HttpClient
• SqlClient

Many instrumentation libraries provide a filter option. For guidance, review the corresponding readme files:

• ASP.NET
• HttpClient
• SqlClient

With Java agent version 3.0.3+, specific autocollected telemetry can be suppressed. For more information, review Configuration options: Azure Monitor Application Insights for Java.

Suppressing autocollected telemetry isn't supported with Java native. To filter telemetry, refer to the relevant external documentation:

• Spring Boot - Spring Boot starter
• Quarkus - Using OpenTelemetry tracing

The following example shows how to exclude a certain URL from being tracked by using the HTTP/HTTPS instrumentation library:

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

// Import the HttpInstrumentationConfig class from the @opentelemetry/instrumentation-http package.
const { HttpInstrumentationConfig }= require("@opentelemetry/instrumentation-http");

// Import the IncomingMessage and RequestOptions classes from the http and https packages, respectively.
const { IncomingMessage } = require("http");
const { RequestOptions } = require("https");

// Create a new HttpInstrumentationConfig object.
const httpInstrumentationConfig: HttpInstrumentationConfig = {
    enabled: true,
    ignoreIncomingRequestHook: (request: IncomingMessage) => {
    // Ignore OPTIONS incoming requests.
    if (request.method === 'OPTIONS') {
        return true;
    }
    return false;
    },
    ignoreOutgoingRequestHook: (options: RequestOptions) => {
    // Ignore outgoing requests with the /test path.
    if (options.path === '/test') {
        return true;
    }
    return false;
    }
};

// Create a new ApplicationInsightsOptions object.
const config: ApplicationInsightsOptions = {
    instrumentationOptions: {
    http: {
        httpInstrumentationConfig
    }
    }
};

// Enable Azure Monitor integration using the useAzureMonitor function and the ApplicationInsightsOptions object.
useAzureMonitor(config);

The following example shows how to exclude a certain URL from being tracked by using the OTEL_PYTHON_EXCLUDED_URLS environment variable:

export OTEL_PYTHON_EXCLUDED_URLS="http://localhost:8080/ignore"

Doing so excludes the endpoint shown in the following Flask example:

...
# Import the Flask and Azure Monitor OpenTelemetry SDK libraries.
import flask
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 to your Azure Monitor Application Insights resource.
configure_azure_monitor(
    connection_string="<your-connection-string>",
)

# Create a Flask application.
app = flask.Flask(__name__)

# Define a route. Requests sent to this endpoint will not be tracked due to
# flask_config configuration.
@app.route("/ignore")
def ignore():
    return "Request received but not tracked."
...

1. Use a custom processor:

   Tip

   Add the processor shown here before adding Azure Monitor.

   // Create an ASP.NET Core application builder.
   var builder = WebApplication.CreateBuilder(args);
   
   // Configure the OpenTelemetry tracer provider to add a new processor named ActivityFilteringProcessor.
   builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddProcessor(new ActivityFilteringProcessor()));
   // Configure the OpenTelemetry tracer provider to add a new source named "ActivitySourceName".
   builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddSource("ActivitySourceName"));
   // Add the Azure Monitor telemetry service to the application. This service will collect and send telemetry data to Azure Monitor.
   builder.Services.AddOpenTelemetry().UseAzureMonitor();
   
   // Build the ASP.NET Core application.
   var app = builder.Build();
   
   // Start the ASP.NET Core application.
   app.Run();
   

2. Add ActivityFilteringProcessor.cs to your project with the following code:

   public class ActivityFilteringProcessor : BaseProcessor<Activity>
   {
       // The OnStart method is called when an activity is started. This is the ideal place to filter activities.
       public override void OnStart(Activity activity)
       {
           // prevents all exporters from exporting internal activities
           if (activity.Kind == ActivityKind.Internal)
           {
               activity.IsAllDataRequested = false;
           }
       }
   }
   

If a particular source isn't explicitly added by using AddSource("ActivitySourceName"), then none of the activities created by using that source are exported.

1. Use a custom processor:

   // Create an OpenTelemetry tracer provider builder.
   // It is important to keep the TracerProvider instance active throughout the process lifetime.
   using var tracerProvider = Sdk.CreateTracerProviderBuilder()
           .AddSource("OTel.AzureMonitor.Demo") // Add a source named "OTel.AzureMonitor.Demo".
           .AddProcessor(new ActivityFilteringProcessor()) // Add a new processor named ActivityFilteringProcessor.
           .AddAzureMonitorTraceExporter() // Add the Azure Monitor trace exporter.
           .Build();
   

2. Add ActivityFilteringProcessor.cs to your project with the following code:

   public class ActivityFilteringProcessor : BaseProcessor<Activity>
   {
       // The OnStart method is called when an activity is started. This is the ideal place to filter activities.
       public override void OnStart(Activity activity)
       {
           // prevents all exporters from exporting internal activities
           if (activity.Kind == ActivityKind.Internal)
           {
               activity.IsAllDataRequested = false;
           }
       }
   }
   

If a particular source isn't explicitly added by using AddSource("ActivitySourceName"), then none of the activities created by using that source are exported.

To filter telemetry from Java applications, you can use sampling overrides (recommended) or telemetry processors. For more information, review the following documentation:

• Sampling overrides
• Telemetry processors (preview)
• Telemetry processor examples

Sampling overrides and telemetry processors aren't supported with Java native. To filter telemetry, refer to the relevant external documentation:

• Spring Boot - Spring Boot starter
• Quarkus - Using OpenTelemetry tracing

You can use a custom span processor to exclude certain spans from being exported. To mark spans to not be exported, set TraceFlag to DEFAULT.

Use the custom property example, but replace the following lines of code:

// Import the necessary packages.
const { SpanKind, TraceFlags } = require("@opentelemetry/api");
const { ReadableSpan, Span, SpanProcessor } = require("@opentelemetry/sdk-trace-base");

// Create a new SpanEnrichingProcessor class.
class SpanEnrichingProcessor implements SpanProcessor {
    forceFlush(): Promise<void> {
        return Promise.resolve();
    }

    shutdown(): Promise<void> {
        return Promise.resolve();
    }

    onStart(_span: Span): void {}

    onEnd(span) {
        // If the span is an internal span, set the trace flags to NONE.
        if(span.kind == SpanKind.INTERNAL){
        span.spanContext().traceFlags = TraceFlags.NONE;
        }
    }
}

You can use a custom span processor to exclude certain spans from being exported. To mark spans to not be exported, set TraceFlag to DEFAULT:

...
# Import the necessary libraries.
from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry import trace

# 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>",
    # Configure the custom span processors to include span filter processor.
    span_processors=[span_filter_processor],
)

...

Add SpanFilteringProcessor to your project with the following code:

# Import the necessary libraries.
from opentelemetry.trace import SpanContext, SpanKind, TraceFlags
from opentelemetry.sdk.trace import SpanProcessor

# Define a custom span processor called `SpanFilteringProcessor`.
class SpanFilteringProcessor(SpanProcessor):

    # Prevents exporting spans from internal activities.
    def on_start(self, span, parent_context):
        # Check if the span is an internal activity.
        if span._kind is SpanKind.INTERNAL:
            # Create a new span context with the following properties:
            #   * The trace ID is the same as the trace ID of the original span.
            #   * The span ID is the same as the span ID of the original span.
            #   * The is_remote property is set to `False`.
            #   * The trace flags are set to `DEFAULT`.
            #   * The trace state is the same as the trace state of the original span.
            span._context = SpanContext(
                span.context.trace_id,
                span.context.span_id,
                span.context.is_remote,
                TraceFlags(TraceFlags.DEFAULT),
                span.context.trace_state,
            )

• To further configure the OpenTelemetry distro, review Azure Monitor OpenTelemetry configuration.
• To review the source code, review the Azure Monitor AspNetCore GitHub repository.
• To install the NuGet package, check for updates, or view release notes, use the Azure Monitor AspNetCore NuGet Package page.
• To become more familiar with Azure Monitor and OpenTelemetry, review the Azure Monitor Example Application.
• To learn more about OpenTelemetry and its community, review the OpenTelemetry .NET GitHub repository.
• To enable usage experiences, enable web or browser user monitoring.
• To review frequently asked questions, troubleshooting steps, support options, or to provide OpenTelemetry feedback, review OpenTelemetry help, support, and feedback for Azure Monitor Application Insights.

• To further configure the OpenTelemetry distro, review Azure Monitor OpenTelemetry configuration
• To review the source code, review the Azure Monitor Exporter GitHub repository.
• To install the NuGet package, check for updates, or view release notes, use the Azure Monitor Exporter NuGet Package page.
• To become more familiar with Azure Monitor and OpenTelemetry, review the Azure Monitor Example Application.
• To learn more about OpenTelemetry and its community, review the OpenTelemetry .NET GitHub repository.
• To enable usage experiences, enable web or browser user monitoring.
• To review frequently asked questions, troubleshooting steps, support options, or to provide OpenTelemetry feedback, review OpenTelemetry help, support, and feedback for Azure Monitor Application Insights.

• Review Java autoinstrumentation configuration options.
• To review the source code, review the Azure Monitor Java autoinstrumentation GitHub repository.
• To learn more about OpenTelemetry and its community, review the OpenTelemetry Java GitHub repository.
• To enable usage experiences, review Enable web or browser user monitoring.
• Review the release notes on GitHub.
• To review frequently asked questions, troubleshooting steps, support options, or to provide OpenTelemetry feedback, review OpenTelemetry help, support, and feedback for Azure Monitor Application Insights.

• For details on adding and modifying Azure Monitor OpenTelemetry, review Add and modify Azure Monitor OpenTelemetry.
• To review the source code, review Azure Monitor OpenTelemetry Distro in Spring Boot native image Java application and Quarkus OpenTelemetry Exporter for Azure.
• To learn more about OpenTelemetry and its community, review the OpenTelemetry Java GitHub repository.
• Review the release notes on GitHub.
• To review frequently asked questions, troubleshooting steps, support options, or to provide OpenTelemetry feedback, review OpenTelemetry help, support, and feedback for Azure Monitor Application Insights.

• To review the source code, review the Azure Monitor OpenTelemetry GitHub repository.
• To install the npm package and check for updates, use the @azure/monitor-opentelemetry npm Package page.
• To become more familiar with Azure Monitor Application Insights and OpenTelemetry, review the Azure Monitor Example Application.
• To learn more about OpenTelemetry and its community, review the OpenTelemetry JavaScript GitHub repository.
• To enable usage experiences, enable web or browser user monitoring.
• To review frequently asked questions, troubleshooting steps, support options, or to provide OpenTelemetry feedback, review OpenTelemetry help, support, and feedback for Azure Monitor Application Insights.

• To review the source code and extra documentation, review the Azure Monitor Distro GitHub repository.
• To review extra samples and use cases, review Azure Monitor Distro samples.
• Review the release notes on GitHub.
• To install the PyPI package, check for updates, or view release notes, use the Azure Monitor Distro PyPI Package page.
• To become more familiar with Azure Monitor Application Insights and OpenTelemetry, review the Azure Monitor Example Application.
• To learn more about OpenTelemetry and its community, review the OpenTelemetry Python GitHub repository.
• To review available OpenTelemetry instrumentations and components, review the OpenTelemetry Contributor Python GitHub repository.
• To enable usage experiences, enable web or browser user monitoring.
• To review frequently asked questions, troubleshooting steps, support options, or to provide OpenTelemetry feedback, review OpenTelemetry help, support, and feedback for Azure Monitor Application Insights.