.NET Core -日志

.NET Core 日志系統日志有： 調試日志，跟蹤日志，診斷日志，事件日志； 為了整合第三方日志和.Net core 自身日志框架的整合 還有一個 統一日志編程模型的框架: ILogger 接口 ILoggerFactory，ILoggerProvider（日志提供程序不同渠道的）

1 調試日志

Debuger靜態類，： Debugger.Log(0,null,"這是一條Debug消息！");

 Debug.WriteLine(""); 這個類型所有的方法都是通過條件編譯的情況得 必須要在Debug模式下才有效

2 跟蹤日志

使用得是觀察者模式/發布訂閱模式

 public static class Sample02
    {
        public static void Run()
        {
            // 發布訂閱模式,這里只是設置發布者                   
            var source = new TraceSource("Trace", SourceLevels.All);
            var eventTypes = (TraceEventType[])Enum.GetValues(typeof(TraceEventType));
            var eventId = 1;
            foreach (var traceEventType in eventTypes)
            {
                source.TraceEvent(traceEventType, eventId++,$"這是一條{traceEventType}消息");
            }

            Console.Read();
        }
    }

  public static class Sample03
    {
        public static void Run()
        {
            //跟蹤控制台的監聽器
            var source = new TraceSource("Trace", SourceLevels.Warning);
            source.Listeners.Add(new ConsoleTraceListener());
            var eventTypes = (TraceEventType[])Enum.GetValues(typeof(TraceEventType));
            var eventId = 1;
            foreach (var traceEventType in eventTypes)
            {
                source.TraceEvent(traceEventType, eventId++,$"這是一條{traceEventType}消息");
            }

            Console.Read();
        }
    }

 public static class Sample04
    {
        public static void Run()
        {      
            using var fileStream = File.OpenWrite("log.txt");
            var source = new TraceSource("Trace", SourceLevels.Warning);
            source.Listeners.Add(new ConsoleTraceListener());
            //文本內容的跟蹤監聽器
            source.Listeners.Add(new TextWriterTraceListener(fileStream));
            var eventTypes = (TraceEventType[])Enum.GetValues(typeof(TraceEventType));
            var eventId = 1;
            foreach (var traceEventType in eventTypes)
            {
                source.TraceEvent(traceEventType, eventId++,$"這是一條{traceEventType}消息");
                //強制把緩沖器的清除
                source.Flush();
            }
        }
    }

 public static class Sample05
    {
        public static void Run()
        {
            const string filename = "log1.csv";
            File.AppendAllText(filename,$"SourceName,EventType,EventId,Message,N/A,ProcessId,N/A,ThreadId,DateTime,{Environment.NewLine}" );//格式是固定的 后面的是換行符

            using var fileStream = new FileStream(filename,FileMode.Append);
            //對跟蹤的信息進行格式化，或者分割，csv的監聽
            var listener = new DelimitedListTraceListener(fileStream)
            {
                Delimiter = ",",
                TraceOutputOptions = TraceOptions.DateTime | TraceOptions.ProcessId | TraceOptions.ThreadId
            };

            var source = new TraceSource("AppTrace", SourceLevels.All);
            source.Listeners.Add(new ConsoleTraceListener());
            source.Listeners.Add(listener);
    
            source.TraceEvent(TraceEventType.Information,1,$"這是一條{TraceEventType.Information}消息");
            source.Flush();


        }
    }

3 診斷日志：

可以使用包Microsoft.Extensions.DiagnosticAdapter

public static class Sample08
    {
        public class Observer<T> : IObserver<T>
        {
            private readonly Action<T> _onNext;

            public Observer(Action<T> onNext)
            {
                _onNext = onNext;
            }

            public void OnCompleted() { }

            public void OnError(Exception error) { }

            public void OnNext(T value)
            {
                _onNext(value);
            }
        }
        /// <summary>
        /// 自定義
        /// </summary>
        public class CustomSourceCollector
        {
            [DiagnosticName("Hello")]
            public void OnHello(int type, string msg)
            {
                Console.WriteLine($"Type:{type}");
                Console.WriteLine($"Msg:{msg}");
            }
        }

        public static void Run()
        {
            DiagnosticListener.AllListeners.Subscribe(new Observer<DiagnosticListener>(listener =>
            {
                if (listener.Name == "AppLog")
                {
                    listener.SubscribeWithAdapter(new CustomSourceCollector());
                }
            }));

            var source = new DiagnosticListener("AppLog");


            source.Write("Hello", new
            {
                Type = 1,
                Msg = "2020年5月11日"
            });


        }
    }

4 統一日志編程模型的框架 (重點)

public class Sample01
    {
        public static void Run()
        {
            var serviceProvider = new ServiceCollection()
                .AddLogging(builder => builder
                    .AddConsole()
                    .AddDebug())
                .BuildServiceProvider();

            //方法1
            var logger1 = serviceProvider.GetRequiredService<ILoggerFactory>()//工廠
                .CreateLogger("ConsoleApp2.Sample01");
            //方法2
            var logger = serviceProvider.GetRequiredService<ILogger<Sample01>>();
            // .CreateLogger("ConsoleApp2.Sample01");

            var leveles = (LogLevel[])Enum.GetValues(typeof(LogLevel));

            var eventId = 1;
            foreach (var level in leveles)
            {
                logger.Log(level, eventId++, $"這是一條{level}消息");
            }

            Console.Read();
        }
    }

 public class Sample02
    {
        public static void Run()
        {
            var serviceProvider = new ServiceCollection()
                .AddLogging(builder =>
                {
                    //跟蹤日志，發布
                    builder.AddTraceSource(
                            new SourceSwitch("Sample02", nameof(SourceLevels.All)),
                            new DefaultTraceListener {LogFileName = "trace.log"});
                    builder.AddConsole();
                    builder.SetMinimumLevel(LogLevel.Trace);//最低等級
                })
                .BuildServiceProvider();
            var logger = serviceProvider.GetRequiredService<ILogger<Sample02>>();

            var leveles = (LogLevel[])Enum.GetValues(typeof(LogLevel));
            var eventId = 1;
            foreach (var level in leveles)
            {
                logger.Log(level, eventId++,$"這是一條{level}消息");
            }

            Console.Read();
        }
    }

  public class Sample03
    {
        public static void Run()
        {
            var serviceProvider = new ServiceCollection()
                .AddLogging(builder => builder
                     //過濾
                    .AddFilter((category, level) =>
                    {
                        return category switch
                        {
                            "LoggerA" => level >= LogLevel.Debug,
                            "LoggerB" => level >= LogLevel.Warning,
                            "LoggerC" => level >= LogLevel.None,
                            _ => level >= LogLevel.Information
                        };
                    })
                    .AddConsole()
                    .AddDebug())
                .BuildServiceProvider();

            var loggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>();
            var loggerA = loggerFactory.CreateLogger("LoggerA");
            var loggerB = loggerFactory.CreateLogger("LoggerB");
            var loggerC = loggerFactory.CreateLogger("LoggerC");

            var leveles = (LogLevel[])Enum.GetValues(typeof(LogLevel));

            var eventId = 1;
            foreach (var level in leveles)
            {
                eventId++;
                loggerA.Log(level, eventId,$"這是一條{level}消息");
                loggerB.Log(level, eventId,$"這是一條{level}消息");
                loggerC.Log(level, eventId,$"這是一條{level}消息");
            }

            Console.Read();
        }
    }

 public class Sample04
    {
        public static void Run()
        {
            var serviceProvider = new ServiceCollection()
                .AddLogging(builder => builder
                      //過濾
                    .AddFilter((provider, category, level) =>
                    {
                        if (provider == typeof(ConsoleLoggerProvider).FullName)
                        {
                            return level >= LogLevel.Debug;
                        }

                        if (provider == typeof(DebugLoggerProvider).FullName)
                        {
                            return level >= LogLevel.Warning;
                        }

                        return level >= LogLevel.Information;
                    })
                    .AddConsole()
                    .AddDebug())
                .BuildServiceProvider();

            var logger = serviceProvider.GetRequiredService<ILogger<Sample04>>();

            var leveles = (LogLevel[])Enum.GetValues(typeof(LogLevel));

            var eventId = 1;
            foreach (var level in leveles)
            {
                logger.Log(level, eventId++,$"這是一條{level}消息");
            }

            Console.Read();
        }
    }

{
  "LogLevel": {
    "Default": "Error",
    "LoggerA": "Debug"
  },
  "Console": {
    "LogLevel": {
      "Default": "Information",
      "LoggerA": "Warning",
      "LoggerB": "Critical"
    } 
  } 
}

 public class Sample05
    {
        public static void Run()
        {
            //通過配置文件夾配置
            var config = new ConfigurationBuilder()
                .AddJsonFile("log.json")
                .Build();

            var serviceProvider = new ServiceCollection()
                .AddLogging(builder => builder
                    .AddConfiguration(config)
                    .AddConsole()
                    .AddDebug())
                .BuildServiceProvider();

            var loggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>();
            var loggerA = loggerFactory.CreateLogger("LoggerA");
            var loggerB = loggerFactory.CreateLogger("LoggerB");
            var loggerC = loggerFactory.CreateLogger("LoggerC");

            var leveles = (LogLevel[])Enum.GetValues(typeof(LogLevel));

            var eventId = 1;
            foreach (var level in leveles)
            {
                eventId++;
                loggerA.Log(level, eventId, $"這是一條{level}消息");
                loggerB.Log(level, eventId, $"這是一條{level}消息");
                loggerC.Log(level, eventId, $"這是一條{level}消息");
            }

            Console.Read();
        }
    }

  public class Sample06
    {
        public static void Run()
        {
            var serviceProvider = new ServiceCollection()
                .AddLogging(builder => builder
                    .SetMinimumLevel(LogLevel.Information)
                    .AddConsole())
                .AddSingleton<GodLog>()
                .BuildServiceProvider();

            var logger = serviceProvider.GetRequiredService<GodLog>();
            logger.Log("Hello");
            Console.Read();
        }

        public class GodLog
        {
            private const string Template = "[{LogTime}]來自{Id}-{Name}的記錄:{Context}";
            private static Action<ILogger, DateTime, int ,string, string, Exception> _logAction;
            private readonly ILogger _logger;

            public GodLog(ILogger<Sample06> logger)
            {
                _logger = logger;
                
                _logAction = LoggerMessage.Define<DateTime, int, string, string>(LogLevel.Information, 1, Template);
            }

            public void Log(string context)
            {
                _logAction(_logger, DateTime.Now, 1, "God", context, null);
            }
        }

        
    }

 public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.ConfigureLogging(builder =>
                        builder.AddConsole(options => options.IncludeScopes = true));//開啟日志上下文

                    webBuilder.UseStartup<Startup>();
                });
    }

public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {

        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILogger<Startup> logger)
        {
            //中間件
            app.Use(async (context, next) =>
            {
                using (logger.BeginScope($"Request Trans {Guid.NewGuid()}"))
                {
                    logger.Log(LogLevel.Information,$"Request Begin at {DateTime.Now}");
                    await next();
                    logger.Log(LogLevel.Information, $"Request End at {DateTime.Now}");
                }
            });

            app.Run(async context =>
            {
                await Task.Delay(1000);
                await context.Response.WriteAsync("Hello");
            });

        }
    }

 public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {

        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILogger<Startup> logger)
        {
            //帶范圍的
            var scopeFactory = LoggerMessage.DefineScope<Guid>("Request Trans {Guid}");
            var requestLog =  LoggerMessage.Define<string, DateTime>(LogLevel.Information, 0, "Request {state} at {DateTime.Now}");

            app.Use(async (context, next) =>
            {
                using (scopeFactory(logger, Guid.NewGuid()))
                {
                    requestLog(logger, "Begin", DateTime.Now, null);
                    await next();
                    requestLog(logger, "End", DateTime.Now, null);
                }
            });

            app.Run(async context =>
            {
                await Task.Delay(1000);
                await context.Response.WriteAsync("Hello");
            });

        }
    }
}

使用NLog 

包 ：NLog  NLog.Web.AspNetCore

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
using NLog.Web;

namespace NLogDemo
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                })
                // 配置使用NLog
                .UseNLog();
    }
}

右鍵添加新建項，然后選擇Web配置文件，命名為nlog.config如下圖所示：

 

 

 nlog.config文件結構如下：

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      autoReload="true"
      throwConfigExceptions="true"
      internalLogLevel="info"
      internalLogFile="E:\log\internal-nlog.txt">
  <!--autoReload：修改后自動加載，可能會有延遲-->
  <!--throwConfigExceptions：NLog日志系統拋出異常-->
  <!--internalLogLevel：內部日志的級別-->
  <!--internalLogFile：內部日志保存路徑，日志的內容大概就是NLog的版本信息，配置文件的地址等等-->
  <!--輸出日志的配置，用於rules讀取-->
  <targets>
    <!--write logs to file-->
    <!--將日志寫入文件中,fileName可以指定日志生成的路徑-->
    <target xsi:type="File" name="allfile" fileName="D:\Log\nlog-all-${shortdate}.log"
             layout="${longdate}|${logger}|${uppercase:${level}}|${message} ${exception}" />
     <!--同樣是將文件寫入日志中，寫入的內容有所差別，差別在layout屬性中體現。寫入日志的數量有差別，差別在路由邏輯中體現-->
    <target xsi:type="File" name="ownFile-web" fileName="D:\Log\nlog-my-${shortdate}.log"
             layout="${longdate}|${logger}|${uppercase:${level}}|${message} ${exception}" />
    <target xsi:type="Null" name="blackhole" />
  </targets>
  <rules>
    <!--路由順序會對日志打印產生影響。路由匹配邏輯為順序匹配。-->
    <!--All logs, including from Microsoft-->
    <logger name="*" minlevel="Trace" writeTo="allfile" />

    <!--Skip Microsoft logs and so log only own logs-->
    <!--以Microsoft打頭的日志將進入此路由，由於此路由沒有writeTo屬性，所有會被忽略-->
    <!--且此路由設置了final，所以當此路由被匹配到時。不會再匹配此路由下面的路由。未匹配到此路由時才會繼續匹配下一個路由-->
    <logger name="Microsoft.*" minlevel="Trace"  final="true" />
    <!--上方已經過濾了所有Microsoft.*的日志，所以此處的日志只會打印除Microsoft.*外的日志-->
    <logger name="*" minlevel="Trace" writeTo="ownFile-web" />
  </rules>
</nlog>

添加完配置文件以后，我們還需要修改配置文件的屬性，設置為始終復制,如下圖所示：

 

 通過上面的步驟，我們已經完成NLog的配置，接下來我們就可以在控制器中使用了，通過構造函數注入的方式實現注入。控制器代碼如下：

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;

namespace NLogDemo.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class NLogTestController : ControllerBase
    {
        private readonly ILogger<NLogTestController> _logger;

        public NLogTestController(ILogger<NLogTestController> logger)
        {
            _logger = logger;
        }

        [HttpGet]
        public IActionResult Get()
        {
            _logger.LogError("這是錯誤信息");
            _logger.LogDebug("這是調試信息");
            _logger.LogInformation("這是提示信息");

            return Ok();
        }
    }
}

運行程序，訪問nlogtest控制器，然后查看是否有日志生成：

 

 其他可參考：https://www.cnblogs.com/dotnet261010/p/13286218.html?utm_source=tuicool