Alkalmazás Elemzések naplózása .NET-tel

Ebből a cikkből megtudhatja, hogyan rögzíthet naplókat az Alkalmazás Elemzések a .NET-alkalmazásokban a Microsoft.Extensions.Logging.ApplicationInsights szolgáltatói csomag használatával. Ha ezt a szolgáltatót használja, az alkalmazás Elemzések eszközeivel lekérdezheti és elemezheti a naplókat.

Feljegyzés

Az alábbi dokumentáció az Alkalmazás Elemzések klasszikus API-ra támaszkodik. Az Alkalmazás Elemzések hosszú távú terve az Adatok gyűjtése Az OpenTelemetria használatával. További információ: Az Azure Monitor OpenTelemetria engedélyezése .NET-, Node.js-, Python- és Java-alkalmazásokhoz.

Feljegyzés

Ha a naplózással együtt szeretné implementálni az alkalmazás-Elemzések telemetriai adatok teljes körét, olvassa el az Alkalmazás Elemzések konfigurálása ASP.NET webhelyekhez vagy az Alkalmazás Elemzések ASP.NET Core-alkalmazásokhoz című témakört.

Tipp.

Az Microsoft.ApplicationInsights.WorkerService Alkalmazás Elemzések háttérszolgáltatásokhoz való engedélyezéséhez használt NuGet-csomag hatókörén kívül esik. További információ: Application Elemzések for Worker Service apps.

ASP.NET Core-alkalmazások

Alkalmazásnaplózás hozzáadása Elemzések ASP.NET Core-alkalmazásokhoz:

1. Telepítse a Microsoft.Extensions.Logging.ApplicationInsights.

2. Hozzáadás 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);
                });
    }
}

Ha telepítve van a NuGet-csomag, és a szolgáltató regisztrálva van a függőséginjektálással, az alkalmazás készen áll a naplózásra. Konstruktorinjektálás esetén vagy ILogger az általános típusú alternatíva ILogger<TCategoryName> szükséges. Ha ezek a megvalósítások megoldódnak, ApplicationInsightsLoggerProvider adja meg őket. A rendszer naplózott üzeneteket vagy kivételeket küld az Alkalmazás Elemzések.

Vegye figyelembe a következő példavezérlőt:

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

További információ: Naplózás az ASP.NET Core-ban és milyen alkalmazás Elemzések telemetriai típus iLogger-naplókból származik? Hol láthatók az ILogger-naplók az Alkalmazás Elemzések?.

Konzolalkalmazás

Az alkalmazás Elemzések naplózás konzolalkalmazásokhoz való hozzáadásához először telepítse a következő NuGet-csomagokat:

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

Az alábbi példa a Microsoft.Extensions.Logging.Application Elemzések csomagot használja, és bemutatja a konzolalkalmazások alapértelmezett viselkedését. A Microsoft.Extensions.Logging.Application Elemzések csomagot egy konzolalkalmazásban kell használni, vagy amikor az alkalmazás Elemzések minimális implementációját szeretné elérni a teljes funkciókészlet nélkül, például metrikák, elosztott nyomkövetés, mintavételezés és telemetriai inicializálók nélkül.

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

További információ: Milyen alkalmazás Elemzések telemetriatípus készül az ILogger-naplókból? Hol láthatók az ILogger-naplók az Alkalmazás Elemzések?.

Naplózási hatókörök

ApplicationInsightsLoggingProvider támogatja a napló hatóköreit. A hatókörök alapértelmezés szerint engedélyezve vannak.

Ha a hatókör típusaIReadOnlyCollection<KeyValuePair<string,object>>, akkor a rendszer a gyűjtemény minden kulcs-érték párját hozzáadja az alkalmazáshoz, Elemzések telemetria egyéni tulajdonságokként. Az alábbi példában a naplók a tulajdonságok szerint vannak rögzítveTraceTelemetry.("MyKey", "MyValue")

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

Ha bármilyen más típust használ hatókörként, az alkalmazás Elemzések telemetria tulajdonsága Scope tárolja. Az alábbi példában van egy olyan tulajdonság neveScope, TraceTelemetry amely tartalmazza a hatókört.

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

Gyakori kérdések

Milyen alkalmazás Elemzések telemetriatípust hoznak létre az ILogger-naplókból? Hol láthatók az ILogger-naplók az Alkalmazás Elemzések?

ApplicationInsightsLoggerProvider rögzíti a naplókat ILogger , és létrehozza TraceTelemetry őket. Ha egy Exception objektumot a rendszer a metódusnak Log ad át, ExceptionTelemetry a rendszer ILoggerahelyett TraceTelemetryjön létre.

ILogger Telemetria megtekintése

Az Azure Portalon:

1. Nyissa meg az Azure Portalt, és nyissa meg az alkalmazás Elemzések erőforrást.
2. Kattintson az Application Elemzések "Naplók" szakaszára.
3. A Kusto lekérdezésnyelv (KQL) használatával lekérdezheti az általában a traces táblában tárolt ILogger-üzeneteket.
   • Példa lekérdezés: traces | where message contains "YourSearchTerm".
4. Pontosítsa a lekérdezéseket, hogy az ILogger-adatokat súlyosság, időtartomány vagy adott üzenettartalom alapján szűrje.

A Visual Studióban (helyi hibakereső):

1. Indítsa el az alkalmazást hibakeresési módban a Visual Studióban.
2. Nyissa meg a "Diagnosztikai eszközök" ablakot az alkalmazás futtatása közben.
3. Az "Események" lapon az ILogger-naplók más telemetriai adatokkal együtt jelennek meg.
4. Használja a keresési és szűrési funkciókat a Diagnosztikai eszközök ablakban adott ILogger-üzenetek megkereséséhez.

Ha mindig szeretne küldeni TraceTelemetry, használja ezt a kódrészletet:

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

Egyes ILogger-naplók miért nem rendelkeznek ugyanazokkal a tulajdonságokkal, mint mások?

Az alkalmazás Elemzések rögzíti és elküldi ILogger a naplókat az TelemetryConfiguration összes többi telemetriához használt információkkal. De van egy kivétel. Alapértelmezés szerint nincs teljesen beállítva, TelemetryConfiguration amikor Program.cs vagy Startup.cs naplóz. Az ezekről a helyekről származó naplók nem rendelkeznek az alapértelmezett konfigurációval, ezért nem minden példányt és TelemetryProcessor példányt futtatnakTelemetryInitializer.

A Microsoft.Extensions.Logging.Application önálló csomagját használom Elemzések és manuálisan szeretnék több egyéni telemetriát naplózni. Hogyan csináljam?

Az önálló csomag TelemetryClient használata esetén a rendszer nem szúrja be a függőséginjektáló (DI) tárolóba. Létre kell hoznia egy új példányt, és ugyanazt a konfigurációt kell használnia TelemetryClient , amelyet a naplózási szolgáltató használ, ahogyan az alábbi kód is mutatja. Ez a követelmény biztosítja, hogy ugyanazt a konfigurációt használja a rendszer az összes egyéni telemetriához és telemetria esetében.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;
   }  
}

Feljegyzés

Ha a csomag használatával engedélyezi az Microsoft.ApplicationInsights.AspNetCore Alkalmazás Elemzések, módosítsa ezt a kódot úgy, hogy közvetlenül a konstruktorba jussonTelemetryClient.

Nincs telepítve az SDK, és az Azure Web Apps bővítmény használatával engedélyezem az Alkalmazás Elemzések a ASP.NET Core-alkalmazásokhoz. Hogyan használni az új szolgáltatót?

Az Azure Web Apps alkalmazás Elemzések bővítménye az új szolgáltatót használja. Az alkalmazás appsettings.json fájljában módosíthatja a szűrési szabályokat.

Következő lépések

• Naplózás a .NET-ben
• Bejelentkezés a ASP.NET Core-ban
• .NET-nyomkövetési naplók az Alkalmazás Elemzések