Op het logeren in ASP.Net-applicaties (Part 1...waarschijnlijk
Inleiding
Loggen is een cruciaal deel van de toepassingen, maar ik zie het vaak verkeerd begrepen / misbruikt in ASP.NET-toepassingen . Dit is gedeeltelijk post en gedeeltelijk manifest over hoe je effectief kan logeren in ASP
Dit is geen volledige gids voor het afteken.
In de hoofd-logging zou USEFUL moeten zijn ; of het's loging tijdens je ontwikkeling is, of in de productie, het zou nuttig voor jou moeten zijn.
Het probleem
Te vaak wordt houtkap gezien als de '-ding, alleen wanneer er uitzonderingen zijn.
LOGGING IS niet alleen voor uitzonderingen
In het algemeen zou je in staat moeten zijn om een belangrijk deel van je toepassing lokaal te runnen. log.LogInformation Is je vriend.
De oplossing
Log-succes
Gedurende de 30 jaren heb ik I'code geschreven I ' heb een paar voorbeelden gezien van goed houtkap en veel meer van slechte houtkap.
Principes van goede houtkap:
- Logging in Development moet voldoende informatie geven over hoe je applicatie werkt om te begrijpen wat er gebeurt.
- Logging in Production geeft je een super snelle en makkelijke manier om te begrijpen hoe je toepassing faalt.
- Veel loggen in de productie is negatief; het kan je toepassing vertragen en het moeilijker maken om belangrijke dingen te vinden.
Onthoud; het logen vertraagt altijd de prestaties van je toepassing; je moet loggen wat je nodig hebt om een probleem te diagnosticeren, maar niet meer in de productie M SK2 waar de prestatie cruciaal is (eMST4gMst5 doe geen prestatietest als je full Debug Loging gebruikt
Typen van aanteken in ASP.NET
Serilog vs Microsoft.Extensions.Logging
In ASP.NET heb je al een ingebouwd logsysteem. Microsoft.Extensions.Logging. Dit is een goed aftekensysteem , maar het is niet zo flexibel als Serilog. Serilog is een flexibeler aftekenstelsel dat je toelaat om te logeren naar meerdere kraantjes.
Bootstrap Logging
Dit is het afteken dat gebeurt wanneer je toepassing opstart.. Het is het eerste wat er gebeurt, ', en het is het allereerste wat je moet zien als je je toepassing uitvoert.
Bijvoorbeeld in Serilog kun je dit doen:
Log.Logger = new LoggerConfiguration()
.WriteTo.Console()
.WriteTo.File("logs/boot-*.txt", rollingInterval: RollingInterval.Day, retainedFileCountLimit: 7)
.CreateBootstrapLogger();
NOTA: Dit is beperkt omdat je op dit punt geen toegang tot de konfiguratie hebt, dus bijvoorbeeld om AppInsights te gebruiken heb je waarschijnlijk een #if RELEASE Blok om de juiste sleutel te bepalen .
Dit geeft je gegevens over alle opstartproblemen in je applicatie; het schrijft zowel naar console als naar een lêer . Het is ook belangrijk om te zorgen dat je niet alle logfiles bewaart.
Je ' wil ook je startmethode ( in deze app omvouwen Ik gebruik de nieuwe Program.cs methode) in een poging/vang en log alle uitzonderingen die daar gebeuren.
try
{
..all your startup code
}
catch (Exception ex)
{
if(args.Contains("migrate"))
{
Log.Information("Migration complete");
return;
}
Log.Fatal(ex, "Application terminated unexpectedly");
}
finally
{
Log.CloseAndFlush();
}
De Log.CloseAndFlush() is belangrijk omdat het ervoor zorgt dat alle logs op de schijf geschreven worden.
Hier detecteer ik ook of de app in een migratiemodus werkt en als dat zo is, log ik dat op en stap uit.
Log.Fatal is de meest ernstige logniveau; het' gebruikt wanneer je applicatie op het punt staat om te crashen
Niet alle uitzonderingen zijn fatal. - moet je gebruiken Log.Error Voor die (, tenzij ze het APP betekenen ( niet de versoek | ) | kunnen ze niet verder gaan dan dat punt
Logniveaus
In ASP heb je een aantal logniveaus.
Log.Fatal- Dit is het meest ernstige logniveau.Log.Error- Dit wordt gebruikt als er een uitzondering plaatsvindt, wat betekent dat de APP niet verder kan gaan dan die punt.Log.Warning- Dit wordt gebruikt als er iets gebeurt dat niet een fout is, maar wel iets waar je bewust van moet zijn. Niet helemaal goed. maar geen fout).Log.Information- Dit wordt gebruikt voor algemene informatie over wat in je toepassing gebeurt.Log.Debug- Dit wordt gebruikt om te weten dat' alleen bruikbaar is als je debugging van je toepassing doet.
Voor de productie stelde I'd de afmeting meestal als volgt uit: Log.Fatal, Log.Error en Log.Warning alleen.
Looptijd Logging
In tegenstelling tot het starten van een log is dit de log die gebeurt als je de toepassing loopt. Dit is het log dat je vertelt wat in je toepassing op elk gegeven moment gebeurt.
Om ze bijvoorbeeld in Serilog te gebruiken, doe je dit.
"Serilog": {
"Enrich": ["FromLogContext", "WithThreadId", "WithThreadName", "WithProcessId", "WithProcessName", "FromLogContext"],
"MinimumLevel": "Warning",
"WriteTo": [
{
"Name": "Seq",
"Args":
{
"serverUrl": "http://seq:5341",
"apiKey": ""
}
},
{
"Name": "Console"
},
{
"Name": "File",
"Args": {
"path": "logs/applog-.txt",
"rollingInterval": "Day"
}
}
],
"Properties": {
"ApplicationName": "mostlylucid"
}
},
Verrijkt
Zoals jullie zullen zien, ben ik een heel grote fan van Serilog. In het boonste voorbeeld zie je I'm mijn logs verrijken met de thread id, thread nameM SK2 proces id en proces naam . Dit kan erg nuttig zijn bij het diagnosticeren van problemen in je toepassingMSC4
Ik stel ook de loging op om naar meerdere outputs te gaan. In dit geval stuur ik het naar de console, naar een lêer en naar Seq.
Multiple zeepoten hebben is handig als er één mislukt, in dit geval is mijn favoriete logservice Seq, dus ik stuur het daar eerst naartoeM SK2 Als dat niet lukt, stuur ik het naar de console en een lêer.
Ik stel ook de ApplicationName-eigenschap in de logs vast; dit kan nuttig zijn als je meerdere toepassingen aan één en dezelfde dienst logt ( wat voor verspreide toepassingen je vaak zal doen ; samen met een correlatie-ID om die logs bij elkaar te binden voor één enkele vraagM SK3
Als je bijvoorbeeld een JS-frontend en een .NET-backend hebt, kun je de correlatie-ID in het frontend opstellen en aan het backend overgeven. Dit laat toe dat je alle logs voor één verzoek op één plek kunt zien.
Er is een geweldige omslaggeving over hoe je dit hier zou kunnen doen.:, https, ://,josef,.,codes,M SK4,append,-,correlatie,Mska6,id,Mske7, tot -, alle, Mske9,log,Msko10, invoeren,Msku11,in,Msek12,asp,Mskie13,net,Mski14,core en Mske15, maar ik zal het in een toekomstig bericht behandelen.
Gestructureerde Logging
Structured logging is een manier om te loggen die het makkelijker maakt je logs te zoeken en filteren. In Serilog kun je dit doen door de Log.Information("This is a log message with {Property1} and {Property2}", property1, property2); syntax. Dit maakt het makkelijker om logs met een bepaalde eigenschap te zoeken.
Contextuele Logging
Met Serilog kan je ook gebruiken. LogContext.PushProperty om eigenschappen aan je logs toe te voegen die alleen relevant zijn voor een bepaalde scope. Dit kan erg nuttig zijn bij het diagnosticeren van problemen in je toepassing.
Serilog Opstelling
Serilog is super flexibel omdat je hem kunt configureren in code en via config. Bijvoorbeeld om de above-configuration te gebruiken doe je dit'd
builder.Host.UseSerilog((context, services, configuration) =>
{
configuration
.MinimumLevel.Warning()
.Enrich.FromLogContext()
.Enrich.WithThreadId()
.Enrich.WithThreadName()
.Enrich.WithProcessId()
.Enrich.WithProcessName()
.WriteTo.Seq("http://seq:5341", apiKey: "")
.WriteTo.Console()
.WriteTo.File("logs/applog-.txt", rollingInterval: RollingInterval.Day)
.Enrich.WithProperty("ApplicationName", "mostlylucid");
});
Dit is hetzelfde als de konfiguratie hierboven, maar in code. Het is bruikbaar als je je loging in code wil opzetten.
Uitsonderingsfilters
In ASP kan je 'Exception Filters' gebruiken om uitzonderingen op te vangen en te logeren. Hoe dan ook, ' is geen vervanging voor het methodenniveau-loggen.; Je moet nog steeds op het methodeniveau logeren zodat je kunt zien wat er gebeurt in je toepassing.; De uitsonderingsfilter laat alleen zien wat gebeurt als de hele verzoekstapel ontwoond is en het kan vaak erg verwarrend zijn om uit te zoeken wat er gebeurde.
Dit veranderde in ASP.NET Core 8 en er is een TON met deze. Nieuwe functies.
Nogmaals, dezelfde principes gelden.; je moet op het methodeniveau logeren zodat je kunt zien wat er gebeurt in je toepassing.
Log alles in orde.
Logging moet geschikt zijn voor de omgeving; In ontwikkeling log je alles zodat je kunt zien wat er op elk punt in je toepassing gebeurt, maar in toets heb je minder aanteken nodig ( Misschien log-informatie hierM SK2 en in productie nog minder ( Waarschuwing en bovenaanMSC4
Het is verleidelijk om alles te logeren in de productie, maar het is een slecht idee.'. Je moet alles logen wat je nodig hebt om een probleem te diagnosticeren, maar niet meer.
Voor een zeer 'active' app die je net won, heb je geen langetermijn-loggen nodig voor die data, maar je hebt een goed idee van wat er gebeurt in de app sinds de laatste dagen van de logs.
Versoek Logging
Eenmaal een gemeenschappelijk probleem dat ik in de productie zie, is het afteken van mislukte verzoeken; terwijl dit interessant kan zijn ( niemand wil een 404 / \401) dit kan een enorme hoeveelheid data zijn en erg duur kunnen zijn om op te slaan. *Je bent van plan het te repareren.*Het kan belangrijk zijn dat dit een gebroken link in je applicatie kan aanwijzen.
Zoals ik al zei, worden deze beter gemanipuleerd in de code die ze daadwerkelijk in ( voorkomen, in het geval van 401); kan het zijn dat deze ook gelogd moeten worden als een Warning of Error In de code die daadwerkelijk het 401. genereert.
Om een Request Logging in Serilog op te zetten, kan je dit doen:
app.UseSerilogRequestLogging();
Dit registreert alle verzoeken naar je toepassing.; Het is een geweldige manier om te zien wat er gebeurt in je toepassing op een hoog niveau, maar je moet nogmaals voorzichtig zijn over wat je registreert en hoe lang je deze logs bijhoudt.
Voor Application Insights wil je misschien nog steeds logeren met informatieniveau omdat het je de handige User Journey-featuur geeft; dit is een geweldige manier om te zien hoe gebruikers jouw toepassing gebruiken en erg nuttig kan zijn bij het diagnosticeren van problemen; maar deze kosten blijven snel oplopen, dus je moet voorzichtig zijn over wat je logt en hoe lang je die logs voorhoudt.
In slotting:
Het is dus een snelle doorloop van hoe je in ASP-applicaties logt. In de ontwikkeling wil je zien hoe het werkt. Hoe de app werkt; in de productie die je wilt zien Hoe de app faalt. Logen is te vaak een onbruikbaar onderdeel van de toepassingsontwikkeling.. Zoals bij alles in software-ontwikkeling moet loggen zich richten op de gebruiker, of het nu u / andere ontwikkelaars zijn tijdens het werken aan de app in je IDE.