首页 > 编程语言 > .net core日志系统相关总结
2021
09-07

.net core日志系统相关总结

前言

本节开始整理日志相关的东西。先整理一下日志的基本原理。

正文

首先介绍一下包:

1.Microsoft.Extengsion.Logging.Abstrations

这个是接口包。

2.Microsoft.Extengsion.Logging

这个是实现包

3.Microsoft.Extengsion.Logging.Console

这个是扩展包

代码如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
static void Main(string[] args)
{
    IConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
    configurationBuilder.AddJsonFile("appsettings.json",optional:false,reloadOnChange:true);
    var config = configurationBuilder.Build();
 
    IServiceCollection serviceCollection = new ServiceCollection();
    serviceCollection.AddSingleton<IConfiguration>(p=>config);
 
    serviceCollection.AddLogging(builder =>
    {
        builder.AddConfiguration(config.GetSection("Logging"));
        builder.AddConsole();
    });
 
    IServiceProvider service = serviceCollection.BuildServiceProvider();
 
    ILoggerFactory loggerFactory = service.GetService<ILoggerFactory>();
 
    var loggerObj = loggerFactory.CreateLogger("Default");
 
    loggerObj.LogInformation(2021, "Default,now that is 2021");
 
    var loggerObj2 = loggerFactory.CreateLogger("loggerObj");
 
    loggerObj2.LogDebug(2021, "loggerObj,now that is 2021");
 
    Console.ReadKey();
}

配置文件:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
  "Logging": {
    "LogLevel": {
      "Default": "Debug",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    },
    "Console": {
      "LogLevel": {
        "Default": "Information",
        "Program": "Trace",
        "loggerObj": "Debug"
      }
    }
  }
}

结果:

首先是配置级别的问题,查看loglevel 文件:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public enum LogLevel
{
/// <summary>Logs that contain the most detailed messages. These messages may contain sensitive application data.
/// These messages are disabled by default and should never be enabled in a production environment.</summary>
Trace,
/// <summary>Logs that are used for interactive investigation during development.  These logs should primarily contain
/// information useful for debugging and have no long-term value.</summary>
Debug,
/// <summary>Logs that track the general flow of the application. These logs should have long-term value.</summary>
Information,
/// <summary>Logs that highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the
/// application execution to stop.</summary>
Warning,
/// <summary>Logs that highlight when the current flow of execution is stopped due to a failure. These should indicate a
/// failure in the current activity, not an application-wide failure.</summary>
Error,
/// <summary>Logs that describe an unrecoverable application or system crash, or a catastrophic failure that requires
/// immediate attention.</summary>
Critical,
/// <summary>Not used for writing log messages. Specifies that a logging category should not write any messages.</summary>
None,
}

从上之下，依次提高log级别。

比如说设置了log 级别是Error，那么Debug、Information、Warning 都不会被答应出来。

那么就来分析一下代码吧。

AddLogging:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static IServiceCollection AddLogging(this IServiceCollection services, Action<ILoggingBuilder> configure)
{
    if (services == null)
    {
        throw new ArgumentNullException(nameof(services));
    }
 
    services.AddOptions();
 
    services.TryAdd(ServiceDescriptor.Singleton<ILoggerFactory, LoggerFactory>());
    services.TryAdd(ServiceDescriptor.Singleton(typeof(ILogger<>), typeof(Logger<>)));
 
    services.TryAddEnumerable(ServiceDescriptor.Singleton<IConfigureOptions<LoggerFilterOptions>>(
        new DefaultLoggerLevelConfigureOptions(LogLevel.Information)));
 
    configure(new LoggingBuilder(services));
    return services;
}

这里面给注册了ILoggerFactory和ILogger。然后设置了一个打印log的级别配置，LogLevel.Information，这个就是如果我们没有配置文件默认就是Information这种级别了。

configure(new LoggingBuilder(services)) 给我们的委托提供了一个LoggingBuilder的实例化对象。这个对象就是用来专门做扩展的，是解耦的一种方式。

?
1
2
3
4
5
6
7
8
9
internal class LoggingBuilder : ILoggingBuilder
{
    public LoggingBuilder(IServiceCollection services)
    {
        Services = services;
    }
 
    public IServiceCollection Services { get; }
}

这个LoggingBuilder 类基本什么功能都没有，但是因为有了这样一个类，就可以作为扩展的标志了。

比如说上文的:

?
1
2
builder.AddConfiguration(config.GetSection("Logging"));
builder.AddConsole();

看下AddConfiguration:

?
1
2
3
4
5
6
7
8
9
10
11
public static ILoggingBuilder AddConfiguration(this ILoggingBuilder builder, IConfiguration configuration)
{
    builder.AddConfiguration();
 
    builder.Services.AddSingleton<IConfigureOptions<LoggerFilterOptions>>(new LoggerFilterConfigureOptions(configuration));
    builder.Services.AddSingleton<IOptionsChangeTokenSource<LoggerFilterOptions>>(new ConfigurationChangeTokenSource<LoggerFilterOptions>(configuration));
 
    builder.Services.AddSingleton(new LoggingConfiguration(configuration));
 
    return builder;
}

这里面给我们注入了配置文件的配置:builder.Services.AddSingleton<IConfigureOptions>(new LoggerFilterConfigureOptions(configuration))

同时给我们注册监听令牌:builder.Services.AddSingleton<IOptionsChangeTokenSource>(new ConfigurationChangeTokenSource(configuration));

这里给我们注册配置保存在LoggingConfiguration中：builder.Services.AddSingleton(new LoggingConfiguration(configuration));

因为LoggingConfiguration 保存了，故而我们随时可以获取到LoggingConfiguration 的配置。

看下AddConsole:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/// <param name="builder">The <see cref="ILoggingBuilder"/> to use.</param>
public static ILoggingBuilder AddConsole(this ILoggingBuilder builder)
{
    builder.AddConfiguration();
 
    builder.AddConsoleFormatter<JsonConsoleFormatter, JsonConsoleFormatterOptions>();
    builder.AddConsoleFormatter<SystemdConsoleFormatter, ConsoleFormatterOptions>();
    builder.AddConsoleFormatter<SimpleConsoleFormatter, SimpleConsoleFormatterOptions>();
 
    builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<ILoggerProvider, ConsoleLoggerProvider>());
    LoggerProviderOptions.RegisterProviderOptions<ConsoleLoggerOptions, ConsoleLoggerProvider>(builder.Services);
 
    return builder;
}

builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<ILoggerProvider, ConsoleLoggerProvider>()) 里面给我们ILoggerProvider 增加了一个ConsoleLoggerProvider，故而我们多了一个打印的功能。

LoggerProviderOptions.RegisterProviderOptions<ConsoleLoggerOptions, ConsoleLoggerProvider>(builder.Services) 给我们加上了ConsoleLoggerOptions 绑定为ConsoleLoggerProvider的配置。

RegisterProviderOptions 如下:

?
1
2
3
4
5
public static void RegisterProviderOptions<TOptions, TProvider>(IServiceCollection services) where TOptions : class
{
    services.TryAddEnumerable(ServiceDescriptor.Singleton<IConfigureOptions<TOptions>, LoggerProviderConfigureOptions<TOptions, TProvider>>());
    services.TryAddEnumerable(ServiceDescriptor.Singleton<IOptionsChangeTokenSource<TOptions>, LoggerProviderOptionsChangeTokenSource<TOptions, TProvider>>());
}

接下来就是调用服务:

?
1
2
3
var loggerObj = loggerFactory.CreateLogger("Default");
 
loggerObj.LogInformation(2021, "Default,now that is 2021");

看下LoggerFactory的CreateLogger：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public ILogger CreateLogger(string categoryName)
{
    if (CheckDisposed())
    {
        throw new ObjectDisposedException(nameof(LoggerFactory));
    }
 
    lock (_sync)
    {
        if (!_loggers.TryGetValue(categoryName, out Logger logger))
        {
            logger = new Logger
            {
                Loggers = CreateLoggers(categoryName),
            };
 
            (logger.MessageLoggers, logger.ScopeLoggers) = ApplyFilters(logger.Loggers);
 
            _loggers[categoryName] = logger;
        }
 
        return logger;
    }
}

里面做了缓存，如果categoryName有缓存的话直接使用缓存，如果没有那么调用CreateLoggers创建。

查看CreateLoggers:

?
1
2
3
4
5
6
7
8
9
private LoggerInformation[] CreateLoggers(string categoryName)
{
    var loggers = new LoggerInformation[_providerRegistrations.Count];
    for (int i = 0; i < _providerRegistrations.Count; i++)
    {
        loggers[i] = new LoggerInformation(_providerRegistrations[i].Provider, categoryName);
    }
    return loggers;
}

这里面就用我们前面注册过的全部logger的provider，封装进LoggerInformation。

查看LoggerInformation:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
internal readonly struct LoggerInformation
{
    public LoggerInformation(ILoggerProvider provider, string category) : this()
    {
        ProviderType = provider.GetType();
        Logger = provider.CreateLogger(category);
        Category = category;
        ExternalScope = provider is ISupportExternalScope;
    }
 
    public ILogger Logger { get; }
 
    public string Category { get; }
 
    public Type ProviderType { get; }
 
    public bool ExternalScope { get; }
}

里面调用了我们，每个provider的CreateLogger。

那么这个时候我们就找一个provider 看下CreateLogger到底做了什么，这里就找一下ConsoleLoggerProvider，因为我们添加了这个。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
[ProviderAlias("Console")]
 public class ConsoleLoggerProvider : ILoggerProvider, ISupportExternalScope
{
        private readonly IOptionsMonitor<ConsoleLoggerOptions> _options;
        public ILogger CreateLogger(string name)
        {
            if (_options.CurrentValue.FormatterName == null || !_formatters.TryGetValue(_options.CurrentValue.FormatterName, out ConsoleFormatter logFormatter))
            {
#pragma warning disable CS0618
                logFormatter = _options.CurrentValue.Format switch
                {
                    ConsoleLoggerFormat.Systemd => _formatters[ConsoleFormatterNames.Systemd],
                    _ => _formatters[ConsoleFormatterNames.Simple],
                };
                if (_options.CurrentValue.FormatterName == null)
                {
                    UpdateFormatterOptions(logFormatter, _options.CurrentValue);
                }
#pragma warning disable CS0618
            }
 
            return _loggers.GetOrAdd(name, loggerName => new ConsoleLogger(name, _messageQueue)
            {
                Options = _options.CurrentValue,
                ScopeProvider = _scopeProvider,
                Formatter = logFormatter,
            });
        }
}

看到这个IOptionsMonitor，就知道console 配置是支持热更新的，里面创建了ConsoleLogger，这个ConsoleLogger就是用来打log正在的调用类。

值得注意的是_messageQueue这个，看了打印log还是有一个队列的，按照先进先出原则。

那么最后来看一下loggerObj.LogInformation(2021, "Default,now that is 2021");:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
第一层
public static void LogInformation(this ILogger logger, EventId eventId, string message, params object[] args)
{
    logger.Log(LogLevel.Information, eventId, message, args);
}
第二层
public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, string message, params object[] args)
{
         logger.Log(logLevel, eventId, null, message, args);
}
第三层
public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, Exception exception, string message, params object[] args)
{
    if (logger == null)
    {
        throw new ArgumentNullException(nameof(logger));
    }
 
    logger.Log(logLevel, eventId, new FormattedLogValues(message, args), exception, _messageFormatter);
}

那么这个logger.Log 是调用具体某个logger，像consoleLogger 吗？ 不是，我们看LoggerFactory的CreateLogger时候封装了：

?
1
2
3
4
logger = new Logger
{
       Loggers = CreateLoggers(categoryName),
};

那么看下Logger的Log到底干了什么。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
internal class Logger : ILogger
{
    public LoggerInformation[] Loggers { get; set; }
    public MessageLogger[] MessageLoggers { get; set; }
    public ScopeLogger[] ScopeLoggers { get; set; }
 
    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
    {
        MessageLogger[] loggers = MessageLoggers;
        if (loggers == null)
        {
            return;
        }
 
        List<Exception> exceptions = null;
        for (int i = 0; i < loggers.Length; i++)
        {
            ref readonly MessageLogger loggerInfo = ref loggers[i];
            if (!loggerInfo.IsEnabled(logLevel))
            {
                continue;
            }
 
            LoggerLog(logLevel, eventId, loggerInfo.Logger, exception, formatter, ref exceptions, state);
        }
 
        if (exceptions != null && exceptions.Count > 0)
        {
            ThrowLoggingError(exceptions);
        }
 
        static void LoggerLog(LogLevel logLevel, EventId eventId, ILogger logger, Exception exception, Func<TState, Exception, string> formatter, ref List<Exception> exceptions, in TState state)
        {
            try
            {
                logger.Log(logLevel, eventId, state, exception, formatter);
            }
            catch (Exception ex)
            {
                if (exceptions == null)
                {
                    exceptions = new List<Exception>();
                }
 
                exceptions.Add(ex);
            }
        }
    }
}

里面循环判断是否当前级别能够输出：!loggerInfo.IsEnabled(logLevel)

然后调用对应的具体ILog实现的Log，这里贴一下ConsoleLogger 的实现:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
[ThreadStatic]
private static StringWriter t_stringWriter;
 
public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
{
    if (!IsEnabled(logLevel))
    {
        return;
    }
    if (formatter == null)
    {
        throw new ArgumentNullException(nameof(formatter));
    }
    t_stringWriter ??= new StringWriter();
    LogEntry<TState> logEntry = new LogEntry<TState>(logLevel, _name, eventId, state, exception, formatter);
    Formatter.Write(in logEntry, ScopeProvider, t_stringWriter);
 
    var sb = t_stringWriter.GetStringBuilder();
    if (sb.Length == 0)
    {
        return;
    }
    string computedAnsiString = sb.ToString();
    sb.Clear();
    if (sb.Capacity > 1024)
    {
        sb.Capacity = 1024;
    }
    _queueProcessor.EnqueueMessage(new LogMessageEntry(computedAnsiString, logAsError: logLevel >= Options.LogToStandardErrorThreshold));
}

把这个队列的也贴一下，比较经典吧。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
internal class ConsoleLoggerProcessor : IDisposable
{
    private const int _maxQueuedMessages = 1024;
 
    private readonly BlockingCollection<LogMessageEntry> _messageQueue = new BlockingCollection<LogMessageEntry>(_maxQueuedMessages);
    private readonly Thread _outputThread;
 
    public IConsole Console;
    public IConsole ErrorConsole;
 
    public ConsoleLoggerProcessor()
    {
        // Start Console message queue processor
        _outputThread = new Thread(ProcessLogQueue)
        {
            IsBackground = true,
            Name = "Console logger queue processing thread"
        };
        _outputThread.Start();
    }
 
    public virtual void EnqueueMessage(LogMessageEntry message)
    {
        if (!_messageQueue.IsAddingCompleted)
        {
            try
            {
                _messageQueue.Add(message);
                return;
            }
            catch (InvalidOperationException) { }
        }
 
        // Adding is completed so just log the message
        try
        {
            WriteMessage(message);
        }
        catch (Exception) { }
    }
 
    // for testing
    internal virtual void WriteMessage(LogMessageEntry entry)
    {
        IConsole console = entry.LogAsError ? ErrorConsole : Console;
        console.Write(entry.Message);
    }
 
    private void ProcessLogQueue()
    {
        try
        {
            foreach (LogMessageEntry message in _messageQueue.GetConsumingEnumerable())
            {
                WriteMessage(message);
            }
        }
        catch
        {
            try
            {
                _messageQueue.CompleteAdding();
            }
            catch { }
        }
    }
 
    public void Dispose()
    {
        _messageQueue.CompleteAdding();
 
        try
        {
            _outputThread.Join(1500); // with timeout in-case Console is locked by user input
        }
        catch (ThreadStateException) { }
    }
}

以上就是.net core日志系统相关总结的详细内容，更多关于.net core日志的资料请关注自学编程网其它相关文章！

编程技巧