Azure Monitor OpenTelemetry configureren

Artikel
12/27/2023

In dit artikel worden configuratie-instellingen voor de Azure Monitor OpenTelemetry-distributie behandeld.

Connection string

Een verbindingsreeks in Application Insights definieert de doellocatie voor het verzenden van telemetriegegevens, zodat deze de juiste resource voor bewaking en analyse bereikt.

Gebruik een van de volgende drie manieren om de verbindingsreeks te configureren:

Voeg toe UseAzureMonitor() aan het opstarten van uw toepassing in uw program.cs klas.

// 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 => {
    options.ConnectionString = "<Your Connection String>";
});

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

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

Stel een omgevingsvariabele in.

APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

Voeg de volgende sectie toe aan uw appsettings.json configuratiebestand.

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

Notitie

Als u de verbindingsreeks op meer dan één plaats instelt, houden we ons aan de volgende prioriteit:

Code
Omgevingsvariabele
Configuratiebestand

Gebruik een van de volgende twee manieren om de verbindingsreeks te configureren:

Voeg de Azure Monitor Exporter toe aan elk OpenTelemetry-signaal bij het opstarten van de toepassing.

// 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>";
});

// 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>";
    });

// 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(options =>
    {
        options.AddAzureMonitorLogExporter(options =>
        {
            options.ConnectionString = "<Your Connection String>";
        });
    });
});

Stel een omgevingsvariabele in.

APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

Notitie

Als u de verbindingsreeks op meer dan één plaats instelt, houden we ons aan de volgende prioriteit:

Code
Omgevingsvariabele

Gebruik een van de volgende twee manieren om de verbindingsreeks te configureren:

Stel een omgevingsvariabele in.

APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

Gebruik een configuratieobject.

// 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);

Gebruik een van de volgende twee manieren om de verbindingsreeks te configureren:

Stel een omgevingsvariabele in.

APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

Gebruik de configure_azure_monitorfunctie.

# 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>",
)

De naam van de cloudrol en het cloudrolexemplaren instellen

Voor ondersteunde talen detecteert De Azure Monitor OpenTelemetry Distro automatisch de resourcecontext en biedt standaardwaarden voor de eigenschappen van de cloudrolnaam en de eigenschappen van het cloudrolexemplaren van uw onderdeel. Het is echter mogelijk dat u de standaardwaarden wilt overschrijven naar iets dat zinvol is voor uw team. De naamwaarde van de cloudrol wordt weergegeven op het toepassingsoverzicht als de naam onder een knooppunt.

Stel de naam van de cloudrol en het cloudrolexemplaren in via resourcekenmerken . Cloudrolnaam gebruikt service.namespace en service.name kenmerken, hoewel deze terugvalt op service.name als service.namespace deze niet is ingesteld. Cloud Role Instance maakt gebruik van de service.instance.id kenmerkwaarde. Zie OpenTelemetry Semantic Conventions (OpenTelemetry Semantic Conventions) voor informatie over standaardkenmerken voor resources.

// 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 OpenTelemetry tracer provider to add the resource attributes to all traces.
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => 
    builder.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();

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

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

// 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(options =>
    {
        // Set ResourceBuilder on the Logging config.
        options.SetResourceBuilder(resourceBuilder);
        options.AddAzureMonitorLogExporter();
    });
});

// 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);

Stel resourcekenmerken in met behulp van de OTEL_RESOURCE_ATTRIBUTES en/of OTEL_SERVICE_NAME omgevingsvariabelen. OTEL_RESOURCE_ATTRIBUTES reeks door komma's gescheiden sleutel-waardeparen. Als u bijvoorbeeld de naam my-namespace.my-helloworld-service van de cloudrol wilt instellen en het cloudrolexemplaren my-instancewilt instellen op, kunt u het volgende instellenOTEL_RESOURCE_ATTRIBUTES:OTEL_SERVICE_NAME

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

Als u het service.namespace kenmerk Resource niet instelt, kunt u ook de naam van de cloudrol instellen met alleen de omgevingsvariabele OTEL_SERVICE_NAME of het service.name kenmerk Resource. Als u bijvoorbeeld de naam my-helloworld-service van de cloudrol wilt instellen en het cloudrolexemplaren my-instancewilt instellen op, kunt u het volgende instellenOTEL_RESOURCE_ATTRIBUTES:OTEL_SERVICE_NAME

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

Steekproeven inschakelen

Mogelijk wilt u steekproeven inschakelen om uw gegevensopnamevolume te verminderen, waardoor uw kosten worden verminderd. Azure Monitor biedt een aangepaste sampler met vaste frequentie waarmee gebeurtenissen worden gevuld met een steekproefverhouding, waarnaar Application Insights wordt geconverteerd ItemCount. De sampler met vaste frequentie zorgt voor nauwkeurige ervaringen en het aantal gebeurtenissen. De sampler is ontworpen om uw traceringen in services te behouden en is interoperabel met oudere Application Insights SDK's. Zie Meer informatie over steekproeven voor meer informatie.

Notitie

Metrische gegevens en logboeken worden niet beïnvloed door steekproeven.

De sampler verwacht een steekproeffrequentie tussen 0 en 1. Een snelheid van 0,1 betekent dat ongeveer 10% van uw traceringen worden verzonden.

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

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

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

De sampler verwacht een steekproeffrequentie tussen 0 en 1. Een snelheid van 0,1 betekent dat ongeveer 10% van uw traceringen worden verzonden.

// 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;
    });

De sampler verwacht een steekproeffrequentie tussen 0 en 1. Een snelheid van 0,1 betekent dat ongeveer 10% van uw traceringen worden verzonden.

// 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);

De configure_azure_monitor() functie maakt automatisch gebruik van ApplicationInsightsSampler voor compatibiliteit met Application Insights SDK's en om uw telemetrie te samplen. De OTEL_TRACES_SAMPLER_ARG omgevingsvariabele kan worden gebruikt om de steekproeffrequentie op te geven, met een geldig bereik van 0 tot 1, waarbij 0 0 is en 1 100%. Een waarde van 0,1 betekent bijvoorbeeld dat 10% van uw traceringen wordt verzonden.

export OTEL_TRACES_SAMPLER_ARG=0.1

Tip

Wanneer u steekproefsampling met vaste snelheid/percentage gebruikt en u niet zeker weet wat u moet instellen als de steekproeffrequentie, begint u bij 5% (d.w.w.v. 0,05 steekproefverhouding) en past u de snelheid aan op basis van de nauwkeurigheid van de bewerkingen die worden weergegeven in de fouten- en prestatiebladeën. Een hogere snelheid resulteert in het algemeen in een hogere nauwkeurigheid. Elke steekproef heeft echter invloed op de nauwkeurigheid, dus we raden u aan waarschuwingen te geven over metrische gegevens van OpenTelemetry, die niet worden beïnvloed door steekproeven.

Microsoft Entra ID-verificatie (voorheen Azure AD) inschakelen

U kunt Microsoft Entra-verificatie inschakelen voor een veiligere verbinding met Azure, waardoor onbevoegde telemetrie niet kan worden opgenomen in uw abonnement.

We ondersteunen de referentieklassen van Azure Identity.

We raden u aan DefaultAzureCredential voor lokale ontwikkeling.
U wordt aangeraden ManagedIdentityCredential voor door het systeem toegewezen en door de gebruiker toegewezen beheerde identiteiten.
- Gebruik voor door het systeem toegewezen de standaardconstructor zonder parameters.
- Geef voor door de gebruiker toegewezen de client-id op voor de constructor.
We raden u aan ClientSecretCredential voor service-principals.
- Geef de tenant-id, client-id en clientgeheim op voor de constructor.

Installeer het nieuwste Azure.Identity-pakket :
```
dotnet add package Azure.Identity
```

Geef de gewenste referentieklasse op:

// 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 credential to the DefaultAzureCredential.
    // This credential will use the Azure identity of the current user or
    // the service principal that the application is running as to authenticate
    // to Azure Monitor.
    options.Credential = new DefaultAzureCredential();
});

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

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

We ondersteunen de referentieklassen van Azure Identity.

We raden u aan DefaultAzureCredential voor lokale ontwikkeling.
U wordt aangeraden ManagedIdentityCredential voor door het systeem toegewezen en door de gebruiker toegewezen beheerde identiteiten.
- Gebruik voor door het systeem toegewezen de standaardconstructor zonder parameters.
- Geef voor door de gebruiker toegewezen de client-id op voor de constructor.
We raden u aan ClientSecretCredential voor service-principals.
- Geef de tenant-id, client-id en clientgeheim op voor de constructor.

Installeer het nieuwste Azure.Identity-pakket :
```
dotnet add package Azure.Identity
```

Geef de gewenste referentieklasse op:

// Create a DefaultAzureCredential.
var credential = new DefaultAzureCredential();

// Create a new OpenTelemetry tracer provider and set the credential.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddAzureMonitorTraceExporter(options =>
    {
        options.Credential = credential;
    });

// Create a new OpenTelemetry meter provider and set the credential.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
    .AddAzureMonitorMetricExporter(options =>
    {
        options.Credential = credential;
    });

// Create a new logger factory and add the OpenTelemetry logger provider with the credential.
// It is important to keep the LoggerFactory instance active throughout the process lifetime.
var loggerFactory = LoggerFactory.Create(builder =>
{
    builder.AddOpenTelemetry(options =>
    {
        options.AddAzureMonitorLogExporter(options =>
        {
            options.Credential = credential;
        });
    });
});

We ondersteunen de referentieklassen van Azure Identity.

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

// Create a new ManagedIdentityCredential object.
const credential = new ManagedIdentityCredential();

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

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

# Import the `ManagedIdentityCredential` class from the `azure.identity` package.
from azure.identity import ManagedIdentityCredential
# 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 a managed identity credential.
# This will allow OpenTelemetry to authenticate to Azure Monitor without requiring you to provide a connection string.
configure_azure_monitor(
    credential=ManagedIdentityCredential(),
)

Offlineopslag en automatische nieuwe pogingen

Om de betrouwbaarheid en tolerantie te verbeteren, schrijven aanbiedingen op basis van Azure Monitor OpenTelemetry standaard naar offline/lokale opslag wanneer een toepassing de verbinding met Application Insights verliest. Hiermee wordt de telemetrie van de toepassing op schijf opgeslagen en wordt er periodiek gedurende maximaal 48 uur opnieuw naartoe verzonden. In toepassingen met hoge belasting wordt telemetrie af en toe om twee redenen verwijderd. Ten eerste, wanneer de toegestane tijd wordt overschreden en ten tweede, wanneer de maximale bestandsgrootte wordt overschreden of de SDK geen mogelijkheid heeft om het bestand te wissen. Als we een keuze moeten maken, slaat het product recentere gebeurtenissen op boven oude gebeurtenissen. Meer informatie

Het Distro-pakket bevat de AzureMonitorExporter, die standaard een van de volgende locaties gebruikt voor offlineopslag (vermeld in volgorde van prioriteit):

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

Als u de standaardmap wilt overschrijven, moet u instellen 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();

Als u deze functie wilt uitschakelen, moet u instellen AzureMonitorOptions.DisableOfflineStorage = true.

Standaard gebruikt AzureMonitorExporter een van de volgende locaties voor offlineopslag (vermeld in volgorde van prioriteit):

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

Als u de standaardmap wilt overschrijven, moet u instellen 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";
    });

// 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";
    });

// 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(options =>
    {
        options.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";
        });
    });
});

Als u deze functie wilt uitschakelen, moet u instellen AzureMonitorExporterOptions.DisableOfflineStorage = true.

AzureMonitorExporter gebruikt standaard een van de volgende locaties voor offlineopslag.

Windows
- %TEMP%\Microsoft\AzureMonitor
Niet-Windows
- %TMPDIR%/Microsoft/AzureMonitor
- /var/tmp/Microsoft/AzureMonitor

Als u de standaardmap wilt overschrijven, moet u instellen storageDirectory.

Voorbeeld:

// 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);

Als u deze functie wilt uitschakelen, moet u instellen disableOfflineStorage = true.

Azure Monitor-exporteurs gebruiken standaard het volgende pad:

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

Als u de standaardmap wilt overschrijven, moet u instellen storage_directory op de gewenste map.

Voorbeeld:

...
# 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",
)
...

Als u deze functie wilt uitschakelen, moet u instellen op disable_offline_storageTrue. Standaard ingesteld op False.

Voorbeeld:

...
# 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,
)
...

De OTLP-exporteur inschakelen

Mogelijk wilt u de OTLP-exporteur (OpenTelemetry Protocol) naast de Azure Monitor-exporteur inschakelen om uw telemetrie naar twee locaties te verzenden.

Notitie

De OTLP-exporteur wordt alleen voor het gemak weergegeven. We ondersteunen de OTLP-exporteur of onderdelen of ervaringen van derden daar niet officieel mee.

Installeer het pakket OpenTelemetry.Exporter.OpenTelemetryProtocol in uw project.
```
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
```

Voeg het volgende codefragment toe. In dit voorbeeld wordt ervan uitgegaan dat u een OpenTelemetry Collector hebt met een OTLP-ontvanger die wordt uitgevoerd. Zie het voorbeeld op GitHub voor meer informatie.

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

Installeer het pakket OpenTelemetry.Exporter.OpenTelemetryProtocol in uw project.
```
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
```

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

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

Installeer de OpenTelemetry Collector Trace Exporter en andere OpenTelemetry-pakketten in uw project.

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

// 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);

Installeer het openelemetry-exporter-otlp-pakket .

Voeg het volgende codefragment toe. In dit voorbeeld wordt ervan uitgegaan dat u een OpenTelemetry Collector hebt met een OTLP-ontvanger die wordt uitgevoerd. Zie deze LEESMIJ voor meer informatie.

# 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!")

OpenTelemetry-configuraties

De volgende OpenTelemetry-configuraties zijn toegankelijk via omgevingsvariabelen tijdens het gebruik van de Azure Monitor OpenTelemetry Distros.

Omgevingsvariabele	Beschrijving
`APPLICATIONINSIGHTS_CONNECTION_STRING`	Stel deze in op de verbindingsreeks voor uw Application Insights-resource.
`APPLICATIONINSIGHTS_STATSBEAT_DISABLED`	Stel deze in om ervoor te `true` kiezen om geen interne verzameling met metrische gegevens te verzamelen.
`OTEL_RESOURCE_ATTRIBUTES`	Sleutel-waardeparen die moeten worden gebruikt als resourcekenmerken. Zie de resource-SDK-specificatie voor meer informatie over resourcekenmerken.
`OTEL_SERVICE_NAME`	Hiermee stelt u de waarde van het `service.name` resourcekenmerk in. Als `service.name` er ook in wordt opgegeven `OTEL_RESOURCE_ATTRIBUTES`, heeft dit `OTEL_SERVICE_NAME` voorrang.

Omgevingsvariabele	Beschrijving
`APPLICATIONINSIGHTS_CONNECTION_STRING`	Stel deze in op de verbindingsreeks voor uw Application Insights-resource.
`APPLICATIONINSIGHTS_STATSBEAT_DISABLED`	Stel deze in om ervoor te `true` kiezen om geen interne verzameling met metrische gegevens te verzamelen.
`OTEL_RESOURCE_ATTRIBUTES`	Sleutel-waardeparen die moeten worden gebruikt als resourcekenmerken. Zie de resource-SDK-specificatie voor meer informatie over resourcekenmerken.
`OTEL_SERVICE_NAME`	Hiermee stelt u de waarde van het `service.name` resourcekenmerk in. Als `service.name` er ook in wordt opgegeven `OTEL_RESOURCE_ATTRIBUTES`, heeft dit `OTEL_SERVICE_NAME` voorrang.

Veelgestelde vragen

In deze sectie vindt u antwoorden op veelgestelde vragen.

Wat is OpenTelemetry?

Het is een nieuwe opensource-standaard voor waarneembaarheid. Meer informatie vindt u op OpenTelemetry.

Waarom investeert Microsoft Azure Monitor in OpenTelemetry?

Microsoft is een van de grootste bijdragers aan OpenTelemetry.

De belangrijkste waardeproposities van OpenTelemetry zijn dat het leverancierneutraal is en consistente API's/SDK's in verschillende talen biedt.

In de loop van de tijd denken we dat OpenTelemetry azure Monitor-klanten in staat stelt toepassingen te observeren die zijn geschreven in talen die buiten onze ondersteunde talen zijn geschreven. Het breidt ook de typen gegevens uit die u kunt verzamelen via een uitgebreide set instrumentatiebibliotheken. Bovendien zijn OpenTelemetry SDK's meestal beter presterend op schaal dan hun voorgangers, de Application Insights SDK's.

Ten slotte sluit OpenTelemetry aan bij de strategie van Microsoft om open source te omarmen.

Wat is de status van OpenTelemetry?

Zie openTelemetry-status.

Wat is de 'Azure Monitor OpenTelemetry Distro'?

U kunt het beschouwen als een dunne wrapper die alle OpenTelemetry-onderdelen bundelt voor een eersteklas ervaring in Azure. Deze wrapper wordt ook wel een distributie genoemd in OpenTelemetry.

Waarom zou ik de 'Azure Monitor OpenTelemetry Distro' gebruiken?

Er zijn verschillende voordelen voor het gebruik van de Azure Monitor OpenTelemetry Distro over systeemeigen OpenTelemetry van de community:

Vermindert de activeringsinspanning
Ondersteund door Microsoft
Brengt azure-specifieke functies, zoals:
- Steekproeven die compatibel zijn met klassieke Application Insights SDK's
- Microsoft Entra-verificatie
- Offlineopslag en automatische nieuwe pogingen
- Statsbeat
- Metrische standaardgegevens van Application Insights
- Resourcemetagegevens detecteren om de naam van de cloudrol en het cloudrolexemplaren automatisch in te vullen in verschillende Azure-omgevingen
- Live Metrics

In de geest van OpenTelemetry hebben we de distributie ontworpen om open en uitbreidbaar te zijn. U kunt bijvoorbeeld het volgende toevoegen:

Een OTLP-exporteur (OpenTelemetry Protocol) en tegelijkertijd naar een tweede bestemming verzenden
Andere instrumentatiebibliotheken die niet zijn opgenomen in de distributie

Omdat de distributie een OpenTelemetry-distributie biedt, ondersteunt de distro alles wat wordt ondersteund door OpenTelemetry. U kunt bijvoorbeeld meer telemetrieprocessors, exporteurs of instrumentatiebibliotheken toevoegen als OpenTelemetry deze ondersteunt.

Notitie

De distributie stelt de sampler in op een aangepaste, vaste-rate sampler voor Application Insights. U kunt dit wijzigen in een andere sampler, maar als u dit doet, kunnen sommige van de meegeleverde mogelijkheden van distro worden uitgeschakeld. Zie de sectie Sampling inschakelen van Azure Monitor OpenTelemetry voor meer informatie over de ondersteunde sampler.

Voor talen zonder een ondersteunde zelfstandige OpenTelemetry-exporteur is Azure Monitor OpenTelemetry Distro de enige ondersteunde manier om OpenTelemetry te gebruiken met Azure Monitor. Voor talen met een ondersteunde zelfstandige OpenTelemetry-exporteur hebt u de mogelijkheid om de Azure Monitor OpenTelemetry Distro of de juiste zelfstandige OpenTelemetry-exporteur te gebruiken, afhankelijk van uw telemetriescenario. Zie Wanneer moet ik de Azure Monitor OpenTelemetry-exporteur gebruiken? voor meer informatie.

Hoe kan ik de Azure Monitor OpenTelemetry Distro testen?

Bekijk onze inschakelingsdocumenten voor .NET, Java, JavaScript (Node.js) en Python.

Moet ik OpenTelemetry of de Application Insights SDK gebruiken?

We raden u aan de OpenTelemetry Distro te gebruiken, tenzij u een functie nodig hebt die alleen beschikbaar is met formele ondersteuning in de Application Insights SDK.

Het gebruik van OpenTelemetry voorkomt nu dat ze op een later tijdstip moeten worden gemigreerd.

Wanneer moet ik de Azure Monitor OpenTelemetry-exporteur gebruiken?

Voor ASP.NET Core, Java, Node.js en Python wordt u aangeraden de Azure Monitor OpenTelemetry Distro te gebruiken. Het is één regel code om aan de slag te gaan.

Voor alle andere .NET-scenario's, waaronder klassieke ASP.NET, console-apps, enzovoort, raden we u aan om de .NET Azure Monitor OpenTelemetry-exporteur te gebruiken: Azure.Monitor.OpenTelemetry.Exporter.

Voor complexere Python-telemetriescenario's waarvoor geavanceerde configuratie is vereist, raden we u aan de Python Azure Monitor OpenTelemetry Exporter te gebruiken.

Wat is de huidige releasestatus van functies in de Azure Monitor OpenTelemetry Distro?

In de volgende grafiek wordt ondersteuning voor OpenTelemetry-functies voor elke taal uitgesplitst.

Functie	.NET	Node.js	Python	Java
Gedistribueerde tracering	✅	✅	✅	✅
Aangepaste meetwaarden	✅	✅	✅	✅
Metrische standaardgegevens (nauwkeurigheid die momenteel wordt beïnvloed door steekproeven)	✅	✅	✅	✅
Steekproeven met vaste frequentie	✅	✅	✅	✅
Offlineopslag en automatische nieuwe pogingen	✅	✅	✅	✅
Uitzonderingsrapportage	✅	✅	✅	✅
Logboekverzameling	✅	⚠️	✅	✅
Aangepaste gebeurtenissen	⚠️	⚠️	⚠️	✅
Microsoft Entra-verificatie	✅	✅	✅	✅
Live metrische gegevens	❌	❌	❌	✅
Resourcecontext detecteren voor VM/VMSS en App Service	✅	❌	✅	✅
Resourcecontext voor AKS en functies detecteren	❌	❌	❌	✅
Spanfiltering voor beschikbaarheidstests	❌	❌	❌	✅
Automatische inpopulatie van gebruikers-id, geverifieerde gebruikers-id en gebruikers-IP	❌	❌	❌	✅
Bewerkingsnaam, gebruikers-id of geverifieerde gebruikers-id handmatig overschrijven/instellen	❌	❌	❌	✅
Adaptieve steekproeven	❌	❌	❌	✅
Profiler	❌	❌	❌	⚠️
Snapshot Debugger	❌	❌	❌	❌

Code

✅ Deze functie is beschikbaar voor alle klanten met formele ondersteuning.
⚠✏ Deze functie is beschikbaar als openbare preview. Zie aanvullende gebruiksvoorwaarden voor Microsoft Azure Previews.
❌ Deze functie is niet beschikbaar of is niet van toepassing.

Kan OpenTelemetry worden gebruikt voor webbrowsers?

Ja, maar we raden het niet aan en Azure biedt geen ondersteuning voor het. OpenTelemetry JavaScript is sterk geoptimaliseerd voor Node.js. In plaats daarvan raden we u aan de JavaScript SDK van Application Insights te gebruiken.

Wanneer kunnen we verwachten dat de OpenTelemetry SDK beschikbaar is voor gebruik in webbrowsers?

De OpenTelemetry-web-SDK heeft geen bepaalde beschikbaarheidstijdlijn. We zijn waarschijnlijk enkele jaren verwijderd van een browser-SDK die een levensvatbaar alternatief is voor de Application Insights JavaScript SDK.

Kan ik OpenTelemetry vandaag testen in een webbrowser?

De OpenTelemetry-web-sandbox is een fork die is ontworpen om OpenTelemetry in een browser te laten werken. Het is nog niet mogelijk om telemetrie te verzenden naar Application Insights. De SDK definieert geen algemene clientevenementen.

Wordt Application Insights uitgevoerd naast concurrerende agents zoals AppDynamics, DataDog en NewRelic?

Nee Deze procedure is niet van plan om te testen of te ondersteunen, hoewel met onze distributies u kunt exporteren naar een OTLP-eindpunt naast Azure Monitor tegelijk.

Kan ik preview-functies gebruiken in productieomgevingen?

We raden het niet aan. Zie aanvullende gebruiksvoorwaarden voor Microsoft Azure Previews.

Wat is het verschil tussen handmatige en automatische instrumentatie?

Zie het Overzicht van OpenTelemetry.

Kan ik de OpenTelemetry Collector gebruiken?

Sommige klanten gebruiken de OpenTelemetry Collector als een alternatief voor agents, ook al ondersteunt Microsoft nog geen op agents gebaseerde benadering voor toepassingsbewaking. Ondertussen heeft de opensource-community bijgedragen aan een OpenTelemetry Collector Azure Monitor Exporter die sommige klanten gebruiken om gegevens naar Azure Monitor Application Insights te verzenden. Dit wordt niet ondersteund door Microsoft.

Wat is het verschil tussen OpenCensus en OpenTelemetry?

OpenCensus is de voorloper van OpenTelemetry. Microsoft heeft OpenTracing en OpenCensus samengebracht om OpenTelemetry te maken, één waarneembaarheidsstandaard voor de wereld. De huidige door productie aanbevolen Python SDK voor Azure Monitor is gebaseerd op OpenCensus. Microsoft streeft ernaar Om Azure Monitor te maken op basis van OpenTelemetry.

Probleemoplossing

Werkt het niet? Bekijk de pagina voor probleemoplossing voor ASP.NET Core.

Ondersteuning

Selecteer een tabblad voor de taal van uw keuze om ondersteuningsopties te ontdekken.

Open een ondersteuning voor Azure ticket voor ondersteuning voor Azure problemen.
Neem voor problemen met OpenTelemetry rechtstreeks contact op met de OpenTelemetry .NET-community .
Zie de GitHub Issues Page (GitHub Issues Page) voor een lijst met openstaande problemen met betrekking tot Azure Monitor Exporter.

Feedback over OpenTelemetry

Feedback geven:

Vul de feedbackenquête van de OpenTelemetry-community in.
Vertel Microsoft over uzelf door deel te nemen aan de OpenTelemetry Early Adopter Community.
Neem contact op met andere Azure Monitor-gebruikers in de Microsoft Tech Community.
Maak een functieaanvraag op het Azure-feedbackforum.

Azure Monitor OpenTelemetry configureren

Connection string

De naam van de cloudrol en het cloudrolexemplaren instellen

Steekproeven inschakelen

Microsoft Entra ID-verificatie (voorheen Azure AD) inschakelen

Offlineopslag en automatische nieuwe pogingen

De OTLP-exporteur inschakelen

OpenTelemetry-configuraties

Veelgestelde vragen

Wat is OpenTelemetry?

Waarom investeert Microsoft Azure Monitor in OpenTelemetry?

Wat is de status van OpenTelemetry?

Wat is de 'Azure Monitor OpenTelemetry Distro'?

Waarom zou ik de 'Azure Monitor OpenTelemetry Distro' gebruiken?

Hoe kan ik de Azure Monitor OpenTelemetry Distro testen?

Moet ik OpenTelemetry of de Application Insights SDK gebruiken?

Wanneer moet ik de Azure Monitor OpenTelemetry-exporteur gebruiken?

Wat is de huidige releasestatus van functies in de Azure Monitor OpenTelemetry Distro?

Kan OpenTelemetry worden gebruikt voor webbrowsers?

Wanneer kunnen we verwachten dat de OpenTelemetry SDK beschikbaar is voor gebruik in webbrowsers?

Kan ik OpenTelemetry vandaag testen in een webbrowser?

Wordt Application Insights uitgevoerd naast concurrerende agents zoals AppDynamics, DataDog en NewRelic?

Kan ik preview-functies gebruiken in productieomgevingen?

Wat is het verschil tussen handmatige en automatische instrumentatie?

Kan ik de OpenTelemetry Collector gebruiken?

Wat is het verschil tussen OpenCensus en OpenTelemetry?

Probleemoplossing

Ondersteuning

Feedback over OpenTelemetry

Aanvullende resources