async Task CompleteCoreAsync(IFileLoggerSettingsBase newSettings)
{
CancellationTokenSource shutdownTokenSource;
Task[] completionTasks;
lock (_logFiles)
{
if (_isDisposed)
{
throw new ObjectDisposedException(nameof(FileLoggerProcessor));
}
shutdownTokenSource = _shutdownTokenSource;
_shutdownTokenSource = new CancellationTokenSource();
completionTasks = _logFiles.Values.Select(lf =>
{
lf.Queue.Complete();
return(lf.Queue.Completion);
}).ToArray();
_logFiles.Clear();
if (newSettings != null)
{
Settings = newSettings.Freeze();
}
}
await Task.WhenAny(Task.WhenAll(completionTasks), Task.Delay(Context.CompletionTimeout)).ConfigureAwait(false);
shutdownTokenSource.Cancel();
shutdownTokenSource.Dispose();
}
public Task CompleteAsync(IFileLoggerSettingsBase newSettings)
{
var result = CompleteCoreAsync(newSettings);
Context.OnComplete(this, result);
return(result);
}
public FileLoggerProcessor(IFileLoggerContext context, IFileLoggerSettingsBase settings)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
#pragma warning disable CS0618 // Type or member is obsolete
var physicalFileProvider = context.FileProvider == null ? null : context.FileProvider as PhysicalFileProvider ??
#pragma warning restore CS0618 // Type or member is obsolete
throw new ArgumentException($"File provider must be {nameof(PhysicalFileProvider)}", nameof(context));
_fallbackFileAppender =
physicalFileProvider != null ?
new Lazy <PhysicalFileAppender>(() => new PhysicalFileAppender(physicalFileProvider)) :
new Lazy <PhysicalFileAppender>(() => new PhysicalFileAppender(Environment.CurrentDirectory));
Context = context;
Settings = settings.Freeze();
_logFiles = new Dictionary <string, LogFileInfo>();
_shutdownTokenSource = new CancellationTokenSource();
_completeTokenRegistration = context.CompleteToken.Register(Complete, useSynchronizationContext: false);
}
void HandleOptionsChanged(IFileLoggerSettingsBase options, string optionsName)
{
if (optionsName == _optionsName)
{
HandleSettingsChangedCore(options);
}
}
async Task CompleteCoreAsync(IFileLoggerSettingsBase newSettings)
{
Task[] completionTasks;
lock (_logFiles)
{
if (_isDisposed)
{
throw new ObjectDisposedException(nameof(FileLoggerProcessor));
}
completionTasks = _logFiles.Values.Select(lf =>
{
lf.Queue.Complete();
return(lf.Queue.Completion);
}).ToArray();
_logFiles.Clear();
if (newSettings != null)
{
newSettings = newSettings.ToImmutable();
_settingsLock.EnterWriteLock();
try { Settings = newSettings; }
finally { _settingsLock.ExitWriteLock(); }
}
}
try { await Task.WhenAll(completionTasks).ConfigureAwait(false); }
catch (OperationCanceledException) { }
}
protected FileLoggerProvider(IFileLoggerContext context, IFileLoggerSettingsBase settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
Context = context ?? FileLoggerContext.Default;
Settings = settings.Freeze();
Processor = CreateProcessor(Settings);
_loggers = new Dictionary <string, FileLogger>();
}
public void Update(string fallbackFileName, IFileLoggerSettingsBase settings)
{
// full thread synchronization is omitted for performance reasons
// as it is considered non-critical (ConsoleLogger is implemented in a similar way)
var state = CreateState(settings);
state.FileName = settings.MapToFileName(CategoryName, fallbackFileName);
state.Filter = settings.BuildFilter(CategoryName);
state.IncludeScopes = settings.IncludeScopes;
state.TextBuilder = settings.TextBuilder ?? FileLogEntryTextBuilder.Instance;
State = state;
}
bool HandleSettingsChangedCore(IFileLoggerSettingsBase settings)
{
lock (_loggers)
{
if (_isDisposed)
{
return(false);
}
Settings = settings.ToImmutable();
foreach (var logger in _loggers.Values)
{
logger.Update(GetFallbackFileName(logger.CategoryName), Settings);
}
}
ResetProcessor(Settings);
return(true);
}
public FileLoggerProcessor(IFileLoggerContext context, IFileLoggerSettingsBase settings)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
Context = context;
Settings = settings.ToImmutable();
_logFiles = new Dictionary <string, LogFileInfo>();
_settingsLock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
_disposeTokenSource = new CancellationTokenSource();
_completeTokenRegistration = context.CompleteToken.Register(Complete, useSynchronizationContext: false);
}
bool HandleSettingsChangedCore(IFileLoggerSettingsBase settings)
{
lock (_loggers)
{
if (_isDisposed)
{
return(false);
}
Settings = settings.Freeze();
var scopeProvider = GetScopeProvider();
foreach (var logger in _loggers.Values)
{
logger.Update(GetFallbackFileName(logger.CategoryName), Settings, scopeProvider);
}
// we must try to wait for the current queues to complete to avoid concurrent file I/O
ResetProcessor(Settings);
}
return(true);
}
protected virtual UpdatableState CreateState(IFileLoggerSettingsBase settings)
{
return(new UpdatableState());
}
public InfoFileLogger(string categoryName, string fallbackFileName, IFileLoggerProcessor processor, IFileLoggerSettingsBase settings, IExternalScopeProvider scopeProvider = null, Func <DateTimeOffset> timestampGetter = null)
: base(categoryName, fallbackFileName, processor, settings, scopeProvider, timestampGetter)
{
}
void ResetProcessor(IFileLoggerSettingsBase newSettings)
{
Processor.CompleteAsync(Settings).ConfigureAwait(false).GetAwaiter().GetResult();
}
protected virtual FileLoggerProcessor CreateProcessor(IFileLoggerSettingsBase settings)
{
return(new FileLoggerProcessor(Context, settings));
}
void ResetProcessor(IFileLoggerSettingsBase newSettings)
{
var timeoutTask = Task.Delay(1500);
Task.WhenAny(Processor.CompleteAsync(newSettings), timeoutTask).ConfigureAwait(false).GetAwaiter().GetResult();
}
void HandleOptionsChanged(IFileLoggerSettingsBase options)
{
HandleSettingsChangedCore(options);
}
public FileLogger(string categoryName, string fallbackFileName, IFileLoggerProcessor processor, IFileLoggerSettingsBase settings,
Func <DateTimeOffset> timestampGetter = null)
: this(
categoryName ?? throw new ArgumentNullException(nameof(categoryName)),
settings?.MapToFileName(categoryName, fallbackFileName ?? throw new ArgumentNullException(nameof(fallbackFileName))) ??
throw new ArgumentNullException(nameof(settings)),
processor,
settings.BuildFilter(categoryName),
settings.IncludeScopes,
settings.TextBuilder,
timestampGetter : timestampGetter)
{
}
public FileLogger(string categoryName, string fallbackFileName, IFileLoggerProcessor processor, IFileLoggerSettingsBase settings,
Func <DateTimeOffset> timestampGetter = null)
: this(categoryName, fallbackFileName, processor, settings, settings.IncludeScopes ? new LoggerExternalScopeProvider() : null, timestampGetter)
{
}
public void Update(string fallbackFileName, IFileLoggerSettingsBase settings)
{
Update(fallbackFileName, settings, settings.IncludeScopes ? new LoggerExternalScopeProvider() : null);
}
