Hoe log je in op een bestand zondereen externe logger (serilog, elmah etc.)in .NET COREte gebruiken?
public void ConfigureServices(IServiceCollection services)
{
services.AddLogging();
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
}
Antwoord 1, autoriteit 100%
Probleem http://github.com/aspnet/Logging/issues/441is gesloten en MS raadt officieel aan om bestandsloggers van derden te gebruiken. Misschien wilt u het gebruik van zware logging-frameworks zoals serilog, nlog enz. vermijden, omdat ze gewoon overdreven zijn in het geval dat u alleen een eenvoudige logger nodig heeft die naar een bestand schrijft en niets meer (zonder extra afhankelijkheden).
Ik zat in dezelfde situatie en implementeerde een eenvoudige (maar efficiënte) bestandslogger: https://github.com/ nreco/logging
- kan worden gebruikt in .NET Core 1.x- en .NET Core 2.x / 3.x-apps
- ondersteunt aangepaste logbericht-handler voor het schrijven van logs in JSON of CSV
- implementeert de eenvoudige functie ‘rollend bestand’ als de maximale logbestandsgrootte is opgegeven
Antwoord 2, autoriteit 49%
.NET Core biedt (en zal waarschijnlijk ook niet) een ingebouwde ILoggerProvider-implementatie voor het loggen van bestanden.
Er is een façadewaarmee trace source logging (het ingebouwde logger-framework is ontstaan in klassiek .NET) beschikbaar is voor .NET Core-applicaties. Het kan goed zijn voor degenen die er al bekend mee zijn, maar wees erop voorbereid dat configuratie enigszins omslachtig is op .NET Core (voor details, zie dit mooie artikel).
Als alternatief kunt u mijn lichtgewicht ILogger<T>-implementatie proberen, die de functies van de ingebouwde ConsoleLoggeromvat en aanvullende essentiële functies en goede aanpasbaarheid biedt. Mijn bibliotheekis gratis, open-source en heeft alleen framework-afhankelijkheden. Het is volledig in overeenstemming met de implementaties van de Microsoft-provider.
Het gebruik is zo eenvoudig als volgt:
dotnet add package Karambolo.Extensions.Logging.File
ASP.NET Core 3.x webapplicaties:
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder
.ConfigureLogging((ctx, builder) =>
{
builder.AddConfiguration(ctx.Configuration.GetSection("Logging"));
builder.AddFile(o => o.RootPath = ctx.HostingEnvironment.ContentRootPath);
})
.UseStartup<Startup>();
});
ASP.NET Core 2.1+ webapplicaties:
public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.ConfigureLogging((ctx, builder) =>
{
builder.AddConfiguration(ctx.Configuration.GetSection("Logging"));
builder.AddFile(o => o.RootPath = ctx.HostingEnvironment.ContentRootPath);
})
.UseStartup<Startup>();
.NET Core 2.1+ console-applicaties:
// build configuration
// var configuration = ...;
// configure DI
var services = new ServiceCollection();
services.AddLogging(builder =>
{
builder.AddConfiguration(configuration.GetSection("Logging"));
builder.AddFile(o => o.RootPath = AppContext.BaseDirectory);
});
// create logger factory
using (var sp = services.BuildServiceProvider())
{
var loggerFactory = sp.GetService<ILoggerFactory>();
// ...
}
Voor configuratiedetails, zie de projectsite.
Antwoord 3, autoriteit 40%
Die van Adam en Vitaliy zijn waarschijnlijk nog steeds de meest eenvoudige tot nu toe (bedankt jongens trouwens!).
Aangezien een externe NuGet hoe dan ook noodzakelijk is, is het vermeldenswaard dat er ook een “standalone” extensie van de Serilog rolling file-sink is die eenvoudig kan worden gebruikt als een logging-provider voor .net core, zonder de logging-pipeline volledig uit te wisselen (trekt andere afhankelijkheden , maar ik zie dat niet als een probleem als je de paar extra functies nodig hebt)
Vanaf maart 2020 is dit het complete plaatje:
Antwoord 4, autoriteit 21%
Als u IIS gebruikt, kunt u stdout-logboeken inschakelen en bekijken:
- Bewerk het bestand web.config.
- Stel stdoutLogEnabledin op
true. - Wijzig het pad stdoutLogFilezodat het naar de logs-map verwijst (bijvoorbeeld
.\logs\stdout). - Bewaar het bestand.
- Doe een verzoek aan de app.
- Navigeer naar de map logs. Zoek en open het meest recente stdout-logboek.
Voor informatie over stdout-logboekregistratie, zie Problemen met ASP.NET Core op IIS oplossen.
Antwoord 5, autoriteit 16%
De meeste antwoorden boden een oplossing met behulp van bibliotheken van derden. Hierdoor klonk het dat het heel ingewikkeld zou zijn om iets anders te doen. Daarom heb ik besloten om deze gemakkelijke manier van inloggen op een bestand te delen zondereen bibliotheek van derden te gebruiken. Het enige wat je hoeft te doen is deze 3 klassen aan je project toe te voegen.
FileLogger:
using Microsoft.Extensions.Logging;
using System;
using System.IO;
namespace WebApp1
{
public class FileLogger : ILogger
{
private string filePath;
private static object _lock = new object();
public FileLogger(string path)
{
filePath = path;
}
public IDisposable BeginScope<TState>(TState state)
{
return null;
}
public bool IsEnabled(LogLevel logLevel)
{
//return logLevel == LogLevel.Trace;
return true;
}
public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
{
if (formatter != null)
{
lock (_lock)
{
string fullFilePath = Path.Combine(filePath, DateTime.Now.ToString("yyyy-MM-dd") + "_log.txt");
var n = Environment.NewLine;
string exc = "";
if (exception != null) exc = exception.GetType() + ": " + exception.Message + n + exception.StackTrace + n;
File.AppendAllText(fullFilePath, logLevel.ToString() + ": " + DateTime.Now.ToString() + " " + formatter(state, exception) + n + exc);
}
}
}
}
}
FileLoggerProvider:
using Microsoft.Extensions.Logging;
namespace WebApp1
{
public class FileLoggerProvider : ILoggerProvider
{
private string path;
public FileLoggerProvider(string _path)
{
path = _path;
}
public ILogger CreateLogger(string categoryName)
{
return new FileLogger(path);
}
public void Dispose()
{
}
}
}
FileLoggerExtensions:
using Microsoft.Extensions.Logging;
namespace WebApp1
{
public static class FileLoggerExtensions
{
public static ILoggerFactory AddFile(this ILoggerFactory factory, string filePath)
{
factory.AddProvider(new FileLoggerProvider(filePath));
return factory;
}
}
}
Voeg deze regels toe aan uw Configure-methode in Startup.cs:
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddFile(Path.Combine(Directory.GetCurrentDirectory(), "logs"));
//...
}
Dus nu moet je een map maken met de naam “logs” in je project. Uw logboeken worden nu geschreven naar bestanden die voor elke datum zijn gemaakt. U kunt het gemaakte bestand bekijken en de logs vergelijken met de console-uitvoer.
Dit antwoord is bijgewerkt. De opmaak van het logbestand is opgelost. Het is nu mogelijk om voor elke datum in verschillende bestanden in te loggen.
Als je de implementatie van mijn logging-provider niet leuk vindt, kun je er zelf een maken met behulp van deze informatie: https://www.codeproject.com/Articles/1556475/How-to-Write-a-Custom-Logging-Provider-in- ASP-NET
Opmerking:dit is een eenvoudige oplossing en is mogelijk niet geschikt voor drukke systemen. Als je geavanceerde logging nodig hebt, overweeg dan een logger van derden te gebruiken.