ASP.NET Core Logging

Logging nima?

Logging — bu dasturda sodir bo'layotgan jarayonlarni kuzatish va ma'lumotlarni yozib borish uchun foydalaniladigan mexanizm. Logger yordamida dastur jarayonlari haqidagi ma'lumotlar log fayllariga yoki boshqa "chiqish manba"lariga yozib boriladi. Loggerlar dasturdagi muammolarni topish, tahlil qilish va ularni bartaraf etishda muhim vositadir.

Loglar qayerda ko'rsatiladi?

Konsol: Loglar konsolga (masalan, Visual Studio, terminal yoki cmd oynasi) chiqariladi. Bu odatda dasturiy ta'minotni sinash yoki debugging jarayonida ishlatiladi.
Fayllar: Loglar .txt yoki .log formatidagi fayllarga yozilishi mumkin. Bu uzoq muddatli saqlash va tahlil uchun qulay.
Ma'lumotlar bazasi: Loglar SQL Server, PostgreSQL yoki boshqa ma'lumotlar bazalarida saqlanishi mumkin. Bu katta hajmdagi loglarni boshqarish uchun ishlatiladi.
Cloud xizmatlar: Loglarni Azure Monitor, AWS CloudWatch, yoki boshqa bulut xizmatlariga yuborish orqali monitoring qilish mumkin.
Event Logs: Windows Event Log yoki Linux'ning tizim loglari kabi platformaga xos log xizmatlariga yozish.
Third-party monitoring vositalari: Serilog, NLog, yoki Elasticsearch (ELK stack) kabi vositalar orqali loglarni boshqarish va tahlil qilish mumkin.

Loglarni yozish qanday boshqariladi?

Loglarni qayerga va qanday yozib borish Logging Providerlar orqali boshqariladi. Microsoft.Extensions.Logging kutubxonasi orqali quyidagi providerlarni sozlash mumkin:
Asosiy Logging Providerlar:

• ConsoleLoggerProvider: Konsolga log yozish uchun.
• DebugLoggerProvider: Debug chiqqanlar uchun log yozish.
• EventLogLoggerProvider: Windows Event Log uchun.
• FileLoggerProvider: Fayllarga log yozish uchun (masalan, Serilog orqali).

---

Log darajalari
ASP.NET Core quyidagi log darajalarini qoʻllab-quvvatlaydi:

Daraja	Maqsad
Trace	Batafsil maʻlumotlar uchun.
Debug	Debug jarayonida kerak boʻladigan maʻlumotlar.
Information	Dasturdagi umumiy jarayonlar haqida ma'lumot.
Warning	Ehtiyot bo‘lishni talab qiluvchi holatlar.
Error	Dasturda yuz bergan xatolar.
Critical	Dastur yoki tizimning ishlashiga xavf soladigan jiddiy muammolar.

1. Trace
Trace - bu turdagi loglar dastur davomidagi har bir qadamni batafsil yozib ketish uchun ishlatiladi. Yangi jarayon, funksiya, loop yoki oqim boshlanishi va tugaganidan keyin iz qoldirish uchun Trace log yozib ketiladi.

public void TraceLogExample(ILogger logger)
{
    logger.LogTrace("Bu {Time} vaqtida Trace darajasidagi log yozildi", DateTime.Now);
}

2. Debug
Debug darajasi faqat dastur debugging rejimida foydalidir.

public void DebugLogExample(ILogger logger)
{
    logger.LogDebug("Debug log yozildi. Funksiya: {FunctionName}", nameof(DebugLogExample));
}

3. Information
Information darajasi odatda oddiy ma'lumotlarni qayd qilish uchun ishlatiladi.

public void InformationLogExample(ILogger logger)
{
    logger.LogInformation("Information darajasidagi log yozildi. {Action}", "Ma'lumot saqlandi");
}

4. Warning
Warning darajasi muammo yuzaga kelishi mumkinligini bildiradi, lekin dastur ishlashni davom ettiradi.

public void WarningLogExample(ILogger logger)
{
    logger.LogWarning("Warning log yozildi. Xatolik ehtimoli: {Probability}%", 50);
}

5. Error
Error darajasi dasturda muammo yuzaga kelgan, lekin tizim ishlashni davom ettirayotgan holatlar uchun ishlatiladi.

public void ErrorLogExample(ILogger logger)
{
    try
    {
        int result = 10 / 0; // Xato kod
    }
    catch (Exception ex)
    {
        logger.LogError(ex, "Error yuz berdi. Xato tafsiloti {Message}", ex.Message);
    }
}

6. Critical
Critical darajasi dastur yoki tizim ishlashga xavf soladigan jiddiy muammolar uchun ishlatiladi.

public void CriticalLogExample(ILogger logger)
{
    try
    {
        throw new InvalidOperationException("Jiddiy xatolik yuz berdi!");
    }
    catch (Exception ex)
    {
        logger.LogCritical(ex, "Critical xatolik: {Message}", ex.Message);
    }
}

LogTrace va LogDebug odatda dasturchilar uchun yo’naltirilgan bo’ladi. Ya’ni bu turdagi loglarni odatda developerlar BUGni qidirib topish uchun ishlatishadi.

To'liq Logger sinovi
Quyida yuqoridagi barcha darajalarni bitta funksiya orqali sinab ko'rish:

public class LoggingExample(ILogger<LoggingExample> logger)
{
    private readonly ILogger<LoggingExample> mylogger = logger;

    public void RunLoggingDemo()
    {
        mylogger.LogTrace("Trace darajadagi log yozildi.");
        mylogger.LogDebug("Debug darajadagi log yozildi.");
        mylogger.LogInformation("Information darajadagi log yozildi.");
        mylogger.LogWarning("Warning darajadagi log yozildi.");
        try
        {
            int result = 10 / 0; // Xato
        }
        catch (Exception ex)
        {
            mylogger.LogError(ex, "Error darajadagi log yozildi.");
        }

        try
        {
            throw new InvalidOperationException("Jiddiy muammo!");
        }
        catch (Exception ex)
        {
            mylogger.LogCritical(ex, "Critical darajadagi log yozildi.");
        }
    }
}

Loglarni sozlash
appsettings.json faylida log darajalari va providerlar quyidagicha belgilanadi:

"Logging": {
  "LogLevel": {
    "Default": "Information",
    "Microsoft": "Warning"
  }
}

Natija:
Konsolda yoki faylda quyidagi loglar ko'rinadi:

trace: Trace darajadagi log yozildi.
debug: Debug darajadagi log yozildi.
info: Information darajadagi log yozildi.
warn: Warning darajadagi log yozildi.
error: Error darajadagi log yozildi.
crit: Critical darajadagi log yozildi.

---

Yuqorida loglarni boshqarish haqida so'z boshlagan edik, keling uni davom ettiramiz. Demak, Dasturda log yoziladi. Logger yozuvlarni providerga yuboradi. Provider yozuvlarni maqsadli joyga saqlaydi.

1. ConsoleLoggerProvider qanday ishlaydi?
ConsoleLoggerProvider Microsoft.Extensions.Logging kutubxonasining bir qismi bo'lib, u log ma'lumotlarini konsolga chiqarish uchun mo'ljallangan. Bu logger tizimning Standart Output (stdout) oqimidan foydalanadi. ConsoleLoggerProvider default holda ASP.NET Core loyihasida mavjud, lekin biz uni qo'lda sozlashimiz mumkin.

var builder = WebApplication.CreateBuilder(args);

// Console loggerni qo'shish
builder.Logging.ClearProviders(); // Barcha default providerlarni tozalash
builder.Logging.AddConsole();     // Faqat konsol loggerini qo'shish

var app = builder.Build();

app.MapGet("/", (ILogger<Program> logger) =>
{
    logger.LogInformation("Bu konsol logining namunasi.");
    return "Hello World!";
});

app.Run();

Natija:

info: MyApp[0]
      Bu konsol logining namunasi.

Konsol loggerini JSON formatida sozlash mumkin:

builder.Logging.AddJsonConsole();

JSON natija:

{
  "Timestamp": "2024-12-19T10:45:00.123Z",
  "LogLevel": "Information",
  "EventId": 0,
  "Message": "Bu konsol logining namunasi.",
  "Source": "MyApp"
}

ConsoleLoggerProvider:

• Oson sozlanadi: Konfiguratsiya qilish oson va debugging uchun qulay.
• Rangli loglar: Loglarni darajalarga qarab rangli qilib ko'rsatadi.
• JSON va matn formatlari: Har xil talablarga mos formatlarni qo'llab-quvvatlaydi.
• Turli darajalarni filtrlaydi: Faqat kerakli loglarni konsolda ko'rinishini boshqaradi.

2. DebugLoggerProvider qanday ishlaydi?
DebugLoggerProvider — bu ASP.NET Core'da loglarni debug chiqish oynasiga yozish uchun ishlatiladigan logging provider. U asosan debugging jarayonida log xabarlarini ko'rish va tahlil qilish uchun ishlatiladi. DebugLoggerProvider loglarni System.Diagnostics.Debug.WriteLine orqali yozadi. Faqat debug rejimida ishlaydi. Agar dastur release rejimida ishlayotgan bo'lsa, bu provider hech qanday log yaratmaydi. Log xabarlarini Visual Studio Output oynasida yoki boshqa debugging vositalarida ko'rish mumkin.
DebugLoggerProvider ASP.NET Core'da default holda o'rnatilgan. Agar siz uni qo'lda qo'shmoqchi bo'lsangiz, quyidagicha sozlashingiz mumkin:

var builder = WebApplication.CreateBuilder(args);

// Debug loggerni qo'shish
builder.Logging.ClearProviders(); // Barcha default providerlarni tozalash
builder.Logging.AddDebug();       // Debug loggerni qo'shish

var app = builder.Build();

app.MapGet("/", (ILogger<Program> logger) =>
{
    logger.LogDebug("Bu DebugLoggerProvider orqali chiqadigan log xabari.");
    return "Hello Debug Logger!";
});

app.Run();

Natija:

dbug: Program[0]
      Bu DebugLoggerProvider orqali chiqadigan log xabari.

3. EventLogLoggerProvider qanday ishlaydi?

EventLogLoggerProvider — bu ASP.NET Core'da log xabarlarini Windows operatsion tizimining Event Log jurnaliga yozish uchun ishlatiladigan logging provider. Bu logging mexanizmi tizim voqealarini qayd qilish va monitoring qilish uchun ishlatiladi.
Windows Event Log bilan integratsiya:

• Log xabarlarini Windows tizimining Event Viewer (Win + R → eventvwr) ilovasida saqlaydi.
• Jurnallar odatda "Application", "Security", yoki "System" bo'limlarida ko'rinadi. Qo'llanilish sohasi:
• Asosan Production muhiti uchun ishlatiladi, chunki bu loglar uzoq muddatli monitoring va auditing uchun tizim darajasida saqlanadi.

Ishlatish uchun shartlar

• Windows platformasida ishlaydi (Linux yoki macOS'da ishlamaydi).
• Administrator huquqlari kerak bo'lishi mumkin, chunki Event Log'ga yozish uchun tizim huquqlari talab qilinadi.

var builder = WebApplication.CreateBuilder(args);

// EventLog loggerni qo'shish
builder.Logging.ClearProviders();
builder.Logging.AddEventLog();

var app = builder.Build();

app.MapGet("/", (ILogger<Program> logger) =>
{
    logger.LogInformation("Bu EventLogLoggerProvider orqali yozilgan log.");
    return "Hello Event Log!";
});

app.Run();

Event Viewer orqali loglarni ko'rish

1. Windows Search oynasidan Event Viewer ilovasini oching.
2. Chap menyudan Windows Logs → Application bo'limini tanlang.
3. Tizimingizda yozilgan log xabarlarini shu yerda ko'rishingiz mumkin.

4. FileLoggerProvider qanday ishlaydi?
FileLoggerProvider loglarni diskdagi fayllarga yozish uchun ishlatiladi. U log xabarlarini ma'lum bir formatda saqlaydi, shunda keyinchalik diagnostika va monitoring uchun foydalanish mumkin.

Ishlash prinsipi:

• Har bir log xabari faylga yoziladi.
• Xabarlar log darajasi (Information, Warning, Error) va timestamp bilan yoziladi.
• Fayl nomi oldindan belgilangan formatda bo‘lishi mumkin (masalan, log-YYYYMMDD.txt).

Qanday foydalaniladi?
Fayl loggerni dasturga qo'shish uchun konfiguratsiyada AddFile yoki Serilog kabi kutubxonalar ishlatiladi. Log fayllari rotatsiya qilinishi (masalan, har kuni yoki fayl hajmiga qarab yangilanishi) va eski loglarni avtomatik o‘chirish imkoniyati mavjud.

Minimal misol (Serilog orqali):

builder.Host.UseSerilog((context, config) =>
{
    config.WriteTo.File("Logs/log-.txt", rollingInterval: RollingInterval.Day);
});

Nima maqsadlarda foydalaniladi?
Tahlil qilish: Dastur faoliyatini tekshirish.
Xatolarni aniqlash: Xato yoki muammolarni qayd qilish.
Xulosa: FileLoggerProvider loglarni tizim fayllarida saqlaydi va u xatolarni kuzatish, diagnostika yoki auditing uchun juda qulay.

---

Serilog
Serilog — bu .NET ilovalari uchun qulay va moslashuvchan loglash kutubxonasi. U JSON yoki boshqa formatlarda yozishni, Loglarni fayl, konsol, ma'lumotlar bazasi, bulutda yozishni taklif qiladi:

Serilog'ni o'rnatish
NuGet orqali kerakli paketlarni o‘rnatish:

dotnet add package Serilog.AspNetCore
dotnet add package Serilog.Sinks.Console
dotnet add package Serilog.Sinks.File

Amaliy misollar
1. Konsolga log yozish

using Serilog;

var builder = WebApplication.CreateBuilder(args);

// Serilog'ni konsol uchun sozlash
builder.Host.UseSerilog((context, config) =>
{
    config.WriteTo.Console();
});

var app = builder.Build();

app.MapGet("/", (ILogger<Program> logger) =>
{
    logger.LogInformation("Bu Serilog yordamida konsolga yozilgan log.");
    return "Hello, Serilog!";
});

app.Run();

Natija (Konsolda):

[12/21/2024 14:00:00 INF] Bu Serilog yordamida konsolga yozilgan log.

2. Faylga log yozish

using Serilog;

var builder = WebApplication.CreateBuilder(args);

// Serilog'ni fayl uchun sozlash
builder.Host.UseSerilog((context, config) =>
{
    config.WriteTo.File("Logs/log-.txt", rollingInterval: RollingInterval.Day);
});

var app = builder.Build();

app.MapGet("/", (ILogger<Program> logger) =>
{
    logger.LogWarning("Bu Serilog yordamida faylga yozilgan log.");
    return "Hello, File Logger!";
});

app.Run();

Natija (Logs/log-20241221.txt faylida):

2024-12-21 14:00:00 [WRN] Bu Serilog yordamida faylga yozilgan log.

3. Konsol va faylga bir vaqtning o‘zida log yozish

using Serilog;

var builder = WebApplication.CreateBuilder(args);

// Konsol va fayl sinklarini birga sozlash
builder.Host.UseSerilog((context, config) =>
{
    config.WriteTo.Console()
          .WriteTo.File("Logs/mixed-log-.txt", rollingInterval: RollingInterval.Day);
});

var app = builder.Build();

app.MapGet("/", (ILogger<Program> logger) =>
{
    logger.LogError("Bu xabar konsol va faylga yoziladi.");
    return "Hello, Multi-Sink Logger!";
});

app.Run();

Natija (Konsolda va faylda):
Konsolda:

[12/21/2024 14:00:00 ERR] Bu xabar konsol va faylga yoziladi.

Faylda (Logs/mixed-log-20241221.txt):

2024-12-21 14:00:00 [ERR] Bu xabar konsol va faylga yoziladi.

4. Log darajalarini boshqarish

using Serilog;

var builder = WebApplication.CreateBuilder(args);

// Faqat `Warning` va undan yuqori darajadagi loglarni yozish
builder.Host.UseSerilog((context, config) =>
{
    config.MinimumLevel.Warning()
          .WriteTo.Console()
          .WriteTo.File("Logs/filtered-log-.txt", rollingInterval: RollingInterval.Day);
});

var app = builder.Build();

app.MapGet("/", (ILogger<Program> logger) =>
{
    logger.LogInformation("Bu log yozilmaydi (daraja past).");
    logger.LogWarning("Bu log yoziladi (daraja mos).");
    logger.LogError("Bu ham yoziladi (daraja yuqori).");
    return "Hello, Filtered Logger!";
});

app.Run();

Natija:
Konsol va faylda faqat Warning va Error darajadagi loglar ko‘rinadi:

[12/21/2024 14:00:00 WRN] Bu log yoziladi (daraja mos).
[12/21/2024 14:00:00 ERR] Bu ham yoziladi (daraja yuqori).

5. Strukturali log yozish (JSON formatida)

using Serilog;

var builder = WebApplication.CreateBuilder(args);

// JSON formatda log yozish
builder.Host.UseSerilog((context, config) =>
{
    config.WriteTo.Console()
          .WriteTo.File(new Serilog.Formatting.Json.JsonFormatter(), "Logs/json-log-.txt", rollingInterval: RollingInterval.Day);
});

var app = builder.Build();

app.MapGet("/", (ILogger<Program> logger) =>
{
    logger.LogInformation("User {UserId} created a new order.", 123);
    return "Hello, JSON Logger!";
});

app.Run();

Natija (Logs/json-log-20241221.txt faylida):
json

{
  "Timestamp": "2024-12-21T14:00:00.000Z",
  "Level": "Information",
  "MessageTemplate": "User {UserId} created a new order.",
  "Properties": {
    "UserId": 123
  }
}

Serilog yordamida loglarni turli formatlarda va joylarda saqlash mumkin. Oddiy WriteTo metodlari bilan moslashuvchanlikni ta'minlaydi. Fayl, konsol, yoki bulut kabi sinklarni qo‘llab-quvvatlaydi. Strukturali loglash funksiyasi tahlil qilishni osonlashtiradi. Serilog loglash ehtiyojlarini qulay va professional darajada qondiradi.