protected virtual LogFileInfo CreateLogFile(ILogFileSettings fileSettings, IFileLoggerSettings settings)
{
LogFileInfo logFile = CreateLogFile();
logFile.BasePath = settings.BasePath ?? string.Empty;
logFile.PathFormat = fileSettings.Path;
logFile.FileAppender = settings.FileAppender ?? _fallbackFileAppender.Value;
logFile.AccessMode = fileSettings.FileAccessMode ?? settings.FileAccessMode ?? LogFileAccessMode.Default;
logFile.Encoding = fileSettings.FileEncoding ?? settings.FileEncoding ?? Encoding.UTF8;
logFile.DateFormat = fileSettings.DateFormat ?? settings.DateFormat ?? "yyyyMMdd";
logFile.CounterFormat = fileSettings.CounterFormat ?? settings.CounterFormat;
logFile.MaxSize = fileSettings.MaxFileSize ?? settings.MaxFileSize ?? 0;
var maxQueueSize = fileSettings.MaxQueueSize ?? settings.MaxQueueSize ?? 0;
logFile.Queue =
maxQueueSize > 0 ?
Channel.CreateBounded <FileLogEntry>(ConfigureChannelOptions(new BoundedChannelOptions(maxQueueSize)
{
FullMode = BoundedChannelFullMode.DropWrite
})) :
Channel.CreateUnbounded <FileLogEntry>(ConfigureChannelOptions(new UnboundedChannelOptions()));
// important: closure must pick up the current token!
CancellationToken forcedCompleteToken = _forcedCompleteTokenSource.Token;
logFile.WriteFileTask = Task.Run(() => WriteFileAsync(logFile, forcedCompleteToken));
return(logFile);
public FileLogger(string categoryName, IFileLoggerProcessor processor, IFileLoggerSettings settings, IExternalScopeProvider scopeProvider = null,
Func <DateTimeOffset> timestampGetter = null)
{
if (categoryName == null)
{
throw new ArgumentNullException(nameof(categoryName));
}
if (processor == null)
{
throw new ArgumentNullException(nameof(processor));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
CategoryName = categoryName;
_processor = processor;
UpdatableState state = CreateState(null, settings);
state.Settings = settings;
state.FileGroups = GetFileGroups(settings);
state.ScopeProvider = scopeProvider;
_state = state;
_timestampGetter = timestampGetter ?? (() => DateTimeOffset.UtcNow);
}
protected virtual LogFileInfo CreateLogFile(ILogFileSettings fileSettings, IFileLoggerSettings settings)
{
LogFileInfo logFile = CreateLogFile();
logFile.BasePath = settings.BasePath ?? string.Empty;
logFile.PathFormat = fileSettings.Path;
logFile.FileAppender = settings.FileAppender ?? _fallbackFileAppender.Value;
logFile.AccessMode = fileSettings.FileAccessMode ?? settings.FileAccessMode ?? LogFileAccessMode.Default;
logFile.Encoding = fileSettings.FileEncoding ?? settings.FileEncoding ?? Encoding.UTF8;
logFile.DateFormat = fileSettings.DateFormat ?? settings.DateFormat ?? "yyyyMMdd";
logFile.CounterFormat = fileSettings.CounterFormat ?? settings.CounterFormat;
logFile.MaxSize = fileSettings.MaxFileSize ?? settings.MaxFileSize ?? 0;
// important: closure must pick up the current token!
CancellationToken forcedCompleteToken = _forcedCompleteTokenSource.Token;
logFile.Queue = new ActionBlock <FileLogEntry>(
e => WriteEntryAsync(logFile, e, forcedCompleteToken),
new ExecutionDataflowBlockOptions
{
MaxDegreeOfParallelism = 1,
BoundedCapacity = fileSettings.MaxQueueSize ?? settings.MaxQueueSize ?? -1,
});
return(logFile);
}
protected FileLoggerProvider(FileLoggerContext context, IFileLoggerSettings settings)
{
_loggers = new Dictionary <string, FileLogger>();
_resetTask = Task.CompletedTask;
Context = context ?? FileLoggerContext.Default;
Settings = settings.Freeze();
Processor = CreateProcessor(Settings);
}
public InfoFileLogger(
string categoryName,
IFileLoggerProcessor processor,
IFileLoggerSettings settings,
IExternalScopeProvider scopeProvider = null,
Func <DateTimeOffset> timestampGetter = null
) : base(categoryName, processor, settings, scopeProvider, timestampGetter)
{
}
public FileLoggerProvider(IFileLoggerContext context, IFileLoggerSettings settings)
: this(context, (IFileLoggerSettingsBase)settings)
{
_settingsRef = settings;
_settingsChangeToken =
settings.ChangeToken != null && !settings.ChangeToken.HasChanged ?
settings.ChangeToken.RegisterChangeCallback(HandleSettingsChanged, null) :
null;
}
public FileLoggerTests()
{
_settings = Substitute.For <IFileLoggerSettings>();
_settings.LogLevel.Returns(LogLevel.Info);
_settings.Directory.Returns("C:\\Test");
_settings.FileName.Returns("Log_{0}.txt");
_settings.MessageFormat.Returns("{0}\t{1:yyyy-MM-dd_HH:mm}:\t{2}");
_fileSystem = Substitute.For <IFileSystem>();
_fileSystem.AppendFileAsync(Arg.Any <string>(), Arg.Any <string>()).Returns(Task.CompletedTask);
_logger = new Logger.FileLogger(_settings, _fileSystem);
}
void HandleSettingsChanged(object state)
{
_settingsChangeToken.Dispose();
_settingsRef = _settingsRef.Reload();
var isNotDisposed = HandleSettingsChangedCore(_settingsRef);
_settingsChangeToken =
isNotDisposed && _settingsRef.ChangeToken != null && !_settingsRef.ChangeToken.HasChanged ?
_settingsRef.ChangeToken.RegisterChangeCallback(HandleSettingsChanged, null) :
null;
}
private FileGroupsDictionary GetFileGroups(IFileLoggerSettings settings)
{
return((settings.Files ?? Enumerable.Empty <ILogFileSettings>())
.Where(file => file != null && !string.IsNullOrEmpty(file.Path))
.Select(file =>
(Settings: file,
MinLevel: file.GetMinLevel(CategoryName)))
.Where(file => file.MinLevel != LogLevel.None)
.GroupBy(
file =>
(file.Settings.TextBuilder ?? settings.TextBuilder ?? FileLogEntryTextBuilder.Instance,
file.Settings.IncludeScopes ?? settings.IncludeScopes ?? false),
file => file)
.ToDictionary(group => group.Key, group => group.ToArray()));
}
public void Update(IFileLoggerSettings settings)
{
FileGroupsDictionary fileGroups = GetFileGroups(settings);
UpdatableState currentState = _state;
for (; ;)
{
UpdatableState newState = CreateState(currentState, settings);
newState.Settings = settings;
newState.FileGroups = fileGroups;
newState.ScopeProvider = currentState.ScopeProvider;
UpdatableState originalState = Interlocked.CompareExchange(ref _state, newState, currentState);
if (currentState == originalState)
{
return;
}
currentState = originalState;
}
}
private void HandleOptionsChanged(IFileLoggerSettings options, string optionsName)
{
if (optionsName != _optionsName)
{
return;
}
Task resetTask;
lock (_loggers)
{
if (_isDisposed)
{
return;
}
_resetTask = resetTask = ResetProcessorAsync(() =>
{
lock (_loggers)
{
if (_isDisposed)
{
return;
}
Settings = options.Freeze();
foreach (FileLogger logger in _loggers.Values)
{
logger.Update(Settings);
}
}
});
}
Reset?.Invoke(this, resetTask);
}
public void Enqueue(FileLogEntry entry, ILogFileSettings fileSettings, IFileLoggerSettings settings)
{
LogFileInfo logFile;
lock (_logFiles)
{
if (_status == Status.Completed)
{
throw new ObjectDisposedException(nameof(FileLoggerProcessor));
}
if (_status != Status.Running)
{
return;
}
if (!_logFiles.TryGetValue(fileSettings, out logFile))
{
_logFiles.Add(fileSettings, logFile = CreateLogFile(fileSettings, settings));
}
}
logFile.Queue.Post(entry);
}
protected override IFileLoggerProcessor CreateProcessor(IFileLoggerSettings settings) => new CustomFileLoggerProcessor(Context);
public static ILoggerFactory AddFile(this ILoggerFactory factory, IFileLoggerContext context, IFileLoggerSettings settings)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
factory.AddProvider(new FileLoggerProvider(context, settings));
return(factory);
}
public LogFileInfo(FileLoggerProcessor processor, ILogFileSettings fileSettings, IFileLoggerSettings settings)
{
BasePath = settings.BasePath ?? string.Empty;
PathFormat = fileSettings.Path;
PathPlaceholderResolver = GetActualPathPlaceholderResolver(fileSettings.PathPlaceholderResolver ?? settings.PathPlaceholderResolver);
FileAppender = settings.FileAppender ?? processor._fallbackFileAppender.Value;
AccessMode = fileSettings.FileAccessMode ?? settings.FileAccessMode ?? LogFileAccessMode.Default;
Encoding = fileSettings.FileEncoding ?? settings.FileEncoding ?? Encoding.UTF8;
DateFormat = fileSettings.DateFormat ?? settings.DateFormat ?? "yyyyMMdd";
CounterFormat = fileSettings.CounterFormat ?? settings.CounterFormat;
MaxSize = fileSettings.MaxFileSize ?? settings.MaxFileSize ?? 0;
Queue = processor.CreateLogFileQueue(fileSettings, settings);
// important: closure must pick up the current token!
CancellationToken forcedCompleteToken = processor._forcedCompleteTokenSource.Token;
WriteFileTask = Task.Run(() => processor.WriteFileAsync(this, forcedCompleteToken));
public void ParsingOptions()
{
var configJson =
$@"{{
""{nameof(FileLoggerOptions.RootPath)}"": ""{Path.DirectorySeparatorChar.ToString().Replace(@"\", @"\\")}"",
""{nameof(FileLoggerOptions.BasePath)}"": ""Logs"",
""{nameof(FileLoggerOptions.FileAccessMode)}"": ""{LogFileAccessMode.OpenTemporarily}"",
""{nameof(FileLoggerOptions.FileEncodingName)}"": ""utf-8"",
""{nameof(FileLoggerOptions.Files)}"": [
{{
""{nameof(LogFileOptions.Path)}"": ""logger.log"",
""{nameof(LogFileOptions.MinLevel)}"": {{
""Karambolo.Extensions.Logging.File"": ""{LogLevel.Warning}"",
""{LogFileOptions.DefaultCategoryName}"": ""{LogLevel.None}"",
}},
}},
{{
""{nameof(LogFileOptions.Path)}"": ""test.log"",
""{nameof(LogFileOptions.MinLevel)}"": {{
""Karambolo.Extensions.Logging.File.Test"": ""{LogLevel.Debug}"",
""{LogFileOptions.DefaultCategoryName}"": ""{LogLevel.None}"",
}},
}}],
""{nameof(FileLoggerOptions.DateFormat)}"": ""yyyyMMdd"",
""{nameof(FileLoggerOptions.CounterFormat)}"": ""000"",
""{nameof(FileLoggerOptions.MaxFileSize)}"": 10,
""{nameof(FileLoggerOptions.TextBuilderType)}"": ""{typeof(CustomLogEntryTextBuilder).AssemblyQualifiedName}"",
""{nameof(FileLoggerOptions.IncludeScopes)}"": true,
""{nameof(FileLoggerOptions.MaxQueueSize)}"": 100,
}}";
var fileProvider = new MemoryFileProvider();
fileProvider.CreateFile("config.json", configJson);
var cb = new ConfigurationBuilder();
cb.AddJsonFile(fileProvider, "config.json", optional: false, reloadOnChange: false);
IConfigurationRoot config = cb.Build();
var services = new ServiceCollection();
services.AddOptions();
services.Configure <FileLoggerOptions>(config);
ServiceProvider serviceProvider = services.BuildServiceProvider();
IFileLoggerSettings settings = serviceProvider.GetService <IOptions <FileLoggerOptions> >().Value;
Assert.True(settings.FileAppender is PhysicalFileAppender);
Assert.Equal(Path.GetPathRoot(Environment.CurrentDirectory), ((PhysicalFileAppender)settings.FileAppender).FileProvider.Root);
Assert.Equal("Logs", settings.BasePath);
Assert.Equal(LogFileAccessMode.OpenTemporarily, settings.FileAccessMode);
Assert.Equal(Encoding.UTF8, settings.FileEncoding);
Assert.Equal(2, settings.Files.Length);
ILogFileSettings fileSettings = Array.Find(settings.Files, f => f.Path == "logger.log");
Assert.NotNull(fileSettings);
Assert.Equal(LogLevel.None, fileSettings.GetMinLevel(typeof(string).ToString()));
Assert.Equal(LogLevel.Warning, fileSettings.GetMinLevel(typeof(FileLogger).ToString()));
Assert.Equal(LogLevel.Warning, fileSettings.GetMinLevel(typeof(SettingsTest).ToString()));
fileSettings = Array.Find(settings.Files, f => f.Path == "test.log");
Assert.NotNull(fileSettings);
Assert.Equal(LogLevel.None, fileSettings.GetMinLevel(typeof(string).ToString()));
Assert.Equal(LogLevel.None, fileSettings.GetMinLevel(typeof(FileLogger).ToString()));
Assert.Equal(LogLevel.Debug, fileSettings.GetMinLevel(typeof(SettingsTest).ToString()));
Assert.Equal("yyyyMMdd", settings.DateFormat);
Assert.Equal("000", settings.CounterFormat);
Assert.Equal(10, settings.MaxFileSize);
Assert.Equal(typeof(CustomLogEntryTextBuilder), settings.TextBuilder.GetType());
Assert.True(settings.IncludeScopes);
Assert.Equal(100, settings.MaxQueueSize);
}
public FileLogger(IFileLoggerSettings settings)
{
_settings = settings;
}
public FileLogger(IFileLoggerSettings settings, IFileSystem fileSystem) : base(settings)
{
_settings = settings;
_fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
}
protected virtual IFileLoggerProcessor CreateProcessor(IFileLoggerSettings settings)
{
return(new FileLoggerProcessor(Context));
}
public FileLogger(IFileLoggerSettings settings)
{
_settings = settings;
}
protected virtual UpdatableState CreateState(UpdatableState currentState, IFileLoggerSettings settings)
{
return(new UpdatableState());
}
public FileLoggerProvider(IFileLoggerSettings settings)
: this(null, settings)
{
}
protected virtual LogFileInfo CreateLogFile(ILogFileSettings fileSettings, IFileLoggerSettings settings)
{
return(new LogFileInfo(this, fileSettings, settings));
}
public static ILoggerFactory AddFile(this ILoggerFactory factory, IFileLoggerContext context, IFileLoggerSettings settings)
{
factory.AddProvider(new FileLoggerProvider(context, settings));
return(factory);
}
protected virtual Channel <FileLogEntry> CreateLogFileQueue(ILogFileSettings fileSettings, IFileLoggerSettings settings)
{
var maxQueueSize = fileSettings.MaxQueueSize ?? settings.MaxQueueSize ?? 0;
return
(maxQueueSize > 0 ?
Channel.CreateBounded <FileLogEntry>(ConfigureChannelOptions(new BoundedChannelOptions(maxQueueSize)
{
FullMode = BoundedChannelFullMode.DropWrite
})) :
Channel.CreateUnbounded <FileLogEntry>(ConfigureChannelOptions(new UnboundedChannelOptions())));
