Filtrage et pré-traitement de la télémétrie dans le Kit de développement logiciel (SDK) Application InsightsFiltering and preprocessing telemetry in the Application Insights SDK

Vous pouvez écrire et configurer des plug-ins pour le kit de développement logiciel (SDK) Application Insights afin de personnaliser l'enrichissement et le traitement des données de télémétrie avant leur envoi au service Application Insights.You can write and configure plug-ins for the Application Insights SDK to customize how telemetry can be enriched and processed before it's sent to the Application Insights service.

  • échantillonnage réduit le volume des données de télémétrie sans affecter les statistiques.Sampling reduces the volume of telemetry without affecting your statistics. Il maintient ensemble les points de données liés de sorte que vous pouvez naviguer entre eux pour diagnostiquer un problème.It keeps together related data points so that you can navigate between them when diagnosing a problem. Dans le portail, les nombres totaux sont multipliés pour compenser l'échantillonnage.In the portal, the total counts are multiplied to compensate for the sampling.
  • Le filtrage avec des processeurs de télémétrie vous permet de filtrer la télémétrie dans le kit de développement logiciel (SDK) avant l’envoi au serveur.Filtering with Telemetry Processors lets you filter out telemetry in the SDK before it is sent to the server. Par exemple, vous pouvez réduire le volume de la télémétrie en excluant les demandes émanant de robots.For example, you could reduce the volume of telemetry by excluding requests from robots. Le filtrage est une approche plus simple que l’échantillonnage pour réduire le trafic.Filtering is a more basic approach to reducing traffic than sampling. Cela vous permet de mieux contrôler ce qui est transmis, mais vous devez être conscient que cela affecte vos statistiques ; par exemple, si vous filtrez toutes les demandes réussies.It allows you more control over what is transmitted, but you have to be aware that it affects your statistics - for example, if you filter out all successful requests.
  • Les initialiseurs de télémétrie ajoutent ou modifient des propriétés à n’importe quelle télémétrie envoyée à partir de votre application, notamment les données de télémétrie fournies par les modules standard.Telemetry Initializers add or modify properties to any telemetry sent from your app, including telemetry from the standard modules. Par exemple, vous pouvez ajouter des valeurs calculées ou des numéros de version permettant de filtrer les données dans le portail.For example, you could add calculated values; or version numbers by which to filter the data in the portal.
  • L'API SDK est utilisée pour envoyer des événements et des mesures personnalisés.The SDK API is used to send custom events and metrics.

Avant de commencer :Before you start:

FiltrageFiltering

Cette technique vous offre un contrôle direct sur ce qui est inclus ou exclu du flux de télémétrie.This technique gives you direct control over what is included or excluded from the telemetry stream. Le filtrage peut être utilisé ne pas envoyer certains éléments de télémétrie à Application Insights.Filtering can be used to drop telemetry items from being sent to Application Insights. Vous pouvez l'utiliser conjointement avec l'échantillonnage, ou séparément.You can use it in conjunction with Sampling, or separately.

Pour filtrer la télémétrie, vous écrivez un processeur de télémétrie et l'enregistrez avec le TelemetryConfiguration.To filter telemetry, you write a telemetry processor and register it with the TelemetryConfiguration. Toute la télémétrie passe par votre processeur et vous pouvez choisir de la supprimer du flux ou de la transmettre au processeur suivant dans la chaîne.All telemetry goes through your processor, and you can choose to drop it from the stream or give it to the next processor in the chain. Cela inclut les données de télémétrie fournies par les modules standard tels que le collecteur de requêtes HTTP et le collecteur de dépendances, ainsi que les données de télémétrie que vous avez suivies vous-même.This includes telemetry from the standard modules such as the HTTP request collector and the dependency collector, and telemetry you have tracked yourself. Vous pouvez, par exemple, exclure la télémétrie concernant les demandes émanant de robots ou les appels de dépendance réussis.You can, for example, filter out telemetry about requests from robots, or successful dependency calls.

Avertissement

Filtrer la télémétrie envoyée depuis le Kit de développement logiciel (SDK) à l’aide de processeurs peut fausser les statistiques que vous voyez dans le portail et rendre difficile le suivi des éléments associés.Filtering the telemetry sent from the SDK using processors can skew the statistics that you see in the portal, and make it difficult to follow related items.

Envisagez plutôt d'utiliser l' échantillonnage.Instead, consider using sampling.

Créer un processeur de télémétrie (C#)Create a telemetry processor (C#)

  1. Pour créer un filtre, implémentez ITelemetryProcessor.To create a filter, implement ITelemetryProcessor.

    Notez que les processeurs de télémétrie construisent une chaîne de traitement.Notice that Telemetry Processors construct a chain of processing. Lorsque vous instanciez un processeur de télémétrie, une référence vous est donnée vers le processeur suivant dans la chaîne.When you instantiate a telemetry processor, you are given a reference to the next processor in the chain. Lorsqu’un point de données de télémétrie est transmis à la méthode de traitement, il effectue son travail, puis appelle (ou n'appelle pas) le processeur de télémétrie suivant dans la chaîne.When a telemetry data point is passed to the Process method, it does its work and then calls (or not calls) the next Telemetry Processor in the chain.

    using Microsoft.ApplicationInsights.Channel;
    using Microsoft.ApplicationInsights.Extensibility;
    
    public class SuccessfulDependencyFilter : ITelemetryProcessor
    {
        private ITelemetryProcessor Next { get; set; }
    
        // next will point to the next TelemetryProcessor in the chain.
        public SuccessfulDependencyFilter(ITelemetryProcessor next)
        {
            this.Next = next;
        }
    
        public void Process(ITelemetry item)
        {
            // To filter out an item, return without calling the next processor.
            if (!OKtoSend(item)) { return; }
    
            this.Next.Process(item);
        }
    
        // Example: replace with your own criteria.
        private bool OKtoSend (ITelemetry item)
        {
            var dependency = item as DependencyTelemetry;
            if (dependency == null) return true;
    
            return dependency.Success != true;
        }
    }
    
  2. Ajoutez votre processeur.Add your processor.

Applications ASP.NET Insérez cet extrait de code dans ApplicationInsights.config :ASP.NET apps Insert this snippet in ApplicationInsights.config:

<TelemetryProcessors>
  <Add Type="WebApplication9.SuccessfulDependencyFilter, WebApplication9">
     <!-- Set public property -->
     <MyParamFromConfigFile>2-beta</MyParamFromConfigFile>
  </Add>
</TelemetryProcessors>

Vous pouvez transférer des valeurs de chaîne depuis le fichier .config en fournissant des propriétés publiques nommées dans votre classe.You can pass string values from the .config file by providing public named properties in your class.

Avertissement

Veillez à faire correspondre le nom de type et les noms de propriété dans le fichier .config aux noms de classe et de propriété dans le code.Take care to match the type name and any property names in the .config file to the class and property names in the code. Si le fichier .config fait référence à un type ou à une propriété qui n'existe pas, le kit de développement peut échouer lors de l'envoi d'une télémétrie quelconque.If the .config file references a non-existent type or property, the SDK may silently fail to send any telemetry.

également initialiser le filtre dans le code.Alternatively, you can initialize the filter in code. Dans une classe d’initialisation appropriée (par exemple, AppStart dans Global.asax.cs), insérez votre processeur dans la chaîne :In a suitable initialization class - for example AppStart in Global.asax.cs - insert your processor into the chain:

var builder = TelemetryConfiguration.Active.DefaultTelemetrySink.TelemetryProcessorChainBuilder;
builder.Use((next) => new SuccessfulDependencyFilter(next));

// If you have more processors:
builder.Use((next) => new AnotherProcessor(next));

builder.Build();

Les clients de télémétrie créés après ce point utiliseront vos processeurs.TelemetryClients created after this point will use your processors.

Applications ASP.NET Core/Worker ServiceASP.NET Core/ Worker Service apps

Notes

L’ajout du processeur à l’aide de ApplicationInsights.config ou TelemetryConfiguration.Active n’est pas valide pour les applications ASP.NET Core ou si vous utilisez le kit de développement logiciel (SDK) Microsoft.ApplicationInsights. WorkerService.Adding processor using ApplicationInsights.config or using TelemetryConfiguration.Active is not valid for ASP.NET Core applications or if you are using Microsoft.ApplicationInsights.WorkerService SDK.

Pour les applications écrites avec ASP.NET Core ou WorkerService, l’ajout d’un nouveau TelemetryProcessor se fait à l'aide de la méthode d'extension AddApplicationInsightsTelemetryProcessor sur IServiceCollection, comme indiqué ci-dessous.For apps written using ASP.NET Core or WorkerService, adding a new TelemetryProcessor is done by using AddApplicationInsightsTelemetryProcessor extension method on IServiceCollection, as shown below. Cette méthode est appelée dans la méthode ConfigureServices de votre classe Startup.cs.This method is called in ConfigureServices method of your Startup.cs class.

    public void ConfigureServices(IServiceCollection services)
    {
        // ...
        services.AddApplicationInsightsTelemetry();
        services.AddApplicationInsightsTelemetryProcessor<SuccessfulDependencyFilter>();

        // If you have more processors:
        services.AddApplicationInsightsTelemetryProcessor<AnotherProcessor>();
    }

Exemples de filtresExample filters

Demandes synthétiquesSynthetic requests

Excluez les robots et les tests web.Filter out bots and web tests. Bien que Metrics Explorer vous donne la possibilité d’exclure les sources synthétiques, cette option réduit le trafic et la taille d'ingestion en les filtrant au niveau du kit de développement (SDK).Although Metrics Explorer gives you the option to filter out synthetic sources, this option reduces traffic and ingestion size by filtering them at the SDK itself.

public void Process(ITelemetry item)
{
  if (!string.IsNullOrEmpty(item.Context.Operation.SyntheticSource)) {return;}

  // Send everything else:
  this.Next.Process(item);
}

Échec d’authentificationFailed authentication

Excluez les demandes avec une réponse de type « 401 ».Filter out requests with a "401" response.

public void Process(ITelemetry item)
{
    var request = item as RequestTelemetry;

    if (request != null &&
    request.ResponseCode.Equals("401", StringComparison.OrdinalIgnoreCase))
    {
        // To filter out an item, return without calling the next processor.
        return;
    }

    // Send everything else
    this.Next.Process(item);
}

Excluez les appels de dépendance à distance rapides.Filter out fast remote dependency calls

Si vous souhaitez uniquement diagnostiquer les appels lents, excluez les appels rapides.If you only want to diagnose calls that are slow, filter out the fast ones.

Notes

Cela faussera les statistiques que vous voyez dans le portail.This will skew the statistics you see on the portal.

public void Process(ITelemetry item)
{
    var request = item as DependencyTelemetry;

    if (request != null && request.Duration.TotalMilliseconds < 100)
    {
        return;
    }
    this.Next.Process(item);
}

Diagnostiquer les problèmes de dépendanceDiagnose dependency issues

Ce blog décrit un projet pour diagnostiquer les problèmes de dépendance en envoyant automatiquement des requêtes ping régulières aux dépendances.This blog describes a project to diagnose dependency issues by automatically sending regular pings to dependencies.

Applications web JavaScriptJavaScript Web applications

Filtrage à l’aide de ITelemetryInitializerFiltering using ITelemetryInitializer

  1. Créez une fonction de rappel de l’initialiseur de télémétrie.Create a telemetry initializer callback function. La fonction de rappel prend ITelemetryItem en tant que paramètre, qui est l’événement en cours de traitement.The callback function takes ITelemetryItem as a parameter, which is the event that is being processed. Le retour de false de ce rappel entraîne le filtrage de l’élément de télémétrie.Returning false from this callback results in the telemetry item to be filtered out.

    var filteringFunction = (envelope) => {
      if (envelope.data.someField === 'tobefilteredout') {
         return false;
      }
    
      return true;
    };
    
  2. Ajoutez votre rappel de l’initialiseur de télémétrie :Add your telemetry initializer callback:

    appInsights.addTelemetryInitializer(filteringFunction);
    

Ajoutez/modifiez des propriétés : ITelemetryInitializerAdd/modify properties: ITelemetryInitializer

Utilisez les initialiseurs de télémétrie pour enrichir la télémétrie avec des informations supplémentaires et/ou remplacer les propriétés de télémétrie définies par les modules de télémétrie standard.Use telemetry initializers to enrich telemetry with additional information and/or to override telemetry properties set by the standard telemetry modules.

Par exemple, le package Application Insights pour le Web collecte la télémétrie sur les requêtes HTTP.For example, the Application Insights for Web package collect telemetry about HTTP requests. Il indique par défaut l’échec de toute requête à l’aide d’un code de réponse supérieur ou égal à 400.By default, it flags as failed any request with a response code >= 400. Toutefois, si 400 vous convient, vous pouvez fournir un initialiseur de télémétrie qui définit la propriété Success.But if you want to treat 400 as a success, you can provide a telemetry initializer that sets the Success property.

Si vous fournissez un initialiseur de télémétrie, celui-ci est appelé chaque fois qu'une des méthodes Track*() est appelée.If you provide a telemetry initializer, it is called whenever any of the Track*() methods are called. Cela inclut les méthodes Track() appelées par les modules de télémétrie standard.This includes Track() methods called by the standard telemetry modules. Par convention, ces modules ne définissent aucune propriété déjà définie par un initialiseur.By convention, these modules do not set any property that has already been set by an initializer. Les initialiseurs de télémétrie sont appelés préalablement aux processeurs de télémétrie.Telemetry initializers are called before calling telemetry processors. Dès lors, tout enrichissement effectué par les initialiseurs est visible des processeurs.So any enrichments done by initializers are visible to processors.

Définir votre initialiseurDefine your initializer

C#C#

using System;
using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.DataContracts;
using Microsoft.ApplicationInsights.Extensibility;

namespace MvcWebRole.Telemetry
{
  /*
   * Custom TelemetryInitializer that overrides the default SDK
   * behavior of treating response codes >= 400 as failed requests
   *
   */
  public class MyTelemetryInitializer : ITelemetryInitializer
  {
    public void Initialize(ITelemetry telemetry)
    {
        var requestTelemetry = telemetry as RequestTelemetry;
        // Is this a TrackRequest() ?
        if (requestTelemetry == null) return;
        int code;
        bool parsed = Int32.TryParse(requestTelemetry.ResponseCode, out code);
        if (!parsed) return;
        if (code >= 400 && code < 500)
        {
            // If we set the Success property, the SDK won't change it:
            requestTelemetry.Success = true;

            // Allow us to filter these requests in the portal:
            requestTelemetry.Properties["Overridden400s"] = "true";
        }
        // else leave the SDK to set the Success property
    }
  }
}

Applications ASP.NET : Charger votre initialiseurASP.NET apps: Load your initializer

Dans ApplicationInsights.config :In ApplicationInsights.config:

<ApplicationInsights>
  <TelemetryInitializers>
    <!-- Fully qualified type name, assembly name: -->
    <Add Type="MvcWebRole.Telemetry.MyTelemetryInitializer, MvcWebRole"/>
    ...
  </TelemetryInitializers>
</ApplicationInsights>

également instancier l'initialiseur dans le code, par exemple dans Global.aspx.cs :Alternatively, you can instantiate the initializer in code, for example in Global.aspx.cs:

protected void Application_Start()
{
    // ...
    TelemetryConfiguration.Active.TelemetryInitializers.Add(new MyTelemetryInitializer());
}

Voir l’intégralité de cet exemple.See more of this sample.

Applications ASP.NET Core/Worker Service : Charger votre initialiseurASP.NET Core/ Worker Service apps: Load your initializer

Notes

L’ajout d’un initialiseur à l’aide de ApplicationInsights.config ou TelemetryConfiguration.Active n’est pas valide pour les applications ASP.NET Core ou si vous utilisez le kit de développement logiciel (SDK) Microsoft.ApplicationInsights. WorkerService.Adding initializer using ApplicationInsights.config or using TelemetryConfiguration.Active is not valid for ASP.NET Core applications or if you are using Microsoft.ApplicationInsights.WorkerService SDK.

Pour les applications écrites avec ASP.NET Core ou WorkerService, l’ajout d’un nouveau TelemetryInitializer se fait en l’ajoutant au conteneur d’injection de dépendance, comme indiqué ci-dessous.For apps written using ASP.NET Core or WorkerService, adding a new TelemetryInitializer is done by adding it to the Dependency Injection container, as shown below. Cette opération est effectuée dans la méthode Startup.ConfigureServices.This is done in Startup.ConfigureServices method.

 using Microsoft.ApplicationInsights.Extensibility;
 using CustomInitializer.Telemetry;
 public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<ITelemetryInitializer, MyTelemetryInitializer>();
}

Initialiseurs de télémétrie JavaJava telemetry initializers

Documentation du Kit de développement logiciel (SDK) JavaJava SDK documentation

public interface TelemetryInitializer
{ /** Initializes properties of the specified object. * @param telemetry The {@link com.microsoft.applicationinsights.telemetry.Telemetry} to initialize. */

void initialize(Telemetry telemetry); }

Enregistrez ensuite l’initialiseur personnalisé dans votre fichier applicationinsights.xml.Then register the custom initializer in your applicationinsights.xml file.

<Add type="mypackage.MyConfigurableContextInitializer">
    <Param name="some_config_property" value="some_value" />
</Add>

Initialiseurs de télémétrie JavaScriptJavaScript telemetry initializers

JavaScriptJavaScript

Insérer un initialiseur de télémétrie immédiatement après le code d’initialisation obtenu à partir du portail :Insert a telemetry initializer immediately after the initialization code that you got from the portal:

<script type="text/javascript">
    // ... initialization code
    ...({
        instrumentationKey: "your instrumentation key"
    });
    window.appInsights = appInsights;


    // Adding telemetry initializer.
    // This is called whenever a new telemetry item
    // is created.

    appInsights.queue.push(function () {
        appInsights.context.addTelemetryInitializer(function (envelope) {
            var telemetryItem = envelope.data.baseData;

            // To check the telemetry items type - for example PageView:
            if (envelope.name == Microsoft.ApplicationInsights.Telemetry.PageView.envelopeType) {
                // this statement removes url from all page view documents
                telemetryItem.url = "URL CENSORED";
            }

            // To set custom properties:
            telemetryItem.properties = telemetryItem.properties || {};
            telemetryItem.properties["globalProperty"] = "boo";

            // To set custom metrics:
            telemetryItem.measurements = telemetryItem.measurements || {};
            telemetryItem.measurements["globalMetric"] = 100;
        });
    });

    // End of inserted code.

    appInsights.trackPageView();
</script>

Pour obtenir un résumé des propriétés non personnalisées disponibles dans le telemetryItem, consultez le modèle d’exportation de données Application Insights.For a summary of the non-custom properties available on the telemetryItem, see Application Insights Export Data Model.

Vous pouvez ajouter autant d’initialiseurs que vous le souhaitez et ceux-ci sont appelés selon l’ordre dans lequel ils ont été ajoutés.You can add as many initializers as you like, and they are called in the order they are added.

Processeurs de télémétrie OpenCensus PythonOpenCensus Python telemetry processors

Les processeurs de télémétrie dans OpenCensus Python sont tout simplement des fonctions de rappel appelées pour traiter les données de télémétrie avant leur exportation.Telemetry processors in OpenCensus Python are simply callback functions called to process telemetry before they are exported. La fonction de rappel doit accepter un type de données enveloppe comme paramètre.The callback function must accept an envelope data type as its parameter. Pour filtrer les données de télémétrie à ne pas exporter, vérifiez que la fonction de rappel retourne False.To filter out telemetry from being exported,make sure the callback function returns False. Vous pouvez voir le schéma des types de données Azure Monitor dans les enveloppes ici.You can see the schema for Azure Monitor data types in the envelopes here.

# Example for log exporter
import logging

from opencensus.ext.azure.log_exporter import AzureLogHandler

logger = logging.getLogger(__name__)

# Callback function to append '_hello' to each log message telemetry
def callback_function(envelope):
    envelope.data.baseData.message += '_hello'
    return True

handler = AzureLogHandler(connection_string='InstrumentationKey=<your-instrumentation_key-here>')
handler.add_telemetry_processor(callback_function)
logger.addHandler(handler)
logger.warning('Hello, World!')
# Example for trace exporter
import requests

from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.trace import config_integration
from opencensus.trace.samplers import ProbabilitySampler
from opencensus.trace.tracer import Tracer

config_integration.trace_integrations(['requests'])

# Callback function to add os_type: linux to span properties
def callback_function(envelope):
    envelope.data.baseData.properties['os_type'] = 'linux'
    return True

exporter = AzureExporter(
    connection_string='InstrumentationKey=<your-instrumentation-key-here>'
)
exporter.add_telemetry_processor(callback_function)
tracer = Tracer(exporter=exporter, sampler=ProbabilitySampler(1.0))
with tracer.span(name='parent'):
response = requests.get(url='https://www.wikipedia.org/wiki/Rabbit')
# Example for metrics exporter
import time

from opencensus.ext.azure import metrics_exporter
from opencensus.stats import aggregation as aggregation_module
from opencensus.stats import measure as measure_module
from opencensus.stats import stats as stats_module
from opencensus.stats import view as view_module
from opencensus.tags import tag_map as tag_map_module

stats = stats_module.stats
view_manager = stats.view_manager
stats_recorder = stats.stats_recorder

CARROTS_MEASURE = measure_module.MeasureInt("carrots",
                                            "number of carrots",
                                            "carrots")
CARROTS_VIEW = view_module.View("carrots_view",
                                "number of carrots",
                                [],
                                CARROTS_MEASURE,
                                aggregation_module.CountAggregation())

# Callback function to only export the metric if value is greater than 0
def callback_function(envelope):
    return envelope.data.baseData.metrics[0].value > 0

def main():
    # Enable metrics
    # Set the interval in seconds in which you want to send metrics
    exporter = metrics_exporter.new_metrics_exporter(connection_string='InstrumentationKey=<your-instrumentation-key-here>')
    exporter.add_telemetry_processor(callback_function)
    view_manager.register_exporter(exporter)

    view_manager.register_view(CARROTS_VIEW)
    mmap = stats_recorder.new_measurement_map()
    tmap = tag_map_module.TagMap()

    mmap.measure_int_put(CARROTS_MEASURE, 1000)
    mmap.record(tmap)
    # Default export interval is every 15.0s
    # Your application should run for at least this amount
    # of time so the exporter will meet this interval
    # Sleep can fulfill this
    time.sleep(60)

    print("Done recording metrics")

if __name__ == "__main__":
    main()

Vous pouvez ajouter autant de processeurs que vous le souhaitez et ceux-ci sont appelés selon l’ordre dans lequel ils ont été ajoutés.You can add as many processors as you like, and they are called in the order they are added. Si un seul processeur lève une exception, cela n’impacte pas les processeurs suivants.If one processor should throw an exception, it does not impact the following processors.

Exemple TelemetryInitializersExample TelemetryInitializers

Ajouter une propriété personnaliséeAdd custom property

L’exemple d’initialiseur suivant ajoute une propriété personnalisée à chaque télémétrie suivie.The following sample initializer adds a custom property to every tracked telemetry.

public void Initialize(ITelemetry item)
{
  var itemProperties = item as ISupportProperties;
  if(itemProperties != null && !itemProperties.ContainsKey("customProp"))
    {
        itemProperties.Properties["customProp"] = "customValue";
    }
}

Ajouter un nom de rôle cloudAdd cloud role name

L’exemple d’initialiseur suivant définit le nom du rôle cloud sur chaque télémétrie suivie.The following sample initializer sets cloud role name to every tracked telemetry.

public void Initialize(ITelemetry telemetry)
{
    if(string.IsNullOrEmpty(telemetry.Context.Cloud.RoleName))
    {
        telemetry.Context.Cloud.RoleName = "MyCloudRoleName";
    }
}

ITelemetryProcessor et ITelemetryInitializerITelemetryProcessor and ITelemetryInitializer

Quelle est la différence entre les processeurs de télémétrie et les initialiseurs de télémétrie ?What's the difference between telemetry processors and telemetry initializers?

  • Il présente des similitudes en termes d'utilisation : tous deux permettent d'ajouter ou de modifier des propriétés de télémétrie, même si pour ce faire, il est recommandé d’utiliser les initialiseurs.There are some overlaps in what you can do with them: both can be used to add or modify properties of telemetry, though it is recommended to use initializers for that purpose.
  • Les TelemetryInitializers sont toujours exécutés avant les TelemetryProcessors.TelemetryInitializers always run before TelemetryProcessors.
  • Les TelemetryInitializers peuvent être appelés plusieurs fois.TelemetryInitializers may be called more than once. Par convention, ils ne définissent aucune propriété déjà définie.By convention, they do not set any property that has already been set.
  • Les TelemetryProcessors permettent de remplacer ou supprimer complètement un élément de télémétrie.TelemetryProcessors allow you to completely replace or discard a telemetry item.
  • Tous les TelemetryInitializers enregistrés sont assurés d’être appelés pour chaque élément de télémétrie.All registered TelemetryInitializers are guaranteed to be called for every telemetry item. En ce qui concerne les processeurs de télémétrie, le kit de développement logiciel (SDK) garantit l’appel du premier processeur de télémétrie.For Telemetry processors, SDK guarantees calling the very first telemetry processor. L'appel des autres processeurs dépend des processeurs de télémétrie précédents.Whether the rest of the processors are called or not, is decided by the preceding telemetry processors.
  • Utilisez TelemetryInitializers pour enrichir la télémétrie avec des propriétés supplémentaires ou remplacer une télémétrie existante.Use TelemetryInitializers to enrich telemetry with additional properties, or override existing one. Utilisez TelemetryProcessor pour filtrer la télémétrie.Use TelemetryProcessor to filter out telemetry.

Résolution des problèmes liés à ApplicationInsights.configTroubleshooting ApplicationInsights.config

  • Vérifiez que le nom de type complet et le nom de l’assembly sont corrects.Confirm that the fully qualified type name and assembly name are correct.
  • Vérifiez que le fichier applicationinsights.config se trouve dans votre répertoire de sortie et qu’il contient éventuellement des modifications récentes.Confirm that the applicationinsights.config file is in your output directory and contains any recent changes.

Documents de référenceReference docs

Code du Kit de développement logiciel (SDK)SDK Code

Étapes suivantesNext steps