Eseguire la migrazione dagli SDK di .NET Application Insights ad Azure Monitor OpenTelemetry

Questa guida fornisce istruzioni dettagliate per migrare diverse applicazioni .NET dall'uso ai kit di sviluppo software (SDK) di Application Insights ad Azure Monitor OpenTelemetry.

Ci si può aspettare un'esperienza simile con la strumentazione OpenTelemetry di Azure Monitor come con gli SDK di Application Insights. Per altre informazioni e un confronto funzionalità per funzionalità, vedere lo stato di rilascio delle funzionalità.

Eseguire la migrazione di ASP.NET Core alla distribuzione OpenTelemetry di Azure Monitor. (Pacchetto NuGet Azure.Monitor.OpenTelemetry.AspNetCore)
ASP.NET, console e migrazione di WorkerService all'utilità di esportazione OpenTelemetry di Monitoraggio di Azure. (Pacchetto NuGet Azure.Monitor.OpenTelemetry.Exporter)

Se stai iniziando con Application Insights e non hai bisogno di migrare dall'API classica, consulta Abilitare Azure Monitor OpenTelemetry.

Nota

Per le app per le funzioni di Azure, vedere Usare OpenTelemetry con Funzioni di Azure.

Prerequisiti

Un'applicazione Web ASP.NET Core già instrumentata con Application Insights senza alcuna personalizzazione
Una versione attivamente supportata di .NET

Suggerimento

Si sta cercando attivamente di ottenere commenti e suggerimenti su questa documentazione per il nostro gruppo di prodotti. Inviare commenti e suggerimenti a [email protected] o consultare la sezione Assistenza clienti.

Rimuovere Application Insights SDK

Nota

Prima di procedere con questi passaggi, è necessario verificare se si è in possesso di un backup corrente dell'applicazione.

Rimuovere i pacchetti NuGet

Rimuovere il pacchetto Microsoft.ApplicationInsights.AspNetCore dal vostro csproj.
```
dotnet remove package Microsoft.ApplicationInsights.AspNetCore
```
Rimuovere il codice di inizializzazione e le personalizzazioni

Rimuovere qualsiasi riferimento ai tipi di Application Insights nella codebase.

Suggerimento

Una volto rimosso il pacchetto di Application Insights, è possibile ricompilare l'applicazione per ottenere un elenco dei riferimenti che devono essere rimossi.
- Rimuovere Application Insights da ServiceCollection eliminando la riga seguente:
```
builder.Services.AddApplicationInsightsTelemetry();
```
- Rimuovere la sezione ApplicationInsights da appsettings.json.
```
{
    "ApplicationInsights": {
        "ConnectionString": "<Your Connection String>"
    }
}
```
Eseguire la pulizia e la compilazione

Ispezionare la directory bin per verificare che tutti i riferimenti a Microsoft.ApplicationInsights.* siano stati rimossi.
Testare l'applicazione

Verificare che non vi siano conseguenze impreviste per l'applicazione.

Rimuovere i pacchetti NuGet

Rimuovere il pacchetto Microsoft.AspNet.TelemetryCorrelation e qualsiasi pacchetto Microsoft.ApplicationInsights.* da csproj e packages.config.
Eliminare il file ApplicationInsights.config

Eliminare la sezione dal file Web.config dell'applicazione

Sono stati aggiunti automaticamente due HttpModules a web.config quando Application Insights è stato aggiunto per la prima volta al progetto. Tutti i riferimenti a TelemetryCorrelationHttpModule e ApplicationInsightsWebTracking devono essere rimossi. Allo stesso modo, se Application Insights è stato aggiunto ai moduli IIS (Internet Information Server), dovrà essere rimosso.

<configuration>
  <system.web>
    <httpModules>
      <add name="TelemetryCorrelationHttpModule" type="Microsoft.AspNet.TelemetryCorrelation.TelemetryCorrelationHttpModule, Microsoft.AspNet.TelemetryCorrelation" />
      <add name="ApplicationInsightsWebTracking" type="Microsoft.ApplicationInsights.Web.ApplicationInsightsHttpModule, Microsoft.AI.Web" />
    </httpModules>
  </system.web>
  <system.webServer>
    <modules>
      <remove name="TelemetryCorrelationHttpModule" />
      <add name="TelemetryCorrelationHttpModule" type="Microsoft.AspNet.TelemetryCorrelation.TelemetryCorrelationHttpModule, Microsoft.AspNet.TelemetryCorrelation" preCondition="managedHandler" />
      <remove name="ApplicationInsightsWebTracking" />
      <add name="ApplicationInsightsWebTracking" type="Microsoft.ApplicationInsights.Web.ApplicationInsightsHttpModule, Microsoft.AI.Web" preCondition="managedHandler" />
    </modules>
  </system.webServer>
</configuration>

Esaminare anche eventuali reindirizzamenti delle versioni assembly aggiunti al file web.config.

Rimuovere il codice di inizializzazione e le personalizzazioni

Rimuovere qualsiasi riferimento ai tipi di Application Insights nella codebase.

Suggerimento

Una volto rimosso il pacchetto di Application Insights, è possibile ricompilare l'applicazione per ottenere un elenco dei riferimenti che devono essere rimossi.
- Rimuovere i riferimenti a TelemetryConfiguration o TelemetryClient. L'inizializzazione dell'SDK di Application Insights fa parte dell'avvio dell'applicazione.
Gli scenari seguenti sono facoltativi e si applicano agli utenti avanzati.
- Se sono presenti altri riferimenti a TelemetryClient e vengono usati per registrare manualmente i dati di telemetria, dovranno essere rimossi.
- Se sono stati aggiunti filtri o arricchimenti personalizzati sotto forma di TelemetryProcessor o TelemetryInitializer personalizzati, dovranno essere rimossi. I riferimenti a tali elementi si trovano nella configurazione.
- Se nel progetto è presente FilterConfig.cs nella directory App_Start, verificare la presenza di eventuali gestori di eccezioni personalizzati con riferimenti ad Application Insights e rimuoverli.
Rimuovere il frammento di codice JavaScript

Se è stato aggiunto un JavaScript SDK per raccogliere i dati di telemetria lato client, è possibile rimuoverlo sebbene continui a funzionare senza .NET SDK. Per esempi di codice completi sugli elementi da rimuovere, vedere la Guida di onboarding per l'SDK di JavaScript.
Rimuovere tutti gli artefatti di Visual Studio

Se è stato usato Visual Studio per eseguire l'onboarding ad Application Insights, è possibile che siano rimasti altri file nel progetto.
- ConnectedService.json potrebbe avere un riferimento alla risorsa di Application Insights.
- [Your project's name].csproj potrebbe avere un riferimento alla risorsa di Application Insights:
```
<ApplicationInsightsResourceId>/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/Default-ApplicationInsights-EastUS/providers/microsoft.insights/components/WebApplication4</ApplicationInsightsResourceId>
```
Eseguire la pulizia e la compilazione

Ispezionare la directory bin per verificare che tutti i riferimenti a Microsoft.ApplicationInsights. siano stati rimossi.
Testare l'applicazione

Verificare che non vi siano conseguenze impreviste per l'applicazione.

Rimuovere i pacchetti NuGet

Rimuovere tutti i pacchetti Microsoft.ApplicationInsights.* da csproj e packages.config.
```
dotnet remove package Microsoft.ApplicationInsights
```
Suggerimento

In caso di utilizzo di Microsoft.ApplicationInsights.WorkerService, consultare le schede WorkerService.
Rimuovere il codice di inizializzazione e le personalizzazioni

Rimuovere qualsiasi riferimento ai tipi di Application Insights nella codebase.

Suggerimento

Una volto rimosso il pacchetto di Application Insights, è possibile ricompilare l'applicazione per ottenere un elenco dei riferimenti che devono essere rimossi.
- Rimuovere i riferimenti a TelemetryConfiguration o TelemetryClient. L'inizializzazione dell'SDK di Application Insights dovrebbe far parte dell'avvio dell'applicazione.
```
var config = TelemetryConfiguration.CreateDefault();
var client = new TelemetryClient(config);
```
Suggerimento

Se hai usato AddApplicationInsightsTelemetryWorkerService() per aggiungere Application Insights a ServiceCollection, fai riferimento alle schede di WorkerService.
Eseguire la pulizia e la compilazione

Ispezionare la directory bin per verificare che tutti i riferimenti a Microsoft.ApplicationInsights. siano stati rimossi.
Testare l'applicazione

Verificare che non vi siano conseguenze impreviste per l'applicazione.

Rimuovere i pacchetti NuGet

Rimuovere il pacchetto Microsoft.ApplicationInsights.WorkerService dal vostro csproj.
```
dotnet remove package Microsoft.ApplicationInsights.WorkerService
```
Rimuovere il codice di inizializzazione e le personalizzazioni

Rimuovere qualsiasi riferimento ai tipi di Application Insights nella codebase.

Suggerimento

Una volto rimosso il pacchetto di Application Insights, è possibile ricompilare l'applicazione per ottenere un elenco dei riferimenti che devono essere rimossi.
- Rimuovere Application Insights da ServiceCollection eliminando la riga seguente:
```
builder.Services.AddApplicationInsightsTelemetryWorkerService();
```
- Rimuovere la sezione ApplicationInsights da appsettings.json.
```
{
    "ApplicationInsights": {
        "ConnectionString": "<Your Connection String>"
    }
}
```
Eseguire la pulizia e la compilazione

Ispezionare la directory bin per verificare che tutti i riferimenti a Microsoft.ApplicationInsights.* siano stati rimossi.
Testare l'applicazione

Verificare che non vi siano conseguenze impreviste per l'applicazione.

Suggerimento

Abilitare OpenTelemetry

Quando si seguono queste istruzioni, è consigliabile creare una risorsa di sviluppo e usare la stringa di connessione.

Pianificare l'aggiornamento della stringa di connessione per inviare i dati di telemetria alla risorsa originale dopo la conferma dell'esito positivo della migrazione.

Installare la distribuzione di Monitoraggio di Azure

La distribuzione di Monitoraggio di Azure abilita la telemetria automatica includendo librerie di strumentazione OpenTelemetry per raccogliere tracce, metriche, log ed eccezioni, inoltre consente di raccogliere dati di telemetria personalizzati.

L'installazione della distribuzione Azure Monitor introduce OpenTelemetry SDK come dipendenza.
```
dotnet add package Azure.Monitor.OpenTelemetry.AspNetCore
```
Aggiungere e configurare sia OpenTelemetry che Monitoraggio di Azure

OpenTelemetry SDK deve essere configurato all'avvio dell'applicazione come parte del ServiceCollection, di solito nel Program.cs.

Il concetto di OpenTelemetry ha tre segnali; Tracce, Metriche e Log. La distribuzione di Monitoraggio di Azure configura ciascuno di questi segnali.

Program.cs

Nell'esempio di codice riportato di seguito sono illustrati i dati principali.

using Azure.Monitor.OpenTelemetry.AspNetCore;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;

public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        // Call AddOpenTelemetry() to add OpenTelemetry to your ServiceCollection.
        // Call UseAzureMonitor() to fully configure OpenTelemetry.
        builder.Services.AddOpenTelemetry().UseAzureMonitor();

        var app = builder.Build();
        app.MapGet("/", () => "Hello World!");
        app.Run();
    }
}

È consigliabile impostare la stringa di connessione in una variabile di ambiente:

APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

Altre opzioni per configurare la stringa di connessione sono descritte in dettaglio qui: Configurare la stringa di connessione di Application Insights.

Installare OpenTelemetry SDK tramite Monitoraggio di Azure

L'installazione dell'utilità di esportazione di Monitoraggio di Azure introduce OpenTelemetry SDK come dipendenza.
```
dotnet add package Azure.Monitor.OpenTelemetry.Exporter
```
Configurare OpenTelemetry come parte dell'avvio dell'applicazione

OpenTelemery SDK deve essere configurato all'avvio dell'applicazione, generalmente in Global.asax.cs. Il concetto di OpenTelemetry ha tre segnali; Tracce, Metriche e Log. Ciascuno di questi segnali deve essere configurato come parte dell'avvio dell'applicazione. TracerProvider, MeterProvider e ILoggerFactory devono essere creati una volta per l'applicazione e quindi eliminati all'arresto dell'applicazione.

Global.asax.cs

Nel codice di esempio seguente è riportato un esempio semplice inteso esclusivamente a illustrare i dati principali. In questa fase non vengono raccolti dati di telemetria.

using Microsoft.Extensions.Logging;
using OpenTelemetry;
using OpenTelemetry.Metrics;
using OpenTelemetry.Trace;

public class Global : System.Web.HttpApplication
{
    private TracerProvider? tracerProvider;
    private MeterProvider? meterProvider;
    // The LoggerFactory needs to be accessible from the rest of your application.
    internal static ILoggerFactory loggerFactory;

    protected void Application_Start()
    {
        this.tracerProvider = Sdk.CreateTracerProviderBuilder()
            .Build();

        this.meterProvider = Sdk.CreateMeterProviderBuilder()
            .Build();

        loggerFactory = LoggerFactory.Create(builder =>
        {
            builder.AddOpenTelemetry();
        });
    }

    protected void Application_End()
    {
        this.tracerProvider?.Dispose();
        this.meterProvider?.Dispose();
        loggerFactory?.Dispose();
    }
}

Installare OpenTelemetry SDK tramite Monitoraggio di Azure

L'installazione dell'utilità di esportazione di Monitoraggio di Azure introduce OpenTelemetry SDK come dipendenza.
```
dotnet add package Azure.Monitor.OpenTelemetry.Exporter
```
Configurare OpenTelemetry come parte dell'avvio dell'applicazione

OpenTelemery SDK deve essere configurato all'avvio dell'applicazione, generalmente in Program.cs. Il concetto di OpenTelemetry ha tre segnali; Tracce, Metriche e Log. Ciascuno di questi segnali deve essere configurato come parte dell'avvio dell'applicazione. TracerProvider, MeterProvider e ILoggerFactory devono essere creati una volta per l'applicazione e quindi eliminati all'arresto dell'applicazione.

Nel codice di esempio seguente è riportato un esempio semplice inteso esclusivamente a illustrare i dati principali. In questa fase non vengono raccolti dati di telemetria.

Program.cs

using Microsoft.Extensions.Logging;
using OpenTelemetry;
using OpenTelemetry.Metrics;
using OpenTelemetry.Trace;

internal class Program
{
    static void Main(string[] args)
    {
        TracerProvider tracerProvider = Sdk.CreateTracerProviderBuilder()
            .Build();

        MeterProvider meterProvider = Sdk.CreateMeterProviderBuilder()
            .Build();

        ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
        {
            builder.AddOpenTelemetry();
        });

        Console.WriteLine("Hello, World!");

        // Dispose tracer provider before the application ends.
        // It will flush the remaining spans and shutdown the tracing pipeline.
        tracerProvider.Dispose();

        // Dispose meter provider before the application ends.
        // It will flush the remaining metrics and shutdown the metrics pipeline.
        meterProvider.Dispose();

        // Dispose logger factory before the application ends.
        // It will flush the remaining logs and shutdown the logging pipeline.
        loggerFactory.Dispose();
    }
}

Installare OpenTelemetry SDK tramite Monitoraggio di Azure

L'installazione dell'utilità di esportazione di Monitoraggio di Azure introduce OpenTelemetry SDK come dipendenza.
```
dotnet add package Azure.Monitor.OpenTelemetry.Exporter
```
Inoltre, è necessario installare il pacchetto Hosting delle estensioni OpenTelemetry.
```
dotnet add package OpenTelemetry.Extensions.Hosting
```
Configurare OpenTelemetry come parte dell'avvio dell'applicazione

OpenTelemery SDK deve essere configurato all'avvio dell'applicazione, generalmente in Program.cs. Il concetto di OpenTelemetry ha tre segnali; Tracce, Metriche e Log. Ciascuno di questi segnali deve essere configurato come parte dell'avvio dell'applicazione. TracerProvider, MeterProvider e ILoggerFactory devono essere creati una volta per l'applicazione e quindi eliminati all'arresto dell'applicazione.

Nel codice di esempio seguente è riportato un esempio semplice inteso esclusivamente a illustrare i dati principali. In questa fase non vengono raccolti dati di telemetria.

Program.cs

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

public class Program
{
    public static void Main(string[] args)
    {
        var builder = Host.CreateApplicationBuilder(args);
        builder.Services.AddHostedService<Worker>();

        builder.Services.AddOpenTelemetry()
            .WithTracing()
            .WithMetrics();

        builder.Logging.AddOpenTelemetry();

        var host = builder.Build();
        host.Run();
    }
}

Suggerimento

Installare e configurare le librerie di strumentazione

Le librerie di strumentazione possono essere aggiunte al progetto per raccogliere automaticamente i dati di telemetria su componenti o dipendenze specifici.

Le librerie seguenti sono incluse nella distribuzione.

Personalizzazione delle librerie di strumentazione

La distribuzione di Monitoraggio di Azure include la strumentazione OpenTelemetry .NET per ASP.NET Core, HttpClient e SQLClient. È possibile personalizzare le strumentazioni incluse o aggiungere manualmente e autonomamente strumentazione aggiuntiva tramite l'API OpenTelemetry.

Di seguito sono riportati alcuni esempi di personalizzazione della strumentazione:

Personalizzazione di AspNetCoreTraceInstrumentationOptions

builder.Services.AddOpenTelemetry().UseAzureMonitor();
builder.Services.Configure<AspNetCoreTraceInstrumentationOptions>(options =>
{
    options.RecordException = true;
    options.Filter = (httpContext) =>
    {
        // only collect telemetry about HTTP GET requests
        return HttpMethods.IsGet(httpContext.Request.Method);
    };
});

Personalizzazione delle opzioni di strumentazione HttpClientTrace

builder.Services.AddOpenTelemetry().UseAzureMonitor();
builder.Services.Configure<HttpClientTraceInstrumentationOptions>(options =>
{
    options.RecordException = true;
    options.FilterHttpRequestMessage = (httpRequestMessage) =>
    {
        // only collect telemetry about HTTP GET requests
        return HttpMethods.IsGet(httpRequestMessage.Method.Method);
    };
});

Personalizzazione delle opzioni di SqlClientInstrumentation

Noi forniamo la strumentazione SQLClient nel nostro pacchetto mentre è ancora in beta. Quando raggiunge una versione stabile, verrà inclusa come riferimento al pacchetto standard. Fino ad allora, per personalizzare la strumentazione SQLClient, aggiungere il riferimento OpenTelemetry.Instrumentation.SqlClient al pacchetto del progetto e usare la relativa API pubblica.

dotnet add package --prerelease OpenTelemetry.Instrumentation.SqlClient

builder.Services.AddOpenTelemetry().UseAzureMonitor().WithTracing(builder =>
{
    builder.AddSqlClientInstrumentation(options =>
    {
        options.SetDbStatementForStoredProcedure = false;
    });
});

Le librerie di strumentazione possono essere aggiunte al progetto per raccogliere automaticamente i dati di telemetria su componenti o dipendenze specifici. È consigliabile usare le librerie seguenti:

OpenTelemetry.Instrumentation.AspNet consente di raccogliere i dati di telemetria per le richieste in ingresso. Monitoraggio di Azure esegue il mapping su Richiedi dati di telemetria.

dotnet add package OpenTelemetry.Instrumentation.AspNet

Esso richiede l'aggiunta di un modulo HttpModule aggiuntivo a Web.config:

<system.webServer>
  <modules>
      <add
          name="TelemetryHttpModule"
          type="OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule,
              OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule"
          preCondition="integratedMode,managedHandler" />
  </modules>
</system.webServer>

Una guida introduttiva completa è disponibile qui: OpenTelemetry.Instrumentation.AspNet Readme

OpenTelemetry.Instrumentation.Http consente di raccogliere i dati di telemetria per le dipendenze http in uscita. Monitoraggio di Azure esegue il mapping su Dati di telemetria delle dipendenze.
```
dotnet add package OpenTelemetry.Instrumentation.Http
```
Una guida introduttiva completa è disponibile qui: OpenTelemetry.Instrumentation.Http Readme
OpenTelemetry.Instrumentation.SqlClient consente di raccogliere i dati di telemetria per le dipendenze MS SQL. Monitoraggio di Azure esegue il mapping su Dati di telemetria delle dipendenze.
```
dotnet add package --prerelease OpenTelemetry.Instrumentation.SqlClient
```
Una guida introduttiva completa è disponibile qui: OpenTelemetry.Instrumentation.SqlClient Readme

Global.asax.cs

Nel codice di esempio riportato di seguito si espande l'esempio precedente. Ora raccoglie i dati di telemetria, ma non li invia ancora ad Application Insights.

using Microsoft.Extensions.Logging;
using OpenTelemetry;
using OpenTelemetry.Metrics;
using OpenTelemetry.Trace;

public class Global : System.Web.HttpApplication
{
    private TracerProvider? tracerProvider;
    private MeterProvider? meterProvider;
    internal static ILoggerFactory loggerFactory;

    protected void Application_Start()
    {
        this.tracerProvider = Sdk.CreateTracerProviderBuilder()
            .AddAspNetInstrumentation()
            .AddHttpClientInstrumentation()
            .AddSqlClientInstrumentation()
            .Build();

        this.meterProvider = Sdk.CreateMeterProviderBuilder()
            .AddAspNetInstrumentation()
            .AddHttpClientInstrumentation()
            .Build();

        loggerFactory = LoggerFactory.Create(builder =>
        {
            builder.AddOpenTelemetry();
        });
    }

    protected void Application_End()
    {
        this.tracerProvider?.Dispose();
        this.meterProvider?.Dispose();
        loggerFactory?.Dispose();
    }
}

OpenTelemetry.Instrumentation.Http consente di raccogliere i dati di telemetria per le dipendenze http in uscita. Monitoraggio di Azure esegue il mapping su Dati di telemetria delle dipendenze.
```
dotnet add package OpenTelemetry.Instrumentation.Http
```
Una guida introduttiva completa è disponibile qui: OpenTelemetry.Instrumentation.Http Readme
OpenTelemetry.Instrumentation.SqlClient consente di raccogliere i dati di telemetria per le dipendenze MS SQL. Monitoraggio di Azure esegue il mapping su Dati di telemetria delle dipendenze.
```
dotnet add package --prerelease OpenTelemetry.Instrumentation.SqlClient
```
Una guida introduttiva completa è disponibile qui: OpenTelemetry.Instrumentation.SqlClient Readme

Nel codice di esempio riportato di seguito si espande l'esempio precedente. Ora raccoglie i dati di telemetria, ma non li invia ancora ad Application Insights.

Program.cs

using Microsoft.Extensions.Logging;
using OpenTelemetry;
using OpenTelemetry.Metrics;
using OpenTelemetry.Trace;

internal class Program
{
    static void Main(string[] args)
    {
        TracerProvider tracerProvider = Sdk.CreateTracerProviderBuilder()
            .AddHttpClientInstrumentation()
            .AddSqlClientInstrumentation()
            .Build();

        MeterProvider meterProvider = Sdk.CreateMeterProviderBuilder()
            .AddHttpClientInstrumentation()
            .Build();

        ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
        {
            builder.AddOpenTelemetry();
        });

        Console.WriteLine("Hello, World!");

        tracerProvider.Dispose();
        meterProvider.Dispose();
        loggerFactory.Dispose();
    }
}

OpenTelemetry.Instrumentation.Http consente di raccogliere i dati di telemetria per le dipendenze http in uscita. Monitoraggio di Azure esegue il mapping su Dati di telemetria delle dipendenze.
```
dotnet add package OpenTelemetry.Instrumentation.Http
```
Una guida introduttiva completa è disponibile qui: OpenTelemetry.Instrumentation.Http Readme
OpenTelemetry.Instrumentation.SqlClient consente di raccogliere i dati di telemetria per le dipendenze MS SQL. Monitoraggio di Azure esegue il mapping su Dati di telemetria delle dipendenze.
```
dotnet add package --prerelease OpenTelemetry.Instrumentation.SqlClient
```
Una guida introduttiva completa è disponibile qui: OpenTelemetry.Instrumentation.SqlClient Readme

Nel codice di esempio riportato di seguito si espande l'esempio precedente. Ora raccoglie i dati di telemetria, ma non li invia ancora ad Application Insights.

Program.cs

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

public class Program
{
    public static void Main(string[] args)
    {
        var builder = Host.CreateApplicationBuilder(args);
        builder.Services.AddHostedService<Worker>();

        builder.Services.AddOpenTelemetry()
            .WithTracing(builder =>
            {
                builder.AddHttpClientInstrumentation();
                builder.AddSqlClientInstrumentation();
            })
            .WithMetrics(builder =>
            {
                builder.AddHttpClientInstrumentation();
            });

        builder.Logging.AddOpenTelemetry();

        var host = builder.Build();
        host.Run();
    }
}

Configurare Monitoraggio di Azure

Application Insights offriva molte altre opzioni di configurazione tramite ApplicationInsightsServiceOptions.

Impostazione di Application Insights	Alternativa a OpenTelemetry
AggiungiEstrattoreDiMetricheAutoRaccolte	N/D
Versione dell'Applicazione	Impostare "service.version" su Risorsa
stringa di connessione	Vedere le istruzioni sulla configurazione della stringa di connessione.
Opzioni di Raccolta di Dipendenze	Non Disponibile Per personalizzare le dipendenze, esaminare le opzioni di configurazione disponibili per le librerie di strumentazione applicabili.
DeveloperMode	N/D
AbilitareImpostazioneConfigurazioneTelemetriaAttiva	N/D
Abilita Campionamento Adattivo	Non Disponibile È supportato solo il campionamento a frequenza fissa.
AbilitaModuloDiTelemetriaHeartbeatServiziApp	N/D
AbilitaTracciamentoAutenticazioneJavaScript	N/D
EnableAzureInstanceMetadataTelemetryModule	N/D
AbilitaModuloDiTelemetriaTracciamentoDipendenza	Consulta le istruzioni per filtrare le Tracce.
AbilitaModuloDiagnosticaTelemetria	N/D
AbilitaModuloRaccoltaContatoriEventi	N/D
AbilitaBattitoCuore	N/D
AbilitaModuloRaccoltaContatoriPrestazioni	N/D
Abilita il flusso di metriche QuickPulse	AzureMonitorOptions.EnableLiveMetrics (Opzioni di Azure Monitor. Abilita Metriche Live)
Modulo di abilitazione della telemetria di tracciamento delle richieste	Consulta le istruzioni per filtrare le Tracce.
Indirizzo di Endpoint	Utilizzare ConnectionString.
Chiave di Strumentazione	Utilizzare ConnectionString.
OpzioniRaccoltaRichieste	Non Disponibile Consulta le opzioni di OpenTelemetry.Instrumentation.AspNetCore.

Rimuovere le configurazioni personalizzate

Gli scenari seguenti sono facoltativi e si applicano solo agli utenti avanzati.

Se sono presenti altri riferimenti a TelemetryClient che potrebbe essere usato per registrare manualmente i dati di telemetria, dovranno essere rimossi.
Se sono stati aggiunti filtri o arricchimenti personalizzati sotto forma di TelemetryProcessor o TelemetryInitializer personalizzati, dovranno essere rimossi. Sono disponibili in ServiceCollection.
```
builder.Services.AddSingleton<ITelemetryInitializer, MyCustomTelemetryInitializer>();
```
```
builder.Services.AddApplicationInsightsTelemetryProcessor<MyCustomTelemetryProcessor>();
```
Rimuovere il frammento di codice JavaScript

Se è stato usato il frammento di codice fornito da Application Insights .NET SDK, dovrà essere rimosso anch’esso. Per gli esempi di codice completi sugli elementi da rimuovere, vedere la guida per abilitare i dati di telemetria sul lato client per le applicazioni Web.

Se è stato aggiunto un JavaScript SDK per raccogliere i dati di telemetria lato client, è possibile rimuoverlo sebbene continui a funzionare senza .NET SDK. Per esempi di codice completi sugli elementi da rimuovere, vedere la Guida di onboarding per l'SDK di JavaScript.
Rimuovere tutti gli artefatti di Visual Studio

Se è stato usato Visual Studio per eseguire l'onboarding ad Application Insights, è possibile che siano rimasti altri file nel progetto.
- Nella directory Properties/ServiceDependencies potrebbe essere presente un riferimento alla risorsa di Application Insights.

Per poter inviare i dati di telemetria ad Application Insights, l'utilità di esportazione di Monitoraggio di Azure deve essere aggiunta alla configurazione di tutti e tre i segnali.

Global.asax.cs

Nel codice di esempio riportato di seguito si espande l'esempio precedente. Ora raccoglie i dati di telemetria e li invia ad Application Insights.

public class Global : System.Web.HttpApplication
{
    private TracerProvider? tracerProvider;
    private MeterProvider? meterProvider;
    internal static ILoggerFactory loggerFactory;

    protected void Application_Start()
    {
        this.tracerProvider = Sdk.CreateTracerProviderBuilder()
            .AddAspNetInstrumentation()
            .AddHttpClientInstrumentation()
            .AddSqlClientInstrumentation()
            .AddAzureMonitorTraceExporter()
            .Build();

        this.meterProvider = Sdk.CreateMeterProviderBuilder()
            .AddAspNetInstrumentation()
            .AddHttpClientInstrumentation()
            .AddAzureMonitorMetricExporter()
            .Build();

        loggerFactory = LoggerFactory.Create(builder =>
        {
            builder.AddOpenTelemetry(logging => logging.AddAzureMonitorLogExporter());
        });
    }

    protected void Application_End()
    {
        this.tracerProvider?.Dispose();
        this.meterProvider?.Dispose();
        loggerFactory?.Dispose();
    }
}

È consigliabile impostare la stringa di connessione in una variabile di ambiente:

APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

Altre opzioni per configurare la stringa di connessione sono descritte in dettaglio qui: Configurare la stringa di connessione di Application Insights.

Per poter inviare i dati di telemetria ad Application Insights, l'utilità di esportazione di Monitoraggio di Azure deve essere aggiunta alla configurazione di tutti e tre i segnali.

Program.cs

Nel codice di esempio riportato di seguito si espande l'esempio precedente. Ora raccoglie i dati di telemetria e li invia ad Application Insights.

using Microsoft.Extensions.Logging;
using OpenTelemetry;
using OpenTelemetry.Metrics;
using OpenTelemetry.Trace;

internal class Program
{
    static void Main(string[] args)
    {
        TracerProvider tracerProvider = Sdk.CreateTracerProviderBuilder()
            .AddHttpClientInstrumentation()
            .AddSqlClientInstrumentation()
            .AddAzureMonitorTraceExporter()
            .Build();

        MeterProvider meterProvider = Sdk.CreateMeterProviderBuilder()
            .AddHttpClientInstrumentation()
            .AddAzureMonitorMetricExporter()
            .Build();

        ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
        {
            builder.AddOpenTelemetry(logging => logging.AddAzureMonitorLogExporter());
        });

        Console.WriteLine("Hello, World!");

        tracerProvider.Dispose();
        meterProvider.Dispose();
        loggerFactory.Dispose();
    }
}

È consigliabile impostare la stringa di connessione in una variabile di ambiente:

APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

Altre opzioni per configurare la stringa di connessione sono descritte in dettaglio qui: Configurare la stringa di connessione di Application Insights.

Rimuovere le configurazioni personalizzate

Gli scenari seguenti sono facoltativi e si applicano agli utenti avanzati.

Se sono presenti altri riferimenti a TelemetryClient che viene usato per registrare manualmente i dati di telemetria, devono essere rimossi.
Rimuovere qualsiasi filtro personalizzato o arricchimento aggiunto come TelemetryProcessor o TelemetryInitializer personalizzato. La configurazione fa riferimento a essi.
Rimuovere tutti gli artefatti di Visual Studio

Se è stato usato Visual Studio per eseguire l'onboarding ad Application Insights, è possibile che siano rimasti altri file nel progetto.
- ConnectedService.json potrebbe avere un riferimento alla risorsa di Application Insights.
- [Your project's name].csproj potrebbe avere un riferimento alla risorsa di Application Insights:
```
<ApplicationInsightsResourceId>/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/Default-ApplicationInsights-EastUS/providers/microsoft.insights/components/WebApplication4</ApplicationInsightsResourceId>
```

Per poter inviare i dati di telemetria ad Application Insights, l'utilità di esportazione di Monitoraggio di Azure deve essere aggiunta alla configurazione di tutti e tre i segnali.

Program.cs

Nel codice di esempio riportato di seguito si espande l'esempio precedente. Ora raccoglie i dati di telemetria e li invia ad Application Insights.

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

public class Program
{
    public static void Main(string[] args)
    {
        var builder = Host.CreateApplicationBuilder(args);
        builder.Services.AddHostedService<Worker>();

        builder.Services.AddOpenTelemetry()
            .WithTracing(builder =>
            {
                builder.AddHttpClientInstrumentation();
                builder.AddSqlClientInstrumentation();
                builder.AddAzureMonitorTraceExporter();
            })
            .WithMetrics(builder =>
            {
                builder.AddHttpClientInstrumentation();
                builder.AddAzureMonitorMetricExporter();
            });

        builder.Logging.AddOpenTelemetry(logging => logging.AddAzureMonitorLogExporter());

        var host = builder.Build();
        host.Run();
    }
}

È consigliabile impostare la stringa di connessione in una variabile di ambiente:

APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

Altre opzioni per configurare la stringa di connessione sono descritte in dettaglio qui: Configurare la stringa di connessione di Application Insights.

Altre configurazioni

Application Insights offriva molte altre opzioni di configurazione tramite ApplicationInsightsServiceOptions.

Impostazione di Application Insights	Alternativa a OpenTelemetry
AggiungiEstrattoreDiMetricheAutoRaccolte	N/D
Versione dell'Applicazione	Impostare "service.version" su Risorsa
stringa di connessione	Vedere le istruzioni sulla configurazione della stringa di connessione.
Opzioni di Raccolta di Dipendenze	Non Disponibile Per personalizzare le dipendenze, esaminare le opzioni di configurazione disponibili per le librerie di strumentazione applicabili.
DeveloperMode	N/D
Abilita Campionamento Adattivo	Non Disponibile È supportato solo il campionamento a frequenza fissa.
AbilitaModuloDiTelemetriaHeartbeatServiziApp	N/D
EnableAzureInstanceMetadataTelemetryModule	N/D
AbilitaModuloDiTelemetriaTracciamentoDipendenza	Consulta le istruzioni per filtrare le Tracce.
AbilitaModuloDiagnosticaTelemetria	N/D
AbilitaModuloRaccoltaContatoriEventi	N/D
AbilitaBattitoCuore	N/D
AbilitaModuloRaccoltaContatoriPrestazioni	N/D
Abilita il flusso di metriche QuickPulse	AzureMonitorOptions.EnableLiveMetrics (Opzioni di Azure Monitor. Abilita Metriche Live)
Indirizzo di Endpoint	Utilizzare ConnectionString.
Chiave di Strumentazione	Utilizzare ConnectionString.

Rimuovere le configurazioni personalizzate

Gli scenari seguenti sono facoltativi e si applicano agli utenti avanzati.

Se sono presenti altri riferimenti a TelemetryClient e vengono usati per registrare manualmente i dati di telemetria, dovranno essere rimossi.
Se sono stati aggiunti eventuali filtri o arricchimenti personalizzati sotto forma di TelemetryProcessor o TelemetryInitializer personalizzato, dovranno essere rimossi. Puoi trovare riferimenti in ServiceCollection.
```
builder.Services.AddSingleton<ITelemetryInitializer, MyCustomTelemetryInitializer>();
```
```
builder.Services.AddApplicationInsightsTelemetryProcessor<MyCustomTelemetryProcessor>();
```
Rimuovere tutti gli artefatti di Visual Studio

Se è stato usato Visual Studio per eseguire l'onboarding ad Application Insights, è possibile che siano rimasti altri file nel progetto.
- Nella directory Properties/ServiceDependencies potrebbe essere presente un riferimento alla risorsa di Application Insights.

Suggerimento

Passaggi successivi

Per esaminare le domande frequenti sul tema, vedere Migrazione dagli SDK di Application Insights .NET al FAQ di OpenTelemetry di Monitoraggio di Azure
Progetto per la demo della distribuzione di Monitoraggio di Azure
Guida introduttiva di OpenTelemetry SDK
Progetto di esempio di ASP.NET Core di OpenTelemetry
Registrazione di C# e .NET
Primi passi con OpenTelemetry di Azure Monitor e ASP.NET Core

Suggerimento

Supporto tecnico

Per i problemi relativi al supporto di Azure, aprire un ticket di supporto tecnico di Azure.
Per i problemi relativi a OpenTelemetry, contattare direttamente la community .NET di OpenTelemetry.
Per un elenco dei problemi aperti relativi all'Esportatore di Azure Monitor, vedere la pagina delle segnalazioni di GitHub.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-05-31

Condividi tramite

Eseguire la migrazione dagli SDK di .NET Application Insights ad Azure Monitor OpenTelemetry

Prerequisiti

Rimuovere Application Insights SDK

Abilitare OpenTelemetry

Program.cs

Installare e configurare le librerie di strumentazione

Personalizzazione delle librerie di strumentazione

Personalizzazione di AspNetCoreTraceInstrumentationOptions

Personalizzazione delle opzioni di strumentazione HttpClientTrace

Personalizzazione delle opzioni di SqlClientInstrumentation

Configurare Monitoraggio di Azure

Rimuovere le configurazioni personalizzate

Passaggi successivi

Supporto tecnico

Commenti e suggerimenti

Risorse aggiuntive