updated LogListenerParser to fix issue #19

catalingavan · Oct 16, 2019 · 4671608 · 4671608
1 parent 3d9ed02
commit 4671608
Show file tree

Hide file tree

Showing 12 changed files with 143 additions and 35 deletions.
diff --git a/src/KissLog.AspNetCore/IOptionsBuilder.cs b/src/KissLog.AspNetCore/IOptionsBuilder.cs
@@ -1,11 +1,10 @@
 using System;
-using System.Collections.Generic;
 
 namespace KissLog.AspNetCore
 {
     public interface IOptionsBuilder
     {
-        List<ILogListener> Listeners { get; }
+        ListenersContainer Listeners { get; }
         Options Options { get; }
         Action<string, LogLevel> InternalLog { get; set; }
     }

diff --git a/src/KissLog.AspNetCore/OptionsBuilder.cs b/src/KissLog.AspNetCore/OptionsBuilder.cs
@@ -5,7 +5,7 @@ namespace KissLog.AspNetCore
 {
     internal class OptionsBuilder : IOptionsBuilder
     {
-        public List<ILogListener> Listeners => KissLogConfiguration.Listeners;
+        public ListenersContainer Listeners => KissLogConfiguration.Listeners;
         public Options Options => KissLogConfiguration.Options;
         public Action<string, LogLevel> InternalLog
         {

diff --git a/src/KissLog/Internal/ExtensionMethods.cs b/src/KissLog/Internal/ExtensionMethods.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using KissLog.FlushArgs;
 using KissLog.Web;
 

diff --git a/src/KissLog/Internal/LogListenerDecorator.cs b/src/KissLog/Internal/LogListenerDecorator.cs
@@ -0,0 +1,48 @@
+using KissLog.Web;
+using System.Collections.Generic;
+
+namespace KissLog.Internal
+{
+    internal class LogListenerDecorator
+    {
+        public LogListenerDecorator(ILogListener listener)
+        {
+            Listener = listener;
+        }
+
+        public ILogListener Listener { get; private set; }
+        public List<string> SkipRequestIds = new List<string>();
+
+        public void Reset()
+        {
+            SkipRequestIds.Clear();
+            SkipRequestIds = new List<string>();
+        }
+
+        public bool ShouldSkipOnMessage(Logger logger)
+        {
+            string requestId = logger.DataContainer?.WebProperties?.Request?._KissLogRequestId;
+
+            if (string.IsNullOrEmpty(requestId))
+                return false;
+
+            if (SkipRequestIds.Contains(requestId))
+                return true;
+
+            return false;
+        }
+
+        public bool ShouldSkipOnFlush(HttpRequest request)
+        {
+            string requestId = request?._KissLogRequestId;
+
+            if (string.IsNullOrEmpty(requestId))
+                return false;
+
+            if (SkipRequestIds.Contains(requestId))
+                return true;
+
+            return false;
+        }
+    }
+}
diff --git a/src/KissLog/Internal/LoggerDataContainer.cs b/src/KissLog/Internal/LoggerDataContainer.cs
@@ -1,4 +1,5 @@
 using KissLog.Web;
+using System;
 using System.Collections.Generic;
 using System.Net;
 
@@ -66,6 +67,11 @@ public void Reset()
 
             LoggerFiles.Dispose();
             LoggerFiles = new LoggerFiles(_logger);
+
+            if (WebProperties?.Request != null)
+            {
+                WebProperties.Request._KissLogRequestId = Guid.NewGuid().ToString();
+            }
         }
     }
 }
diff --git a/src/KissLog/Internal/NotifyListeners/NotifyOnBeginRequestService.cs b/src/KissLog/Internal/NotifyListeners/NotifyOnBeginRequestService.cs
@@ -1,22 +1,41 @@
-using KissLog.Web;
-using System.Linq;
+using KissLog.FlushArgs;
+using KissLog.Web;
 
 namespace KissLog.Internal
 {
     internal static class NotifyOnBeginRequestService
     {
         public static void Notify(HttpRequest httpRequest, Logger logger)
         {
-            if (KissLogConfiguration.Listeners == null || KissLogConfiguration.Listeners.Any() == false)
-                return;
-
-            foreach (ILogListener listener in KissLogConfiguration.Listeners)
+            foreach (LogListenerDecorator decorator in KissLogConfiguration.Listeners.Get())
             {
-                if (listener == null)
+                ILogListener listener = decorator.Listener;
+
+                BeginRequestArgs args = new BeginRequestArgs
+                {
+                    IsCreatedByHttpRequest = logger.IsCreatedByHttpRequest(),
+                    Request = httpRequest
+                };
+
+                if (ShouldUseListener(listener, args) == false)
+                {
+                    // make the listener skip all the events for the current request
+                    decorator.SkipRequestIds.Add(args.Request._KissLogRequestId);
+
                     continue;
+                }
 
                 listener.OnBeginRequest(httpRequest, logger);
             }
         }
+
+        private static bool ShouldUseListener(ILogListener listener, BeginRequestArgs args)
+        {
+            LogListenerParser parser = listener.Parser;
+            if (parser == null)
+                return true;
+
+            return parser.ShouldLog(args, listener);
+        }
     }
 }
diff --git a/src/KissLog/Internal/NotifyListeners/NotifyOnFlushService.cs b/src/KissLog/Internal/NotifyListeners/NotifyOnFlushService.cs
@@ -14,7 +14,7 @@ public static void Notify(ILogger[] loggers)
             if (loggers == null || !loggers.Any())
                 return;
 
-            if (KissLogConfiguration.Listeners == null || KissLogConfiguration.Listeners.Any() == false)
+            if (KissLogConfiguration.Listeners.Get().Any() == false)
                 return;
 
             Logger[] theLoggers = loggers.OfType<Logger>().ToArray();
@@ -31,14 +31,20 @@ public static void Notify(ILogger[] loggers)
 
             string defaultArgsJsonJson = JsonConvert.SerializeObject(defaultArgs);
 
-            foreach (ILogListener listener in KissLogConfiguration.Listeners)
+            foreach (LogListenerDecorator decorator in KissLogConfiguration.Listeners.Get())
             {
+                ILogListener listener = decorator.Listener;
+
+                if (decorator.ShouldSkipOnFlush(defaultArgs.WebProperties.Request))
+                    continue;
+
                 FlushLogArgs args = CreateFlushArgsForListener(defaultLogger, listener, defaultArgs, defaultArgsJsonJson, defaultFiles.ToList());
 
                 if (ShouldUseListener(listener, args) == false)
                     continue;
 
-                listener.Parser?.BeforeFlush(args, listener);
+                if(listener.Parser != null)
+                    listener.Parser.BeforeFlush(args, listener);
 
                 listener.OnFlush(args, defaultLogger);
             }
@@ -47,6 +53,11 @@ public static void Notify(ILogger[] loggers)
             {
                 logger.Reset();
             }
+
+            foreach (LogListenerDecorator decorator in KissLogConfiguration.Listeners.Get())
+            {
+                decorator.Reset();
+            }
         }
 
         internal static ArgsResult CreateArgs(ILogger[] loggers)

diff --git a/src/KissLog/Internal/NotifyListeners/NotifyOnMessageService.cs b/src/KissLog/Internal/NotifyListeners/NotifyOnMessageService.cs
@@ -1,23 +1,20 @@
-using System.Linq;
-
-namespace KissLog.Internal
+namespace KissLog.Internal
 {
     internal static class NotifyOnMessageService
     {
         public static void Notify(LogMessage message, Logger logger)
         {
-            if (KissLogConfiguration.Listeners == null || KissLogConfiguration.Listeners.Any() == false)
-                return;
-
-            foreach (ILogListener listener in KissLogConfiguration.Listeners)
+            foreach (LogListenerDecorator decorator in KissLogConfiguration.Listeners.Get())
             {
-                if (listener == null)
+                ILogListener listener = decorator.Listener;
+
+                if (decorator.ShouldSkipOnMessage(logger))
                     continue;
 
                 if (listener.Parser != null && listener.Parser.ShouldLog(message, listener) == false)
                     continue;
 
-                listener.OnMessage(message, logger);
+                decorator.Listener.OnMessage(message, logger);
             }
         }
     }

diff --git a/src/KissLog/KissLogConfiguration.cs b/src/KissLog/KissLogConfiguration.cs
@@ -1,11 +1,10 @@
 using System;
-using System.Collections.Generic;
 
 namespace KissLog
 {
     public static class KissLogConfiguration
     {
-        public static List<ILogListener> Listeners = new List<ILogListener>();
+        public static ListenersContainer Listeners { get; } = new ListenersContainer();
 
         public static Options Options { get; } = new Options();
 

diff --git a/src/KissLog/ListenersContainer.cs b/src/KissLog/ListenersContainer.cs
@@ -0,0 +1,35 @@
+using KissLog.Internal;
+using System.Collections.Generic;
+
+namespace KissLog
+{
+    public class ListenersContainer
+    {
+        private readonly List<LogListenerDecorator> _listeners;
+        public ListenersContainer()
+        {
+            _listeners = new List<LogListenerDecorator>();
+        }
+
+        public void Add(ILogListener listener)
+        {
+            if (listener == null)
+                return;
+
+            var decorator = new LogListenerDecorator(listener);
+            _listeners.Add(decorator);
+        }
+
+        internal IList<LogListenerDecorator> Get()
+        {
+            List<LogListenerDecorator> result = new List<LogListenerDecorator>();
+
+            foreach(LogListenerDecorator decorator in _listeners)
+            {
+                result.Add(decorator);
+            }
+
+            return result;
+        }
+    }
+}
diff --git a/src/KissLog/LogListenerParser.cs b/src/KissLog/LogListenerParser.cs
@@ -32,7 +32,7 @@ public virtual void AlterDataBeforePersisting(FlushLogArgs args)
             "video/"
         };
 
-        public virtual bool ShouldLog(BeginRequestArgs args)
+        public virtual bool ShouldLog(BeginRequestArgs args, ILogListener logListener)
         {
             if (args.Request == null)
                 return true;
@@ -88,16 +88,6 @@ public virtual bool ShouldLog(FlushLogArgs args, ILogListener logListener)
                 }
             }
 
-            string localPath = args.WebProperties.Request.Url?.LocalPath.ToLowerInvariant();
-            if (string.IsNullOrEmpty(localPath) == false)
-            {
-                if (UrlsToIgnore?.Any() == true)
-                {
-                    if (UrlsToIgnore.Any(p => localPath.Contains(p.ToLowerInvariant())))
-                        return false;
-                }
-            }
-
             return true;
         }
 

diff --git a/src/KissLog/Web/HttpRequest.cs b/src/KissLog/Web/HttpRequest.cs
@@ -4,6 +4,8 @@ namespace KissLog.Web
 {
     public class HttpRequest
     {
+        internal string _KissLogRequestId { get; set; }
+
         public Uri Url { get; set; }
 
         public string UserAgent { get; set; }
@@ -31,6 +33,7 @@ public class HttpRequest
         public HttpRequest()
         {
             Properties = new RequestProperties();
+            _KissLogRequestId = Guid.NewGuid().ToString();
         }
     }
 }