Add some memory analysis

Author: mauroservienti

src/ServiceControl.Audit.Persistence.RavenDB/CustomChecks/CheckDirtyMemory.cs

@@ -28,8 +28,10 @@ public override async Task<CheckResult> PerformCheck(CancellationToken cancellat
             lastDirtyMemoryReads.RemoveAt(lastDirtyMemoryReads.Count - 1);
         }
 
-        // evaluate the trends
-        // if the amount of dirty memory is constantly growing log a warning and fail the check
+        if (lastDirtyMemoryReads.Count > 3 && AnalyzeTrendUsingRegression(lastDirtyMemoryReads) == TrendDirection.Increasing) // Three means we'll be observing for 15 minutes before calculating the trend
+        {
+            // log a warning and fail the check
+        }
 
         return CheckResult.Pass;
     }
@@ -45,4 +47,53 @@ async Task<MemoryInformationRetriever> GetMemoryRetriever(CancellationToken canc
         }
         return _retriever;
     }
+
+    static TrendDirection AnalyzeTrendUsingRegression(List<int> values)
+    {
+        if (values == null || values.Count <= 1)
+        {
+            throw new ArgumentException("Need at least two values to determine a trend");
+        }
+
+        // Calculate slope using linear regression
+        double n = values.Count;
+        double sumX = 0;
+        double sumY = 0;
+        double sumXY = 0;
+        double sumXX = 0;
+
+        for (int i = 0; i < values.Count; i++)
+        {
+            double x = i;
+            double y = values[i];
+
+            sumX += x;
+            sumY += y;
+            sumXY += x * y;
+            sumXX += x * x;
+        }
+
+        double slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
+
+        // Determine trend based on slope
+        if (Math.Abs(slope) < 0.001) // Small threshold to handle floating-point precision
+        {
+            return TrendDirection.Flat;
+        }
+
+        if (slope > 0)
+        {
+            return TrendDirection.Increasing;
+        }
+
+        return TrendDirection.Decreasing;
+    }
+
+    enum TrendDirection
+    {
+        Increasing,
+        Decreasing,
+        Flat,
+        Mixed
+    }
 }