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 async Task LogsTheException()
{
KissLog.Tests.Common.CommonTestHelpers.ResetContext();
var ex = new Exception($"Exception {Guid.NewGuid()}");
FlushLogArgs flushLogArgs = null;
KissLogConfiguration.Listeners.Add(new KissLog.Tests.Common.CustomLogListener(onFlush: (FlushLogArgs arg) =>
{
flushLogArgs = arg;
}));
var context = Helpers.MockHttpContext();
var middleware = new KissLogMiddleware((innerHttpContext) =>
{
throw ex;
});
try
{
await middleware.Invoke(context.Object);
}
catch
{
// ignored
}
CapturedException capturedException = flushLogArgs.Exceptions.First();
LogMessage message = flushLogArgs.MessagesGroups.First().Messages.First();
Assert.AreEqual(ex.Message, capturedException.Message);
Assert.IsTrue(message.Message.Contains(ex.Message));
}
public async Task ExceptionSetsTheStatusCodeTo500()
{
KissLog.Tests.Common.CommonTestHelpers.ResetContext();
FlushLogArgs flushLogArgs = null;
KissLogConfiguration.Listeners.Add(new KissLog.Tests.Common.CustomLogListener(onFlush: (FlushLogArgs arg) =>
{
flushLogArgs = arg;
}));
var context = Helpers.MockHttpContext();
context.Setup(p => p.Response.StatusCode).Returns(200);
var middleware = new KissLogMiddleware((innerHttpContext) =>
{
throw new Exception();
});
try
{
await middleware.Invoke(context.Object);
}
catch
{
// ignored
}
Assert.AreEqual(500, flushLogArgs.HttpProperties.Response.StatusCode);
}
public void OptionsAreEvaluated()
{
CommonTestHelpers.ResetContext();
FlushLogArgs flushLogArgs = null;
KissLogConfiguration.Options.ShouldLogRequestHeader((OptionsArgs.LogListenerHeaderArgs args) => false);
KissLogConfiguration.Options.ShouldLogRequestCookie((OptionsArgs.LogListenerCookieArgs args) => false);
KissLogConfiguration.Options.ShouldLogFormData((OptionsArgs.LogListenerFormDataArgs args) => false);
KissLogConfiguration.Options.ShouldLogServerVariable((OptionsArgs.LogListenerServerVariableArgs args) => false);
KissLogConfiguration.Options.ShouldLogClaim((OptionsArgs.LogListenerClaimArgs args) => false);
KissLogConfiguration.Options.ShouldLogInputStream((OptionsArgs.LogListenerInputStreamArgs args) => false);
KissLogConfiguration.Options.ShouldLogResponseHeader((OptionsArgs.LogListenerHeaderArgs args) => false);
KissLogConfiguration.Listeners.Add(new CustomLogListener(onFlush: (FlushLogArgs arg) => flushLogArgs = arg));
Logger logger = new Logger();
logger.DataContainer.SetHttpProperties(CommonTestHelpers.Factory.CreateHttpProperties());
NotifyFlush.Notify(new[] { logger });
Assert.AreEqual(0, flushLogArgs.HttpProperties.Request.Properties.Headers.Count());
Assert.AreEqual(0, flushLogArgs.HttpProperties.Request.Properties.Cookies.Count());
Assert.AreEqual(0, flushLogArgs.HttpProperties.Request.Properties.FormData.Count());
Assert.AreEqual(0, flushLogArgs.HttpProperties.Request.Properties.ServerVariables.Count());
Assert.AreEqual(0, flushLogArgs.HttpProperties.Request.Properties.Claims.Count());
Assert.IsNull(flushLogArgs.HttpProperties.Request.Properties.InputStream);
Assert.AreEqual(0, flushLogArgs.HttpProperties.Response.Properties.Headers.Count());
}
public void ThrowsExceptionWhenHttpPropertiesIsNull()
{
FlushLogArgs item = new FlushLogArgs(new FlushLogArgs.CreateOptions
{
HttpProperties = null
});
}
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 void OnFlush(FlushLogArgs args)
{
bool isValid = ValidateProperties();
if (!isValid)
{
return;
}
InternalLogger.Log("RequestLogsApiListener: OnFlush begin", LogLevel.Trace);
ObfuscateFlushLogArgsService obfuscateService = new ObfuscateFlushLogArgsService(ObfuscationService);
obfuscateService.Obfuscate(args);
CreateRequestLogRequest request = PayloadFactory.Create(args);
request.OrganizationId = _application.OrganizationId;
request.ApplicationId = _application.ApplicationId;
request.Keywords = InternalHelpers.WrapInTryCatch(() => Options.Handlers.GenerateSearchKeywords(args));
FlushOptions flushOptions = new FlushOptions
{
UseAsync = UseAsync,
OnException = OnException
};
IPublicApi kisslogApi = _kisslogApi ?? new PublicRestApi(ApiUrl, IgnoreSslCertificate);
Flusher.FlushAsync(flushOptions, kisslogApi, args, request).ConfigureAwait(false);
InternalLogger.Log("RequestLogsApiListener: OnFlush complete", LogLevel.Trace);
}
public void OnFlush(FlushLogArgs args)
{
IEnumerable <LogMessage> logMessages = args.MessagesGroups.SelectMany(p => p.Messages).OrderBy(p => p.DateTime).ToList();
string filePath = _listener.GetFilePath();
string beginRequest = _textFormatter.FormatBeginRequest(args.HttpProperties.Request);
string endRequest = _textFormatter.FormatEndRequest(args.HttpProperties.Request, args.HttpProperties.Response);
lock (Locker)
{
using (StreamWriter sw = File.AppendText(filePath))
{
if (!string.IsNullOrEmpty(beginRequest))
{
sw.WriteLine(beginRequest);
}
if (!string.IsNullOrEmpty(endRequest))
{
sw.WriteLine(endRequest);
}
foreach (var logMessage in logMessages)
{
string value = _textFormatter.FormatLogMessage(logMessage);
if (!string.IsNullOrEmpty(value))
{
sw.WriteLine(value);
}
}
}
}
}
public void OnFlush(FlushLogArgs args, ILogger logger)
{
FlushProperties flushProperties = GetAndValidateFlushProperties(args);
if (flushProperties == null)
{
return;
}
InternalHelpers.Log("KissLogApiListener: OnFlush begin", LogLevel.Trace);
ObfuscateService?.Obfuscate(args);
TruncateService?.Truncate(args);
Requests.CreateRequestLogRequest request = CreateRequestLogRequestFactory.Create(args);
request.OrganizationId = flushProperties.Application.OrganizationId;
request.ApplicationId = flushProperties.Application.ApplicationId;
request.Keywords = Configuration.Configuration.Options.ApplyAddRequestKeywordstHeader(args);
// we need to copy files, because we start a new Thread, and the existing files will be deleted before accessing them
IList <LoggerFile> copy = CopyFiles(args.Files?.ToList());
IFlusher flusher = CreateFlusher(flushProperties);
if (UseAsync == true)
{
flusher.FlushAsync(request, copy).ConfigureAwait(false);
}
else
{
flusher.Flush(request, copy);
}
InternalHelpers.Log("KissLogApiListener: OnFlush complete", LogLevel.Trace);
}
public void CreateCopiesAllProperties()
{
FlushLogArgs args = CommonTestHelpers.Factory.CreateFlushLogArgs();
var logMessages = args.MessagesGroups.SelectMany(p => p.Messages).OrderBy(p => p.DateTime).ToList();
var result = PayloadFactory.Create(args);
Assert.IsNotNull(result.SdkName);
Assert.IsNotNull(result.SdkVersion);
Assert.AreEqual(args.HttpProperties.Request.StartDateTime, result.StartDateTime);
Assert.IsTrue(result.DurationInMilliseconds >= 0);
Assert.AreEqual(args.HttpProperties.Request.MachineName, result.MachineName);
Assert.AreEqual(args.HttpProperties.Request.IsNewSession, result.IsNewSession);
Assert.AreEqual(args.HttpProperties.Request.SessionId, result.SessionId);
Assert.AreEqual(args.HttpProperties.Request.IsAuthenticated, result.IsAuthenticated);
Assert.IsNull(result.User);
Assert.AreEqual(logMessages.Count, result.LogMessages.Count());
Assert.AreEqual(args.Exceptions.Count(), result.Exceptions.Count());
Assert.AreEqual(args.CustomProperties.Count(), result.CustomProperties.Count);
for (int i = 0; i < logMessages.Count; i++)
{
TestLogMessage(logMessages[i], result.LogMessages.ElementAt(i));
}
for (int i = 0; i < args.Exceptions.Count(); i++)
{
TestCapturedException(args.Exceptions.ElementAt(i), result.Exceptions.ElementAt(i));
}
}
public void GetFileNameReflectsTheFileName(FlushTrigger flushTrigger)
{
string filename = $"{Guid.NewGuid()}.log";
string logsDirectoryPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "tests", $"logs-{Guid.NewGuid()}");
var listener = new LocalTextFileListener(logsDirectoryPath, flushTrigger)
{
GetFileName = () => filename
};
FlushLogArgs flushLogArgs = CommonTestHelpers.Factory.CreateFlushLogArgs();
listener.OnFlush(flushLogArgs);
try
{
Assert.IsTrue(File.Exists(Path.Combine(logsDirectoryPath, filename)));
}
finally
{
if (Directory.Exists(logsDirectoryPath))
{
Directory.Delete(logsDirectoryPath, true);
}
}
}
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 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 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 CloneCopiesAllTheProperties()
{
FlushLogArgs item = CommonTestHelpers.Factory.CreateFlushLogArgs();
FlushLogArgs clone = item.Clone();
Assert.AreEqual(System.Text.Json.JsonSerializer.Serialize(item), System.Text.Json.JsonSerializer.Serialize(clone));
}
public void ObfuscateDoesNotThrowExceptionForNullObfuscationService()
{
FlushLogArgs flushLogArgs = CommonTestHelpers.Factory.CreateFlushLogArgs();
var service = new ObfuscateFlushLogArgsService(null);
service.Obfuscate(flushLogArgs);
}
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 bool ShouldLog(FlushLogArgs args, ILogListener listener)
{
if (ShouldLogFlush != null)
{
return(ShouldLogFlush.Invoke(args));
}
return(true);
}
internal IEnumerable <string> ApplyAddRequestKeywordstHeader(FlushLogArgs args)
{
if (AddRequestKeywordsFn == null)
{
return(null);
}
return(AddRequestKeywordsFn(args));
}
public void SetFilesThrowsExceptionForNull()
{
FlushLogArgs item = new FlushLogArgs(new FlushLogArgs.CreateOptions
{
HttpProperties = CommonTestHelpers.Factory.CreateHttpProperties()
});
item.SetFiles(null);
}
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 MessagesGroupsIsNotNull()
{
FlushLogArgs item = new FlushLogArgs(new FlushLogArgs.CreateOptions
{
HttpProperties = CommonTestHelpers.Factory.CreateHttpProperties(),
MessagesGroups = null
});
Assert.IsNotNull(item.MessagesGroups);
}
public void FilesIsNotNull()
{
FlushLogArgs item = new FlushLogArgs(new FlushLogArgs.CreateOptions
{
HttpProperties = CommonTestHelpers.Factory.CreateHttpProperties(),
Files = null
});
Assert.IsNotNull(item.Files);
}
public void OnFlush(FlushLogArgs args)
{
var logMessages = args.MessagesGroups.SelectMany(p => p.Messages).OrderBy(p => p.DateTime).ToList();
RequestLog requestLog = CreateModel(args.HttpProperties);
requestLog.Messages = logMessages.Select(p => CreateModel(p)).ToList();
_mongoDatabase.Value.GetCollection <RequestLog>("RequestLog").InsertOne(requestLog);
}
public void ConstructorUpdatesTheProperties()
{
FlushLogArgs flushLogArgs = CommonTestHelpers.Factory.CreateFlushLogArgs();
ApiResult apiResult = new ApiResult();
var result = new ExceptionArgs(flushLogArgs, apiResult);
Assert.AreSame(flushLogArgs, result.FlushArgs);
Assert.AreSame(apiResult, result.ApiResult);
}
private Http.ResponseProperties CreateResponseProperties(FlushLogArgs flushLogArgs)
{
var headers = Obfuscate(flushLogArgs.HttpProperties.Response.Properties.Headers, GetPropertyName(p => p.HttpProperties.Response.Properties.Headers));
return(new Http.ResponseProperties(new Http.ResponseProperties.CreateOptions
{
ContentLength = flushLogArgs.HttpProperties.Response.Properties.ContentLength,
Headers = headers
}));
}
public void OnFlush(FlushLogArgs args)
{
lock (Locker)
{
string filePath = GetFileName(_logsDirectoryFullPath);
using (StreamWriter sw = System.IO.File.AppendText(filePath))
{
Write(sw, args);
}
}
}
private static ArgsResult CreateArgs(Logger[] loggers)
{
Logger defaultLogger = loggers.FirstOrDefault(p => p.CategoryName == Logger.DefaultCategoryName) ?? loggers.First();
LoggerDataContainer dataContainer = defaultLogger.DataContainer;
WebProperties webProperties = dataContainer.WebProperties;
string errorMessage = dataContainer.Exceptions.LastOrDefault()?.ExceptionMessage;
List <LogMessagesGroup> logMessages = new List <LogMessagesGroup>();
List <CapturedException> exceptions = new List <CapturedException>();
List <KeyValuePair <string, object> > customProperties = new List <KeyValuePair <string, object> >();
foreach (Logger logger in loggers)
{
logMessages.Add(new LogMessagesGroup
{
CategoryName = logger.CategoryName,
Messages = logger.DataContainer.LogMessages.ToList()
});
exceptions.AddRange(logger.DataContainer.Exceptions);
var properties = GetCustomProperties(logger);
customProperties.AddRange(properties);
}
exceptions = exceptions.Distinct(new CapturedExceptionComparer()).ToList();
if (defaultLogger.IsCreatedByHttpRequest() == false && exceptions.Any())
{
webProperties.Response.HttpStatusCode = System.Net.HttpStatusCode.InternalServerError;
}
webProperties.Response.EndDateTime = DateTime.UtcNow;
List <LoggerFile> files = dataContainer.LoggerFiles.GetFiles().ToList();
FlushLogArgs args = new FlushLogArgs
{
IsCreatedByHttpRequest = defaultLogger.IsCreatedByHttpRequest(),
WebProperties = webProperties,
MessagesGroups = logMessages,
CapturedExceptions = exceptions,
CustomProperties = customProperties
};
args.Files = files;
return(new ArgsResult
{
Args = args,
Files = files
});
}
public void Obfuscate(FlushLogArgs args)
{
if (args.WebProperties.Request != null)
{
Obfuscate(args.WebProperties.Request.Properties.Headers);
Obfuscate(args.WebProperties.Request.Properties.Cookies);
Obfuscate(args.WebProperties.Request.Properties.QueryString);
Obfuscate(args.WebProperties.Request.Properties.FormData);
Obfuscate(args.WebProperties.Request.Properties.ServerVariables);
Obfuscate(args.WebProperties.Request.Properties.Claims);
}
}
public void EvaluatesOptionsShouldLogClaim()
{
CommonTestHelpers.ResetContext();
KissLogConfiguration.Options.ShouldLogClaim((OptionsArgs.LogListenerClaimArgs args) => false);
FlushLogArgs flushLogArgs = CommonTestHelpers.Factory.CreateFlushLogArgs();
FlushLogArgs result = NotifyFlush.CreateArgsForListener(flushLogArgs, new CustomLogListener());
Assert.AreEqual(0, result.HttpProperties.Request.Properties.Claims.Count());
Assert.AreNotEqual(0, flushLogArgs.HttpProperties.Request.Properties.Claims.Count());
}
