Application Insights-logboekregistratie met .NET

In dit artikel leert u hoe u logboeken kunt vastleggen met Application Insights in .NET-apps met behulp van het Microsoft.Extensions.Logging.ApplicationInsights providerpakket. Als u deze provider gebruikt, kunt u uw logboeken opvragen en analyseren met behulp van de Application Insights-hulpprogramma's.

Notitie

De volgende documentatie is afhankelijk van de klassieke Application Insights-API. Het langetermijnplan voor Application Insights is het verzamelen van gegevens met behulp van OpenTelemetry. Zie Azure Monitor OpenTelemetry inschakelen voor .NET-, Node.js-, Python- en Java-toepassingen voor meer informatie.

Notitie

Zie Application Insights configureren voor uw ASP.NET websites of Application Insights voor ASP.NET Core-toepassingen als u het volledige scala aan Application Insights-telemetrie wilt implementeren, samen met logboekregistratie.

Tip

Het Microsoft.ApplicationInsights.WorkerService NuGet-pakket, dat wordt gebruikt om Application Insights in te schakelen voor achtergrondservices, valt buiten het bereik. Zie Application Insights voor Werkservice-apps voor meer informatie.

ASP.NET Core-toepassingen

Application Insights-logboekregistratie toevoegen aan ASP.NET Core-toepassingen:

1. Installeer de Microsoft.Extensions.Logging.ApplicationInsights.

2. Toevoegen ApplicationInsightsLoggerProvider:

.NET 6.0+

using Microsoft.Extensions.Logging.ApplicationInsights;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

builder.Logging.AddApplicationInsights(
        configureTelemetryConfiguration: (config) => 
            config.ConnectionString = builder.Configuration.GetConnectionString("APPLICATIONINSIGHTS_CONNECTION_STRING"),
            configureApplicationInsightsLoggerOptions: (options) => { }
    );

builder.Logging.AddFilter<ApplicationInsightsLoggerProvider>("your-category", LogLevel.Trace);

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

.NET 5.0

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

namespace WebApplication
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var host = CreateHostBuilder(args).Build();

            var logger = host.Services.GetRequiredService<ILogger<Program>>();
            logger.LogInformation("From Program, running the host now.");

            host.Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                })
                .ConfigureLogging((context, builder) =>
                {
                    builder.AddApplicationInsights(
                        configureTelemetryConfiguration: (config) => config.ConnectionString = context.Configuration["APPLICATIONINSIGHTS_CONNECTION_STRING"],
                        configureApplicationInsightsLoggerOptions: (options) => { }
                    );

                    // Capture all log-level entries from Startup
                    builder.AddFilter<ApplicationInsightsLoggerProvider>(
                        typeof(Startup).FullName, LogLevel.Trace);
                });
    }
}

Wanneer het NuGet-pakket is geïnstalleerd en de provider wordt geregistreerd met afhankelijkheidsinjectie, is de app klaar om te registreren. Bij constructorinjectie ILogger is een of een algemeen alternatief ILogger<TCategoryName> vereist. Wanneer deze implementaties zijn opgelost, ApplicationInsightsLoggerProvider worden deze verstrekt. Vastgelegde berichten of uitzonderingen worden verzonden naar Application Insights.

Bekijk de volgende voorbeeldcontroller:

public class ValuesController : ControllerBase
{
    private readonly ILogger _logger;

    public ValuesController(ILogger<ValuesController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    public ActionResult<IEnumerable<string>> Get()
    {
        _logger.LogWarning("An example of a Warning trace..");
        _logger.LogError("An example of an Error level message");

        return new string[] { "value1", "value2" };
    }
}

Zie Logboekregistratie in ASP.NET Core en welk Type Application Insights-telemetrie wordt geproduceerd uit ILogger-logboeken voor meer informatie? Waar zie ik ILogger-logboeken in Application Insights?

Consoletoepassing

Als u Application Insights-logboekregistratie wilt toevoegen aan consoletoepassingen, moet u eerst de volgende NuGet-pakketten installeren:

• Microsoft.Extensions.Logging.ApplicationInsights
• Microsoft.Extensions.DependencyInjection

In het volgende voorbeeld wordt het pakket Microsoft.Extensions.Logging.ApplicationInsights gebruikt en wordt het standaardgedrag voor een consoletoepassing gedemonstreert. Het pakket Microsoft.Extensions.Logging.ApplicationInsights moet worden gebruikt in een consoletoepassing of wanneer u een minimale implementatie van Application Insights wilt zonder de volledige functieset, zoals metrische gegevens, gedistribueerde tracering, sampling en telemetrie-initialisatie.

.NET 6.0+

using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

using var channel = new InMemoryChannel();

try
{
    IServiceCollection services = new ServiceCollection();
    services.Configure<TelemetryConfiguration>(config => config.TelemetryChannel = channel);
    services.AddLogging(builder =>
    {
        // Only Application Insights is registered as a logger provider
        builder.AddApplicationInsights(
            configureTelemetryConfiguration: (config) => config.ConnectionString = "<YourConnectionString>",
            configureApplicationInsightsLoggerOptions: (options) => { }
        );
    });

    IServiceProvider serviceProvider = services.BuildServiceProvider();
    ILogger<Program> logger = serviceProvider.GetRequiredService<ILogger<Program>>();

    logger.LogInformation("Logger is working...");
}
finally
{
    // Explicitly call Flush() followed by Delay, as required in console apps.
    // This ensures that even if the application terminates, telemetry is sent to the back end.
    channel.Flush();

    await Task.Delay(TimeSpan.FromMilliseconds(1000));
}

.NET 5.0

using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.Extensibility;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.ApplicationInsights;
using System;
using System.Threading.Tasks;

namespace ConsoleApp
{
    class Program
    {
        static async Task Main(string[] args)
        {
            using var channel = new InMemoryChannel();

            try
            {
                IServiceCollection services = new ServiceCollection();
                services.Configure<TelemetryConfiguration>(config => config.TelemetryChannel = channel);
                services.AddLogging(builder =>
                {
                    // Only Application Insights is registered as a logger provider
                    builder.AddApplicationInsights(
                        configureTelemetryConfiguration: (config) => config.ConnectionString = "<YourConnectionString>",
                        configureApplicationInsightsLoggerOptions: (options) => { }
                    );
                });

                IServiceProvider serviceProvider = services.BuildServiceProvider();
                ILogger<Program> logger = serviceProvider.GetRequiredService<ILogger<Program>>();

                logger.LogInformation("Logger is working...");
            }
            finally
            {
                // Explicitly call Flush() followed by Delay, as required in console apps.
                // This ensures that even if the application terminates, telemetry is sent to the back end.
                channel.Flush();

                await Task.Delay(TimeSpan.FromMilliseconds(1000));
            }
        }
    }
}

Zie Voor meer informatie welk Type Application Insights-telemetrie wordt geproduceerd uit ILogger-logboeken? Waar zie ik ILogger-logboeken in Application Insights?

Bereiken voor logboekregistratie

ApplicationInsightsLoggingProvider ondersteunt logboekbereiken. Bereiken zijn standaard ingeschakeld.

Als het bereik van het type IReadOnlyCollection<KeyValuePair<string,object>>is, wordt elk sleutel-/waardepaar in de verzameling als aangepaste eigenschappen toegevoegd aan de Application Insights-telemetrie. In het volgende voorbeeld worden logboeken vastgelegd als TraceTelemetry en hebben ("MyKey", "MyValue") ze eigenschappen.

using (_logger.BeginScope(new Dictionary<string, object> { ["MyKey"] = "MyValue" }))
{
    _logger.LogError("An example of an Error level message");
}

Als een ander type wordt gebruikt als een bereik, wordt het opgeslagen onder de eigenschap Scope in Application Insights-telemetrie. In het volgende voorbeeld TraceTelemetry heeft u een eigenschap Scope die het bereik bevat.

    using (_logger.BeginScope("hello scope"))
    {
        _logger.LogError("An example of an Error level message");
    }

Veelgestelde vragen

Welk Type Application Insights-telemetrie wordt geproduceerd uit ILogger-logboeken? Waar zie ik ILogger-logboeken in Application Insights?

ApplicationInsightsLoggerProviderlegt logboeken vast en maakt TraceTelemetry van deze logboekenILogger. Als een Exception object wordt doorgegeven aan de Log methode on ILogger, ExceptionTelemetry wordt deze gemaakt in plaats van TraceTelemetry.

ILogger-telemetrie weergeven

In the Azure Portal:

1. Ga naar Azure Portal en open uw Application Insights-resource.
2. Klik op de sectie Logboeken in Application Insights.
3. Gebruik Kusto-querytaal (KQL) om query's uit te voeren op ILogger-berichten, meestal opgeslagen in de traces tabel.
   • Voorbeeldquery: traces | where message contains "YourSearchTerm".
4. Verfijn uw query's om ILogger-gegevens te filteren op ernst, tijdsbereik of specifieke berichtinhoud.

In Visual Studio (lokaal foutopsporingsprogramma):

1. Start uw toepassing in de foutopsporingsmodus in Visual Studio.
2. Open het venster Diagnostische hulpprogramma's terwijl de toepassing wordt uitgevoerd.
3. Op het tabblad Gebeurtenissen worden ILogger-logboeken samen met andere telemetriegegevens weergegeven.
4. Gebruik de zoek- en filterfuncties in het venster Diagnostische hulpprogramma's om specifieke ILogger-berichten te vinden.

Als u liever altijd verzendt TraceTelemetry, gebruikt u dit fragment:

builder.AddApplicationInsights(
    options => options.TrackExceptionsAsExceptionTelemetry = false);

Waarom hebben sommige ILogger-logboeken niet dezelfde eigenschappen als andere?

Application Insights legt logboeken vast en verzendt ILogger deze met behulp van dezelfde TelemetryConfiguration informatie die wordt gebruikt voor elke andere telemetrie. Maar er is een uitzondering. TelemetryConfiguration Standaard is deze niet volledig ingesteld wanneer u zich aanmeldt vanuit Program.cs of Startup.cs. Logboeken van deze locaties hebben niet de standaardconfiguratie, dus worden niet alle TelemetryInitializer exemplaren en TelemetryProcessor exemplaren uitgevoerd.

Ik gebruik het zelfstandige pakket Microsoft.Extensions.Logging.ApplicationInsights en ik wil meer aangepaste telemetrie handmatig registreren. Hoe moet ik dat doen?

Wanneer u het zelfstandige pakket gebruikt, TelemetryClient wordt deze niet geïnjecteerd in de container voor afhankelijkheidsinjectie (DI). U moet een nieuw exemplaar maken van TelemetryClient en dezelfde configuratie gebruiken die door de logboekregistratieprovider wordt gebruikt, zoals in de volgende code wordt weergegeven. Deze vereiste zorgt ervoor dat dezelfde configuratie wordt gebruikt voor alle aangepaste telemetrie en telemetrie van ILogger.

public class MyController : ApiController
{
   // This TelemetryClient instance can be used to track additional telemetry through the TrackXXX() API.
   private readonly TelemetryClient _telemetryClient;
   private readonly ILogger _logger;

   public MyController(IOptions<TelemetryConfiguration> options, ILogger<MyController> logger)
   {
        _telemetryClient = new TelemetryClient(options.Value);
        _logger = logger;
   }  
}

Notitie

Als u het Microsoft.ApplicationInsights.AspNetCore pakket gebruikt om Application Insights in te schakelen, wijzigt u deze code om rechtstreeks in de constructor te komen TelemetryClient .

Ik heb de SDK niet geïnstalleerd en ik gebruik de Azure Web Apps-extensie om Application Insights in te schakelen voor mijn ASP.NET Core-toepassingen. Hoe kan ik de nieuwe provider gebruiken?

De Application Insights-extensie in Azure Web Apps maakt gebruik van de nieuwe provider. U kunt de filterregels in het appsettings.json-bestand voor uw toepassing wijzigen.

Volgende stappen

• Logboekregistratie in .NET
• Aanmelden bij ASP.NET Core
• .NET-traceringslogboeken in Application Insights