Ignore suggestions based on previously ignored

src/Geta.NotFoundHandler/Core/Suggestions/RequestLogger.cs

@@ -3,9 +3,12 @@
 
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Linq;
+using Geta.NotFoundHandler.Core.Redirects;
 using Geta.NotFoundHandler.Data;
 using Geta.NotFoundHandler.Infrastructure.Configuration;
+using Geta.NotFoundHandler.Infrastructure.Processing;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 
@@ -15,28 +18,30 @@ public class RequestLogger : IRequestLogger
     {
         private readonly ILogger<RequestLogger> _logger;
         private readonly ISuggestionRepository _suggestionRepository;
+        private readonly IRedirectsService _redirectsService;
         private readonly NotFoundHandlerOptions _configuration;
 
         public RequestLogger(
             IOptions<NotFoundHandlerOptions> options,
             ILogger<RequestLogger> logger,
-            ISuggestionRepository suggestionRepository)
+            ISuggestionRepository suggestionRepository,
+            IRedirectsService redirectsService)
         {
             _logger = logger;
             _suggestionRepository = suggestionRepository;
+            _redirectsService = redirectsService;
             _configuration = options.Value;
         }
 
         public void LogRequest(string oldUrl, string referer)
         {
-            var bufferSize = _configuration.BufferSize;
-            if (!LogQueue.IsEmpty && LogQueue.Count >= bufferSize)
+            if (AllowLogOfRequests())
             {
                 lock (LogQueue)
                 {
                     try
                     {
-                        if (LogQueue.Count >= bufferSize)
+                        if (AllowLogOfRequests())
                         {
                             LogRequests(LogQueue);
                         }
@@ -58,14 +63,15 @@ private void LogRequests(ConcurrentQueue<LogEvent> logEvents)
             var threshold = _configuration.ThreshHold;
             var start = logEvents.First().Requested;
             var end = logEvents.Last().Requested;
-            var diff = (end - start).Seconds;
+            var diff = (int)Math.Floor((end - start).TotalSeconds);
 
             if ((diff != 0 && bufferSize / diff <= threshold)
                 || bufferSize == 0)
             {
+                var ignored = _redirectsService.GetIgnored().Select(x => x.OldUrl);
                 while (!logEvents.IsEmpty)
                 {
-                    if (logEvents.TryDequeue(out var logEvent))
+                    if (logEvents.TryDequeue(out var logEvent) && !IgnoreSuggestion(logEvent, ignored))
                     {
                         _suggestionRepository.Save(logEvent.OldUrl, logEvent.Referer, logEvent.Requested);
                     }
@@ -80,6 +86,30 @@ private void LogRequests(ConcurrentQueue<LogEvent> logEvents)
             }
         }
 
+        private bool AllowLogOfRequests()
+        {
+            if (LogQueue.IsEmpty)
+                return false;
+
+            var bufferSize = _configuration.BufferSize;
+            var threshold = _configuration.ThreshHold;
+            if (threshold > 0 && bufferSize > 0 && (bufferSize / (DateTime.UtcNow - LogQueue.Last().Requested).TotalSeconds) <= threshold)
+                return true;
+
+            return LogQueue.Count >= bufferSize;
+        }
+
+        private static bool IgnoreSuggestion(LogEvent logEvent, IEnumerable<string> ignored)
+        {
+            if (logEvent.OldUrl.StartsWith("/EPiServer/", StringComparison.InvariantCultureIgnoreCase))
+                return true;
+
+            if (ignored.Any(x => logEvent.OldUrl.AsPathSpan().UrlPathMatch(x.AsPathSpan()) && logEvent.OldUrl.AsPathSpan().StartsWith(x.AsQuerySpan(), StringComparison.InvariantCultureIgnoreCase)))
+                return true;
+
+            return false;
+        }
+
         private static ConcurrentQueue<LogEvent> LogQueue { get; } = new ConcurrentQueue<LogEvent>();
     }
 }