public static void Initialize(string logsDirectory, string componentName, LogConsoleFormat logConsoleFormat,
int logFileSize, RollingInterval logFileInterval, int logFileRetentionCount, bool disableLogFile,
string logConfig = "logconfig.json")
{
if (Interlocked.Exchange(ref Initialized, 1) == 1)
{
throw new InvalidOperationException($"{nameof(Initialize)} may not be called more than once.");
}
if (logsDirectory.StartsWith("~"))
{
throw new ApplicationInitializationException(
"The given log path starts with a '~'. Event Store does not expand '~'.");
}
var logConfigurationDirectory = Path.IsPathRooted(logConfig)
? Path.GetDirectoryName(logConfig)
: Locations
.GetPotentialConfigurationDirectories()
.FirstOrDefault(directory => File.Exists(Path.Combine(directory, logConfig)));
if (logConfigurationDirectory == null)
{
throw new FileNotFoundException(
$"Could not find {logConfig} in the following directories: {string.Join(", ", Locations.GetPotentialConfigurationDirectories())}");
}
var configurationRoot = new ConfigurationBuilder()
.AddJsonFile(config => {
config.Optional = false;
config.FileProvider = new PhysicalFileProvider(logConfigurationDirectory)
{
UseActivePolling = true,
UsePollingFileWatcher = true
};
config.OnLoadException = context => Serilog.Log.Error(context.Exception, "err");
config.Path = Path.GetFileName(logConfig);
config.ReloadOnChange = true;
})
.Build();
Serilog.Debugging.SelfLog.Enable(ConsoleLog.Information);
Serilog.Log.Logger = (configurationRoot.GetSection("Serilog").Exists()
? FromConfiguration(configurationRoot)
: Default(logsDirectory, componentName, configurationRoot, logConsoleFormat, logFileInterval,
logFileSize, logFileRetentionCount, disableLogFile))
.CreateLogger();
Serilog.Debugging.SelfLog.Disable();
}
private EventStoreLoggerConfiguration(string logsDirectory, string componentName,
IConfigurationRoot logLevelConfigurationRoot, LogConsoleFormat logConsoleFormat,
RollingInterval logFileInterval, int logFileSize, int logFileRetentionCount, bool disableLogFile)
{
if (logsDirectory == null)
{
throw new ArgumentNullException(nameof(logsDirectory));
}
if (componentName == null)
{
throw new ArgumentNullException(nameof(componentName));
}
if (logLevelConfigurationRoot == null)
{
throw new ArgumentNullException(nameof(logLevelConfigurationRoot));
}
_logsDirectory = logsDirectory;
_componentName = componentName;
var loglevelSection = logLevelConfigurationRoot.GetSection("Logging").GetSection("LogLevel");
var defaultLogLevelSection = loglevelSection.GetSection("Default");
lock (_defaultLogLevelSwitchLock) {
_defaultLogLevelSwitch = new LoggingLevelSwitch {
MinimumLevel = LogEventLevel.Verbose
};
ApplyLogLevel(defaultLogLevelSection, _defaultLogLevelSwitch);
}
var loggerConfiguration = StandardLoggerConfiguration
.MinimumLevel.ControlledBy(_defaultLogLevelSwitch)
.WriteTo.Async(AsyncSink);
foreach (var namedLogLevelSection in loglevelSection.GetChildren().Where(x => x.Key != "Default"))
{
var levelSwitch = new LoggingLevelSwitch();
ApplyLogLevel(namedLogLevelSection, levelSwitch);
loggerConfiguration = loggerConfiguration.MinimumLevel.Override(namedLogLevelSection.Key, levelSwitch);
}
_loggerConfiguration = loggerConfiguration;
void AsyncSink(LoggerSinkConfiguration configuration)
{
configuration.Logger(c => c
.Filter.ByIncludingOnly(RegularStats)
.WriteTo.Logger(Stats));
configuration.Logger(c => c
.Filter.ByExcluding(RegularStats)
.WriteTo.Logger(Default));
}
void Default(LoggerConfiguration configuration)
{
if (logConsoleFormat == LogConsoleFormat.Plain)
{
configuration.WriteTo.Console(outputTemplate: ConsoleOutputTemplate);
}
else
{
configuration.WriteTo.Console(new ExpressionTemplate(CompactJsonTemplate));
}
if (!disableLogFile)
{
configuration.WriteTo
.RollingFile(GetLogFileName(), new ExpressionTemplate(CompactJsonTemplate),
logFileRetentionCount, logFileInterval, logFileSize)
.WriteTo.Logger(Error);
}
}
void Error(LoggerConfiguration configuration)
{
if (!disableLogFile)
{
configuration
.Filter.ByIncludingOnly(Errors)
.WriteTo
.RollingFile(GetLogFileName("err"), new ExpressionTemplate(CompactJsonTemplate),
logFileRetentionCount, logFileInterval, logFileSize);
}
}
void Stats(LoggerConfiguration configuration)
{
if (!disableLogFile)
{
configuration.WriteTo.RollingFile(GetLogFileName("stats"),
new ExpressionTemplate(CompactJsonTemplate), logFileRetentionCount, logFileInterval,
logFileSize);
}
}
void ApplyLogLevel(IConfigurationSection namedLogLevelSection, LoggingLevelSwitch levelSwitch)
{
TrySetLogLevel(namedLogLevelSection, levelSwitch);
ChangeToken.OnChange(namedLogLevelSection.GetReloadToken,
() => TrySetLogLevel(namedLogLevelSection, levelSwitch));
}
private static LoggerConfiguration Default(string logsDirectory, string componentName,
IConfigurationRoot logLevelConfigurationRoot, LogConsoleFormat logConsoleFormat,
RollingInterval logFileInterval, int logFileSize, int logFileRetentionCount, bool disableLogFile) =>
new EventStoreLoggerConfiguration(logsDirectory, componentName, logLevelConfigurationRoot, logConsoleFormat,
logFileInterval, logFileSize, logFileRetentionCount, disableLogFile);
