Azure Monitor OpenTelemetry konfigurieren

In diesem Artikel werden Konfigurationseinstellungen für die OpenTelemetry-Distribution von Azure Monitor behandelt.

Verbindungszeichenfolge

Eine Verbindungszeichenfolge in Application Insights definiert den Zielspeicherort für das Senden von Telemetriedaten und stellt sicher, dass die entsprechende Ressource für die Überwachung und Analyse erreicht wird.

ASP.NET Core

Verwenden Sie eine der folgenden drei Möglichkeiten, um die Verbindungszeichenfolge zu konfigurieren:

• Fügen Sie UseAzureMonitor() in Ihrer program.cs-Klasse Ihrem Anwendungsstart hinzu.

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

• Legen Sie eine Umgebungsvariable fest.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

• Fügen Sie den folgenden Abschnitt in Ihrer Konfigurationsdatei appsettings.json hinzu.

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

Hinweis

Wenn Sie die Verbindungszeichenfolge an mehreren Stellen festlegen, wird die folgende Rangfolge eingehalten:

1. Code
2. Umgebungsvariable
3. Konfigurationsdatei

.NET

Verwenden Sie eine der folgenden beiden Methoden zum Konfigurieren der Verbindungszeichenfolge:

• Fügen Sie jedem OpenTelemetry-Signal beim Anwendungsstart den Azure Monitor Exporter hinzu.

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

• Legen Sie eine Umgebungsvariable fest.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

Hinweis

Wenn Sie die Verbindungszeichenfolge an mehreren Stellen festlegen, wird die folgende Rangfolge eingehalten:

1. Code
2. Umgebungsvariable

Java

Lesen Sie zum Festlegen der Verbindungszeichenfolge die Informationen unter Verbindungszeichenfolge.

Node.js

Verwenden Sie eine der folgenden beiden Methoden zum Konfigurieren der Verbindungszeichenfolge:

• Legen Sie eine Umgebungsvariable fest.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

• Verwend Sie ein Konfigurationsobjekt.

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

Python

Verwenden Sie eine der folgenden beiden Methoden zum Konfigurieren der Verbindungszeichenfolge:

• Legen Sie eine Umgebungsvariable fest.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

• Sie verwenden die Funktion configure_azure_monitor.

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

Festlegen von Cloudrollennamen und Cloudrolleninstanz

Bei unterstützten Sprachenerkennt die OpenTelemetry-Distribution von Azure Monitor automatisch den Ressourcenkontext und stellt Standardwerte für den Cloudrollennamen und die Eigenschaften der Cloudrolleninstanz Ihrer Komponente bereit. Möglicherweise möchten Sie jedoch die Standardwerte durch für Ihr Team sinnvollere Werte überschreiben. Der Wert des Cloudrollennamens wird in der Anwendungszuordnung als Name unter einem Knoten angezeigt.

ASP.NET Core

Legen Sie den Cloudrollennamen und die Cloudrolleninstanz über Ressourcenattribute fest. Der Cloudrollenname verwendet die Attribute service.namespace und service.name, obwohl er auf service.name zurückfällt, wenn service.namespace nicht festgelegt ist. Die Cloudrolleninstanz verwendet den service.instance.id-Attributwert. Informationen zu Standardattributen für Ressourcen finden Sie unter OpenTelemetry-Semantikkonventionen.

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

.NET

Legen Sie den Cloudrollennamen und die Cloudrolleninstanz über Ressourcenattribute fest. Der Cloudrollenname verwendet die Attribute service.namespace und service.name, obwohl er auf service.name zurückfällt, wenn service.namespace nicht festgelegt ist. Die Cloudrolleninstanz verwendet den service.instance.id-Attributwert. Informationen zu Standardattributen für Ressourcen finden Sie unter OpenTelemetry-Semantikkonventionen.

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

Java

Informationen zum Festlegen des Cloudrollennamens finden Sie unter Name der Cloudrolle.

Informationen zum Festlegen der Cloudrolleninstanz finden Sie unter Cloudrolleninstanz.

Node.js

Legen Sie den Cloudrollennamen und die Cloudrolleninstanz über Ressourcenattribute fest. Der Cloudrollenname verwendet die Attribute service.namespace und service.name, obwohl er auf service.name zurückfällt, wenn service.namespace nicht festgelegt ist. Die Cloudrolleninstanz verwendet den service.instance.id-Attributwert. Informationen zu Standardattributen für Ressourcen finden Sie unter OpenTelemetry-Semantikkonventionen.

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

Python

Legen Sie den Cloudrollennamen und die Cloudrolleninstanz über Ressourcenattribute fest. Der Cloudrollenname verwendet die Attribute service.namespace und service.name, obwohl er auf service.name zurückfällt, wenn service.namespace nicht festgelegt ist. Die Cloudrolleninstanz verwendet den service.instance.id-Attributwert. Informationen zu Standardattributen für Ressourcen finden Sie unter OpenTelemetry-Semantikkonventionen.

Legen Sie Ressourcenattribute mithilfe der Umgebungsvariablen OTEL_RESOURCE_ATTRIBUTES und/oder OTEL_SERVICE_NAME fest. OTEL_RESOURCE_ATTRIBUTES übernimmt eine Reihe von durch Kommata getrennten Schlüssel-Wert-Paaren. Wenn Sie beispielsweise den Cloudrollennamen auf my-namespace.my-helloworld-service festlegen und die Cloudrolleninstanz auf my-instance, können Sie OTEL_RESOURCE_ATTRIBUTES und OTEL_SERVICE_NAME wie folgt festlegen:

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

Wenn Sie das service.namespace-Ressourcenattribut nicht setzen, können Sie alternativ den Namen der Cloud-Rolle nur mit der Umgebungsvariablen OTEL_SERVICE_NAME oder dem service.name-Ressourcenattribut setzen. Wenn Sie beispielsweise den Cloudrollennamen auf my-helloworld-service festlegen und die Cloudrolleninstanz auf my-instance, können Sie OTEL_RESOURCE_ATTRIBUTES und OTEL_SERVICE_NAME wie folgt festlegen:

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

Aktivieren der Stichprobenentnahme

Es empfiehlt sich gegebenenfalls, die Stichprobenentnahme zu aktivieren, um den Umfang der Datenerfassung und somit Ihre Kosten zu reduzieren. Azure Monitor bietet eine benutzerdefinierte Stichprobenentnahme mit festem Prozentsatz, die Ereignisse mit einem Stichprobenverhältnis auffüllt, das von Application Insights in ItemCount konvertiert wird. Die Stichprobenentnahme mit fester Rate gewährleistet eine präzise Erfahrung sowie genaue Ereignisanzahlwerte. Die Stichprobenentnahme ist so konzipiert, dass Ablaufverfolgungen dienstübergreifend erhalten bleiben, und sie ist mit älteren Application Insights-SDKs kompatibel. Weitere Informationen zu Stichproben finden Sie hier.

Hinweis

Metriken und Protokolle sind vom Sampling nicht betroffen.

ASP.NET Core

Von der Stichprobenentnahme wird eine Stichprobenrate zwischen 0 und 1 (einschließlich) erwartet. Bei einer Rate von 0,1 werden ca. zehn Prozent Ihrer Ablaufverfolgungen gesendet.

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

.NET

Von der Stichprobenentnahme wird eine Stichprobenrate zwischen 0 und 1 (einschließlich) erwartet. Bei einer Rate von 0,1 werden ca. zehn Prozent Ihrer Ablaufverfolgungen gesendet.

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

Java

Ab Version 3.4.0 steht Sampling mit Ratenbegrenzung zur Verfügung und ist jetzt Standard. Weitere Informationen zum Sampling finden Sie unter Java-Sampling.

Node.js

Von der Stichprobenentnahme wird eine Stichprobenrate zwischen 0 und 1 (einschließlich) erwartet. Bei einer Rate von 0,1 werden ca. zehn Prozent Ihrer Ablaufverfolgungen gesendet.

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

Python

Die configure_azure_monitor()-Funktion verwendet automatisch ApplicationInsightsSampler, um die Kompatibilität mit Application Insights-SDKs zu gewährleisten und Stichproben Ihrer Telemetriedaten zu erfassen. Die OTEL_TRACES_SAMPLER_ARG-Umgebungsvariable kann verwendet werden, um die Stichprobenentnahmerate anzugeben, mit einem gültigen Bereich von 0 bis 1, wobei 0 0 % und 1 100 % ist. Ein Wert von 0,1 bedeutet beispielsweise, dass 10 % Ihrer Ablaufverfolgungen gesendet werden.

export OTEL_TRACES_SAMPLER_ARG=0.1

Tipp

Wenn Sie Stichproben mit einer festen Rate bzw. Prozentsatzstichproben verwenden und nicht sicher sind, auf welchen Wert Sie die Stichprobenrate festlegen sollen, beginnen Sie mit fünf Prozent (entspricht einem Stichprobenverhältnis von 0,05), und passen Sie die Rate basierend auf der Genauigkeit der Vorgänge an, die auf den Blättern zu Fehlern und zur Leistung angezeigt werden. Eine höhere Rate führt im Allgemeinen zu einer höheren Genauigkeit. Eine Stichprobenentnahme wirkt sich jedoch IMMER auf die Genauigkeit aus. Für Warnungen sollten deshalb OpenTelemetry-Metriken verwendet werden, da diese nicht von der Stichprobenentnahme betroffen sind.

Aktivieren der Microsoft Entra ID-Authentifizierung (früher Azure AD)

Es empfiehlt sich gegebenenfalls, die Microsoft Entra-Authentifizierung zu aktivieren, um eine sicherere Verbindung mit Azure herzustellen, wodurch verhindert wird, dass nicht autorisierte Telemetriedaten in Ihrem Abonnement erfasst werden.

ASP.NET Core

Wir unterstützen die von Azure Identity bereitgestellten Anmeldeinformationsklassen.

• Wir empfehlen DefaultAzureCredential für die lokale Entwicklung.
• Wir empfehlen ManagedIdentityCredential wird für systemseitig zugewiesene und benutzerseitig zugewiesene verwaltete Identitäten.
  • Verwenden Sie bei systemseitig zugewiesenen Identitäten den Standardkonstruktor ohne Parameter.
  • Stellen Sie bei benutzerseitig zugewiesenen Identitäten die Client-ID für den Konstruktor bereit.
• Wir empfehlen ClientSecretCredential für Dienstprinzipale.
  • Geben Sie die Mandanten-ID, die Client-ID und den geheimen Clientschlüssel für den Konstruktor an.

1. Installieren Sie das neueste Azure.Identity-Paket:

   dotnet add package Azure.Identity
   

2. Geben Sie die gewünschte Klasse für Anmeldeinformation an:

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

.NET

Wir unterstützen die von Azure Identity bereitgestellten Anmeldeinformationsklassen.

• Wir empfehlen DefaultAzureCredential für die lokale Entwicklung.
• Wir empfehlen ManagedIdentityCredential wird für systemseitig zugewiesene und benutzerseitig zugewiesene verwaltete Identitäten.
  • Verwenden Sie bei systemseitig zugewiesenen Identitäten den Standardkonstruktor ohne Parameter.
  • Stellen Sie bei benutzerseitig zugewiesenen Identitäten die Client-ID für den Konstruktor bereit.
• Wir empfehlen ClientSecretCredential für Dienstprinzipale.
  • Geben Sie die Mandanten-ID, die Client-ID und den geheimen Clientschlüssel für den Konstruktor an.

1. Installieren Sie das neueste Azure.Identity-Paket:

   dotnet add package Azure.Identity
   

2. Geben Sie die gewünschte Klasse für Anmeldeinformation an:

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

Java

Weitere Informationen zu Java finden Sie in der ergänzenden Java-Dokumentation.

Node.js

Wir unterstützen die von Azure Identity bereitgestellten Anmeldeinformationsklassen.

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

Python

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

Offlinespeicher und automatische Wiederholungen

Um die Zuverlässigkeit und Resilienz zu verbessern, schreiben auf Azure Monitor OpenTelemetry basierende Angebote standardmäßig in Offlinespeicher bzw. in lokalen Speicher, wenn die Application Insights-Verbindung einer Anwendung unterbrochen wird. Anwendungstelemetriedaten werden auf dem Datenträger gespeichert, und es wird regelmäßig bis zu 48 Stunden lang erneut versucht, die Daten zu senden. In Anwendungen mit hoher Auslastung wird Telemetrie gelegentlich aus zwei Gründen gelöscht. Entweder beim Überschreiten der zulässigen Zeit oder beim Überschreiten der maximalen Dateigröße oder wenn das SDK keine Möglichkeit hat, die Datei zu bereinigen. Falls erforderlich, werden alte Ereignisse mit neueren Ereignissen überschrieben. Weitere Informationen

ASP.NET Core

Das Distributionspaket enthält den AzureMonitorExporter, der standardmäßig einen der folgenden Speicherorte für den Offlinespeicher verwendet (in der Reihenfolge der Vorrangs aufgeführt):

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

Das Standardverzeichnis kann durch Festlegen von AzureMonitorOptions.StorageDirectory überschrieben werden.

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

Wenn Sie das Feature deaktivieren möchten, legen Sie AzureMonitorOptions.DisableOfflineStorage = true fest.

.NET

Standardmäßig verwendet AzureMonitorExporter einen der folgenden Speicherorte als Offlinespeicher (in der angegebenen Reihenfolge):

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

Das Standardverzeichnis kann durch Festlegen von AzureMonitorExporterOptions.StorageDirectory überschrieben werden.

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

Wenn Sie das Feature deaktivieren möchten, legen Sie AzureMonitorExporterOptions.DisableOfflineStorage = true fest.

Java

Das Konfigurieren von Offlinespeicher und automatischen Wiederholungsversuchen ist in Java nicht verfügbar.

Eine vollständige Liste der verfügbaren Konfigurationen finden Sie unter Konfigurationsoptionen.

Node.js

Standardmäßig verwendet AzureMonitorExporter einen der folgenden Speicherorte als Offlinespeicher:

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

Das Standardverzeichnis kann durch Festlegen von storageDirectory überschrieben werden.

Beispiel:

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

Wenn Sie das Feature deaktivieren möchten, legen Sie disableOfflineStorage = true fest.

Python

Von den Azure Monitor-Exportprogrammen wird standardmäßig folgender Pfad verwendet:

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

Wenn Sie das Standardverzeichnis überschreiben möchten, können Sie storage_directory auf das gewünschte Verzeichnis festlegen.

Beispiel:

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

Wenn Sie das Feature deaktivieren möchten, legen Sie disable_offline_storage auf True fest. Wird standardmäßig auf False festgelegt.

Beispiel:

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

Aktivieren des OTLP-Exporters

Sie sollten neben Azure Monitor Exporter auch den OTLP-Exporter (OpenTelemetry Protocol) aktivieren, um Ihre Telemetriedaten an zwei Speicherorte zu senden.

Hinweis

Der OTLP-Exporter wird nur als Beispiel gezeigt. Wir unterstützen offiziell weder den OTLP-Exporter noch irgendwelche Komponenten oder Angebote von Drittanbietern, die diesem nachgeschaltet sind.

ASP.NET Core

1. Installieren Sie in Ihrem Projekt das Paket OpenTelemetry.Exporter.OpenTelemetryProtocol.

   dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
   

2. Fügen Sie den folgenden Codeausschnitt hinzu. In diesem Beispiel wird davon ausgegangen, dass Sie über einen OpenTelemetry-Collector mit einem aktuell ausgeführten OTLP-Empfänger verfügen. Weitere Informationen finden Sie im Beispiel zu 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();
   

.NET

1. Installieren Sie in Ihrem Projekt das Paket OpenTelemetry.Exporter.OpenTelemetryProtocol.

   dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
   

2. Fügen Sie den folgenden Codeausschnitt hinzu. In diesem Beispiel wird davon ausgegangen, dass Sie über einen OpenTelemetry-Collector mit einem aktuell ausgeführten OTLP-Empfänger verfügen. Weitere Informationen finden Sie im Beispiel zu 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();
   
   // 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();
   

Java

Weitere Informationen zu Java finden Sie in der ergänzenden Java-Dokumentation.

Node.js

1. Installieren Sie den OpenTelemetry Collector Trace Exporter und andere OpenTelemetry-Pakete in Ihrem Projekt.

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

2. Fügen Sie den folgenden Codeausschnitt hinzu. In diesem Beispiel wird davon ausgegangen, dass Sie über einen OpenTelemetry-Collector mit einem aktuell ausgeführten OTLP-Empfänger verfügen. Weitere Informationen finden Sie im Beispiel zu 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);
   

Python

1. Installieren Sie das Paket opentelemetry-exporter-otlp.

2. Fügen Sie den folgenden Codeausschnitt hinzu. In diesem Beispiel wird davon ausgegangen, dass Sie über einen OpenTelemetry-Collector mit einem aktuell ausgeführten OTLP-Empfänger verfügen. Weitere Informationen finden Sie in dieser 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!")
   

OpenTelemetry-Konfigurationen

Auf die folgenden OpenTelemetry-Konfigurationen kann bei der Verwendung der OpenTelemetry-Distributionen von Azure Monitor über Umgebungsvariablen zugegriffen werden.

ASP.NET Core

Umgebungsvariable	Beschreibung
APPLICATIONINSIGHTS_CONNECTION_STRING	Legen Sie dies auf die Verbindungszeichenfolge für Ihre Application Insights-Ressource fest.
APPLICATIONINSIGHTS_STATSBEAT_DISABLED	Legen Sie dies auf true fest, um die interne Metriksammlung zu deaktivieren.
OTEL_RESOURCE_ATTRIBUTES	Schlüssel-Wert-Paare, die als Ressourcenattribute verwendet werden. Weitere Informationen zu Ressourcenattributen finden Sie in der Resource SDK-Spezifikation.
OTEL_SERVICE_NAME	Legt den Wert des Ressourcenattributes service.name fest. Wenn service.name auch in OTEL_RESOURCE_ATTRIBUTES bereitgestellt wird, hat OTEL_SERVICE_NAME Vorrang.

.NET

Umgebungsvariable	Beschreibung
APPLICATIONINSIGHTS_CONNECTION_STRING	Legen Sie dies auf die Verbindungszeichenfolge für Ihre Application Insights-Ressource fest.
APPLICATIONINSIGHTS_STATSBEAT_DISABLED	Legen Sie dies auf true fest, um die interne Metriksammlung zu deaktivieren.
OTEL_RESOURCE_ATTRIBUTES	Schlüssel-Wert-Paare, die als Ressourcenattribute verwendet werden. Weitere Informationen zu Ressourcenattributen finden Sie in der Resource SDK-Spezifikation.
OTEL_SERVICE_NAME	Legt den Wert des Ressourcenattributes service.name fest. Wenn service.name auch in OTEL_RESOURCE_ATTRIBUTES bereitgestellt wird, hat OTEL_SERVICE_NAME Vorrang.

Java

Weitere Informationen zu Java finden Sie in der ergänzenden Java-Dokumentation.

Node.js

Weitere Informationen zur Konfiguration des OpenTelemetry SDK finden Sie in der OpenTelemetry-Dokumentation.

Python

Weitere Informationen zur Konfiguration des OpenTelemetry SDK finden Sie in der OpenTelemetry-Dokumentation und unter Verwendung der Azure Monitor-Distribution.

Häufig gestellte Fragen

Dieser Abschnitt enthält Antworten auf häufig gestellte Fragen.

Was ist OpenTelemetry?

Es handelt sich um einen neuen Open-Source-Standard für Einblicke. Weitere Informationen finden Sie unter OpenTelemetry.

Warum investiert Microsoft Azure Monitor in OpenTelemetry?

Microsoft gehört zu den Unternehmen, die den größten Beitrag zu OpenTelemetry leisten.

Die wichtigsten Wertversprechen von OpenTelemetry sind, dass es anbieterneutral ist und über einheitliche APIs und SDKs für alle Sprachen verfügt.

Wir glauben, dass OpenTelemetry im Laufe der Zeit Azure Monitor-Kunden ermöglichen wird, auch Anwendungen zu überwachen, die in anderen als den von uns unterstützten Sprachen geschrieben wurden. Außerdem werden die Datentypen erweitert, die Sie über einen umfangreichen Satz von Instrumentierungsbibliotheken erfassen können. Darüber hinaus sind OpenTelemetry-SDKs tendenziell im großen Stil leistungsstärker als ihre Vorgänger, die Application Insights-SDKs.

Darüber hinaus ist OpenTelemetry an der Microsoft-Strategie zur Förderung von Open Source ausgerichtet.

Wie ist der Status von OpenTelemetry?

Siehe OpenTelemetry Status.

Was ist die OpenTelemetry-Distribution von Azure Monitor?

Sie können es sich als dünnen Wrapper vorstellen, der alle OpenTelemetry-Komponenten für eine erstklassige Erfahrung in Azure bündelt. Dieser Wrapper wird auch als Verteilung in OpenTelemetry bezeichnet.

Warum sollte ich die OpenTelemetry-Distribution von Azure Monitor verwenden?

Die Verwendung der OpenTelemetry-Distribution von Azure Monitor hat gegenüber der nativen OpenTelemetry aus der Community mehrere Vorteile:

• Reduziert den Aktivierungsaufwand
• Unterstützt von Microsoft
• Bietet Azure-spezifische Features, z. B.:
  • Sampling kompatibel mit klassischen Application Insights SDKs
  • Microsoft Entra-Authentifizierung
  • Offlinespeicher und automatische Wiederholungen
  • Statsbeat
  • Application Insights-Standardmetriken
  • Erkennen von Ressourcenmetadaten zum automatischen Auffüllen von Cloudrollennamen und Cloudrolleninstanzen in verschiedenen Azure-Umgebungen
  • Livemetriken

Im Sinne von OpenTelemetry haben wir die Distribution so konzipiert, dass sie offen und erweiterbar ist. Sie können beispielsweise Folgendes tun:

• Ein OpenTelemetry Protocol (OTLP)-Exporter und gleichzeitiges Senden an ein zweites Ziel
• Andere Instrumentierungsbibliotheken, die nicht in der Distribution enthalten sind

Da die Distro eine OpenTelemetry-Verteilung bereitstellt, unterstützt die Distro alles, was von OpenTelemetry unterstützt wird. Sie können beispielsweise weitere Telemetrieprozessoren, Exporteure oder Instrumentierungsbibliotheken hinzufügen, wenn OpenTelemetry sie unterstützt.

Hinweis

Die Distro legt den Sampler auf einen benutzerdefinierten Sampler mit fester Rate für Application Insights fest. Sie können dies in einen anderen Sampler ändern, dies kann jedoch einige der enthaltenen Funktionen von Distro deaktivieren. Weitere Informationen zum unterstützten Sampler finden Sie im Abschnitt Aktivieren des Samplings von Konfigurieren von Azure Monitor OpenTelemetry.

Für Sprachen ohne einen unterstützten eigenständigen OpenTelemetry-Exporter ist der Azure Monitor OpenTelemetry Distro die einzige derzeit unterstützte Methode zur Verwendung von OpenTelemetry mit Azure Monitor. Für Sprachen mit einem unterstützten eigenständigen OpenTelemetry-Exporter haben Sie je nach Telemetrieszenario die Möglichkeit, entweder den Azure Monitor OpenTelemetry Distro oder den entsprechenden eigenständigen OpenTelemetry-Exporter zu verwenden. Weitere Informationen finden Sie unter Wann sollte ich den OpenTelemetry-Exporter von Azure Monitor verwenden?.

Wie kann ich die OpenTelemetry-Distribution von Azure Monitor testen?

Sehen Sie sich unsere Aktivierungsdokumentation für .NET, Java, JavaScript (Node.js) und Python an.

Sollte ich OpenTelemetry oder das Application Insights-SDK verwenden?

Wir empfehlen die Verwendung der OpenTelemetry-Distribution, es sei denn, Sie benötigen ein Feature, das nur mit formaler Unterstützung im Application Insights-SDK verfügbar ist.

Wenn OpenTelemetry jetzt eingeführt wird, wird verhindert, dass zu einem späteren Zeitpunkt migriert werden muss.

Wann sollte ich den OpenTelemetry-Exporter von Azure Monitor verwenden?

Für ASP.NET Core, Java, Node.js und Python empfehlen wir die Verwendung der Azure Monitor OpenTelemetry Distro. Es ist nur eine Codezeile, um loszulegen.

Für alle anderen .NET-Szenarien, einschließlich klassischem ASP.NET, Konsolenanwendungen usw., empfehlen wir die Verwendung des .NET Azure Monitor OpenTelemetry-Exporters: Azure.Monitor.OpenTelemetry.Exporter.

Für komplexere Python-Telemetrieszenarien, die eine erweiterte Konfiguration erfordern, empfehlen wir die Verwendung des Python Azure Monitor OpenTelemetry-Exporters.

Wie lautet der aktuelle Releasestatus der Features in der OpenTelemetry-Distribution von Azure Monitor?

Im folgenden Diagramm ist die Unterstützung der OpenTelemetry-Funktion für jede Sprache aufgeschlüsselt.

Funktion	.NET	Node.js	Python	Java
Verteilte Ablaufverfolgung	✅	✅	✅	✅
Benutzerdefinierte Metriken	✅	✅	✅	✅
Standardmetriken (Genauigkeit derzeit beeinflusst durch Sampling)	✅	✅	✅	✅
Stichprobenerstellung mit festem Prozentsatz	✅	✅	✅	✅
Offlinespeicher und automatische Wiederholungsversuche	✅	✅	✅	✅
Ausnahmeberichterstattung	✅	✅	✅	✅
Protokollerfassung	✅	⚠️	✅	✅
Benutzerdefinierte Ereignisse	⚠️	⚠️	⚠️	✅
Microsoft Entra-Authentifizierung	✅	✅	✅	✅
Livemetriken	❌	❌	❌	✅
Erkennen des Ressourcenkontexts für VM/VMSS und App Service	✅	❌	✅	✅
Erkennen des Ressourcenkontexts für AKS und Functions	❌	❌	❌	✅
Filterung nach Verfügbarkeitstestspanne	❌	❌	❌	✅
Automatisches Auffüllen von Benutzer-ID, authentifizierter Benutzer-ID und Benutzer-IP-Adresse	❌	❌	❌	✅
Manuelles Überschreiben/Festlegen von Vorgangsname, Benutzer-ID oder authentifizierter Benutzer-ID	❌	❌	❌	✅
Adaptive Stichprobenerstellung	❌	❌	❌	✅
Profiler	❌	❌	❌	⚠️
Momentaufnahmedebugger	❌	❌	❌	❌

Schlüssel

• ✅: Dieses Feature steht allen Kunden mit formellem Support zur Verfügung.
• ⚠: Dieses Feature ist als Public Preview (öffentliche Vorschau) verfügbar. Siehe Ergänzende Nutzungsbedingungen für Microsoft Azure-Vorschauversionen.
• ❌ Dieses Feature ist nicht verfügbar oder nicht anwendbar.

Kann OpenTelemetry für Webbrowser verwendet werden?

Ja, aber wir empfehlen es nicht, und Azure unterstützt es nicht. OpenTelemetry JavaScript ist in hohem Maße für Node.js optimiert. Stattdessen wird empfohlen, das Application Insights JavaScript SDK zu verwenden.

Wann können wir damit rechnen, dass das OpenTelemetry SDK für die Verwendung in Webbrowsern verfügbar sein wird?

Für das OpenTelemetry-Web-SDK gibt es keine festgelegte Verfügbarkeitszeitachse. Wir sind wahrscheinlich noch einige Jahre von einem Browser-SDK entfernt, das eine brauchbare Alternative zum Application Insights JavaScript-SDK wäre.

Kann ich OpenTelemetry heute in einem Webbrowser testen?

Die OpenTelemetry Web Sandbox ist ein Fork, mit dem OpenTelemetry in einem Browser funktioniert. Es ist aber noch nicht möglich, Telemetriedaten an Application Insights zu senden. Das SDK definiert keine allgemeinen Clientereignisse.

Wird die Ausführung von Application Insights zusammen mit Agents von Mitbewerbern wie AppDynamics, DataDog und NewRelic unterstützt?

Nein. Wir haben nicht vor, diese Praxis zu testen oder zu unterstützen, obwohl unsere Distributionen es Ihnen ermöglichen, gleichzeitig neben Azure Monitor einen OTLP-Endpunkt zu exportieren.

Kann ich in Produktionsumgebungen die Previewfunktionen verwenden?

Wir raten davon ab. Siehe Ergänzende Nutzungsbedingungen für Microsoft Azure-Vorschauversionen.

Was ist der Unterschied zwischen manueller und automatischer Instrumentierung?

Weitere Informationen finden Sie in der OpenTelemetry-Übersicht.

Kann ich den OpenTelemetry-Collector verwenden?

Einige Kunden verwenden den OpenTelemetry-Collector als Agent-Alternative, obwohl Microsoft einen Agent-basierenden Ansatz für die Anwendungsüberwachung noch nicht offiziell unterstützt. In der Zwischenzeit wurde von der Open-Source-Community ein Azure Monitor-Exporter für den OpenTelemetry-Collector bereitgestellt, der von einigen Kunden zum Senden von Daten an Azure Monitor Application Insights verwendet wird. Dies wird von Microsoft nicht unterstützt.

Worin besteht der Unterschied zwischen OpenCensus und OpenTelemetry?

OpenCensus ist der Vorgänger von OpenTelemetry. Mit der Hilfe von Microsoft entstand OpenTelemetry aus einer Zusammenführung von OpenTracing und OpenCensus als einzelner Einblickstandard für die ganze Welt. Das aktuelle für die Produktion empfohlene Python SDK für Azure Monitor basiert auf OpenCensus. Microsoft hat sich verpflichtet, Azure Monitor auf der Grundlage von OpenTelemetry zu entwickeln.

Problembehandlung

ASP.NET Core

Funktioniert etwas nicht? Sehen Sie sich die Problembehandlungsseite für ASP.NET Core an.

.NET

Funktioniert etwas nicht? Sehen Sie sich die Problembehandlungsseite für .NET an.

Java

Funktioniert etwas nicht? Sehen Sie sich die Problembehandlungsseite für Java an.

Node.js

Funktioniert etwas nicht? Sehen Sie sich die Problembehandlungsseite für Node.js an.

Python

Funktioniert etwas nicht? Sehen Sie sich die Problembehandlungsseite für Python an.

Unterstützung

Wählen Sie eine Registerkarte für die Sprache Ihrer Wahl aus, um Supportoptionen zu ermitteln.

ASP.NET Core

• Bei Azure-Supportproblemen öffnen Sie ein Azure-Supportticket.
• Wenden Sie sich bei OpenTelemetry-Problemen direkt an die OpenTelemetry .NET-Community.
• Eine Liste der offenen Probleme im Zusammenhang mit Azure Monitor Exporter finden Sie auf der Issues-Seite auf GitHub.

.NET

• Bei Azure-Supportproblemen öffnen Sie ein Azure-Supportticket.
• Wenden Sie sich bei OpenTelemetry-Problemen direkt an die OpenTelemetry .NET-Community.
• Eine Liste der offenen Probleme im Zusammenhang mit Azure Monitor Exporter finden Sie auf der Issues-Seite auf GitHub.

Java

• Bei Azure-Supportproblemen öffnen Sie ein Azure-Supportticket.
• Hilfestellungen für die Problembehandlung finden Sie in den Problembehandlungsschritten.
• Wenden Sie sich bei OpenTelemetry-Problemen direkt an die OpenTelemetry-Community.
• Eine Liste der offenen Probleme im Zusammenhang mit automatischer Azure Monitor-Java-Instrumentierung finden Sie auf der Issues-Seite auf GitHub.

Node.js

• Bei Azure-Supportproblemen öffnen Sie ein Azure-Supportticket.
• Wenden Sie sich bei OpenTelemetry-Problemen direkt an die OpenTelemetry JavaScript-Community.
• Eine Liste der offenen Probleme im Zusammenhang mit Azure Monitor Exporter finden Sie auf der Issues-Seite auf GitHub.

Python

• Bei Azure-Supportproblemen öffnen Sie ein Azure-Supportticket.
• Wenden Sie sich bei OpenTelemetry-Problemen direkt an die OpenTelemetry Python-Community.
• Eine Liste der offenen Probleme im Zusammenhang mit der Azure Monitor-Distribution finden Sie auf der Seite der GitHub-Probleme.

OpenTelemetry-Feedback

So können Sie Feedback geben

• Füllen Sie die Kundenfeedbackumfrage der OpenTelemetry-Community aus.
• Erzählen Sie Microsoft von sich, indem Sie der OpenTelemetry Early Adopter-Community beitreten.
• Interagieren Sie mit anderen Azure Monitor-Benutzern in der Technischen Community von Microsoft.
• Featureanfragen können Sie im Azure-Feedbackforum stellen.