.net core日志系統(tǒng)相關總結

更新時間：2021年06月17日 11:06:01 作者：不問前世

多年的經(jīng)驗，日志記錄是軟件開發(fā)的重要組成部分。沒有日志記錄機制的系統(tǒng)不是完善的系統(tǒng)。在開發(fā)階段可以通過debug附件進程進行交互調試，可以檢測到一些問題，但是在上線之后，日志的記錄起到至關重要的作用。本文講解下日志系統(tǒng)的相關使用

前言

本節(jié)開始整理日志相關的東西。先整理一下日志的基本原理。

正文

首先介紹一下包:

1.Microsoft.Extengsion.Logging.Abstrations

這個是接口包。

2.Microsoft.Extengsion.Logging

這個是實現(xiàn)包

3.Microsoft.Extengsion.Logging.Console

這個是擴展包

代碼如下:

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

配置文件:

{
  "Logging": {
    "LogLevel": {
      "Default": "Debug",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    },
    "Console": {
      "LogLevel": {
        "Default": "Information",
        "Program": "Trace",
        "loggerObj": "Debug"
      }
    }
  }
}

結果:

首先是配置級別的問題,查看loglevel 文件:

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:

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的實例化對象。這個對象就是用來專門做擴展的，是解耦的一種方式。

internal class LoggingBuilder : ILoggingBuilder
{
	public LoggingBuilder(IServiceCollection services)
	{
		Services = services;
	}

	public IServiceCollection Services { get; }
}

這個LoggingBuilder 類基本什么功能都沒有，但是因為有了這樣一個類，就可以作為擴展的標志了。

比如說上文的:

builder.AddConfiguration(config.GetSection("Logging"));
builder.AddConsole();

看下AddConfiguration:

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))

同時給我們注冊監(jiān)聽令牌:builder.Services.AddSingleton<IOptionsChangeTokenSource>(new ConfigurationChangeTokenSource(configuration));

這里給我們注冊配置保存在LoggingConfiguration中：builder.Services.AddSingleton(new LoggingConfiguration(configuration));

因為LoggingConfiguration 保存了，故而我們隨時可以獲取到LoggingConfiguration 的配置。

看下AddConsole:

/// <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 如下:

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

接下來就是調用服務:

var loggerObj = loggerFactory.CreateLogger("Default");

loggerObj.LogInformation(2021, "Default,now that is 2021");

看下LoggerFactory的CreateLogger：

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創(chuàng)建。

查看CreateLoggers:

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:

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，因為我們添加了這個。

[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 配置是支持熱更新的，里面創(chuàng)建了ConsoleLogger，這個ConsoleLogger就是用來打log正在的調用類。

值得注意的是_messageQueue這個，看了打印log還是有一個隊列的，按照先進先出原則。

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

第一層
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時候封裝了：

logger = new Logger
{
       Loggers = CreateLoggers(categoryName),
};

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

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

里面循環(huán)判斷是否當前級別能夠輸出：!loggerInfo.IsEnabled(logLevel)

然后調用對應的具體ILog實現(xiàn)的Log，這里貼一下ConsoleLogger 的實現(xiàn):

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

把這個隊列的也貼一下，比較經(jīng)典吧。

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日志系統(tǒng)相關總結的詳細內容，更多關于.net core日志的資料請關注腳本之家其它相關文章！

您可能感興趣的文章:

.net等比縮放生成縮略圖的方法
本文給大家匯總了2個C#中等比縮放實現(xiàn)生成縮略圖的方法，第一種稍微簡單些，第二種是本人常用的方法，這里推薦給大家，有需要的小伙伴可以參考下。
2015-11-11
Asp.net在ashx文件中處理Session問題解決方法
Asp.net在ashx文件中處理Session問題解決方法，需要的朋友可以參考一下
2013-05-05
.net設計模式之裝飾模式（Decorator）
這篇文章主要為大家詳細介紹了.net設計模式之裝飾模式Decorator，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2018-06-06
GridView多層嵌套和折疊與展開(修改適合自己使用)
這個功能的GridView多層嵌套沒有問題，因為已經(jīng)做了無限次數(shù)，但是折疊與展開的功能，卻花上不少時間(網(wǎng)上找資料)，雖找到資料可參考，還是了解明它，并修改適合自己程序使用,感興趣的朋友可以了解下
2013-01-01
Asp.net 后臺添加CSS、JS、Meta標簽的方法
是從Asp.net 后臺添加CSS、JS、Meta標簽的寫法，我們這里寫成函數(shù)方便以后使用，需要的朋友可以參考下
2013-12-12
ASP.NET mvc異常處理的方法示例介紹
這篇文章主要介紹了ASP.NET mvc異常處理的方法,需要的朋友可以參考下
2014-04-04
.NET中的狀態(tài)機庫Stateless的操作流程
本文給大家介紹了.NET中的狀態(tài)機庫Stateless, 使用它我們可以很容易的定義出自己業(yè)務需要的狀態(tài)機，或者基于狀態(tài)機的工作流，本文大部分的內容都來自官方Github，有興趣的同學可以深入研究一下
2021-12-12
asp.net基于替換模版頁的形式生成靜態(tài)頁的方法
這篇文章主要介紹了asp.net基于替換模版頁的形式生成靜態(tài)頁的方法,涉及asp.net模板的設置、變量替換、配置文件設置與讀取、以及文件夾與靜態(tài)文件的創(chuàng)建等技巧,需要的朋友可以參考下
2016-07-07
asp.net開發(fā)微信公眾平臺之驗證消息的真實性
這篇文章主要介紹了asp.net開發(fā)微信公眾平臺之驗證消息的真實性的相關資料,需要的朋友可以參考下
2015-06-06
asp.net上傳execl文件后,在頁面上加載顯示(示例代碼)
本篇文章主要是對asp.net上傳execl文件后,在頁面上加載顯示(示例代碼)進行了介紹，需要的朋友可以過來參考下，希望對大家有所幫助
2014-02-02