refactor

Author: liammclennan

src/SeqCli/Cli/Commands/Bench/BenchCommand.cs

@@ -113,6 +113,12 @@ public BenchCommand(SeqConnectionFactory connectionFactory)
 
     protected override async Task<int> Run()
     {
+        if (!_withIngestion && !_withQueries)
+        {
+            Log.Error("Use at least one of --with-ingestion and --with-queries");
+            return 1;
+        }
+        
         try
         {
             var (_, apiKey) = _connectionFactory.GetConnectionDetails(_connection);
@@ -138,12 +144,14 @@ protected override async Task<int> Run()
                 {
                     var t = IngestionBenchmark(reportingLogger, runId, connection, apiKey, seqVersion,
                         isQueryBench: _withQueries, cancellationToken)
-                        .ContinueWith(async t =>
+                        .ContinueWith(t =>
                         {
                             if (t.Exception is not null)
                             {
-                                await Console.Error.WriteLineAsync(t.Exception.Message);
+                                return Console.Error.WriteLineAsync(t.Exception.Message);
                             }
+
+                            return Task.CompletedTask;
                         });
 
                     if (!_withQueries)
@@ -223,20 +231,20 @@ async Task IngestionBenchmark(Logger reportingLogger, string runId, SeqConnectio
         }
     }
 
-    async Task<CollectedTimings> QueryBenchmark(Logger reportingLogger, string runId, SeqConnection connection, string seqVersion)
+    async Task<QueryBenchRunResults> QueryBenchmark(Logger reportingLogger, string runId, SeqConnection connection, string seqVersion)
     {
         var cases = ReadCases(_cases);
-        CollectedTimings collectedTimings = new(reportingLogger);
+        QueryBenchRunResults queryBenchRunResults = new(reportingLogger);
         reportingLogger.Information(
             "Query benchmark run {RunId} against {ServerUrl} ({SeqVersion}); {CaseCount} cases, {Runs} runs, from {Start} to {End}",
             runId, connection.Client.ServerUrl, seqVersion, cases.Cases.Count, _runs, _range.Start, _range.End);
 
 
         foreach (var c in cases.Cases.OrderBy(c => c.Id)
-                     .Concat(new [] { CollectedTimings.FINAL_COUNT_CASE }))
+                     .Concat(new [] { QueryBenchRunResults.FINAL_COUNT_CASE }))
         {
             var timings = new QueryBenchCaseTimings(c);
-            collectedTimings.Add(timings);
+            queryBenchRunResults.Add(timings);
 
             foreach (var i in Enumerable.Range(1, _runs))
             {
@@ -274,7 +282,7 @@ async Task<CollectedTimings> QueryBenchmark(Logger reportingLogger, string runId
             }
         }
 
-        return collectedTimings;
+        return queryBenchRunResults;
     }
 
     /// <summary>

src/SeqCli/Cli/Commands/Bench/QueryBenchCaseTimings.cs

@@ -15,61 +15,13 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Serilog.Core;
 
 namespace SeqCli.Cli.Commands.Bench;
 
-class CollectedTimings
-{
-    readonly Logger _reportingLogger;
-    List<QueryBenchCaseTimings> _collectedTimings = new();
-
-    public static QueryBenchCase FINAL_COUNT_CASE = new QueryBenchCase()
-    {
-        Id = "final-count-star",
-        Query = "select count(*) from stream",
-    };
-
-    public CollectedTimings(Logger reportingLogger)
-    {
-        _reportingLogger = reportingLogger;
-    }
-
-    public void Add(QueryBenchCaseTimings caseTimings)
-    {
-        _collectedTimings.Add(caseTimings);
-    }
-
-    public void LogSummary(string description)
-    {
-        _reportingLogger.Information(
-            "Query benchmark {Description} complete in {TotalMeanElapsed:N0} ms with {MeanRelativeStandardDeviationPercentage:N1}% deviation, processed {FinalEventCount:N0} events at {EventsPerMs:N0} events/ms", 
-            description,
-            TotalMeanElapsed(),
-            MeanRelativeStandardDeviationPercentage(),
-            FinalEventCount(),
-            FinalEventCount() * _collectedTimings.Count / TotalMeanElapsed());
-    }
-
-    private double TotalMeanElapsed()
-    {
-        return _collectedTimings.Sum(c => c.MeanElapsed);
-    }
-
-    private double MeanRelativeStandardDeviationPercentage()
-    {
-        return _collectedTimings.Average(c => c.RelativeStandardDeviationElapsed) * 100;
-    }
-
-    private int FinalEventCount()
-    {
-        var benchCase = _collectedTimings.Single(c => c.Id == FINAL_COUNT_CASE.Id);
-        return Convert.ToInt32(benchCase.LastResult);
-    }
-}
-
 /*
- * Collects benchmarking elapsed time measurements and calculates statistics. 
+ * Collects benchmarking elapsed time measurements and calculates statistics.
+ *
+ * The results for one bench case.
  */
 class QueryBenchCaseTimings
 {

src/SeqCli/Cli/Commands/Bench/QueryBenchRunResults.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Serilog.Core;
+
+namespace SeqCli.Cli.Commands.Bench;
+
+class QueryBenchRunResults
+{
+    readonly Logger _reportingLogger;
+    List<QueryBenchCaseTimings> _collectedTimings = new();
+
+    public static QueryBenchCase FINAL_COUNT_CASE = new()
+    {
+        Id = "final-count-star",
+        Query = "select count(*) from stream",
+    };
+
+    public QueryBenchRunResults(Logger reportingLogger)
+    {
+        _reportingLogger = reportingLogger;
+    }
+
+    public void Add(QueryBenchCaseTimings caseTimings)
+    {
+        _collectedTimings.Add(caseTimings);
+    }
+
+    public void LogSummary(string description)
+    {
+        _reportingLogger.Information(
+            "Query benchmark {Description} complete in {TotalMeanElapsed:N0} ms with {MeanRelativeStandardDeviationPercentage:N1}% deviation, processed {FinalEventCount:N0} events at {EventsPerMs:N0} events/ms", 
+            description,
+            TotalMeanElapsed(),
+            MeanRelativeStandardDeviationPercentage(),
+            FinalEventCount(),
+            FinalEventCount() * _collectedTimings.Count / TotalMeanElapsed());
+    }
+
+    private double TotalMeanElapsed()
+    {
+        return _collectedTimings.Sum(c => c.MeanElapsed);
+    }
+
+    private double MeanRelativeStandardDeviationPercentage()
+    {
+        return _collectedTimings.Average(c => c.RelativeStandardDeviationElapsed) * 100;
+    }
+
+    private int FinalEventCount()
+    {
+        var benchCase = _collectedTimings.Single(c => c.Id == FINAL_COUNT_CASE.Id);
+        return Convert.ToInt32(benchCase.LastResult);
+    }
+}