Activez Azure Monitor OpenTelemetry pour les applications .NET, Node.js et Python (préversion)

Azure Monitor OpenTelemetry Exporter est un composant qui envoie des traces et des métriques (et éventuellement toute la télémétrie d’application) à Azure Monitor Application Insights. Pour en savoir plus sur les concepts OpenTelemetry, consultez la vue d’ensemble d’OpenTelemetry ou les questions fréquentes (FAQ).

Cet article explique comment activer et configurer l’offre en préversion Azure Monitor basée sur OpenTelemetry. Après avoir suivi les instructions de cet article, vous pourrez envoyer des traces et des métriques OpenTelemetry à Azure Monitor Application Insights.

Important

L’offre Azure Monitor basée sur OpenTelemetry Azure pour les applications .NET, Node.js et Python est actuellement en préversion. Pour connaître les conditions juridiques qui s’appliquent aux fonctionnalités Azure en version bêta, en préversion ou plus généralement non encore en disponibilité générale, consultez l’Avenant aux conditions d’utilisation des préversions de Microsoft Azure.

Limitations de la version préliminaire

Déterminez si cette préversion vous convient. Elle active le suivi distribué, les métriques et , mais exclut les éléments suivants :

  • Métriques temps réel
  • API de journalisation (telles que les journaux de la console et les bibliothèques de journalisation)
  • Profiler
  • Débogueur de capture instantanée
  • Authentification Azure Active Directory
  • Remplissage automatique du nom du rôle cloud et de l’instance du rôle cloud dans les environnements Azure
  • Remplissage automatique de l’ID utilisateur et de l’ID utilisateur authentifié lors de l’utilisation du SDK JavaScript Application Insights
  • Remplissage automatique de l’adresse IP de l’utilisateur (pour déterminer les attributs de l’emplacement)
  • Possibilité de remplacer le nom de l’opération
  • Possibilité de définir manuellement l’ID utilisateur ou l’ID utilisateur authentifié
  • Propagation du nom de l’opération à la télémétrie des dépendances
  • Prise en charge des bibliothèques d’instrumentation sur Azure Functions
  • Etat prend en charge statuscode(unset,ok,error) et status-description. La « Description de l’état » est ignorée par les Exportateurs Azure Monitor.

Si vous avez besoin d’une expérience complète,utilisez le Kit de développement logiciel (SDK) ASP.NET ou ASP.NET Core Application Insights existant jusqu’à ce que l’offre basée sur OpenTelemetry gagne en maturité.

Bien démarrer

Suivez les étapes de cette section pour instrumenter votre application avec OpenTelemetry.

Prérequis

  • Application utilisant une version officiellement prise en charge de .NET Core ou de .NET Framework qui est au moins .NET Framework 4.6.2

Installer les bibliothèques de client

Installez le package NuGet Azure.Monitor.OpenTelemetry.Exporter le plus récent :

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

Si vous recevez une erreur de type « Aucune version n’est disponible pour le package 'Azure.Monitor.OpenTelemetry.Exporter' », cela est probablement dû au fait qu’il manque le paramètre des sources du package NuGet. Vous pouvez essayer de spécifier la source avec l’option -s :

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

Activer Azure Monitor Application Insights

Cette section fournit des instructions qui indiquent comment activer OpenTelemetry.

Ajouter du code d’instrumentation OpenTelemetry

Le code suivant illustre l’activation d’OpenTelemetry dans une application console C# en configurant OpenTelemetry TracerProvider. Ce code doit être présent au démarrage de l’application. Pour ASP.NET Core, nous utilisons généralement la méthode ConfigureServices de la classe Startup de l’application. Pour les applications ASP.NET, nous utilisons généralement Global.asax.cs.

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

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

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

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

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

Notes

Les classes Activity et ActivitySource de l’espace de noms System.Diagnostics représentent les concepts OpenTelemetry de Span et Tracer respectivement. Vous créez ActivitySource directement à l’aide de son constructeur à la place de TracerProvider. Chaque classe ActivitySource doit être explicitement connectée àTracerProvider à l’aide de AddSource() . Cela est dû au fait que des parties de l’API de suivi OpenTelemetry sont incorporées directement dans le runtime .NET. Pour plus d’informations, consultez Présentation de l’API de suivi .NET OpenTelemetry.

Conseil

Ajoutez des bibliothèques d’instrumentation pour collecter automatiquement les données de télémétrie dans les frameworks et bibliothèques populaires.

Définir la chaîne de connexion Application Insights

Remplacez l’espace réservé <Your Connection String> dans le code ci-dessus par la chaîne de connexion de votre ressource Application Insights.

Capture d’écran de la chaîne de connexion Application Insights.

Confirmer le déplacement des données

Exécutez votre application et ouvrez votre onglet Ressource Application Insights dans le portail Azure. L’affichage des données dans le portail peut prendre plusieurs minutes.

Notes

Si vous n’êtes pas en mesure d’exécuter l’application ou si vous n’obtenez pas de données comme prévu, accédez à la section Résolution des problèmes.

Capture d’écran de l’onglet Vue d’ensemble d’Application Insights avec les demandes serveur et le temps de réponse du serveur mis en évidence.

Important

Si vous avez deux ou plusieurs services émettant de la télémétrie vers la même ressource Application Insights, vous devez définir les noms des rôles cloud pour les représenter correctement sur la cartographie d’application.

Dans le cadre de l’utilisation de l’instrumentation Application Insights, nous collectons et envoyons des données de diagnostic à Microsoft. Ces données nous permettent d’exécuter et d’améliorer Application Insights. Vous pouvez désactiver la collecte de données non essentielles. Pour en savoir plus, consultez Statsbeat dans Azure Application Insights.

Définir le nom du rôle cloud et l’instance de rôle cloud

Vous pouvez définir le nom du rôle cloud et l’instance de rôle cloud via les attributs Ressource. Cela remplace la valeur par défaut du nom du rôle cloud et de l’instance de rôle cloud par quelque chose qui a un sens pour votre équipe. Cela s’affiche sur la cartographie d’application en tant que nom sous un nœud. Le nom du rôle cloud utilise les attributs service.namespace et service.name, mais il retourne à la valeur service.name si service.namespace n’est pas défini. L’instance de rôle cloud utilise la valeur d’attribut service.instance.id.

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

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

Pour plus d’informations sur les attributs standard pour les ressources, consultez Conventions sémantiques des ressources.

Activer l’échantillonnage

Vous pouvez activer l’échantillonnage pour réduire votre volume d’ingestion de données, ce qui réduit vos coûts. Azure Monitor fournit un échantillonneur à taux fixe personnalisé qui remplit les événements avec un « ratio d’échantillonnage », qu’Application Insights convertit en « ItemCount ». L’échantillonneur à taux fixe garantit des expériences et des comptes d’événements précis. L’échantillonneur est conçu pour préserver vos traces entre les services, et il est interopérable avec des Kits de développement logiciel (SDK) Application Insights plus anciens. L’échantillonneur s’attend à un taux d’échantillonnage compris entre 0 et 1 inclus. Un taux de 0,1 signifie qu’environ 10 % de vos traces seront envoyées. Pour plus d’informations, consultez En savoir plus sur l’échantillonnage.

Notes

Les métriques ne sont pas affectées par l’échantillonnage.

Dans cet exemple, nous utilisons le ApplicationInsightsSampler, qui offre une compatibilité avec les Kits de développement logiciel (SDK) Application Insights.

dotnet add package --prerelease OpenTelemetry.Extensions.AzureMonitor
var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddSource("OTel.AzureMonitor.Demo")
    .SetSampler(new ApplicationInsightsSampler(0.1F))
    .AddAzureMonitorTraceExporter(o =>
    {
     o.ConnectionString = "<Your Connection String>";
    })
    .Build();

Conseil

Si vous ne savez pas où définir le taux d’échantillonnage, commencez à 5 % (c’est-à-dire 0,05 du taux d’échantillonnage) et ajustez le taux en fonction de la précision des opérations affichées dans les volets d’échecs et de performances. Un taux plus élevé entraîne généralement une plus grande précision. Toutefois, l’échantillonnage ANY affecte la précision. Nous vous recommandons donc de générer des alertes sur les métriques OpenTelemetry, lesquelles ne sont pas affectées par l’échantillonnage.

Bibliothèques d’instrumentation

Les bibliothèques suivantes sont validées pour fonctionner avec la Préversion :

Avertissement

Les bibliothèques d’instrumentation sont basées sur des spécifications OpenTelemetry expérimentales. L’engagement de prise en charge de la préversion par Microsoft permet de s’assurer que les bibliothèques listées ci-dessous émettent des données pour Azure Monitor Application Insights, mais il est possible que des modifications avec rupture ou qu’un mappage expérimental bloquent certains éléments de données.

Suivi distribué

Demandes

Les dépendances

(1) Prend en charge la création de rapports automatiques (en tant que SpanEvent) d’exceptions non gérées

Mesures

Conseil

Les offres Basées sur OpenTelemetry émettent actuellement toutes les métriques en tant que Métriques personnalisées dans Metrics Explorer. Tout ce que vous définissez comme nom du compteur devient l’espace de noms des métriques.

Modifier la télémétrie

Cette section explique comment modifier la télémétrie.

Ajouter des attributs d’étendue

Pour ajouter des attributs span, utilisez l’une des deux méthodes suivantes :

Ces attributs peuvent inclure l’ajout d’une propriété personnalisée à votre télémétrie. Vous pouvez également utiliser des attributs pour définir des champs facultatifs dans le schéma Application Insights, comme une adresse IP de client.

Conseil

L’avantage de l’utilisation des options fournies par les bibliothèques d’instrumentation, lorsqu’elles sont disponibles, est que tout le contexte est disponible. Par conséquent, les utilisateurs peuvent choisir d’ajouter ou de filtrer davantage d’attributs. Par exemple, l’option enrichir de la bibliothèque d’instrumentation HttpClient permet aux utilisateurs d’accéder au httpRequestMessage lui-même. Ils peuvent sélectionner n’importe quoi et le stocker en tant qu’attribut.

Ajoutez une propriété personnalisée à une Trace

Tous les attributs que vous ajoutez aux étendues sont exportés en tant que propriétés personnalisées. Ils remplissent le champ customDimensions dans les tables de requêtes ou de dépendances dans Application Insights.

  1. De nombreuses bibliothèques d’instrumentation fournissent une option enrichir. Pour obtenir de l’aide, consultez les fichiers Lisez-moi des bibliothèques d’instrumentation individuelles :

  2. Utilisation d’un processeur personnalisé :

Conseil

Ajoutez le processeur indiqué ci-dessous avant Azure Monitor Exporter.

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

Ajoutez ActivityEnrichingProcessor.cs à votre projet avec le code ci-dessous :

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

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

Définir l’IP utilisateur

Vous pouvez renseigner le champ client_IP pour les requêtes en définissant l’attribut http.client_ip sur l’étendue. Application Insights utilise l’adresse IP pour générer des attributs d’emplacement utilisateur, puis la supprime par défaut.

Utilisez l’exemple d’ajout d’une propriété personnalisée, mais changez les lignes de code suivantes dans ActivityEnrichingProcessor.cs :

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

Filtrer les données de télémétrie

Vous pouvez utiliser les méthodes suivantes pour filtrer les données de télémétrie avant qu’elles ne quittent votre application.

  1. De nombreuses bibliothèques d’instrumentation fournissent une option de filtre. Pour obtenir de l’aide, consultez les fichiers Lisez-moi des bibliothèques d’instrumentation individuelles :

  2. Utilisation d’un processeur personnalisé :

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

    Ajoutez ActivityFilteringProcessor.cs à votre projet avec le code ci-dessous :

    using System.Diagnostics;
    using OpenTelemetry;
    using OpenTelemetry.Trace;
    
    public class ActivityFilteringProcessor : BaseProcessor<Activity>
    {
        public override void OnStart(Activity activity)
        {
            // prevents all exporters from exporting internal activities
            if (activity.Kind == ActivityKind.Internal)
            {
                activity.IsAllDataRequested = false;
            }
        }
    }
    
  3. Si une source particulière n’est pas explicitement ajoutée à l’aide de AddSource("ActivitySourceName"), alors aucune des activités créées à l’aide de cette source n’est exportée.

Télémétrie personnalisée

Cette section explique comment collecter des données de télémétrie personnalisées à partir de votre application.

Ajoutez des métriques personnalisées

Notes

Les métriques personnalisées sont en préversion dans Azure Monitor Application Insights. Les métriques personnalisées sans dimensions sont disponibles par défaut. Pour afficher et générer des alertes sur les dimensions, vous devez vous inscrire.

Vous pouvez collecter des métriques au-delà de ce qui est collecté par les bibliothèques d’instrumentation.

L’API OpenTelemetry propose six « instruments » de métrique pour couvrir différents scénarios de métrique et vous devez choisir le « Type d’agrégation » correct lors de la visualisation des métriques dans Metrics Explorer. Cette exigence est vraie lors de l’utilisation de l’API de métrique OpenTelemetry pour envoyer des métriques et lors de l’utilisation d’une bibliothèque d’instrumentation.

Le tableau suivant présente les types d’agrégation recommandés pour chacun des instruments de métriques OpenTelemetry.

Instrumentation OpenTelemetry Type d’agrégation Azure Monitor
Compteur Sum
Compteur asynchrone Sum
Histogramme Min, Max, Average, Sum et Count
Jauge asynchrone Moyenne
UpDownCounter Sum
UpDownCounter asynchrone Sum

Attention

Les types d’agrégation au-delà des éléments affichés dans le tableau ne sont généralement pas significatifs.

La Spécification OpenTelemetry décrit les instruments et fournit des exemples de cas où vous pouvez utiliser chacun d’eux.

Conseil

L’histogramme est l’équivalent le plus versatile et le plus proche de l’API Application Insights Track Metric précédente. Azure Monitor aplatit actuellement l’instrumentation de l’histogramme dans nos cinq types d’agrégation pris en charge. La prise en charge des centiles est en cours. Bien que moins polyvalents, les autres instruments OpenTelemetry ont un impact moindre sur les performances de votre application.

Exemple d’histogramme

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

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

    public static void Main()
    {
        using var meterProvider = Sdk.CreateMeterProviderBuilder()
            .AddMeter("OTel.AzureMonitor.Demo")
            .AddAzureMonitorMetricExporter(o =>
            {
                o.ConnectionString = "<Your Connection String>";
            })
            .Build();

        Histogram<long> myFruitSalePrice = meter.CreateHistogram<long>("FruitSalePrice");

        var rand = new Random();
        myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "red"));
        myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));
        myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));
        myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "green"));
        myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "red"));
        myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));

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

Exemple de compteur

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

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

    public static void Main()
    {
        using var meterProvider = Sdk.CreateMeterProviderBuilder()
            .AddMeter("OTel.AzureMonitor.Demo")
            .AddAzureMonitorMetricExporter(o =>
            {
                o.ConnectionString = "<Your Connection String>";
            })
            .Build();

        Counter<long> myFruitCounter = meter.CreateCounter<long>("MyFruitCounter");

        myFruitCounter.Add(1, new("name", "apple"), new("color", "red"));
        myFruitCounter.Add(2, new("name", "lemon"), new("color", "yellow"));
        myFruitCounter.Add(1, new("name", "lemon"), new("color", "yellow"));
        myFruitCounter.Add(2, new("name", "apple"), new("color", "green"));
        myFruitCounter.Add(5, new("name", "apple"), new("color", "red"));
        myFruitCounter.Add(4, new("name", "lemon"), new("color", "yellow"));

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

Exemple de jauge

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

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

    public static void Main()
    {
        using var meterProvider = Sdk.CreateMeterProviderBuilder()
            .AddMeter("OTel.AzureMonitor.Demo")
            .AddAzureMonitorMetricExporter(o =>
            {
                o.ConnectionString = "<Your Connection String>";
            })
            .Build();

        var process = Process.GetCurrentProcess();
        
        ObservableGauge<int> myObservableGauge = meter.CreateObservableGauge("Thread.State", () => GetThreadState(process));

        System.Console.WriteLine("Press Enter key to exit.");
        System.Console.ReadLine();
    }
    
    private static IEnumerable<Measurement<int>> GetThreadState(Process process)
    {
        foreach (ProcessThread thread in process.Threads)
        {
            yield return new((int)thread.ThreadState, new("ProcessId", process.Id), new("ThreadId", thread.Id));
        }
    }
}

Ajoutez des exceptions personnalisées

Sélectionnez des bibliothèques d’instrumentation qui prennent automatiquement en charge les exceptions à Application Insights. Toutefois, vous pouvez signaler manuellement des exceptions au-delà du rapport des bibliothèques d’instrumentation. Par exemple, les exceptions interceptées par votre code ne sont généralement pas* signalées. Vous pouvez les signaler pour attirer l’attention sur les expériences pertinentes, notamment la section échecs et les vues de transaction de bout en bout.

using (var activity = activitySource.StartActivity("ExceptionExample"))
{
    try
    {
        throw new Exception("Test exception");
    }
    catch (Exception ex)
    {
        activity?.SetStatus(ActivityStatusCode.Error);
        activity?.RecordException(ex);
    }
}

Activer l’exportateur OTLP

Vous pouvez activer OpenTelemetry Protocol (OTLP) Exporter en plus d’Azure Monitor Exporter pour envoyer vos données de télémétrie à deux emplacements.

Notes

OTLP Exporter est illustré pour des raisons pratiques uniquement. Nous ne prenons pas officiellement en charge OTLP Exporter ni les composants ou les expériences tierces qui en découlent. Nous vous suggérons de signaler le problème auprès de OpenTelemetry-Collector pour les problèmes OpenTelemetry qui ne relèvent pas du Support Azure.

  1. Installez le package OpenTelemetry.Exporter.OpenTelemetryProtocol avec Azure.Monitor.OpenTelemetry.Exporter dans votre projet.

  2. Ajoutez l’extrait de code suivant : Cet exemple suppose que vous disposez d’un OpenTelemetry Collector avec un récepteur OTLP en cours d’exécution. Pour plus d’informations, consultez l' exemple relatif à GitHub.

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

Configuration

Stockage hors connexion et nouvelles tentatives automatiques

Pour améliorer la fiabilité et la résilience, les offres Azure Monitor basées sur OpenTelemetry écrivent dans un stockage hors connexion/local par défaut lorsqu’une application perd sa connexion avec Application Insights. Il enregistre la télémétrie de l’application pendant 48 heures et tente régulièrement de l’envoyer à nouveau. En plus de dépasser le temps autorisé, les données de télémétrie sont parfois supprimées dans des applications à charge élevée lorsque la taille maximale du fichier est dépassée ou que le Kit de développement logiciel (SDK) n’a pas la possibilité d’effacer le fichier. Si nous devons choisir, le produit enregistre les événements les plus récents sur les anciens. Dans certains cas, vous pouvez désactiver cette fonctionnalité pour optimiser les performances de l’application. En savoir plus

Par défaut, AzureMonitorExporter utilise l’un des emplacements suivants pour le stockage hors connexion (répertorié dans l’ordre de priorité) :

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

Pour remplacer le répertoire par défaut, vous devez définir AzureMonitorExporterOptions.StorageDirectory.

Par exemple :

var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddAzureMonitorTraceExporter(o => {
        o.ConnectionString = "<Your Connection String>";
        o.StorageDirectory = "C:\\SomeDirectory";
    })
    .Build();

Pour désactiver cette fonctionnalité, vous devez définir AzureMonitorExporterOptions.DisableOfflineStorage = true.

Dépannage

Cette section fournit de l’aide sur la résolution des problèmes.

Activer la journalisation des diagnostics

Azure Monitor Exporter utilise EventSource pour sa propre journalisation interne. Les journaux de l’outil d’exportation sont disponibles pour n’importe quel EventListener en vous abonnant à la source nommée « OpenTelemetry-AzureMonitor-Exporter ». Pour obtenir les étapes de dépannage, consultez Résolution des problèmes OpenTelemetry.

Problèmes connus

Les problèmes connus pour Azure Monitor OpenTelemetry Exporters incluent :

  • Le nom de l’opération est manquant sur la télémétrie des dépendances, ce qui a un impact négatif sur l’expérience de l’onglet des échecs et des performances.
  • Le modèle d’appareil est manquant sur la télémétrie de la demande et de la dépendance, ce qui a un impact négatif sur l’analyse de la cohorte d’appareils.
  • Le nom du serveur de base de données ne figure pas dans le nom de la dépendance, ce qui agrège de manière incorrecte les tables portant le même nom sur des serveurs différents.

Tester la connectivité entre votre hôte d’application et le service d’ingestion

Les SDK et les agents Application Insights envoient de la télémétrie à ingérer en tant qu’appels REST à nos points de terminaison d’ingestion. Vous pouvez tester la connectivité de votre serveur web ou de votre machine hôte d’application vers les points de terminaison de service d’ingestion en utilisant des clients du Representational State Transfer (REST) bruts à partir de commandes PowerShell ou curl. Consultez Résoudre les problèmes de télémétrie d’application manquante dans Azure Monitor Application Insights.

Support

Pour bénéficier du support technique :

  • Passez en revue les étapes de résolution des problèmes décrites dans cet article.
  • Pour les problèmes de support Azure, ouvrez un ticket de support Azure.

Pour les problèmes OpenTelemetry, contactez directement la communauté OpenTelemetry .NET.

Commentaires OpenTelemetry

Pour fournir des commentaires :

Étapes suivantes