standard logging C# example

Program.cs

using System.Diagnostics;
using System.Linq;
using Microsoft.Extensions.Logging; // dotnet add package Microsoft.Extensions.Logging.Console --version 9.0.0
using Microsoft.Extensions.Logging.Console;

namespace LoggingExample
{
    class Program
    {
        static async Task Main()
        {
            Console.OutputEncoding = System.Text.Encoding.UTF8;

            // створює фабрику логерів з консольним провайдером
            using var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
            var logger = loggerFactory.CreateLogger<Program>();

            var process = Process.GetCurrentProcess();
            var stopwatch = Stopwatch.StartNew();

            logger.LogInformation("Програма запущена успішно.");

            try
            {
                // симулює складну операцію: паралельні обчислення для навантаження CPU
                await SimulateHeavyComputation(logger, process);

                // симулює транзакцію
                await SimulateTransaction(logger);

                // симулює API-виклик
                await SimulateApiCall(logger);
            }
            catch (Exception ex)
            {
                // логування винятку з контекстом, включаючи inner exceptions
                logger.LogError(ex, "Виникла неочікувана помилка під час виконання: {Message}. Inner: {InnerMessage}. StackTrace: {StackTrace}", ex.Message, ex.InnerException?.Message, ex.StackTrace);
            }
            finally
            {
                stopwatch.Stop();
                var finalCpu = CalculateCpuUsage(process);
                var finalMemory = process.WorkingSet64 / (1024 * 1024); // MB
                logger.LogInformation("Програма завершена. Загальний час: {Elapsed}. Фінальний моніторинг: CPU ~{Cpu}%, Пам'ять ~{Memory} MB", stopwatch.Elapsed, finalCpu, finalMemory);
            }
        }

        static async Task SimulateHeavyComputation(ILogger logger, Process process)
        {
            logger.LogInformation("Початок складних обчислень для навантаження CPU.");

            var tasks = new List<Task>();
            for (int i = 0; i < Environment.ProcessorCount * 2; i++) // більше потоків для навантаження
            {
                tasks.Add(Task.Run(() => HeavyCpuWork(5000000, logger))); // збільшено ітерацій
            }

            // моніторинг ресурсів кожні 2 секунди
            var cts = new CancellationTokenSource();
            var monitorTask = MonitorResourcesAsync(logger, process, cts.Token);

            await Task.WhenAll(tasks);
            cts.Cancel();

            await monitorTask;

            logger.LogInformation("Складні обчислення завершені.");
        }

        static void HeavyCpuWork(int iterations, ILogger logger)
        {
            double result = 0;
            for (int i = 0; i < iterations; i++)
            {
                // складніші обчислення: sin, cos, pow, sqrt, log
                result += Math.Sin(i) * Math.Cos(i) * Math.Pow(i, 0.5) * Math.Sqrt(i + 1) * Math.Log(i + 2);
            }
            logger.LogDebug("Потік завершив обчислення: {Result:F2}", result);
        }

        static async Task MonitorResourcesAsync(ILogger logger, Process process, CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                var cpuUsage = CalculateCpuUsage(process);
                var memoryUsage = process.WorkingSet64 / (1024 * 1024); // MB
                var threadsCount = process.Threads.Count;
                var handleCount = process.HandleCount;

                logger.LogInformation("Моніторинг: CPU ~{Cpu}%, Пам'ять ~{Memory} MB, Потоки: {Threads}, Хендли: {Handles}", cpuUsage, memoryUsage, threadsCount, handleCount);

                await Task.Delay(2000, token);
            }
        }

        static double CalculateCpuUsage(Process process)
        {
            var startTime = DateTime.UtcNow;
            var startCpuTime = process.TotalProcessorTime;
            Thread.Sleep(500);
            var endTime = DateTime.UtcNow;
            var endCpuTime = process.TotalProcessorTime;

            var elapsed = (endTime - startTime).TotalSeconds;
            var cpuUsed = (endCpuTime - startCpuTime).TotalSeconds;
            return Math.Min(100, (cpuUsed / elapsed / Environment.ProcessorCount) * 100);
        }

        static async Task SimulateTransaction(ILogger logger)
        {
            logger.LogInformation("Початок симуляції транзакції. Custom code: TXN-001.");
            await Task.Delay(1500); // симуляція
            if (new Random().Next(0, 10) > 6) // 30% шанс помилки
            {
                var innerEx = new TimeoutException("Таймаут з'єднання з БД.");
                throw new InvalidOperationException("Транзакція не вдалася через мережеву помилку. Error code: DB-ERR-404.", innerEx);
            }
            logger.LogInformation("Транзакція успішно завершена. Custom code: TXN-001-OK.");
        }

        static async Task SimulateApiCall(ILogger logger)
        {
            logger.LogInformation("Початок симуляції API-виклику. Endpoint: /api/users.");
            await Task.Delay(800);
            var statusCode = new Random().Next(200, 500);
            if (statusCode >= 400)
            {
                logger.LogWarning("API-виклик завершився з помилкою: Status {StatusCode}", statusCode);
            }
            else
            {
                logger.LogInformation("API-виклик успішно виконано. Status: {StatusCode}", statusCode);
            }
        }
    }
}