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()); }