ScopeTimer (#26)

Adds a new utility `ScopeTimer` that measures the duration of its lifecycle using RAII.

e.g.:
```cpp
void critical_operation() {
    ScopeTimer<> _timer([](double elapsed_sec){
        std::cout << "critical_operation() took " << elapsed_sec << " seconds." << std::endl;
    });
    // do stuff
}
```

Author: JoshStoddard

include/metrics/README.md

@@ -154,6 +154,6 @@ We currently rely on [*prometheus-cpp*](https://github.com/jupp0r/prometheus-cpp
 ### Efficient lookup
 * Lookup of existing metric object is supported by *prometheus-cpp* but inefficient. A more optimized lookup would make metric values more accessible in disjoint places within ApertureDB.
 ### Typed metric values
-* Metric values with templatized value types may provide performance, memory, and/or payload improvements.
+* Metric values with templatized value types may provide performance, memory, and/or payload improvements. For example, integer-valued counters.
 ### Remove redundancy
 * Histograms and Summaries currently encode redundant data in the distribution. As an added benefit, this may remove the need to represent infinite floating point values in JSON.

include/metrics/Timer.h

@@ -6,11 +6,10 @@
 
 #pragma once
 
-#include <time.h>
-#include <math.h>
-#include <chrono>
+#include <memory>
 #include <prometheus/histogram.h>
 #include <prometheus/counter.h>
+#include "util/ScopeTimer.h"
 
 namespace metrics
 {
@@ -23,28 +22,20 @@ template<
 class Timer
 {
 public:
+    using this_type = Timer< METRIC_TYPE, TIME_UNIT >;
     using metric_type = METRIC_TYPE;
-    using duration_type = typename std::chrono::duration< double, typename TIME_UNIT::period >;
+    using timer_type = ScopeTimer< TIME_UNIT, double >;
+    using duration_type = typename timer_type::duration_type;
 
 private:
-    metric_type* _timer;
-    timespec _start;
+    std::unique_ptr< timer_type > _timer;
 
 public:
-    explicit Timer(metric_type* timer = nullptr,
+    explicit Timer(metric_type* metric = nullptr,
         prometheus::Counter* start_counter = nullptr)
-    : _timer(timer)
-    , _start()
+    : _timer()
     {
-        clock_gettime(CLOCK_MONOTONIC, &_start);
-        if (start_counter)
-            start_counter->Increment();
-    }
-
-    ~Timer() {
-        try {
-            reset();
-        } catch (...) {}
+        reset(metric, start_counter);
     }
 
     // not copyable
@@ -53,34 +44,28 @@ class Timer
 
     // noexcept moveable
     explicit Timer(Timer&& other) noexcept
-    : _timer( other._timer )
-    , _start( std::move(other._start) )
+    : _timer(std::move(other._timer))
     {
-        other._timer = nullptr;
     }
 
     Timer& operator=(Timer&& other) noexcept {
         if (&other != this) {
-            _timer = other._timer;
-            other._timer = nullptr;
-            _start = std::move( other._start );
+            _timer = std::move( other._timer );
         }
         return *this;
     }
 
-    void reset(metric_type* timer = nullptr,
+    void reset(metric_type* metric = nullptr,
         prometheus::Counter* start_counter = nullptr)
     {
-        timespec now;
-        clock_gettime(CLOCK_MONOTONIC, &now);
-        if (_timer) {
-            duration_type dur =
-                std::chrono::nanoseconds(now.tv_nsec - _start.tv_nsec) +
-                std::chrono::seconds(now.tv_sec - _start.tv_sec);
-            _timer->Observe(dur.count());
+        if (metric) {
+            _timer = std::make_unique< timer_type >([metric](double elapsed) {
+                metric->Observe(elapsed);
+            });
+        }
+        else {
+            _timer.reset();
         }
-        _timer = timer;
-        _start = std::move( now );
         if ( start_counter ) start_counter->Increment();
     }
 };

include/util/ScopeTimer.h

@@ -0,0 +1,54 @@
+/**
+ *
+ * @copyright Copyright (c) 2022 ApertureData
+ *
+ */
+
+#pragma once
+
+#include <time.h>
+#include <math.h>
+#include <chrono>
+
+// A scoped timer that calls the provided callback on destruction passing the elapsed time as arg.
+// Usage example:
+// void profile_foo() {
+//     ScopeTimer<> _timer([](double elapsed_sec){
+//         std::cout << "foo() took " << elapsed_sec << " seconds." << std::endl;
+//     });
+//     foo();
+// }
+template<
+    typename TIME_UNIT = std::chrono::seconds,
+    typename TIME_REP = double
+>
+class ScopeTimer {
+public:
+    using callback_type = std::function< void(TIME_REP) >;
+    using duration_type = typename std::chrono::duration< TIME_REP, typename TIME_UNIT::period >;
+
+private:
+    callback_type _cb;
+    timespec _start;
+
+public:
+    explicit ScopeTimer(callback_type cb)
+    : _cb(std::move(cb))
+    , _start()
+    {
+        clock_gettime(CLOCK_MONOTONIC, &_start);
+    }
+
+    ~ScopeTimer() {
+        try {
+            timespec now;
+            clock_gettime(CLOCK_MONOTONIC, &now);
+            if (_cb) {
+                duration_type dur =
+                    std::chrono::nanoseconds(now.tv_nsec - _start.tv_nsec) +
+                    std::chrono::seconds(now.tv_sec - _start.tv_sec);
+                _cb(std::move(dur).count());
+            }
+        } catch (...) {}
+    }
+};