Logging Architecture

using System;

// A LogLevel enum, lowest severity to highest. The NUMBER behind each name
// (Trace = 0 ... Critical = 5) is what lets us compare and filter later.
enum LogLevel { Trace, Debug, Information, Warning, Error, Critical }

class Logger
{
    // The heart of any logger: ONE place that decides how a line is written.
    public void Log(LogLevel level, string message)
    {
        // {level} prints the enum name (e.g. "Information"); -11 left-pads it.
        Console.WriteLine($"[{lev
...

using System;

// 🎯 YOUR TURN — finish the Log method, then press "Try it Yourself".
enum LogLevel { Trace, Debug, Information, Warning, Error, Critical }

class Logger
{
    public void Log(LogLevel level, string message)
    {
        // 1) Print one line in the form:  [LEVEL] message
        //    Use string interpolation. {level} prints the enum name.
        ___;   // 👉 Console.WriteLine($"[{level}] {message}");
    }
}

class Program
{
    static void Main()
    {
        var log = new L
...

using System;

enum LogLevel { Trace, Debug, Information, Warning, Error, Critical }

class Logger
{
    // The "volume knob": anything BELOW this level is silently dropped.
    public LogLevel MinimumLevel { get; set; } = LogLevel.Information;

    public void Log(LogLevel level, string message)
    {
        // Enums compare by their underlying number, so Warning (3) >= Information (2).
        if (level < MinimumLevel) return;   // too quiet to care about — skip it
        Console.WriteLine($
...

using System;

// 🎯 YOUR TURN — add level filtering so quiet messages are skipped.
enum LogLevel { Trace, Debug, Information, Warning, Error, Critical }

class Logger
{
    public LogLevel MinimumLevel { get; set; } = LogLevel.Information;

    public void Log(LogLevel level, string message)
    {
        // 1) If this message is LESS important than MinimumLevel, stop here.
        //    Enums compare like numbers: Trace(0) < Debug(1) < ... < Critical(5).
        if (___) return;   // 👉 level 
...

using System;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

class OrderProcessor
{
    // ILogger<T> is the .NET logging interface. The <OrderProcessor> tags every
    // line with this class name as its "category", for free.
    private readonly ILogger<OrderProcessor> _logger;

    public OrderProcessor(ILogger<OrderProcessor> logger) => _logger = logger;

    public void ProcessOrder(string orderId, decimal amount)
    {
        // STRUCTURED logging: {O
...

using Microsoft.Extensions.Logging;

// Two ways to log the same event. They look almost identical — but only one
// is useful at 3am when you're searching millions of log lines.
class Demo
{
    public void Show(ILogger logger, string email, string orderId, decimal amount)
    {
        // ❌ BAD — string concatenation/interpolation. The values are baked into
        //    a flat string. A log tool sees ONE blob of text it can't query.
        logger.LogInformation("User " + email + " placed ord
...

using Serilog;

// Serilog is the most popular third-party logger. A "sink" is a DESTINATION —
// where the logs go. You can attach as many as you like at once.
class Program
{
    static void Main()
    {
        Log.Logger = new LoggerConfiguration()
            .MinimumLevel.Information()
            .WriteTo.Console()                       // sink 1: the terminal
            .WriteTo.File("logs/app-.txt",           // sink 2: a rolling file
                rollingInterval: RollingInterval.Da
...