public void CreateLogger_MultipleTimesWithTheSameName_ExistingReturned()
{
var sut = new FileLoggerProvider(logFile, 1);
const string loggerName = "name";
var logger1 = sut.CreateLogger(loggerName);
var logger2 = sut.CreateLogger(loggerName);
logger1.Should().Be(logger2);
}
public void ShouldConsiderPriority()
{
//Arrange
var fileName = $"testlog{Guid.NewGuid()}";
var logDir = _logDir;
_fileLoggerProvider = new FileLoggerProvider(new OptionsManager <FileLoggerOptions>(new List <IConfigureOptions <FileLoggerOptions> >()
{
new ConfigureOptions <FileLoggerOptions>(
(x) =>
{
x.FileName = fileName;
x.LogDirectory = logDir;
})
}));
var logger = _fileLoggerProvider.CreateLogger();
var guid = Guid.NewGuid();
var guid2 = Guid.NewGuid();
var guid3 = Guid.NewGuid();
//Act
logger.Log(Severity.Debug, new Exception($"Simple debug error {guid}"));
logger.Log(Severity.Debug, new Exception($"Simple debug error2 {guid2}"));
logger.Log(Severity.Critical, new Exception($"Simple critical error {guid3}"));
//Assert
Thread.Sleep(5000);
var lastLine = File.ReadLines(GetFullName(fileName, (DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day))).Last();
Assert.True(lastLine.Contains(guid2.ToString()));
}
public void ShouldBeChronological_IfProcessingWithDelay()
{
//Arrange
var fileName = $"testlog{Guid.NewGuid()}";
var logDir = _logDir;
_fileLoggerProvider = new FileLoggerProvider(new OptionsManager <FileLoggerOptions>(new List <IConfigureOptions <FileLoggerOptions> >()
{
new ConfigureOptions <FileLoggerOptions>(
(x) =>
{
x.FileName = fileName;
x.LogDirectory = logDir;
})
}));
var logger = _fileLoggerProvider.CreateLogger();
var guid = Guid.NewGuid();
var guid2 = Guid.NewGuid();
//Act
logger.Log(Severity.Debug, new Exception($"Simple debug {guid}"));
Thread.Sleep(1000);
logger.Log(Severity.Info, new Exception($"Simple info {guid2}"));
//Assert
Thread.Sleep(5000); //to ensure that async processing of messages finished
var lastLine = File.ReadLines(GetFullName(fileName, (DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day))).Last();
Assert.True(lastLine.Contains(guid2.ToString()));//last info
}
public void FileLogger_CreateLogger()
{
var loggerProvider = new FileLoggerProvider(options => { });
var logger = loggerProvider.CreateLogger("test");
Assert.IsNotNull(logger);
}
public void CreateLogger_FirstTime_NewLoggerCreated()
{
var sut = new FileLoggerProvider(logFile, 1);
var logger = sut.CreateLogger("name");
logger.Should().NotBeNull();
}
public void CreateLogger_WithName_LoggerNameIsLogged()
{
var sut = new FileLoggerProvider(logFile, 1);
const string loggerName = "my logger name";
var logger = sut.CreateLogger(loggerName);
logger.LogInformation("Hello world!");
A.CallTo(() => logFile.Write(A <string> .That.Contains(loggerName), A <bool> ._))
.MustHaveHappenedOnceExactly();
}
public void MainTest()
{
var config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
var factory = new FileLoggerProvider(config, null);
var logger = factory.CreateLogger("SampleController");
logger.LogInformation("Sample 1");
logger.LogDebug("Sample 2");
logger.LogError("Sample 3");
logger.LogTrace("Sample 4");
logger.LogCritical("Sample 5");
}
public void BackgroundThread_TransientIOError_ContinuesWorking()
{
var sut = new FileLoggerProvider(logFile, 1);
var logger = sut.CreateLogger("name");
A.CallTo(() => logFile.Write(A <string> ._, A <bool> ._)).Throws <Exception>().Once().Then.DoesNothing();
logger.LogInformation("message 1");
logger.LogInformation("message 2");
sut.Dispose();
A.CallTo(() => logFile.Write(A <string> .That.Contains("message 1"), A <bool> ._)).MustHaveHappenedOnceExactly()
.Then(A.CallTo(() => logFile.Write(A <string> .That.Contains("message 2"), A <bool> ._)).MustHaveHappenedOnceExactly());
}
public void ShouldConsiderPriority_ForAllMessageTypes_Concurrent()
{
//Arrange
var fileName = $"testlog{Guid.NewGuid()}";
var logDir = _logDir;
_fileLoggerProvider = new FileLoggerProvider(new OptionsManager <FileLoggerOptions>(new List <IConfigureOptions <FileLoggerOptions> >()
{
new ConfigureOptions <FileLoggerOptions>(
(x) =>
{
x.FileName = fileName;
x.LogDirectory = logDir;
})
}));
var logger = _fileLoggerProvider.CreateLogger();
var guid = Guid.NewGuid();
var guid2 = Guid.NewGuid();
var guid3 = Guid.NewGuid();
var guid4 = Guid.NewGuid();
var guid5 = Guid.NewGuid();
//Act
new Thread(() => logger.Log(Severity.Debug, new Exception($"Simple debug error {guid}"))).Start();
new Thread(() => logger.Log(Severity.Info, new Exception($"Simple info error {guid2}"))).Start();
new Thread(() => logger.Log(Severity.Error, new Exception($"Simple error error {guid4}"))).Start();
new Thread(() => logger.Log(Severity.Critical, new Exception($"Simple critical error {guid5}"))).Start();
new Thread(() => logger.Log(Severity.Warn, new Exception($"Simple warn error {guid3}"))).Start();
//Assert
Thread.Sleep(5000);
var lastLines = File.ReadLines(GetFullName(fileName, (DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day)))
.TakeLast(10).ToArray(); //10 - because every log puts 2 lines into log file
Assert.True(lastLines[0].Contains(guid5.ToString()));
Assert.True(lastLines[2].Contains(guid4.ToString()));
Assert.True(lastLines[4].Contains(guid3.ToString()));
Assert.True(lastLines[6].Contains(guid2.ToString()));
Assert.True(lastLines[8].Contains(guid.ToString()));
}
public void Dispose_ManyLogMessages_WaitsUntilAllWritten()
{
// ARRANGE
var sut = new FileLoggerProvider(logFile, 1);
var logger = sut.CreateLogger("name");
var blockWrite = true;
// Imitate a file write delay.
A.CallTo(() => logFile.Write(A <string> ._, A <bool> ._)).Invokes(() =>
{
while (blockWrite)
{
}
});
logger.LogInformation("some message");
var blocked = true;
// ACT
// Dispose the provider in background thread and ensure it remains
// blocked because the file operation is not yet complete.
ThreadPool.QueueUserWorkItem(state =>
{
sut.Dispose();
blocked = false;
});
// ASSERT
Thread.Sleep(100);
blocked.Should().BeTrue("The file operation is not yet complete, Dispose() must not return");
// ACT
// Now complete the file operation. Since it was the last operation,
// the Dispose must return as its' background thread has completed everything.
blockWrite = false;
Thread.Sleep(100);
blocked.Should().BeFalse();
}
public void FailingEntryDontGetStuck()
{
var tempPath = Path.GetTempPath();
var logPath = Path.Combine(tempPath, LogsDirName);
if (Directory.Exists(logPath))
{
Directory.Delete(logPath, recursive: true);
}
Directory.CreateDirectory(logPath);
try
{
var context = new TestFileLoggerContext(new PhysicalFileProvider(tempPath), "fallback.log");
context.SetWriteRetryDelay(TimeSpan.FromMilliseconds(250));
context.SetCompletionTimeout(TimeSpan.FromMilliseconds(2000));
var completionTasks = new List <Task>();
context.Complete += (s, e) => completionTasks.Add(e);
var cts = new CancellationTokenSource();
var settings = new FileLoggerSettings
{
BasePath = LogsDirName,
FileNameMappings = new Dictionary <string, string>
{
{ "Default", "default.log" }
},
Switches = new Dictionary <string, LogLevel>
{
{ FileLoggerSettingsBase.DefaultCategoryName, LogLevel.Information }
},
ChangeToken = new CancellationChangeToken(cts.Token)
};
var filePath = Path.Combine(logPath, "default.log");
using (var loggerProvider = new FileLoggerProvider(context, settings))
{
ILogger logger = loggerProvider.CreateLogger("X");
logger.LogInformation("This should get through.");
var newCts = new CancellationTokenSource();
settings.ChangeToken = new CancellationChangeToken(newCts.Token);
cts.Cancel();
cts = newCts;
Assert.Single(completionTasks);
Task.WhenAll(completionTasks).GetAwaiter().GetResult();
using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
logger.LogInformation("This shouldn't get through.");
cts.Cancel();
Assert.Equal(2, completionTasks.Count);
var delayTask = Task.Delay(5000);
Assert.Equal(completionTasks[1], Task.WhenAny(completionTasks[1], delayTask).GetAwaiter().GetResult());
Assert.Equal(TaskStatus.RanToCompletion, completionTasks[1].Status);
}
}
var lines = System.IO.File.ReadAllLines(filePath);
Assert.Equal(lines, new[]
{
$"info: X[0] @ {context.GetTimestamp().ToLocalTime():o}",
$" This should get through.",
});
}
finally
{
Directory.Delete(logPath, recursive: true);
}
}