Share via


Filtrare e pre-elaborare i dati di telemetria in Application Insights SDK

È possibile scrivere codice per filtrare, modificare o arricchire i dati di telemetria prima dell'invio dall'SDK. L'elaborazione include i dati inviati dai moduli di telemetria standard, come la raccolta delle richieste HTTP e la raccolta delle dipendenze.

  • L'applicazione di filtri consente di modificare o rimuovere i dati di telemetria prima che vengano inviati dall'SDK implementando ITelemetryProcessor. È possibile, ad esempio, ridurre il volume della telemetria escludendo le richieste dei robot. A differenza del campionamento, si ha il controllo completo su ciò che viene inviato o rimosso, ma influisce su qualsiasi metrica basata su log aggregati. A seconda della modalità di eliminazione degli elementi, è anche possibile perdere la possibilità di spostarsi tra gli elementi correlati.

  • Aggiungere o modificare proprietà a tutti i dati di telemetria inviati dall'app implementando un oggetto ITelemetryInitializer. Ad esempio, è possibile aggiungere valori calcolati o numeri di versione in base ai quali filtrare i dati nel portale.

  • campionamento riduce il volume della telemetria senza effetti sulle statistiche. Mantiene insieme i punti dati correlati in modo che sia possibile spostarsi tra di essi durante la diagnosi di un problema. Nel portale i conteggi totali vengono moltiplicati per compensare il campionamento.

Nota

L'API SDK viene usata per inviare metriche ed eventi personalizzati.

Prima di iniziare:

Filtro

Questa tecnica consente di controllare direttamente gli elementi inclusi o esclusi dal flusso di telemetria. Il filtro può essere usato per eliminare gli elementi di telemetria dall'invio ad Application Insights. È possibile usare il filtro con il campionamento o separatamente.

Per filtrare i dati di telemetria, scrivere un processore di telemetria e registrarlo con TelemetryConfiguration. Tutti i dati di telemetria passano attraverso il processore. È possibile scegliere di rilasciarlo dal flusso o assegnarlo al processore successivo nella catena. I dati di telemetria dai moduli standard, ad esempio l'agente di raccolta richieste HTTP e l'agente di raccolta dipendenze, e i dati di telemetria rilevati manualmente sono inclusi. Ad esempio, è possibile filtrare i dati di telemetria relativi alle richieste dei robot o alle chiamate di dipendenza riuscite.

Avviso

Filtrare i dati di telemetria inviati dall'SDK usando processori può asimmetriare le statistiche visualizzate nel portale e rendere difficile seguire gli elementi correlati.

In alternativa, valutare la possibilità di usare il campionamento.

Creare un processore di telemetria

C#

  1. Per creare un filtro, implementare ITelemetryProcessor.

    I processori di telemetria costruiscono una catena di elaborazione. Quando si crea un'istanza di un processore di telemetria, viene fornito un riferimento al processore successivo nella catena. Quando un punto dati di telemetria viene passato al metodo di processo, esegue il lavoro e quindi chiama (o non chiama) il processore di telemetria successivo nella catena.

    using Microsoft.ApplicationInsights.Channel;
    using Microsoft.ApplicationInsights.Extensibility;
    using Microsoft.ApplicationInsights.DataContracts;
    
    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. Aggiungere il processore.

app ASP.NET

Inserire questo frammento di codice in ApplicationInsights.config:

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

È possibile passare i valori della stringa dal file .config fornendo proprietà denominate come pubbliche nella classe.

Avviso

Prestare attenzione a fare corrispondere il nome del tipo e i nomi delle proprietà nel file. config ai nomi di classe e di proprietà nel codice. Se il file config fa riferimento a un tipo o a una proprietà inesistente, l'SDK potrebbe non inviare dati di telemetria invisibile all'utente.

In alternativa , è possibile inizializzare il filtro nel codice. In una classe di inizializzazione appropriata, ad esempio AppStart in Global.asax.cs, inserire il processore nella catena:

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

I client di telemetria creati dopo questo punto useranno i processori.

ASP.NET app del servizio Core/Worker

Nota

L'aggiunta di un processore tramite ApplicationInsights.config o TelemetryConfiguration.Active non è valida per ASP.NET applicazioni Core o se si usa Microsoft.ApplicationInsights.WorkerService SDK.

Per le app scritte usando ASP.NET Core o WorkerService, l'aggiunta di un nuovo processore di telemetria viene eseguita usando il AddApplicationInsightsTelemetryProcessor metodo di estensione in IServiceCollection, come illustrato. Questo metodo viene chiamato nel ConfigureServices metodo della Startup.cs classe .

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

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

Per registrare processori di telemetria che necessitano di parametri in ASP.NET Core, creare una classe personalizzata che implementa ITelemetryProcessorFactory. Chiamare il costruttore con i parametri desiderati nel metodo Create e quindi usare AddSingleton<ITelemetryProcessorFactory, MyTelemetryProcessorFactory>().

Filtri di esempio

Richieste sintetiche

Filtrare i robot e i test Web. Anche se Esplora metriche offre la possibilità di filtrare le origini sintetiche, questa opzione riduce il traffico e le dimensioni di inserimento filtrandoli nell'SDK stesso.

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

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

Autenticazione non riuscita

Filtrare le richieste con una risposta "401".

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

Filtrare le chiamate di dipendenza remote rapide

Se si desidera diagnosticare solo le chiamate lente, filtrarne le veloci.

Nota

Questo filtro inclina le statistiche visualizzate nel portale.

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

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

Diagnosticare i problemi di dipendenza

Questo blog descrive un progetto per diagnosticare i problemi di dipendenza con l'invio automatico di ping regolari alle dipendenze.

Java

Per altre informazioni sui processori di telemetria e sulla relativa implementazione in Java, vedere la documentazione sui processori di telemetria Java.

Applicazioni Web JavaScript

Filtrare usando ITelemetryInitializer

  1. Creare una funzione di callback dell'inizializzatore di telemetria. La funzione di callback accetta ITelemetryItem come parametro, ovvero l'evento in fase di elaborazione. Se si restituisce false da questo callback, l'elemento di telemetria viene filtrato.

    var filteringFunction = (envelope) => {
      if (envelope.data.someField === 'tobefilteredout') {
          return false;
      }
    
      return true;
    };
    
  2. Aggiungere il callback dell'inizializzatore di telemetria:

    appInsights.addTelemetryInitializer(filteringFunction);
    

Aggiungere/modificare le proprietà: ITelemetryInitializer

Usare gli inizializzatori di telemetria per arricchire i dati di telemetria con informazioni aggiuntive o per eseguire l'override delle proprietà di telemetria impostate dai moduli di telemetria standard.

Ad esempio, Application Insights per un pacchetto Web raccoglie i dati di telemetria sulle richieste HTTP. Per impostazione predefinita, contrassegna come non riuscita qualsiasi richiesta con un codice >di risposta =400. Tuttavia, se si vuole considerare 400 come esito positivo, è possibile fornire un inizializzatore di telemetria che imposta la proprietà success.

Se si specifica un inizializzatore di telemetria, viene chiamato ogni volta che viene chiamato uno dei metodi Track*(). Questo inizializzatore include Track() metodi chiamati dai moduli di telemetria standard. Per convenzione, questi moduli non impostano alcuna proprietà già impostata da un inizializzatore. Gli inizializzatori di telemetria vengono chiamati prima di chiamare i processori di telemetria. Tutti gli arricchimenti eseguiti dagli inizializzatori sono quindi visibili ai processori.

Definire l'inizializzatore

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
    }
  }
}

app ASP.NET: caricare l'inizializzatore

In ApplicationInsights.config:

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

In alternativa, è possibile creare un'istanza dell'inizializzatore nel codice, ad esempio in Global.aspx.cs:

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

Per altre informazioni, vedere questo esempio.

ASP.NET app del servizio Core/Worker: caricare l'inizializzatore

Nota

L'aggiunta di un inizializzatore tramite ApplicationInsights.config o TelemetryConfiguration.Active non è valida per ASP.NET applicazioni Core o se si usa Microsoft.ApplicationInsights.WorkerService SDK.

Per le app scritte con ASP.NET Core o WorkerService, l'aggiunta di un nuovo inizializzatore di telemetria viene eseguita aggiungendola al contenitore Dependency Injection, come illustrato. Eseguire questo passaggio nel Startup.ConfigureServices metodo .

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

Inizializzatori di telemetria JavaScript

Inserire un inizializzatore di telemetria JavaScript, se necessario. Per altre informazioni sugli inizializzatori di telemetria per Application Insights JavaScript SDK, vedere Inizializzatori di telemetria.

Inserire un inizializzatore di telemetria aggiungendo la funzione di callback onInit nella configurazione dello script del caricatore SDK JavaScript (Web):

<script type="text/javascript">
!(function (cfg){function e(){cfg.onInit&&cfg.onInit(i)}var S,u,D,t,n,i,C=window,x=document,w=C.location,I="script",b="ingestionendpoint",E="disableExceptionTracking",A="ai.device.";"instrumentationKey"[S="toLowerCase"](),u="crossOrigin",D="POST",t="appInsightsSDK",n=cfg.name||"appInsights",(cfg.name||C[t])&&(C[t]=n),i=C[n]||function(l){var d=!1,g=!1,f={initialize:!0,queue:[],sv:"7",version:2,config:l};function m(e,t){var n={},i="Browser";function a(e){e=""+e;return 1===e.length?"0"+e:e}return n[A+"id"]=i[S](),n[A+"type"]=i,n["ai.operation.name"]=w&&w.pathname||"_unknown_",n["ai.internal.sdkVersion"]="javascript:snippet_"+(f.sv||f.version),{time:(i=new Date).getUTCFullYear()+"-"+a(1+i.getUTCMonth())+"-"+a(i.getUTCDate())+"T"+a(i.getUTCHours())+":"+a(i.getUTCMinutes())+":"+a(i.getUTCSeconds())+"."+(i.getUTCMilliseconds()/1e3).toFixed(3).slice(2,5)+"Z",iKey:e,name:"Microsoft.ApplicationInsights."+e.replace(/-/g,"")+"."+t,sampleRate:100,tags:n,data:{baseData:{ver:2}},ver:4,seq:"1",aiDataContract:undefined}}var h=-1,v=0,y=["js.monitor.azure.com","js.cdn.applicationinsights.io","js.cdn.monitor.azure.com","js0.cdn.applicationinsights.io","js0.cdn.monitor.azure.com","js2.cdn.applicationinsights.io","js2.cdn.monitor.azure.com","az416426.vo.msecnd.net"],k=l.url||cfg.src;if(k){if((n=navigator)&&(~(n=(n.userAgent||"").toLowerCase()).indexOf("msie")||~n.indexOf("trident/"))&&~k.indexOf("ai.3")&&(k=k.replace(/(\/)(ai\.3\.)([^\d]*)$/,function(e,t,n){return t+"ai.2"+n})),!1!==cfg.cr)for(var e=0;e<y.length;e++)if(0<k.indexOf(y[e])){h=e;break}var i=function(e){var a,t,n,i,o,r,s,c,p,u;f.queue=[],g||(0<=h&&v+1<y.length?(a=(h+v+1)%y.length,T(k.replace(/^(.*\/\/)([\w\.]*)(\/.*)$/,function(e,t,n,i){return t+y[a]+i})),v+=1):(d=g=!0,o=k,c=(p=function(){var e,t={},n=l.connectionString;if(n)for(var i=n.split(";"),a=0;a<i.length;a++){var o=i[a].split("=");2===o.length&&(t[o[0][S]()]=o[1])}return t[b]||(e=(n=t.endpointsuffix)?t.location:null,t[b]="https://"+(e?e+".":"")+"dc."+(n||"services.visualstudio.com")),t}()).instrumentationkey||l.instrumentationKey||"",p=(p=p[b])?p+"/v2/track":l.endpointUrl,(u=[]).push((t="SDK LOAD Failure: Failed to load Application Insights SDK script (See stack for details)",n=o,r=p,(s=(i=m(c,"Exception")).data).baseType="ExceptionData",s.baseData.exceptions=[{typeName:"SDKLoadFailed",message:t.replace(/\./g,"-"),hasFullStack:!1,stack:t+"\nSnippet failed to load ["+n+"] -- Telemetry is disabled\nHelp Link: https://go.microsoft.com/fwlink/?linkid=2128109\nHost: "+(w&&w.pathname||"_unknown_")+"\nEndpoint: "+r,parsedStack:[]}],i)),u.push((s=o,t=p,(r=(n=m(c,"Message")).data).baseType="MessageData",(i=r.baseData).message='AI (Internal): 99 message:"'+("SDK LOAD Failure: Failed to load Application Insights SDK script (See stack for details) ("+s+")").replace(/\"/g,"")+'"',i.properties={endpoint:t},n)),o=u,c=p,JSON&&((r=C.fetch)&&!cfg.useXhr?r(c,{method:D,body:JSON.stringify(o),mode:"cors"}):XMLHttpRequest&&((s=new XMLHttpRequest).open(D,c),s.setRequestHeader("Content-type","application/json"),s.send(JSON.stringify(o))))))},a=function(e,t){g||setTimeout(function(){!t&&f.core||i()},500),d=!1},T=function(e){var n=x.createElement(I),e=(n.src=e,cfg[u]);return!e&&""!==e||"undefined"==n[u]||(n[u]=e),n.onload=a,n.onerror=i,n.onreadystatechange=function(e,t){"loaded"!==n.readyState&&"complete"!==n.readyState||a(0,t)},cfg.ld&&cfg.ld<0?x.getElementsByTagName("head")[0].appendChild(n):setTimeout(function(){x.getElementsByTagName(I)[0].parentNode.appendChild(n)},cfg.ld||0),n};T(k)}try{f.cookie=x.cookie}catch(p){}function t(e){for(;e.length;)!function(t){f[t]=function(){var e=arguments;d||f.queue.push(function(){f[t].apply(f,e)})}}(e.pop())}var r,s,n="track",o="TrackPage",c="TrackEvent",n=(t([n+"Event",n+"PageView",n+"Exception",n+"Trace",n+"DependencyData",n+"Metric",n+"PageViewPerformance","start"+o,"stop"+o,"start"+c,"stop"+c,"addTelemetryInitializer","setAuthenticatedUserContext","clearAuthenticatedUserContext","flush"]),f.SeverityLevel={Verbose:0,Information:1,Warning:2,Error:3,Critical:4},(l.extensionConfig||{}).ApplicationInsightsAnalytics||{});return!0!==l[E]&&!0!==n[E]&&(t(["_"+(r="onerror")]),s=C[r],C[r]=function(e,t,n,i,a){var o=s&&s(e,t,n,i,a);return!0!==o&&f["_"+r]({message:e,url:t,lineNumber:n,columnNumber:i,error:a,evt:C.event}),o},l.autoExceptionInstrumented=!0),f}(cfg.cfg),(C[n]=i).queue&&0===i.queue.length?(i.queue.push(e),i.trackPageView({})):e();})({
src: "https://js.monitor.azure.com/scripts/b/ai.3.gbl.min.js",
crossOrigin: "anonymous",
onInit: function (sdk) {
  sdk.addTelemetryInitializer(function (envelope) {
    envelope.data = envelope.data || {};
    envelope.data.someField = 'This item passed through my telemetry initializer';
  });
}, // Once the application insights instance has loaded and initialized this method will be called
cfg: { // Application Insights Configuration
    connectionString: "YOUR_CONNECTION_STRING"
}});
</script>

Per un riepilogo delle proprietà non personalizzate disponibili nell'elemento di telemetria, vedere Esportazione del modello di dati di Application Insights.

È possibile aggiungere tutti gli inizializzatori desiderati. Vengono chiamati nell'ordine in cui vengono aggiunti.

Processori di telemetria Python OpenCensus

I processori di telemetria in OpenCensus Python sono semplicemente funzioni di callback chiamate per elaborare i dati di telemetria prima dell'esportazione. La funzione di callback deve accettare un tipo di dati envelope come parametro. Per escludere i dati di telemetria dall'esportazione, assicurarsi che la funzione di callback restituisca False. È possibile visualizzare lo schema per i tipi di dati di Monitoraggio di Azure nelle buste in GitHub.

Nota

È possibile modificare cloud_RoleName modificando l'attributo ai.cloud.role nel tags campo .

def callback_function(envelope):
    envelope.tags['ai.cloud.role'] = 'new_role_name'
# 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()

È possibile aggiungere tutti i processori desiderati. Vengono chiamati nell'ordine in cui vengono aggiunti. Se un processore genera un'eccezione, non influisce sui processori seguenti.

Esempio di TelemetryInitializers

Aggiungere una proprietà personalizzata

L'inizializzatore di esempio seguente aggiunge una proprietà personalizzata a ogni telemetria rilevata.

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

Aggiungere un nome di ruolo cloud

L'inizializzatore di esempio seguente imposta il nome del ruolo cloud su ogni telemetria rilevata.

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

Controllare l'indirizzo IP client usato per i mapping di georilevazione

L'inizializzatore di esempio seguente imposta l'IP client che verrà usato per il mapping della georilevazione, anziché per l'indirizzo IP del socket client, durante l'inserimento dei dati di telemetria.

public void Initialize(ITelemetry telemetry)
{
    var request = telemetry as RequestTelemetry;
    if (request == null) return true;
    request.Context.Location.Ip = "{client ip address}"; // Could utilize System.Web.HttpContext.Current.Request.UserHostAddress;   
    return true;
}

ITelemetryProcessor e ITelemetryInitializer

Qual è la differenza tra processori di telemetria e inizializzatori di telemetria?

  • Ci sono alcune sovrapposizioni in ciò che è possibile fare con loro. Entrambi possono essere usati per aggiungere o modificare le proprietà dei dati di telemetria, anche se è consigliabile usare gli inizializzatori a tale scopo.
  • Gli inizializzatori di telemetria vengono sempre eseguiti prima dei processori di telemetria.
  • Gli inizializzatori di telemetria possono essere chiamati più volte. Per convenzione, non impostano alcuna proprietà già impostata.
  • I processori di telemetria consentono di sostituire o rimuovere completamente un elemento di telemetria.
  • Tutti gli inizializzatori di telemetria registrati vengono chiamati per ogni elemento di telemetria. Per i processori di telemetria, SDK garantisce la chiamata al primo processore di telemetria. Se il resto dei processori viene chiamato o meno viene deciso dai processori di telemetria precedenti.
  • Usare gli inizializzatori di telemetria per arricchire i dati di telemetria con più proprietà o eseguire l'override di uno esistente. Usare un processore di telemetria per filtrare i dati di telemetria.

Nota

JavaScript include solo inizializzatori di telemetria che possono filtrare gli eventi usando ITelemetryInitializer

Risolvere i problemi di ApplicationInsights.config

  • Verificare che il nome di tipo completo e il nome di assembly siano corretti.
  • Verificare che il file applicationinsights.config si trovi nella directory di output e includa le ultime modifiche apportate.

Riferimento ai tipi di dati di telemetria di Monitoraggio di Azure

Documentazione di riferimento

Codice SDK

Passaggi successivi