public static ILoggerFactory AddFile(this ILoggerFactory factory, Action <FileLoggerOptions> options = null)
{
var option = new FileLoggerOptions();
options?.Invoke(option);
factory.AddProvider(new FileLoggerProvider(option));
return(factory);
}
public IronJsonLogger(FileLoggerOptions options, string CategoryName)
{
_options = options;
_categoryName = CategoryName;
_jsonOptions = new JsonSerializerOptions()
{
IgnoreNullValues = true
};
}
public static ILoggingBuilder AddFile(this ILoggingBuilder builder, Action <FileLoggerOptions> options = null)
{
var option = new FileLoggerOptions();
options?.Invoke(option);
builder.Services.AddSingleton(option);
builder.Services.AddSingleton <ILoggerProvider, FileLoggerProvider>();
return(builder);
}
private void InitializeFromOptions(FileLoggerOptions options)
{
_path = options.Path ?? ConfigurationManager.AppSettings[options.PathKey];
if (string.IsNullOrEmpty(_path))
{
throw new Exception("File logger path could not be resoled");
}
}
public void ParsingOptions()
{
var configJson =
$@"{{
'{nameof(FileLoggerOptions.RootPath)}': '{Path.DirectorySeparatorChar.ToString().Replace(@"\", @"\\")}',
'{nameof(FileLoggerOptions.BasePath)}': 'Logs',
'{nameof(FileLoggerOptions.EnsureBasePath)}': true,
'{nameof(FileLoggerOptions.FileEncodingName)}': 'utf-8',
'{nameof(FileLoggerOptions.FallbackFileName)}': 'other.log',
'{nameof(FileLoggerOptions.FileNameMappings)}': {{
'Karambolo.Extensions.Logging.File': 'logger.log',
'Karambolo.Extensions.Logging.File.Test': 'test.log',
}},
'{nameof(FileLoggerOptions.DateFormat)}': 'yyyyMMdd',
'{nameof(FileLoggerOptions.CounterFormat)}': '000',
'{nameof(FileLoggerOptions.MaxFileSize)}': 10,
'{nameof(FileLoggerOptions.TextBuilderType)}': '{typeof(CustomLogEntryTextBuilder).AssemblyQualifiedName}',
'{nameof(FileLoggerOptions.IncludeScopes)}': true,
'{nameof(FileLoggerOptions.IncludeScopes)}': true,
'{nameof(FileLoggerOptions.MaxQueueSize)}': 100,
}}";
var fileProvider = new MemoryFileProvider();
fileProvider.CreateFile("config.json", configJson, Encoding.UTF8);
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();
FileLoggerOptions options = serviceProvider.GetService <IOptions <FileLoggerOptions> >().Value;
Assert.True(options.FileAppender is PhysicalFileAppender);
Assert.Equal(Path.GetPathRoot(Environment.CurrentDirectory), ((PhysicalFileAppender)options.FileAppender).FileProvider.Root);
Assert.Equal("Logs", options.BasePath);
Assert.True(options.EnsureBasePath);
Assert.Equal(Encoding.UTF8, options.FileEncoding);
Assert.Equal("other.log", options.FallbackFileName);
Assert.Equal("test.log", options.MapToFileName(typeof(SettingsTest).FullName, "default.log"));
Assert.Equal("logger.log", options.MapToFileName(typeof(FileLogger).FullName, "default.log"));
Assert.Equal("default.log", options.MapToFileName("X.Y", "default.log"));
Assert.Equal("yyyyMMdd", options.DateFormat);
Assert.Equal("000", options.CounterFormat);
Assert.Equal(10, options.MaxFileSize);
Assert.Equal(typeof(CustomLogEntryTextBuilder), options.TextBuilder.GetType());
Assert.True(options.IncludeScopes);
Assert.Equal(100, options.MaxQueueSize);
}
/// <summary>
/// Adds a file logger.
/// </summary>
public static ILoggingBuilder AddFile(this ILoggingBuilder builder, string fileName, Action <FileLoggerOptions> configure)
{
builder.Services.Add(ServiceDescriptor.Singleton <ILoggerProvider, FileLoggerProvider>(
(srvPrv) => {
var options = new FileLoggerOptions();
configure(options);
return(new FileLoggerProvider(fileName, options));
}
));
return(builder);
}
private static void InitLogger()
{
var options = new FileLoggerOptions
{
FileName = "DownloaderConsole-",
LogDirectory = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetCallingAssembly().Location), "LogFiles"),
FileSizeLimit = 5 * 1024 * 1024
};
AppLogger.LoggerFactory.AddProvider(new FileLoggerProvider(new MyLoggerOptions(options)));
logger = AppLogger.CreateLogger <DownloaderConsole>();
}
public void TimeSpanDeserializationTest()
{
string json = @"{
""CutoverAndArchiveTimeZoneMode"": ""Local"",
""LogFileCutoverTime"": ""01:02:03"",
""LogFileArchiveTime"": null
}" ;
FileLoggerOptions Options = JsonSerializer.Deserialize <FileLoggerOptions>(json);
Assert.IsNotNull(Options);
Assert.AreEqual(DateTimeKind.Local, Options.CutoverAndArchiveTimeZoneMode);
Assert.AreEqual(new TimeSpan(1, 2, 3), Options.LogFileCutoverTime);
Assert.IsFalse(Options.LogFileArchiveTime.HasValue);
}
static LogSettings()
{
LoggerFactory = new LoggerFactory();
var fileOptions = new FileLoggerOptions
{
IsLogCallingMethodsSequence = false,
LogFilePath = GetLogSessionFilePath()
};
LoggerFactory.AddFileProvider(fileOptions);
var consoleOptions = new ConsoleLoggerOptions()
{
IsLogCallingMethodsSequence = false,
};
LoggerFactory.AddConsoleProvider(consoleOptions);
}
private static FileLoggerProvider CreateFromConfiguration(IConfiguration configuration, Action <FileLoggerOptions> configure)
{
var fileSection = configuration.GetSection("File");
if (fileSection == null)
{
return(null); // file logger is not configured
}
var fileName = fileSection["Path"];
if (String.IsNullOrWhiteSpace(fileName))
{
return(null); // file logger is not configured
}
var fileLoggerOptions = new FileLoggerOptions();
var appendVal = fileSection["Append"];
if (!String.IsNullOrEmpty(appendVal) && bool.TryParse(appendVal, out var append))
{
fileLoggerOptions.Append = append;
}
var fileLimitVal = fileSection["FileSizeLimitBytes"];
if (!String.IsNullOrEmpty(fileLimitVal) && Int64.TryParse(fileLimitVal, out var fileLimit))
{
fileLoggerOptions.FileSizeLimitBytes = fileLimit;
}
var maxFilesVal = fileSection["MaxRollingFiles"];
if (!String.IsNullOrEmpty(maxFilesVal) && Int32.TryParse(maxFilesVal, out var maxFiles))
{
fileLoggerOptions.MaxRollingFiles = maxFiles;
}
if (configure != null)
{
configure(fileLoggerOptions);
}
return(new FileLoggerProvider(fileName, fileLoggerOptions));
}
private static void ConfigureServices(IServiceCollection services)
{
// configure logger options
FileLoggerOptions fileLogger = new FileLoggerOptions();
fileLogger.FileName = "DXF";
fileLogger.Extension = ".log";
// configure logging
services.AddLogging(builder =>
builder
.AddDebug()
//.AddConsole()
.SetMinimumLevel(LogLevel.Debug)
.AddProvider(new FileLoggerProvider(fileLogger))
.AddProvider(new CustomLoggerProvider())
);
services.AddTransient <App>();
}
public ILogger CreateLogger(string categoryName)
{
FileLoggerOptions options = new FileLoggerOptions();
_config.GetSection(FileLoggerOptions.FileLoggerOption).Bind(options);
if (options.Path.StartsWith("\\"))
{
if (_env != null)
{
options.Path = _env.ContentRootPath + options.Path;
}
else
{
options.Path = System.IO.Directory.GetCurrentDirectory() + options.Path;
}
}
return(options.LoggerType switch
{
"txt" => new IronTxtLogger(options, categoryName),
"json" => new IronJsonLogger(options, categoryName),
_ => null,
});
public FileLoggerProvider(FileLoggerOptions options)
{
this.options = options;
}
public async Task FailingEntryDontGetStuck()
{
var logsDirName = Guid.NewGuid().ToString("D");
var tempPath = Path.Combine(Path.GetTempPath());
var logPath = Path.Combine(tempPath, logsDirName);
if (Directory.Exists(logPath))
{
Directory.Delete(logPath, recursive: true);
}
var fileProvider = new PhysicalFileProvider(tempPath);
var options = new FileLoggerOptions
{
FileAppender = new PhysicalFileAppender(fileProvider),
BasePath = logsDirName,
Files = new[]
{
new LogFileOptions
{
Path = "default.log",
},
},
};
var optionsMonitor = new DelegatedOptionsMonitor <FileLoggerOptions>(_ => options);
var completeCts = new CancellationTokenSource();
var completionTimeoutMs = 2000;
var context = new TestFileLoggerContext(completeCts.Token, TimeSpan.FromMilliseconds(completionTimeoutMs), writeRetryDelay: TimeSpan.FromMilliseconds(250));
context.SetTimestamp(new DateTime(2017, 1, 1, 0, 0, 0, DateTimeKind.Utc));
var services = new ServiceCollection();
services.AddOptions();
services.AddLogging(b => b.AddFile(context));
services.AddSingleton <IOptionsMonitor <FileLoggerOptions> >(optionsMonitor);
string filePath = Path.Combine(logPath, "default.log");
try
{
FileLoggerProvider[] providers;
using (ServiceProvider sp = services.BuildServiceProvider())
{
providers = context.GetProviders(sp).ToArray();
Assert.Equal(1, providers.Length);
var resetTasks = new List <Task>();
foreach (FileLoggerProvider provider in providers)
{
provider.Reset += (s, e) => resetTasks.Add(e);
}
ILoggerFactory loggerFactory = sp.GetRequiredService <ILoggerFactory>();
ILogger logger = loggerFactory.CreateLogger("X");
logger.LogInformation("This should get through.");
optionsMonitor.Reload();
// ensuring that reset has been finished and the new settings are effective
await Task.WhenAll(resetTasks);
using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
logger.LogInformation("This shouldn't get through.");
Task completion = context.GetCompletion(sp);
Assert.False(completion.IsCompleted);
completeCts.Cancel();
Assert.Equal(completion, await Task.WhenAny(completion, Task.Delay(TimeSpan.FromMilliseconds(completionTimeoutMs * 2))));
Assert.Equal(TaskStatus.RanToCompletion, completion.Status);
}
}
IFileInfo logFile = fileProvider.GetFileInfo($"{logsDirName}/default.log");
Assert.True(logFile.Exists && !logFile.IsDirectory);
var lines = logFile.ReadAllText(out Encoding encoding).Split(new[] { Environment.NewLine }, StringSplitOptions.None);
Assert.Equal(Encoding.UTF8, encoding);
Assert.Equal(new[]
{
$"info: X[0] @ {context.GetTimestamp().ToLocalTime():o}",
$" This should get through.",
""
}, lines);
}
finally
{
Directory.Delete(logPath, recursive: true);
}
}
public IronTxtLogger(FileLoggerOptions options, string CategoryName)
{
_options = options;
_categoryName = CategoryName;
}
internal FileLoggerProvider(Action <FileLoggerOptions> optionsConfiguration)
{
_options = FileLoggerOptions.Configure(optionsConfiguration);
}
private async Task LoggingToMemoryWithoutDICore(LogFileAccessMode accessMode)
{
const string logsDirName = "Logs";
var fileProvider = new MemoryFileProvider();
var filterOptions = new LoggerFilterOptions {
MinLevel = LogLevel.Trace
};
var options = new FileLoggerOptions
{
FileAppender = new MemoryFileAppender(fileProvider),
BasePath = logsDirName,
FileAccessMode = accessMode,
FileEncoding = Encoding.UTF8,
MaxQueueSize = 100,
DateFormat = "yyMMdd",
CounterFormat = "000",
MaxFileSize = 10,
Files = new[]
{
new LogFileOptions
{
Path = "<date>/<date:MM>/logger.log",
DateFormat = "yyyy",
MinLevel = new Dictionary <string, LogLevel>
{
["Karambolo.Extensions.Logging.File"] = LogLevel.None,
[LogFileOptions.DefaultCategoryName] = LogLevel.Information,
}
},
new LogFileOptions
{
Path = "test-<date>-<counter>.log",
MinLevel = new Dictionary <string, LogLevel>
{
["Karambolo.Extensions.Logging.File"] = LogLevel.Information,
[LogFileOptions.DefaultCategoryName] = LogLevel.None,
}
},
},
TextBuilder = new CustomLogEntryTextBuilder(),
IncludeScopes = true,
};
var completeCts = new CancellationTokenSource();
var context = new TestFileLoggerContext(completeCts.Token, completionTimeout: Timeout.InfiniteTimeSpan);
context.SetTimestamp(new DateTime(2017, 1, 1, 0, 0, 0, DateTimeKind.Utc));
var ex = new Exception();
var provider = new FileLoggerProvider(context, Options.Create(options));
try
{
using (var loggerFactory = new LoggerFactory(new[] { provider }, filterOptions))
{
ILogger <LoggingTest> logger1 = loggerFactory.CreateLogger <LoggingTest>();
logger1.LogInformation("This is a nice logger.");
using (logger1.BeginScope("SCOPE"))
{
logger1.LogWarning(1, "This is a smart logger.");
logger1.LogTrace("This won't make it.");
using (logger1.BeginScope("NESTED SCOPE"))
{
ILogger logger2 = loggerFactory.CreateLogger("X");
logger2.LogWarning("Some warning.");
logger2.LogError(0, ex, "Some failure!");
}
}
}
}
finally
{
#if NETCOREAPP3_0
await provider.DisposeAsync();
#else
await Task.CompletedTask;
provider.Dispose();
#endif
}
Assert.True(provider.Completion.IsCompleted);
var logFile = (MemoryFileInfo)fileProvider.GetFileInfo($"{logsDirName}/test-{context.GetTimestamp().ToLocalTime():yyMMdd}-000.log");
Assert.True(logFile.Exists && !logFile.IsDirectory);
var lines = logFile.ReadAllText(out Encoding encoding).Split(new[] { Environment.NewLine }, StringSplitOptions.None);
Assert.Equal(Encoding.UTF8, encoding);
Assert.Equal(new[]
{
$"[info]: {typeof(LoggingTest)}[0] @ {context.GetTimestamp().ToLocalTime():o}",
$" This is a nice logger.",
""
}, lines);
logFile = (MemoryFileInfo)fileProvider.GetFileInfo($"{logsDirName}/test-{context.GetTimestamp().ToLocalTime():yyMMdd}-001.log");
Assert.True(logFile.Exists && !logFile.IsDirectory);
lines = logFile.ReadAllText(out encoding).Split(new[] { Environment.NewLine }, StringSplitOptions.None);
Assert.Equal(Encoding.UTF8, encoding);
Assert.Equal(new[]
{
$"[warn]: {typeof(LoggingTest)}[1] @ {context.GetTimestamp().ToLocalTime():o}",
$" => SCOPE",
$" This is a smart logger.",
""
}, lines);
logFile = (MemoryFileInfo)fileProvider.GetFileInfo(
$"{logsDirName}/{context.GetTimestamp().ToLocalTime():yyyy}/{context.GetTimestamp().ToLocalTime():MM}/logger.log");
Assert.True(logFile.Exists && !logFile.IsDirectory);
lines = logFile.ReadAllText(out encoding).Split(new[] { Environment.NewLine }, StringSplitOptions.None);
Assert.Equal(Encoding.UTF8, encoding);
Assert.Equal(new[]
{
$"[warn]: X[0] @ {context.GetTimestamp().ToLocalTime():o}",
$" => SCOPE => NESTED SCOPE",
$" Some warning.",
$"[fail]: X[0] @ {context.GetTimestamp().ToLocalTime():o}",
$" => SCOPE => NESTED SCOPE",
$" Some failure!",
}
.Concat(ex.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.None))
.Append(""), lines);
}
/// <summary>
/// 文件日志提供程序
/// </summary>
/// <param name="options"></param>
public FileLoggerProvider(FileLoggerOptions options = null)
{
_options = options ?? new FileLoggerOptions();
_fileLoggerWriter = new FileLoggerWriter(_options);
}
internal FileLogger(FileLoggerOptions options)
{
InitializeFromOptions(options);
}
public static ILoggerFactory AddFileLogger(this ILoggerFactory loggerFactory, FileLoggerOptions options)
{
loggerFactory.AddProvider(new FileLoggerProvider(options));
return(loggerFactory);
}
