public ActionResult Index()
{
_logger.Trace("Trace log");
_logger.Debug("Debug log");
_logger.Info("Information log");
_logger.Warn("Warning log");
_logger.Error("Error log");
_logger.Critical("Critical log");
_logger.Error(new DivideByZeroException());
string file = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Web.config");
_logger.LogAsFile($"Text content logged as file. Guid: {Guid.NewGuid()}", "file-01.txt");
_logger.LogFile(file, "Web.config");
_logger.AddCustomProperty("CorrelationId", Guid.NewGuid());
_logger.AddCustomProperty("boolean", true);
_logger.AddCustomProperty("date", DateTime.UtcNow);
_logger.AddCustomProperty("integer", 100);
_logger.LogResponseBody(true);
Logger logger = _logger as Logger;
FlushLogArgs args = FlushLogArgsFactory.Create(new[] { logger });
string json = JsonSerializer.Serialize(args, new JsonSerializerOptions {
WriteIndented = true
});
return(Content(json, "application/json"));
}
public static void Notify(Logger[] loggers)
{
if (loggers == null)
{
throw new ArgumentNullException();
}
if (!loggers.Any())
{
return;
}
FlushLogArgs args = FlushLogArgsFactory.Create(loggers);
Guid?httpRequestId = args.HttpProperties == null ? (Guid?)null : args.HttpProperties.Request.Id;
List <LogListenerDecorator> logListeners = KissLogConfiguration.Listeners.GetAll();
foreach (LogListenerDecorator decorator in logListeners)
{
InternalHelpers.WrapInTryCatch(() =>
{
Notify(args, decorator, httpRequestId);
});
}
foreach (Logger logger in loggers)
{
logger.Reset();
}
}
public void OnExceptionIsExecutedWhenApiResultHasException()
{
Logger logger = new Logger();
ExceptionArgs exceptionArgs = null;
FlushLogArgs flushArgs = FlushLogArgsFactory.Create(new[] { logger });
CreateRequestLogRequest request = PayloadFactory.Create(flushArgs);
var kisslogApi = new Mock <IPublicApi>();
kisslogApi.Setup(p => p.CreateRequestLog(It.IsAny <CreateRequestLogRequest>(), It.IsAny <IEnumerable <File> >()))
.Returns(new ApiResult <RequestLog>
{
Exception = new ApiException
{
ErrorMessage = $"Error {Guid.NewGuid()}"
}
});
FlushOptions options = new FlushOptions
{
UseAsync = false,
OnException = (ExceptionArgs args) =>
{
exceptionArgs = args;
}
};
Flusher.FlushAsync(options, kisslogApi.Object, flushArgs, request).ConfigureAwait(false);
Assert.IsNotNull(exceptionArgs);
}
public void ChangesFlushLogArgsFiles()
{
Logger logger = new Logger();
logger.LogAsFile("Content 1", "File1.txt");
logger.LogAsFile("Content 2", "File2.txt");
FlushLogArgs flushArgs = FlushLogArgsFactory.Create(new[] { logger });
IEnumerable <LoggedFile> files = flushArgs.Files;
CreateRequestLogRequest request = PayloadFactory.Create(flushArgs);
var kisslogApi = new Mock <IPublicApi>();
kisslogApi.Setup(p => p.CreateRequestLog(It.IsAny <CreateRequestLogRequest>(), It.IsAny <IEnumerable <File> >()))
.Returns(new ApiResult <RequestLog>());
Flusher.FlushAsync(new FlushOptions {
UseAsync = false
}, kisslogApi.Object, flushArgs, request).ConfigureAwait(false);
Assert.AreNotSame(files, flushArgs.Files);
Assert.AreEqual(files.Count(), flushArgs.Files.Count());
logger.Reset();
}
public void MachineNameIsCopied(string url)
{
FlushLogArgs item = FlushLogArgsFactory.Create(new[] { new Logger(url: url) });
string machineName = InternalHelpers.GetMachineName();
Assert.AreEqual(machineName, item.HttpProperties.Request.MachineName);
}
public void DefaultLoggerCategoryHasPriorityWhenSelectingHttpProperties()
{
Logger logger1 = new Logger(categoryName: "SomeLogger", url: "/SomeLogger/Method1");
Logger logger2 = new Logger(url: "/DefaultLogger/Method1");
FlushLogArgs item = FlushLogArgsFactory.Create(new[] { logger1, logger2 });
Assert.AreEqual("/DefaultLogger/Method1", item.HttpProperties.Request.Url.LocalPath);
}
public void IsCreatedByHttpRequestMatchesIsManagedByHttpRequest(bool isManagedByHttpRequest)
{
Logger logger = new Logger();
logger.DataContainer.LoggerProperties.IsManagedByHttpRequest = isManagedByHttpRequest;
FlushLogArgs item = FlushLogArgsFactory.Create(new[] { logger });
Assert.AreEqual(isManagedByHttpRequest, item.IsCreatedByHttpRequest);
}
public void GetExplicitStatusCodeReturnsNullIfNoValueIsFound()
{
Logger logger1 = new Logger();
Logger logger2 = new Logger();
int?value = FlushLogArgsFactory.GetExplicitStatusCode(new List <Logger> {
logger1, logger2
});
Assert.IsNull(value);
}
public void ExceptionsAreNotReferenced()
{
Logger logger = new Logger();
logger.Trace(new Exception());
FlushLogArgs item = FlushLogArgsFactory.Create(new[] { logger });
logger.Trace(new Exception());
int count = item.Exceptions.Count();
Assert.AreEqual(1, count);
}
public void MessagesAreNotReferenced()
{
Logger logger = new Logger();
logger.Trace("Message 1");
FlushLogArgs item = FlushLogArgsFactory.Create(new[] { logger });
logger.Trace("Message 2");
int count = item.MessagesGroups.Sum(p => p.Messages.Count());
Assert.AreEqual(1, count);
}
public void GetExplicitStatusCodeUsesDefaultLoggerAsPrimarySource()
{
Logger logger1 = new Logger(categoryName: "Category 1");
Logger logger2 = new Logger();
logger1.SetStatusCode(200);
logger2.SetStatusCode(400);
int?value = FlushLogArgsFactory.GetExplicitStatusCode(new List <Logger> {
logger1, logger2
});
Assert.AreEqual(400, value.Value);
}
public void FilesAreNotReferenced()
{
Logger logger = new Logger();
logger.LogAsFile("File 1");
FlushLogArgs item = FlushLogArgsFactory.Create(new[] { logger });
logger.LogAsFile("File 2");
int count = item.Files.Count();
logger.Reset();
Assert.AreEqual(1, count);
}
public void GetExplicitStatusCodeReturnsTheFirstValueFound()
{
Logger logger1 = new Logger();
Logger logger2 = new Logger();
Logger logger3 = new Logger();
logger2.SetStatusCode(100);
logger3.SetStatusCode(200);
int?value = FlushLogArgsFactory.GetExplicitStatusCode(new List <Logger> {
logger1, logger2, logger3
});
Assert.AreEqual(100, value.Value);
}
public void MessagesGroupsDoesNotContainEmptyLogsMessages()
{
Logger logger1 = new Logger();
logger1.Trace("Message");
Logger logger2 = new Logger();
FlushLogArgs item = FlushLogArgsFactory.Create(new[] { logger1, logger2 });
int messagesGroups = item.MessagesGroups.Count();
int messagesCount = item.MessagesGroups.Sum(p => p.Messages.Count());
Assert.AreEqual(1, messagesGroups);
Assert.AreEqual(1, messagesCount);
}
public void HasExceptionsFromAllTheLoggers()
{
List <Logger> loggers = new List <Logger>();
for (int i = 0; i < 10; i++)
{
Logger logger = new Logger();
logger.Trace(new Exception($"Exception from Logger {i}"));
loggers.Add(logger);
}
FlushLogArgs item = FlushLogArgsFactory.Create(loggers.ToArray());
int count = item.Exceptions.Count();
Assert.AreEqual(10, count);
}
public void LoggerNotManagedByHttpRequestAlwaysReturnsTrueForShouldLogFlushLogArgs(bool isManagedByHttpRequest)
{
var interceptor = new StatusCodeInterceptor
{
MinimumResponseHttpStatusCode = 600
};
ILogListener listener = new Mock <ILogListener>().Object;
Logger logger = new Logger();
logger.DataContainer.LoggerProperties.IsManagedByHttpRequest = isManagedByHttpRequest;
FlushLogArgs flushLogArgs = FlushLogArgsFactory.Create(new[] { logger });
bool result = interceptor.ShouldLog(flushLogArgs, listener);
bool expectedResult = isManagedByHttpRequest == true ? false : true;
Assert.AreEqual(expectedResult, result);
}
public void HasMessagesGroupsFromAllTheLoggers()
{
List <Logger> loggers = new List <Logger>();
for (int i = 0; i < 10; i++)
{
Logger logger = new Logger();
logger.Trace($"Message from Logger {i}");
loggers.Add(logger);
}
FlushLogArgs item = FlushLogArgsFactory.Create(loggers.ToArray());
int messagesGroups = item.MessagesGroups.Count();
int messagesCount = item.MessagesGroups.Sum(p => p.Messages.Count());
Assert.AreEqual(10, messagesGroups);
Assert.AreEqual(10, messagesCount);
}
public void CreatesACopyOfTheFilesAndDeletesThem(bool apiThrowsException)
{
Logger logger = new Logger();
logger.LogAsFile("Content 1", "File1.txt");
logger.LogAsFile("Content 2", "File2.txt");
FlushLogArgs flushArgs = FlushLogArgsFactory.Create(new[] { logger });
CreateRequestLogRequest request = PayloadFactory.Create(flushArgs);
var kisslogApi = new Mock <IPublicApi>();
kisslogApi.Setup(p => p.CreateRequestLog(It.IsAny <CreateRequestLogRequest>(), It.IsAny <IEnumerable <File> >())).Callback(() =>
{
if (apiThrowsException)
{
throw new Exception();
}
})
.Returns(new ApiResult <RequestLog>());
Flusher.FlushAsync(new FlushOptions {
UseAsync = false
}, kisslogApi.Object, flushArgs, request).ConfigureAwait(false);
IEnumerable <LoggedFile> flushArgsFiles = flushArgs.Files;
IEnumerable <LoggedFile> loggerFiles = logger.DataContainer.FilesContainer.GetLoggedFiles();
foreach (var file in flushArgsFiles)
{
Assert.IsFalse(System.IO.File.Exists(file.FilePath));
}
foreach (var file in loggerFiles)
{
Assert.IsTrue(System.IO.File.Exists(file.FilePath));
}
logger.Reset();
}
public void HasFilesFromAllTheLoggers()
{
List <Logger> loggers = new List <Logger>();
for (int i = 0; i < 10; i++)
{
Logger logger = new Logger();
logger.LogAsFile($"File {i}");
loggers.Add(logger);
}
FlushLogArgs item = FlushLogArgsFactory.Create(loggers.ToArray());
int count = item.Files.Count();
foreach (Logger logger in loggers)
{
logger.Reset();
}
Assert.AreEqual(10, count);
}
public void ThrowsExceptionForEmptyList()
{
FlushLogArgsFactory.Create(new Logger[] { });
}
public void HttpPropertiesResponseIsNotNull(string url)
{
FlushLogArgs item = FlushLogArgsFactory.Create(new[] { new Logger(url: url) });
Assert.IsNotNull(item.HttpProperties.Response);
}
public void ThrowsExceptionForNullLoggers()
{
FlushLogArgsFactory.Create(null);
}
public void GetExplicitStatusCodeThrowsExceptionForNullList()
{
int?value = FlushLogArgsFactory.GetExplicitStatusCode(null);
}
public void GetExplicitStatusCodeReturnsNullForEmptyList()
{
int?value = FlushLogArgsFactory.GetExplicitStatusCode(new List <Logger>());
Assert.IsNull(value);
}
public void HasValueForEmptyLogger()
{
FlushLogArgs item = FlushLogArgsFactory.Create(new[] { new Logger() });
Assert.IsNotNull(item);
}
