Enable Azure Monitor OpenTelemetry Exporter for .NET, Node.js, and Python applications (preview)

Artikel
06/07/2022
17 minit untuk dibaca

The Azure Monitor OpenTelemetry Exporter is a component that sends traces (and eventually all application telemetry) to Azure Monitor Application Insights. To learn more about OpenTelemetry concepts, see the OpenTelemetry overview or OpenTelemetry FAQ.

This article describes how to enable and configure the OpenTelemetry-based Azure Monitor Preview offering. After you finish the instructions in this article, you'll be able to send OpenTelemetry traces to Azure Monitor Application Insights.

Important

Azure Monitor OpenTelemetry Exporter for .NET, Node.js, and Python applications is currently in preview. See the Supplemental Terms of Use for Microsoft Azure Previews for legal terms that apply to Azure features that are in beta, preview, or otherwise not yet released into general availability.

Limitations of the preview release

Carefully consider whether this preview is right for you. It enables distributed tracing only and excludes:

Metrics API (like custom metrics and pre-aggregated metrics)
Live Metrics
Logging API (like console logs and logging libraries)
Autocapture of unhandled exceptions
Profiler
Snapshot Debugger
Offline disk storage and retry logic
Azure Active Directory authentication
Sampling
Autopopulation of Cloud Role Name and Cloud Role Instance in Azure environments
Autopopulation of User ID and Authenticated User ID when you use the Application Insights JavaScript SDK
Autopopulation of User IP (to determine location attributes)
Ability to override Operation Name
Ability to manually set User ID or Authenticated User ID
Propagating Operation Name to Dependency Telemetry
Instrumentation libraries support on Azure Functions

If you require a full-feature experience, use the existing Application Insights ASP.NET or ASP.NET Core SDK until the OpenTelemetry-based offering matures.

Get started

Follow the steps in this section to instrument your application with OpenTelemetry.

Prerequisites

Azure subscription: Create an Azure subscription for free
Application Insights resource: Create an Application Insights resource

Application using an officially supported version of .NET Core or .NET Framework that's at least .NET Framework 4.6.1

Install the client libraries

Install the latest Azure.Monitor.OpenTelemetry.Exporter NuGet package:

dotnet add package --prerelease Azure.Monitor.OpenTelemetry.Exporter

If you get an error like "There are no versions available for the package Azure.Monitor.OpenTelemetry.Exporter," it's probably because the setting of NuGet package sources is missing. Try to specify the source with the -s option:

# Install the latest package with the NuGet package source specified.
dotnet add package --prerelease Azure.Monitor.OpenTelemetry.Exporter -s https://api.nuget.org/v3/index.json

Install these packages:

npm install @opentelemetry/sdk-trace-base
npm install @opentelemetry/sdk-trace-node
npm install @azure/monitor-opentelemetry-exporter

The following packages are also used for some specific scenarios described later in this article:

npm install @opentelemetry/api
npm install @opentelemetry/resources
npm install @opentelemetry/semantic-conventions
npm install @opentelemetry/instrumentation-http

Install the latest azure-monitor-opentelemetry-exporter PyPI package:

pip install azure-monitor-opentelemetry-exporter

Enable Azure Monitor Application Insights

This section provides guidance that shows how to enable OpenTelemetry.

Add OpenTelemetry instrumentation code

The following code demonstrates how to enable OpenTelemetry in a C# console application by setting up OpenTelemetry TracerProvider. This code must be in the application startup. For ASP.NET Core, it's done typically in the ConfigureServices method of the application Startup class. For ASP.NET applications, it's done typically in Global.asax.cs.

using System.Diagnostics;
using Azure.Monitor.OpenTelemetry.Exporter;
using OpenTelemetry;
using OpenTelemetry.Trace;

public class Program
{
    private static readonly ActivitySource MyActivitySource = new ActivitySource(
        "OTel.AzureMonitor.Demo");

    public static void Main()
    {
        using var tracerProvider = Sdk.CreateTracerProviderBuilder()
            .AddSource("OTel.AzureMonitor.Demo")
            .AddAzureMonitorTraceExporter(o =>
            {
                o.ConnectionString = "<Your Connection String>";
            })
            .Build();

        using (var activity = MyActivitySource.StartActivity("TestActivity"))
        {
            activity?.SetTag("CustomTag1", "Value1");
            activity?.SetTag("CustomTag2", "Value2");
        }

        System.Console.WriteLine("Press Enter key to exit.");
        System.Console.ReadLine();
    }
}

Note

The Activity and ActivitySource classes from the System.Diagnostics namespace represent the OpenTelemetry concepts of Span and Tracer, respectively. You create ActivitySource directly by using its constructor instead of by using TracerProvider. Each ActivitySource class must be explicitly connected to TracerProvider by using AddSource(). That's because parts of the OpenTelemetry tracing API are incorporated directly into the .NET runtime. To learn more, see Introduction to OpenTelemetry .NET Tracing API.

The following code demonstrates how to enable OpenTelemetry in a simple Node.js application:

const { AzureMonitorTraceExporter } = require("@azure/monitor-opentelemetry-exporter");
const { BatchSpanProcessor, Span } = require("@opentelemetry/sdk-trace-base");
const { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");

const provider = new NodeTracerProvider();
provider.register();

// Create an exporter instance.
const exporter = new AzureMonitorTraceExporter({
  instrumentationKey: "<Your Connection String>"
});

// Add the exporter to the provider.
provider.addSpanProcessor(
  new BatchSpanProcessor(exporter, {
    bufferTimeout: 15000,
    bufferSize: 1000
  })
);
// Create a span. A span must be closed.
const parentSpan = tracer.startSpan("main");
for (let i = 0; i < 10; i += 1) {
   doWork(parentSpan);
}
// Be sure to end the span.
parentSpan.end();

function doWork(parent: Span) {
  // Start another span. In this example, the main method already started a
  // span, so that will be the parent span, and this will be a child span.
  const ctx = opentelemetry.trace.setSpan(opentelemetry.context.active(), parent);
  const span = tracer.startSpan("doWork", undefined, ctx);
  // Simulate some random work.
  for (let i = 0; i <= Math.floor(Math.random() * 40000000); i += 1) {
    // empty
  }
  // Set attributes to the span.
  span.setAttribute("key", "value");
  // Annotate our span to capture metadata about our operation.
  span.addEvent("invoking doWork");
  span.end();
}

The following code demonstrates how to enable OpenTelemetry in a simple Python application:

import os
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.from_connection_string(
    "<Your Connection String>"
)

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
span_processor = BatchSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

with tracer.start_as_current_span("hello"):
    print("Hello, World!")

Tip

Add instrumentation libraries to autocollect telemetry across popular frameworks and libraries.

Set the Application Insights connection string

Replace the placeholder <Your Connection String> in the preceding code with the connection string from your Application Insights resource.

Screenshot of the Application Insights connection string.

Confirm data is flowing

Run your application and open your Application Insights Resource tab in the Azure portal. It might take a few minutes for data to show up in the portal.

Note

If you can't run the application or you aren't getting data as expected, see Troubleshooting.

Screenshot of the Application Insights Overview tab with server requests and server response time highlighted.

Important

If you have two or more services that emit telemetry to the same Application Insights resource, you're required to set Cloud Role Names to represent them properly on the Application Map.

As part of using Application Insights instrumentation, we collect and send diagnostic data to Microsoft. This data helps us run and improve Application Insights. You have the option to disable nonessential data collection. To learn more, see Statsbeat in Azure Application Insights.

Set the Cloud Role Name and the Cloud Role Instance

You might set the Cloud Role Name and the Cloud Role Instance via Resource attributes. This step updates Cloud Role Name and Cloud Role Instance from their default values to something that makes sense to your team. They'll appear on the Application Map as the name underneath a node. 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.

// Setting role name and role instance
var resourceAttributes = new Dictionary<string, object> {
    { "service.name", "my-service" },
    { "service.namespace", "my-namespace" },
    { "service.instance.id", "my-instance" }};
var resourceBuilder = ResourceBuilder.CreateDefault().AddAttributes(resourceAttributes);
// Done setting role name and role instance

// Set ResourceBuilder on the provider.
using var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .SetResourceBuilder(resourceBuilder)
        .AddSource("OTel.AzureMonitor.Demo")
        .AddAzureMonitorTraceExporter(o =>
        {
            o.ConnectionString = "<Your Connection String>";
        })
        .Build();

...
import { NodeTracerProvider, NodeTracerConfig } from "@opentelemetry/sdk-trace-node";
import { Resource } from "@opentelemetry/resources";
import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions";

// ----------------------------------------
// Setting role name and role instance
// ----------------------------------------
const config: NodeTracerConfig = {
        resource: new Resource({
            [SemanticResourceAttributes.SERVICE_NAME]: "my-helloworld-service",
            [SemanticResourceAttributes.SERVICE_NAMESPACE]: "my-namespace",
            [SemanticResourceAttributes.SERVICE_INSTANCE_ID]: "my-instance",
        }),
    };
// ----------------------------------------
// Done setting role name and role instance
// ----------------------------------------
const provider = new NodeTracerProvider(config);
...

...
from opentelemetry.sdk.resources import SERVICE_NAME, SERVICE_NAMESPACE, SERVICE_INSTANCE_ID, Resource
trace.set_tracer_provider(
    TracerProvider(
        resource=Resource.create(
            {
                SERVICE_NAME: "my-helloworld-service",
# ----------------------------------------
# Setting role name and role instance
# ----------------------------------------
                SERVICE_NAMESPACE: "my-namespace",
                SERVICE_INSTANCE_ID: "my-instance",
# ----------------------------------------------
# Done setting role name and role instance
# ----------------------------------------------
            }
        )
    )
)
...

For information on standard attributes for resources, see Resource Semantic Conventions.

Sampling

Sampling is supported in OpenTelemetry, but it isn't supported in the Azure Monitor OpenTelemetry Exporter at this time.

Warning

Enabling sampling in OpenTelemetry makes standard and log-based metrics extremely inaccurate, which adversely affects all Application Insights experiences. Also, enabling sampling alongside the existing Application Insights SDKs results in broken traces.

Instrumentation libraries

The following libraries are validated to work with the preview release.

Warning

Instrumentation libraries are based on experimental OpenTelemetry specifications. Microsoft's preview support commitment is to ensure that the following libraries emit data to Azure Monitor Application Insights, but it's possible that breaking changes or experimental mapping will block some data elements.

HTTP

Database

SQL client version: 1.0.0-rc7

Note

The preview offering only includes instrumentations that handle HTTP and database requests. To learn more, see OpenTelemetry Semantic Conventions.

Modify telemetry

This section explains how to modify telemetry.

Add span attributes

To add span attributes, use either of the following two ways:

Use options provided by instrumentation libraries.
Add a custom span processor.

These attributes might include adding a custom property to your telemetry. You might also use attributes to set optional fields in the Application Insights schema, like Client IP.

Tip

The advantage of using options provided by instrumentation libraries, when they're available, is that the entire context is available. As a result, users can select to add or filter more attributes. For example, the enrich option in the HttpClient instrumentation library gives users access to the httpRequestMessage itself. They can select anything from it and store it as an attribute.

Add a custom property

Any attributes you add to spans are exported as custom properties. They populate the customDimensions field in the requests or the dependencies tables in Application Insights.

Many instrumentation libraries provide an enrich option. For guidance, see the readme files of individual instrumentation libraries:
Use a custom processor:

Tip

Add the processor shown here before the Azure Monitor Exporter.

using var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddSource("OTel.AzureMonitor.Demo")
        .AddProcessor(new ActivityEnrichingProcessor())
        .AddAzureMonitorTraceExporter(o =>
        {
                o.ConnectionString = "<Your Connection String>"
        })
        .Build();

Add ActivityEnrichingProcessor.cs to your project with the following code:

using System.Diagnostics;
using OpenTelemetry;
using OpenTelemetry.Trace;

public class ActivityEnrichingProcessor : BaseProcessor<Activity>
{
    public override void OnEnd(Activity activity)
    {
        // The updated activity will be available to all processors which are called after this processor.
        activity.DisplayName = "Updated-" + activity.DisplayName;
        activity.SetTag("CustomDimension1", "Value1");
        activity.SetTag("CustomDimension2", "Value2");
    }
}

Use a custom processor:

Tip

Add the processor shown here before the Azure Monitor Exporter.

import { AzureMonitorTraceExporter } from "@azure/monitor-opentelemetry-exporter";
import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
import { ReadableSpan, SimpleSpanProcessor, Span, SpanProcessor } from "@opentelemetry/sdk-trace-base";

class SpanEnrichingProcessor implements SpanProcessor{
    forceFlush(): Promise<void>{
        return Promise.resolve();
    }
    shutdown(): Promise<void>{
        return Promise.resolve();
    }
    onStart(_span: Span): void{}
    onEnd(span: ReadableSpan){
        span.attributes["CustomDimension1"] = "value1";
        span.attributes["CustomDimension2"] = "value2";
    }
}

const provider = new NodeTracerProvider();
const azureExporter = new AzureMonitorTraceExporter();
provider.addSpanProcessor(new SpanEnrichingProcessor());
provider.addSpanProcessor(new SimpleSpanProcessor(azureExporter));

Use a custom processor:

Tip

Add the processor shown here before the Azure Monitor Exporter.

...
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

trace.set_tracer_provider(TracerProvider())
span_processor = BatchSpanProcessor(exporter)
span_enrich_processor = SpanEnrichingProcessor()
trace.get_tracer_provider().add_span_processor(span_enrich_processor)
trace.get_tracer_provider().add_span_processor(span_processor)
...

Add SpanEnrichingProcessor.py to your project with the following code:

from opentelemetry.sdk.trace import SpanProcessor

class SpanEnrichingProcessor(SpanProcessor):

    def on_end(self, span):
        span._name = "Updated-" + span.name
        span._attributes["CustomDimension1"] = "Value1"
        span._attributes["CustomDimension2"] = "Value2"

Set the user IP

You can populate the client_IP field for requests by setting the http.client_ip attribute on the span. Application Insights uses the IP address to generate user location attributes and then discards it by default.

Use the add custom property example, but replace the following lines of code in ActivityEnrichingProcessor.cs:

// only applicable in case of activity.Kind == Server
activity.SetTag("http.client_ip", "<IP Address>");

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

...
import { SemanticAttributes } from "@opentelemetry/semantic-conventions";

class SpanEnrichingProcessor implements SpanProcessor{
    ...

    onEnd(span: ReadableSpan){
        span.attributes[SemanticAttributes.HTTP_CLIENT_IP] = "<IP Address>";
    }
}

Use the add custom property example, but replace the following lines of code in SpanEnrichingProcessor.py:

span._attributes["http.client_ip"] = "<IP Address>"

Filter telemetry

You might use the following ways to filter out telemetry before it leaves your application.

Many instrumentation libraries provide a filter option. For guidance, see the readme files of individual instrumentation libraries:

Use a custom processor:

using var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddSource("OTel.AzureMonitor.Demo")
        .AddProcessor(new ActivityFilteringProcessor())
        .AddAzureMonitorTraceExporter(o =>
        {
                o.ConnectionString = "<Your Connection String>"
        })
        .Build();

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

using System.Diagnostics;
using OpenTelemetry;
using OpenTelemetry.Trace;

public class ActivityFilteringProcessor : BaseProcessor<Activity>
{
    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 will be exported.

Exclude the URL option provided by many HTTP instrumentation libraries.

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

...
import { HttpInstrumentation, HttpInstrumentationConfig } from "@opentelemetry/instrumentation-http";

...
const httpInstrumentationConfig: HttpInstrumentationConfig = {
    ignoreIncomingPaths: [new RegExp(/dc.services.visualstudio.com/i)]
};
const httpInstrumentation = new HttpInstrumentation(httpInstrumentationConfig);
provider.register();
registerInstrumentations({
    instrumentations: [
        httpInstrumentation,
    ]
});

Use a custom processor. 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 add custom property example, but replace the following lines of code:

...
import { SpanKind, TraceFlags } from "@opentelemetry/api";

class SpanEnrichingProcessor implements SpanProcessor{
    ...

    onEnd(span: ReadableSpan) {
        if(span.kind == SpanKind.INTERNAL){
            span.spanContext().traceFlags = TraceFlags.NONE;
        }
    }
}

Exclude the URL option provided by many HTTP instrumentation libraries.

The following example shows how to exclude a certain URL from being tracked by using the Flask instrumentation:

...
import flask

from opentelemetry.instrumentation.flask import FlaskInstrumentor

# You might also populate OTEL_PYTHON_FLASK_EXCLUDED_URLS env variable
# List will consist of comma delimited regexes representing which URLs to exclude
excluded_urls = "client/.*/info,healthcheck"

FlaskInstrumentor().instrument(excluded_urls=excluded_urls) # Do this before flask.Flask
app = flask.Flask(__name__)
...

Use a custom processor. 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.

...
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

trace.set_tracer_provider(TracerProvider())
span_processor = BatchSpanProcessor(exporter)
span_filter_processor = SpanFilteringProcessor()
trace.get_tracer_provider().add_span_processor(span_filter_processor)
trace.get_tracer_provider().add_span_processor(span_processor)
...

Add SpanFilteringProcessor.py to your project with the following code:

from opentelemetry.trace import SpanContext, SpanKind, TraceFlags
from opentelemetry.sdk.trace import SpanProcessor

class SpanFilteringProcessor(SpanProcessor):

    # prevents exporting spans from internal activities
    def on_start(self, span):
        if span._kind is SpanKind.INTERNAL:
            span._context = SpanContext(
                span.context.trace_id,
                span.context.span_id,
                span.context.is_remote,
                TraceFlags.DEFAULT,
                span.context.trace_state,
            )

Enable the OTLP Exporter

You might want to enable the OpenTelemetry Protocol (OTLP) Exporter alongside your Azure Monitor Exporter to send your telemetry to two locations.

Note

The OTLP Exporter is shown for convenience only. We don't officially support the OTLP Exporter or any components or third-party experiences downstream of it. We suggest you open an issue with the OpenTelemetry-Collector for OpenTelemetry issues outside the Azure support boundary.

Install the OpenTelemetry.Exporter.OpenTelemetryProtocol package along with Azure.Monitor.OpenTelemetry.Exporter in your project.

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.

// Sends data to Application Insights as well as OTLP
using var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddSource("OTel.AzureMonitor.Demo")
        .AddAzureMonitorTraceExporter(o =>
        {
            o.ConnectionString = "<Your Connection String>"
        })
        .AddOtlpExporter()
        .Build();

Install the OpenTelemetry Collector Exporter package along with the Azure Monitor OpenTelemetry Exporter in your project.
```
    npm install @opentelemetry/exporter-otlp-http
    npm install @azure/monitor-opentelemetry-exporter
```

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.

const { BasicTracerProvider, SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-base');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-otlp-http');

const provider = new BasicTracerProvider();
const azureMonitorExporter = new AzureMonitorTraceExporter({
  instrumentationKey: os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
});
const otlpExporter = new OTLPTraceExporter();
provider.addSpanProcessor(new SimpleSpanProcessor(azureMonitorExporter));
provider.addSpanProcessor(new SimpleSpanProcessor(otlpExporter));
provider.register();

Install the azure-monitor-opentelemetry-exporter and opentelemetry-exporter-otlp packages.

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

from opentelemetry import trace 

from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__) 

exporter = AzureMonitorTraceExporter.from_connection_string(
    "<Your Connection String>"
)
otlp_exporter = OTLPSpanExporter(endpoint="http://localhost:4317")
span_processor = BatchSpanProcessor(otlp_exporter) 
trace.get_tracer_provider().add_span_processor(span_processor)

with tracer.start_as_current_span("test"):
    print("Hello world!")

Troubleshooting

This section provides help with troubleshooting.

Enable diagnostic logging

The Azure Monitor Exporter uses EventSource for its own internal logging. The exporter logs are available to any EventListener by opting into the source named OpenTelemetry-AzureMonitor-Exporter. For troubleshooting steps, see OpenTelemetry Troubleshooting.

Azure Monitor Exporter uses the OpenTelemetry API Logger for internal logs. To enable it, use the following code:

const { diag, DiagConsoleLogger, DiagLogLevel } = require("@opentelemetry/api");
const { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");

const provider = new NodeTracerProvider();
diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.ALL);
provider.register();

The Azure Monitor Exporter uses the Python standard logging library for its own internal logging. OpenTelemetry API and Azure Monitor Exporter logs are usually logged at the severity level of WARNING or ERROR for irregular activity. The INFO severity level is used for regular or successful activity. By default, the Python logging library sets the severity level to WARNING, so you must change the severity level to see logs under this severity setting. The following example shows how to output logs of all severity levels to the console and a file:

...
import logging

logging.basicConfig(format="%(asctime)s:%(levelname)s:%(message)s", level=logging.DEBUG)

logger = logging.getLogger(__name__)
file = logging.FileHandler("example.log")
stream = logging.StreamHandler()
logger.addHandler(file)
logger.addHandler(stream)
...

Known issues

Known issues for the Azure Monitor OpenTelemetry Exporters include:

Operation name is missing on dependency telemetry, which adversely affects failures and performance tab experience.
Device model is missing on request and dependency telemetry, which adversely affects device cohort analysis.
Database server name is left out of dependency name, which incorrectly aggregates tables with the same name on different servers.

Support

To get support:

Review troubleshooting steps in this article.
For Azure support issues, open an Azure support ticket.

For OpenTelemetry issues, contact the OpenTelemetry .NET community directly.

OpenTelemetry feedback

To provide feedback:

Fill out the OpenTelemetry community's customer feedback survey.
Tell Microsoft about yourself by joining the OpenTelemetry Early Adopter Community.
Engage with other Azure Monitor users in the Microsoft Tech Community.
Make a feature request at the Azure Feedback Forum.

Next steps

To review the source code, see the Azure Monitor Exporter GitHub repository.
To install the NuGet package, check for updates, or view release notes, see the Azure Monitor Exporter NuGet Package page.
To become more familiar with Azure Monitor Application Insights and OpenTelemetry, see the Azure Monitor Example Application.
To learn more about OpenTelemetry and its community, see the OpenTelemetry .NET GitHub repository.
To enable usage experiences, enable web or browser user monitoring.

Enable Azure Monitor OpenTelemetry Exporter for .NET, Node.js, and Python applications (preview)

Limitations of the preview release

Get started

Prerequisites

Install the client libraries

Enable Azure Monitor Application Insights

Add OpenTelemetry instrumentation code

Set the Application Insights connection string

Confirm data is flowing

Set the Cloud Role Name and the Cloud Role Instance

Sampling

Instrumentation libraries

HTTP

Database

Modify telemetry

Add span attributes

Add a custom property

Set the user IP

Filter telemetry

Enable the OTLP Exporter

Troubleshooting

Enable diagnostic logging

Known issues

Support

OpenTelemetry feedback

Next steps

Maklum balas