.Net?Core日志記錄器實(shí)例分析

這篇“.Net Core日志記錄器實(shí)例分析”文章的知識(shí)點(diǎn)大部分人都不太理解，所以小編給大家總結(jié)了以下內(nèi)容，內(nèi)容詳細(xì)，步驟清晰，具有一定的借鑒價(jià)值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“.Net Core日志記錄器實(shí)例分析”文章吧。

日志記錄器工廠

1 ILoggerFactory 接口

public interface ILoggerFactory : IDisposable
{
    ILogger CreateLogger(string categoryName);

    void AddProvider(ILoggerProvider provider);
}

ILoggerFactory是日志記錄器的工廠接口類，用于配置日志記錄系統(tǒng)并創(chuàng)建Logger實(shí)例的類，默認(rèn)實(shí)現(xiàn)兩個(gè)接口方法為，通過CreateLogger()方法來創(chuàng)建ILogger實(shí)例，（其中參數(shù)categoryName是一個(gè)日志類別，用于調(diào)用Logger所在類的全名，類別指明日志消息是誰寫入的，一般我們將日志所屬的的組件、服務(wù)或者消息類型名稱作為日志類別。） 而AddProvider()添加日志記錄提供程序，向日志系統(tǒng)注冊(cè)添加一個(gè)ILoggerProvider。工廠接口類的默認(rèn)實(shí)現(xiàn)類為LoggerFactory , 我們繼續(xù)往下看：

2 LoggerFactory 實(shí)現(xiàn)

ILoggerFactory 的默認(rèn)實(shí)現(xiàn)是 LoggerFactory ,在構(gòu)造函數(shù)中，如下：

    public class LoggerFactory : ILoggerFactory
    {
        private static readonly LoggerRuleSelector RuleSelector = new LoggerRuleSelector();

        private readonly Dictionary<string, Logger> _loggers = new Dictionary<string, Logger>(StringComparer.Ordinal);
        
        private readonly List<ProviderRegistration> _providerRegistrations = new List<ProviderRegistration>();
        
        private readonly object _sync = new object();
        
        private volatile bool _disposed;
        
        private IDisposable _changeTokenRegistration;
        
        private LoggerFilterOptions _filterOptions;
        
        private LoggerExternalScopeProvider _scopeProvider;
        
        public LoggerFactory() : this(Enumerable.Empty<ILoggerProvider>())
        {
        }
        
        public LoggerFactory(IEnumerable<ILoggerProvider> providers) : this(providers, new StaticFilterOptionsMonitor(new LoggerFilterOptions()))
        {
        }
        
        public LoggerFactory(IEnumerable<ILoggerProvider> providers, LoggerFilterOptions filterOptions) : this(providers, new StaticFilterOptionsMonitor(filterOptions))
        {
        }
        
        public LoggerFactory(IEnumerable<ILoggerProvider> providers, IOptionsMonitor<LoggerFilterOptions> filterOption)
        {
            foreach (var provider in providers)
            {
                AddProviderRegistration(provider, dispose: false);
            }

            _changeTokenRegistration = filterOption.OnChange(RefreshFilters);
            RefreshFilters(filterOption.CurrentValue);
        }
        
        private void AddProviderRegistration(ILoggerProvider provider, bool dispose)
        {
            _providerRegistrations.Add(new ProviderRegistration
            {
                Provider = provider,
                ShouldDispose = dispose
            });

            if (provider is ISupportExternalScope supportsExternalScope)
            {
                if (_scopeProvider == null)
                {
                    _scopeProvider = new LoggerExternalScopeProvider();
                }

                supportsExternalScope.SetScopeProvider(_scopeProvider);
            }
        }
    }

從LoggerFactory 中 的構(gòu)造函數(shù)中可以發(fā)現(xiàn)，通過注入的方式獲取到ILoggerProvider（這個(gè)在下文中會(huì)說明），并調(diào)用AddProviderRegistration方法添加注冊(cè)程序，將ILoggerProvider保存到ProviderRegistration集合中。

AddProviderRegistration 方法：

這是一個(gè)日志程序提供器，將ILoggerProvider保存到ProviderRegistration集合中。當(dāng)日志提供器實(shí)現(xiàn) ISupportExternalScope 接口將單例 LoggerExternalScopeProvider 保存到 provider._scopeProvider 中。

ProviderRegistration集合:

private struct ProviderRegistration
{
   public ILoggerProvider Provider;
   public bool ShouldDispose;
}

其中的 ShouldDispose 字段標(biāo)識(shí)在在LoggerFactory生命周期結(jié)束之后，該ILoggerProvider是否需要釋放。雖然在系統(tǒng)中LoggerFactory為單例模式，但是其提供了一個(gè)靜態(tài)方法生成一個(gè)可釋放的DisposingLoggerFactory。

在LoggerFactory 實(shí)現(xiàn)默認(rèn)的接口方法CreateLogger(),AddProvider()

查看源碼如下：

CreateLogger

創(chuàng)建ILogger實(shí)例，CreateLogger() 源碼如下：

    public class LoggerFactory : ILoggerFactory
    { 
        private readonly Dictionary<string, Logger> _loggers = new Dictionary<string, Logger>(StringComparer.Ordinal);
        
         private readonly List<ProviderRegistration> _providerRegistrations = new List<ProviderRegistration>();
        
        private struct ProviderRegistration
        {
            public ILoggerProvider Provider;
            public bool ShouldDispose;
        }
        
        public ILogger CreateLogger(string categoryName)
        {
            if (CheckDisposed())
            {
                throw new ObjectDisposedException(nameof(LoggerFactory));
            }
            lock (_sync)
            {
                if (!_loggers.TryGetValue(categoryName, out var logger))
                {
                    logger = new Logger
                    {
                        Loggers = CreateLoggers(categoryName),
                    };
                    (logger.MessageLoggers, logger.ScopeLoggers) = ApplyFilters(logger.Loggers);

                    _loggers[categoryName] = logger;
                }
                return logger;
            }
        }
        
        private LoggerInformation[] CreateLoggers(string categoryName)
        {
            var loggers = new LoggerInformation[_providerRegistrations.Count];
            for (var i = 0; i < _providerRegistrations.Count; i++)
            {
                loggers[i] = new LoggerInformation(_providerRegistrations[i].Provider, categoryName);
            }
            return loggers;
        }
    }

從源碼可以看出，CreateLogger方法中，會(huì)檢測(cè)資源是否被釋放，在方法中，根據(jù)內(nèi)部定義的字典集合Dictionary<string, Logger> _loggers,判斷字典中是否存在對(duì)應(yīng)的Logger屬性對(duì)象，如果不存在，會(huì)調(diào)用CreateLoggers方法根據(jù)之前注冊(cè)的的所有ILoggerProvider 所創(chuàng)建出來 ProviderRegistration 集合來實(shí)現(xiàn)創(chuàng)建Logger屬性集合（根據(jù)日志類別生成了對(duì)應(yīng)實(shí)際的日志寫入類FileLogger、ConsoleLogger等），并通過字典集合的方式保存categoryName和對(duì)應(yīng)的Logger。

創(chuàng)建 Logger 需要的 LoggerInformation[]

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; }
}

根據(jù)注冊(cè)的ILoggerProvider，創(chuàng)建ILogger 其中的字段說明：

Logger ：具體日志類別寫入途徑實(shí)現(xiàn)類

Category ： 日志類別名稱

ProviderType ： 日志提供器Type

ExternalScope ：是否支持 ExternalScope

繼續(xù)看CreateLogger方法，在創(chuàng)建Logger之后，還調(diào)用了ApplyFilters方法：

        private (MessageLogger[] MessageLoggers, ScopeLogger[] ScopeLoggers) ApplyFilters(LoggerInformation[] loggers)
        {
            var messageLoggers = new List<MessageLogger>();
            var scopeLoggers = _filterOptions.CaptureScopes ? new List<ScopeLogger>() : null;

            foreach (var loggerInformation in loggers)
            {
                RuleSelector.Select(_filterOptions,
                    loggerInformation.ProviderType,
                    loggerInformation.Category,
                    out var minLevel,
                    out var filter);

                if (minLevel != null && minLevel > LogLevel.Critical)
                {
                    continue;
                }

                messageLoggers.Add(new MessageLogger(loggerInformation.Logger, loggerInformation.Category, loggerInformation.ProviderType.FullName, minLevel, filter));

                if (!loggerInformation.ExternalScope)
                {
                    scopeLoggers?.Add(new ScopeLogger(logger: loggerInformation.Logger, externalScopeProvider: null));
                }
            }

            if (_scopeProvider != null)
            {
                scopeLoggers?.Add(new ScopeLogger(logger: null, externalScopeProvider: _scopeProvider));
            }

            return (messageLoggers.ToArray(), scopeLoggers?.ToArray());
        }

由源碼可以看出，

MessageLogger[] 集合取值：

在獲取LoggerInformation[]后進(jìn)行傳參，進(jìn)行遍歷，根據(jù)RuleSelector過濾器，從配置文件中讀取對(duì)應(yīng)的日志級(jí)別，過濾器會(huì)返回獲取最低級(jí)別和對(duì)應(yīng)的一條過濾規(guī)則，如果配置文件中沒有對(duì)應(yīng)的配置，默認(rèn)取全局最低級(jí)別（MinLevel）,如果讀取到的日志級(jí)別大于LogLevel.Critical,則將其加入MessageLogger[]。

過濾器的規(guī)則：

選擇當(dāng)前記錄器類型的規(guī)則，如果沒有，請(qǐng)選擇未指定記錄器類型的規(guī)則

選擇最長匹配類別的規(guī)則

如果沒有與類別匹配的內(nèi)容，則采用所有沒有類別的規(guī)則

如果只有一條規(guī)則，則使用它的級(jí)別和過濾器

如果有多個(gè)規(guī)則，請(qǐng)選擇使用最后一條。

如果沒有適用的規(guī)則，請(qǐng)使用全局最低級(jí)別

通過MessageLogger[]添加消息日志集合

internal readonly struct MessageLogger
{
    public MessageLogger(ILogger logger, string category, string providerTypeFullName, LogLevel? minLevel, Func<string, string, LogLevel, bool> filter)
    {
        Logger = logger;
        Category = category;
        ProviderTypeFullName = providerTypeFullName;
        MinLevel = minLevel;
        Filter = filter;
    }

    public ILogger Logger { get; }

    public string Category { get; }

    private string ProviderTypeFullName { get; }

    public LogLevel? MinLevel { get; }

    public Func<string, string, LogLevel, bool> Filter { get; }

    public bool IsEnabled(LogLevel level)
    {
        if (MinLevel != null && level < MinLevel)
        {
            return false;
        }

        if (Filter != null)
        {
            return Filter(ProviderTypeFullName, Category, level);
        }

        return true;
    }
}

internal readonly struct ScopeLogger
{
    public ScopeLogger(ILogger logger, IExternalScopeProvider externalScopeProvider)
    {
        Logger = logger;
        ExternalScopeProvider = externalScopeProvider;
    }

    public ILogger Logger { get; }

    public IExternalScopeProvider ExternalScopeProvider { get; }

    public IDisposable CreateScope<TState>(TState state)
    {
        if (ExternalScopeProvider != null)
        {
            return ExternalScopeProvider.Push(state);
        }
        return Logger.BeginScope<TState>(state);
    }
}

在MessageLogger[]中帶有MinLevel屬性和Filter委托兩種過濾配置，而這兩種配置的來源，在上一章中可以看到，分別是從配置文件（AddConfiguration）和直接使用委托（AddFilter）來進(jìn)行配置的。

再由上面的IsEnabled方法可以看出，會(huì)先使用 MinLevel 過濾，再使用 Filter 進(jìn)行過濾。所以這兩者存在優(yōu)先級(jí)。

ScopeLogger[ ] 取值 :

如果 ILoggerProvider實(shí)現(xiàn)了ISupportExternalScope接口，那么使用LoggerExternalScopeProvider作為Scope功能的實(shí)現(xiàn)。反之，使用ILogger作為其Scope功能的實(shí)現(xiàn)。

LoggerExternalScopeProvider ：

• 通過 Scope 組成了一個(gè)單向鏈表，每次 beginscope 向鏈表末端增加一個(gè)新的元素，Dispose的時(shí)候，刪除鏈表最末端的元素。我們知道LoggerExternalScopeProvider 在系統(tǒng)中是單例模式，多個(gè)請(qǐng)求進(jìn)來，加入線程池處理。通過使用AsyncLoca來實(shí)現(xiàn)不同線程間數(shù)據(jù)獨(dú)立。

• 有兩個(gè)地方開啟了日志作用域：

• 1、通過socket監(jiān)聽到請(qǐng)求后，將KestrelConnection加入線程池，線程池調(diào)度執(zhí)行IThreadPoolWorkItem.Execute()方法。在這里開啟了一次

• 2、在構(gòu)建請(qǐng)求上下文對(duì)象的時(shí)候(HostingApplication.CreateContext())，開啟了一次

由上源碼可以得出：在工廠記錄器類中，通過系統(tǒng)依賴注入的方式解析所有注冊(cè)的ILoggerProvider，然后調(diào)用其中的CreateLogger方法實(shí)現(xiàn)創(chuàng)建一個(gè)Logger實(shí)例對(duì)象，而這個(gè)Logger實(shí)例對(duì)象會(huì)根據(jù)根據(jù)注冊(cè)的ILoggerProvider創(chuàng)建需要的 LoggerInformation[]，并將此對(duì)象作為參數(shù)進(jìn)行ApplyFilters過濾器篩選,得到對(duì)應(yīng)的最低等級(jí)或過濾規(guī)則，最后通過調(diào)用Log方法日志記錄的時(shí)候，會(huì)遍歷MessageLogger[]集合，根據(jù)logger日志類別對(duì)應(yīng)實(shí)際不同的日志寫入類，調(diào)用ILoggerProvider具體實(shí)現(xiàn)類 (可以看下文說明) 中的Log方法。

AddProviderRegistration→CreateLoggers→LoggerInformation[]→ApplyFilters→MessageLogger[]→Log→ILoggerProvider ( 執(zhí)行具體類中的Log方法 )

ILoggerFactory 來源：

應(yīng)用程序在啟動(dòng)初始化的時(shí)候會(huì)通過注入的方式CreateDefaultBuilder→ConfigureLogging→AddLogging

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;
}

實(shí)現(xiàn)將把ILoggerFactory對(duì)象以依賴注入的方式托管到集合容器中，為程序調(diào)用提供使用。

日志記錄提供器

1 ILoggerProvider 接口

創(chuàng)建ILogger實(shí)例的類型，根據(jù)日志類別名稱創(chuàng)建一個(gè)新的ILogger實(shí)例

public interface ILoggerProvider : IDisposable
{
    ILogger CreateLogger(string categoryName);
}

這個(gè)是具體的日志寫入類，在工廠記錄器中我們已經(jīng)提到了這個(gè)，在LoggerInformation[]中會(huì)根據(jù)日志類別注冊(cè)對(duì)應(yīng)的ILoggerProvider，在系統(tǒng)中我們就可以通過ILogger同時(shí)向多個(gè)途經(jīng)寫入日志信息。（這也是對(duì)上一篇中留下的問題進(jìn)行再次說明）

ILoogerProvider繼承了IDisposable接口，如果某個(gè)具體的ILoggerProvider對(duì)象需要釋放資源，就可以將相關(guān)的操作實(shí)現(xiàn)在Dispose方法中。

默認(rèn)的實(shí)現(xiàn)方式為多個(gè)，官方實(shí)現(xiàn)的由ConsoleLoggerProvider 、DebugLoggerProvider 、EventSourceLoggerProvider、EventLogLoggerProvider 、TraceSourceLoggerProvider

以ConsoleLoggerProvider為列

    [ProviderAlias("Console")]
    public class ConsoleLoggerProvider : ILoggerProvider, ISupportExternalScope
    {
        private readonly IOptionsMonitor<ConsoleLoggerOptions> _options;
        private readonly ConcurrentDictionary<string, ConsoleLogger> _loggers;
        private readonly ConsoleLoggerProcessor _messageQueue;

        private IDisposable _optionsReloadToken;
        private IExternalScopeProvider _scopeProvider = NullExternalScopeProvider.Instance;
 
        public ConsoleLoggerProvider(IOptionsMonitor<ConsoleLoggerOptions> options)
        {
            _options = options;
            _loggers = new ConcurrentDictionary<string, ConsoleLogger>();

            ReloadLoggerOptions(options.CurrentValue);
            _optionsReloadToken = _options.OnChange(ReloadLoggerOptions);

            _messageQueue = new ConsoleLoggerProcessor();
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                _messageQueue.Console = new WindowsLogConsole();
                _messageQueue.ErrorConsole = new WindowsLogConsole(stdErr: true);
            }
            else
            {
                _messageQueue.Console = new AnsiLogConsole(new AnsiSystemConsole());
                _messageQueue.ErrorConsole = new AnsiLogConsole(new AnsiSystemConsole(stdErr: true));
            }
        }
        private void ReloadLoggerOptions(ConsoleLoggerOptions options)
        {
            foreach (var logger in _loggers)
            {
                logger.Value.Options = options;
            }
        }
        public ILogger CreateLogger(string name)
        {
            return _loggers.GetOrAdd(name, loggerName => new ConsoleLogger(name, _messageQueue)
            {
                Options = _options.CurrentValue,
                ScopeProvider = _scopeProvider
            });
        } 
        public void Dispose()
        {
            _optionsReloadToken?.Dispose();
            _messageQueue.Dispose();
        }
 
        public void SetScopeProvider(IExternalScopeProvider scopeProvider)
        {
            _scopeProvider = scopeProvider;

            foreach (var logger in _loggers)
            {
                logger.Value.ScopeProvider = _scopeProvider;
            }

        }
    }

在ConsoleLoggerProvider類型定義中，標(biāo)注了ProviderAliasAttribute特性，并設(shè)置別名為Console,所以在配置過濾規(guī)則的時(shí)候，可以直接使用這個(gè)名稱。ILogger的創(chuàng)建實(shí)現(xiàn)了具體日志類ConsoleLogger。 

日志記錄器

1 ILogger 接口

表示用于執(zhí)行日志記錄的類型，是系統(tǒng)中寫入日志的統(tǒng)一入口。

public interface ILogger
{ 
    void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter); 
    
    bool IsEnabled(LogLevel logLevel); 
    
    IDisposable BeginScope<TState>(TState state);
}

定義了三個(gè)方法，Log<TState>() 用于寫入日志，IsEnabled()用于檢查判斷日志級(jí)別是否開啟，BeginScope() 用于指日志作用域。

2 Logger 實(shí)現(xiàn)

ILogger執(zhí)行記錄接口類的具體實(shí)現(xiàn)Logger如下：

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)
    {
        var loggers = MessageLoggers;
        if (loggers == null)
        {
            return;
        }

        List<Exception> exceptions = null;
        for (var i = 0; i < loggers.Length; i++)
        {
            ref readonly var 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);
            }
        }
    }
    public bool IsEnabled(LogLevel logLevel)
    {
        var loggers = MessageLoggers;
        if (loggers == null)
        {
            return false;
        }

        List<Exception> exceptions = null;
        var i = 0;
        for (; i < loggers.Length; i++)
        {
            ref readonly var loggerInfo = ref loggers[i];
            if (!loggerInfo.IsEnabled(logLevel))
            {
                continue;
            }

            if (LoggerIsEnabled(logLevel, loggerInfo.Logger, ref exceptions))
            {
                break;
            }
        }

        if (exceptions != null && exceptions.Count > 0)
        {
            ThrowLoggingError(exceptions);
        }

        return i < loggers.Length ? true : false;

        static bool LoggerIsEnabled(LogLevel logLevel, ILogger logger, ref List<Exception> exceptions)
        {
            try
            {
                if (logger.IsEnabled(logLevel))
                {
                    return true;
                }
            }
            catch (Exception ex)
            {
                if (exceptions == null)
                {
                    exceptions = new List<Exception>();
                }

                exceptions.Add(ex);
            }

            return false;
        }
    }
}

源碼中MessageLogger[]在上文已經(jīng)提到了，其中保存了在配置中啟用的那些對(duì)應(yīng)的ILogger。

需要注意的是，由于配置文件更改后，會(huì)調(diào)用ApplyFilters()方法，并為MessageLogger[]賦新值，所以在遍歷之前，需要保存當(dāng)前值，再進(jìn)行處理。否則會(huì)出現(xiàn)修改異常。

在系統(tǒng)中統(tǒng)一寫入日志的入口，通過日志等級(jí)作為參數(shù)調(diào)用其IsEnabled方法來確定當(dāng)前日志是否執(zhí)行對(duì)應(yīng)具體日志的實(shí)現(xiàn)類，當(dāng)符合條件執(zhí)行具體日志輸出到對(duì)應(yīng)的寫入途徑中會(huì)調(diào)用對(duì)應(yīng)的Log方法（需要提供一個(gè)EventId來標(biāo)識(shí)當(dāng)前日志事件）

ILogger默認(rèn)的實(shí)現(xiàn)方式為多個(gè)，官方實(shí)現(xiàn)的由ConsoleLogger 、DebugLogger 、EventSourceLogger、EventLogLogger、TraceSourceLogger具體日志實(shí)現(xiàn)類代表不同的日志寫入途徑。

以上就是關(guān)于“.Net Core日志記錄器實(shí)例分析”這篇文章的內(nèi)容，相信大家都有了一定的了解，希望小編分享的內(nèi)容對(duì)大家有幫助，若想了解更多相關(guān)的知識(shí)內(nèi)容，請(qǐng)關(guān)注億速云行業(yè)資訊頻道。