feat(measurements): add measurements

fossapps · Nov 16, 2019 · 0906c8a · 0906c8a
1 parent 4546206
commit 0906c8a
Show file tree

Hide file tree

Showing 5 changed files with 73 additions and 6 deletions.
diff --git a/Micro.KeyStore.Api/Keys/KeysController.cs b/Micro.KeyStore.Api/Keys/KeysController.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using App.Metrics;
 using Micro.KeyStore.Api.Keys.Models;
 using Micro.KeyStore.Api.Keys.Repositories;
 using Micro.KeyStore.Api.Keys.Services;
@@ -27,6 +28,7 @@ public KeysController(IKeyService keyService, IKeyRepository keyRepository, ILog
         [HttpPost]
         [ProducesResponseType(typeof(KeyCreatedResponse), StatusCodes.Status201Created)]
         [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status409Conflict)]
+        [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status500InternalServerError)]
         public async Task<IActionResult> Add(CreateKeyRequest request)
         {
             var key = new Key
@@ -60,6 +62,7 @@ public async Task<IActionResult> Add(CreateKeyRequest request)
 
         [HttpGet("{id}")]
         [ProducesResponseType(typeof(KeyCreatedResponse), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
         public async Task<IActionResult> Get(string id)
         {
             var key = await _keyRepository.FindByShortSha(id);

diff --git a/Micro.KeyStore.Api/Measurements/KeyController.cs b/Micro.KeyStore.Api/Measurements/KeyController.cs
@@ -0,0 +1,7 @@
+namespace Micro.KeyStore.Api.Measurements
+{
+    public static class KeyController
+    {
+        public static void Measure
+    }
+}
diff --git a/Micro.KeyStore.Api/Measurements/Timer.cs b/Micro.KeyStore.Api/Measurements/Timer.cs
@@ -23,5 +23,13 @@ public static (TimeSpan, T) Measure<T>(Func<T> fn)
             var elapsed = stopwatch.Elapsed;
             return (elapsed, result);
         }
+
+        public static async Task<TimeSpan> MeasureAsync(Func<Task> fn)
+        {
+            var stopwatch = new Stopwatch();
+            stopwatch.Start();
+            await fn();
+            return stopwatch.Elapsed;
+        }
     }
 }
diff --git a/Micro.KeyStore.Api/Measurements/WorkerMeasurements.cs b/Micro.KeyStore.Api/Measurements/WorkerMeasurements.cs
@@ -0,0 +1,40 @@
+using System;
+using App.Metrics;
+
+namespace Micro.KeyStore.Api.Measurements
+{
+    public class WorkerMeasurements
+    {
+        public static void MeasureTime(IMetrics metrics, TimeSpan duration)
+        {
+            var timer = new App.Metrics.Timer.TimerOptions
+            {
+                Name = "KeyArchiveSaveTime",
+                DurationUnit = TimeUnit.Milliseconds,
+                RateUnit = TimeUnit.Milliseconds
+            };
+            metrics?.Provider?.Timer.Instance(timer).Record((long) duration.TotalMilliseconds, TimeUnit.Milliseconds);
+        }
+
+        public static void MeasureArchiveOccurrence(IMetrics metrics)
+        {
+            var meter = new App.Metrics.Meter.MeterOptions
+            {
+                Name = "KeyArchive",
+                MeasurementUnit = Unit.Events,
+                RateUnit = TimeUnit.Seconds
+            };
+            metrics?.Provider?.Meter.Instance(meter).Mark();
+        }
+        public static void MeasureErrorOccurrence(IMetrics metrics)
+        {
+            var meter = new App.Metrics.Meter.MeterOptions
+            {
+                Name = "KeyArchiveError",
+                MeasurementUnit = Unit.Events,
+                RateUnit = TimeUnit.Seconds
+            };
+            metrics?.Provider?.Meter.Instance(meter).Mark();
+        }
+    }
+}
diff --git a/Micro.KeyStore.Api/Workers/CleanupKeysWorker.cs b/Micro.KeyStore.Api/Workers/CleanupKeysWorker.cs
@@ -5,6 +5,7 @@
 using App.Metrics;
 using Micro.KeyStore.Api.Archive;
 using Micro.KeyStore.Api.Keys.Repositories;
+using Micro.KeyStore.Api.Measurements;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
@@ -41,31 +42,39 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
             {
                 while (!stoppingToken.IsCancellationRequested)
                 {
-                    var keys = await _keyRepository.FindCreatedBefore(
-                        DateTime.Now.Subtract(TimeSpan.FromMinutes(_config.TimeToLiveInMinutes)), _config.BatchSize);
+                    var keys = (await _keyRepository.FindCreatedBefore(
+                        DateTime.Now.Subtract(TimeSpan.FromMinutes(_config.TimeToLiveInMinutes)), _config.BatchSize)).ToList();
                     foreach (var key in keys)
                     {
                         try
                         {
-                            await _archiver.Save(new Key
+                            var elapsed = await Measurements.Timer.MeasureAsync(async () => await _archiver.Save(new Key
                             {
                                 Body = key.Body,
                                 Id = key.ShortSha
-                            });
+                            }));
+                            WorkerMeasurements.MeasureTime(_metrics, elapsed);
+                            WorkerMeasurements.MeasureArchiveOccurrence(_metrics);
                             await _keyRepository.Remove(key.Id);
                         }
                         catch (Exception e)
                         {
+                            WorkerMeasurements.MeasureErrorOccurrence(_metrics);
                             _logger.LogError(e, "exception caught");
                         }
+
+                        if (stoppingToken.IsCancellationRequested)
+                        {
+                            return;
+                        }
                     }
 
-                    _logger.LogInformation($"Archived {keys.Count()} keys at {DateTime.Now}");
+                    _logger.LogInformation($"Archived {keys.Count} keys at {DateTime.Now}");
                     if (stoppingToken.IsCancellationRequested) return;
                     await Task.Delay(TimeSpan.FromSeconds(_config.BatchIntervalInSeconds), stoppingToken);
                 }
             }
-            catch (OperationCanceledException e)
+            catch (OperationCanceledException)
             {
                 // do nothing
             }