Add direct access API for metrics

This adds COUNTER_VALUE, GAUGE_VALUE, and HISTOGRAM_VALUE macros that
allow reading metric values directly as native types (int64_t for
counters/gauges, HistogramStatistics struct for histograms) without
going through JSON serialization.

Also made gather_result() public to allow custom metric collection
without JSON if needed.

Tests added to farm_test.cpp verify the new direct access methods
work correctly across all metric types.

Signed-off-by: Xiaoxi Chen <xiaoxchen@ebay.com>

Author: xiaoxichen

conanfile.py

@@ -9,7 +9,7 @@
 
 class SISLConan(ConanFile):
     name = "sisl"
-    version = "13.1.1"
+    version = "13.1.2"
 
     homepage = "https://github.com/eBay/sisl"
     description = "Library for fast data structures, utilities"

include/sisl/metrics/metrics.hpp

@@ -292,7 +292,12 @@ struct NamedHistogram< tstring< elements... > > {
 #define COUNTER_DECREMENT_IF_ELSE(group, cond, namea, nameb, ...)                                                      \
     __VALIDATE_AND_EXECUTE_IF_ELSE(group, NamedCounter, counter_decrement, cond, namea, nameb, __VA_ARGS__)
 
+#define COUNTER_VALUE(group, name)                                                                                     \
+    ((group).m_impl_ptr->counter_get(COUNTER_INDEX(name)))
+
 #define GAUGE_UPDATE(group, name, ...) __VALIDATE_AND_EXECUTE(group, NamedGauge, gauge_update, name, __VA_ARGS__)
+#define GAUGE_VALUE(group, name)                                                                                       \
+    ((group).m_impl_ptr->gauge_get(GAUGE_INDEX(name)))
 #define GAUGE_UPDATE_IF_ELSE(group, cond, namea, nameb, ...)                                                           \
     __VALIDATE_AND_EXECUTE_IF_ELSE(group, NamedGauge, gauge_update, cond, namea, nameb, __VA_ARGS__)
 
@@ -301,6 +306,9 @@ struct NamedHistogram< tstring< elements... > > {
 #define HISTOGRAM_OBSERVE_IF_ELSE(group, cond, namea, nameb, ...)                                                      \
     __VALIDATE_AND_EXECUTE_IF_ELSE(group, NamedHistogram, histogram_observe, cond, namea, nameb, __VA_ARGS__)
 
+#define HISTOGRAM_VALUE(group, name)                                                                                   \
+    ((group).m_impl_ptr->histogram_get(HISTOGRAM_INDEX(name)))
+
 #if 0
 #define COUNTER_INCREMENT(group, name, ...)                                                                            \
     {                                                                                                                  \

include/sisl/metrics/metrics_atomic.hpp

@@ -97,8 +97,10 @@ class AtomicMetricsGroup : public MetricsGroupImpl {
 
     void counter_increment(const uint64_t index, const int64_t val = 1) override;
     void counter_decrement(const uint64_t index, const int64_t val = 1) override;
+    int64_t counter_get(const uint64_t index) override;
     void histogram_observe(const uint64_t index, const int64_t val) override;
     void histogram_observe(const uint64_t index, const int64_t val, const uint64_t count) override;
+    HistogramStatistics histogram_get(const uint64_t index) override;
 
     [[nodiscard]] group_impl_type_t impl_type() const { return group_impl_type_t::atomic; }
 

include/sisl/metrics/metrics_group_impl.hpp

@@ -261,6 +261,15 @@ class HistogramStaticInfo {
     const hist_bucket_boundaries_t& m_bkt_boundaries;
 };
 
+// Structure to hold histogram statistics
+struct HistogramStatistics {
+    int64_t count{0};
+    double average{0.0};
+    double p50{0.0};  // 50th percentile (median)
+    double p95{0.0};  // 95th percentile
+    double p99{0.0};  // 99th percentile
+};
+
 class HistogramDynamicInfo {
     friend class MetricsGroupImpl;
 
@@ -385,11 +394,14 @@ class MetricsGroupImpl {
 
     virtual void counter_increment(const uint64_t index, const int64_t val = 1) = 0;
     virtual void counter_decrement(const uint64_t index, const int64_t val = 1) = 0;
+    virtual int64_t counter_get(const uint64_t index) = 0;
 
     void gauge_update(const uint64_t index, const int64_t val);
+    int64_t gauge_get(const uint64_t index) { return m_gauge_values[index].get(); }
 
     virtual void histogram_observe(const uint64_t index, const int64_t val, const uint64_t count) = 0;
     virtual void histogram_observe(const uint64_t index, const int64_t val) = 0;
+    virtual HistogramStatistics histogram_get(const uint64_t index) = 0;
 
     nlohmann::json get_result_in_json(const bool need_latest);
     [[nodiscard]] const std::string& get_group_name() const;
@@ -448,7 +460,7 @@ class MetricsGroupImpl {
 
     virtual void on_register() = 0;
 
-protected:
+    // Public API to gather metrics with callbacks for direct access to counter/gauge/histogram values
     virtual void gather_result(const bool need_latest, const counter_gather_cb_t& counter_cb,
                                const gauge_gather_cb_t& gauge_cb, const histogram_gather_cb_t& histogram_cb) = 0;
 

include/sisl/metrics/metrics_rcu.hpp

@@ -38,8 +38,10 @@ class WisrBufferMetricsGroup : public MetricsGroupImpl {
 
     void counter_increment(uint64_t index, int64_t val = 1) override;
     void counter_decrement(uint64_t index, int64_t val = 1) override;
+    int64_t counter_get(uint64_t index) override;
     void histogram_observe(uint64_t index, int64_t val) override;
     void histogram_observe(uint64_t index, int64_t val, uint64_t count) override;
+    HistogramStatistics histogram_get(uint64_t index) override;
 
     group_impl_type_t impl_type() const { return group_impl_type_t::rcu; }
 

include/sisl/metrics/metrics_tlocal.hpp

@@ -86,8 +86,10 @@ class ThreadBufferMetricsGroup : public MetricsGroupImpl {
 
     void counter_increment(const uint64_t index, const int64_t val = 1) override;
     void counter_decrement(const uint64_t index, const int64_t val = 1) override;
+    int64_t counter_get(const uint64_t index) override;
     void histogram_observe(const uint64_t index, const int64_t val) override;
     void histogram_observe(const uint64_t index, const int64_t val, const uint64_t count) override;
+    HistogramStatistics histogram_get(const uint64_t index) override;
 
     static void flush_core_cache();
 

src/metrics/metrics_atomic.cpp

@@ -49,6 +49,8 @@ void AtomicMetricsGroup::counter_increment(uint64_t index, int64_t val) { m_coun
 
 void AtomicMetricsGroup::counter_decrement(uint64_t index, int64_t val) { m_counter_values[index].decrement(val); }
 
+int64_t AtomicMetricsGroup::counter_get(uint64_t index) { return m_counter_values[index].to_counter_value().get(); }
+
 // If we were to call the method with count parameter and compiler inlines them, binaries linked with libsisl gets
 // linker errors. At the same time we also don't want to non-inline this method, since its the most obvious call
 // everyone makes and wanted to avoid additional function call in the stack. Hence we are duplicating the function
@@ -60,4 +62,18 @@ void AtomicMetricsGroup::histogram_observe(uint64_t index, int64_t val) {
 void AtomicMetricsGroup::histogram_observe(uint64_t index, int64_t val, uint64_t count) {
     m_histogram_values[index].observe(val, hist_static_info(index).get_boundaries(), count);
 }
+
+HistogramStatistics AtomicMetricsGroup::histogram_get(uint64_t index) {
+    HistogramStatistics stats;
+    HistogramValue hvalue = m_histogram_values[index].to_histogram_value();
+    const auto& boundaries = hist_static_info(index).get_boundaries();
+
+    stats.count = hist_dynamic_info(index).count(hvalue);
+    stats.average = hist_dynamic_info(index).average(hvalue);
+    stats.p50 = hist_dynamic_info(index).percentile(hvalue, boundaries, 50.0f);
+    stats.p95 = hist_dynamic_info(index).percentile(hvalue, boundaries, 95.0f);
+    stats.p99 = hist_dynamic_info(index).percentile(hvalue, boundaries, 99.0f);
+
+    return stats;
+}
 } // namespace sisl

src/metrics/metrics_rcu.cpp

@@ -33,6 +33,12 @@ void WisrBufferMetricsGroup::counter_decrement(uint64_t index, int64_t val) {
     m->get_counter(index).decrement(val);
 }
 
+int64_t WisrBufferMetricsGroup::counter_get(uint64_t index) {
+    // Get the latest snapshot and read the specific counter
+    PerThreadMetrics* tmetrics = m_metrics->now();
+    return tmetrics->get_counter(index).get();
+}
+
 // If we were to call the method with count parameter and compiler inlines them, binaries linked with libsisl gets
 // linker errors. At the same time we also don't want to non-inline this method, since its the most obvious call
 // everyone makes and wanted to avoid additional function call in the stack. Hence we are duplicating the function
@@ -47,6 +53,22 @@ void WisrBufferMetricsGroup::histogram_observe(uint64_t index, int64_t val, uint
     m->get_histogram(index).observe(val, hist_static_info(index).get_boundaries(), count);
 }
 
+HistogramStatistics WisrBufferMetricsGroup::histogram_get(uint64_t index) {
+    // Get the latest snapshot and read the specific histogram
+    PerThreadMetrics* tmetrics = m_metrics->now();
+    const HistogramValue& hvalue = tmetrics->get_histogram(index);
+    const auto& boundaries = hist_static_info(index).get_boundaries();
+
+    HistogramStatistics stats;
+    stats.count = hist_dynamic_info(index).count(hvalue);
+    stats.average = hist_dynamic_info(index).average(hvalue);
+    stats.p50 = hist_dynamic_info(index).percentile(hvalue, boundaries, 50.0f);
+    stats.p95 = hist_dynamic_info(index).percentile(hvalue, boundaries, 95.0f);
+    stats.p99 = hist_dynamic_info(index).percentile(hvalue, boundaries, 99.0f);
+
+    return stats;
+}
+
 void WisrBufferMetricsGroup::gather_result(bool need_latest, const counter_gather_cb_t& counter_cb,
                                            const gauge_gather_cb_t& gauge_cb,
                                            const histogram_gather_cb_t& histogram_cb) {

src/metrics/metrics_tlocal.cpp

@@ -150,6 +150,18 @@ void ThreadBufferMetricsGroup::counter_decrement(const uint64_t index, const int
     m_metrics_buf->get()->get_counter(index).decrement(val);
 }
 
+int64_t ThreadBufferMetricsGroup::counter_get(const uint64_t index) {
+    // Gather the specific counter value from all threads
+    flush_core_cache();
+    CounterValue result_counter;
+    m_metrics_buf->access_all_threads([&](PerThreadMetrics* tmetrics, [[maybe_unused]] bool is_thread_running,
+                                          [[maybe_unused]] bool is_last_thread) {
+        result_counter.merge(tmetrics->get_counter(index));
+        return true;
+    });
+    return result_counter.get();
+}
+
 // If we were to call the method with count parameter and compiler inlines them, binaries linked with libsisl gets
 // linker errors. At the same time we also don't want to non-inline this method, since its the most obvious call
 // everyone makes and wanted to avoid additional function call in the stack. Hence we are duplicating the function
@@ -161,4 +173,26 @@ void ThreadBufferMetricsGroup::histogram_observe(const uint64_t index, const int
 void ThreadBufferMetricsGroup::histogram_observe(const uint64_t index, const int64_t val, const uint64_t count) {
     m_metrics_buf->get()->get_histogram(index).observe(val, m_static_info->m_histograms[index].get_boundaries(), count);
 }
+
+HistogramStatistics ThreadBufferMetricsGroup::histogram_get(const uint64_t index) {
+    // Gather the specific histogram value from all threads
+    flush_core_cache();
+    HistogramValue result_histogram;
+    const auto& boundaries = hist_static_info(index).get_boundaries();
+
+    m_metrics_buf->access_all_threads([&](PerThreadMetrics* tmetrics, [[maybe_unused]] bool is_thread_running,
+                                          [[maybe_unused]] bool is_last_thread) {
+        result_histogram.merge(tmetrics->get_histogram(index), boundaries);
+        return true;
+    });
+
+    HistogramStatistics stats;
+    stats.count = hist_dynamic_info(index).count(result_histogram);
+    stats.average = hist_dynamic_info(index).average(result_histogram);
+    stats.p50 = hist_dynamic_info(index).percentile(result_histogram, boundaries, 50.0f);
+    stats.p95 = hist_dynamic_info(index).percentile(result_histogram, boundaries, 95.0f);
+    stats.p99 = hist_dynamic_info(index).percentile(result_histogram, boundaries, 99.0f);
+
+    return stats;
+}
 } // namespace sisl

src/metrics/tests/farm_test.cpp

@@ -34,33 +34,47 @@ SISL_LOGGING_INIT(vmod_metrics_framework)
 
 using namespace sisl;
 
+class Group1Metrics : public MetricsGroup {
+public:
+    explicit Group1Metrics(const char* inst_name)
+        : MetricsGroup("Group1", inst_name, group_impl_type_t::thread_buf_signal) {
+        REGISTER_COUNTER(counter1, "Counter1");
+        REGISTER_COUNTER(counter2, "Counter2");
+        REGISTER_COUNTER(counter3, "Counter3");
+        register_me_to_farm();
+    }
+    ~Group1Metrics() { deregister_me_from_farm(); }
+};
+
+class Group2Metrics : public MetricsGroup {
+public:
+    explicit Group2Metrics(const char* inst_name)
+        : MetricsGroup("Group2", inst_name, group_impl_type_t::thread_buf_signal) {
+        REGISTER_GAUGE(gauge1, "Gauge1");
+        REGISTER_GAUGE(gauge2, "Gauge2");
+        register_me_to_farm();
+    }
+    ~Group2Metrics() { deregister_me_from_farm(); }
+};
+
 void userA() {
-    auto mgroup = std::make_shared< ThreadBufferMetricsGroup >("Group1", "Instance1");
-    mgroup->register_counter("counter1", "Counter1");
-    mgroup->register_counter("counter2", "Counter2");
-    mgroup->register_counter("counter3", "Counter3");
-    MetricsFarm::getInstance().register_metrics_group(mgroup);
-
-    mgroup->counter_increment(0);
-    mgroup->counter_increment(2, 4);
+    Group1Metrics metrics("Instance1");
+
+    COUNTER_INCREMENT(metrics, counter1, 1);
+    COUNTER_INCREMENT(metrics, counter3, 4);
     std::this_thread::sleep_for(std::chrono::seconds(3));
-    mgroup->counter_increment(1);
+    COUNTER_INCREMENT(metrics, counter2, 1);
     std::this_thread::sleep_for(std::chrono::seconds(4));
-    MetricsFarm::getInstance().deregister_metrics_group(mgroup);
 }
 
 void userB() {
-    auto mgroup = std::make_shared< ThreadBufferMetricsGroup >("Group2", "Instance1");
-    mgroup->register_gauge("gauge1", "Gauge1");
-    mgroup->register_gauge("gauge2", "Gauge2");
-    MetricsFarm::getInstance().register_metrics_group(mgroup);
+    Group2Metrics metrics("Instance1");
 
-    mgroup->gauge_update(0, 5);
+    GAUGE_UPDATE(metrics, gauge1, 5);
     std::this_thread::sleep_for(std::chrono::seconds(3));
-    mgroup->gauge_update(1, 2);
-    mgroup->gauge_update(0, 3);
+    GAUGE_UPDATE(metrics, gauge2, 2);
+    GAUGE_UPDATE(metrics, gauge1, 3);
     std::this_thread::sleep_for(std::chrono::seconds(4));
-    MetricsFarm::getInstance().deregister_metrics_group(mgroup);
 }
 
 // clang-format off
@@ -134,7 +148,7 @@ void gather() {
     }
 }
 
-TEST(farmTest, gather) {
+TEST(FarmTest, gather) {
     std::thread th1(userA);
     std::thread th2(userB);
     std::thread th3(gather);
@@ -144,6 +158,67 @@ TEST(farmTest, gather) {
     th3.join();
 }
 
+// Helper class for DirectAccess tests
+class TestMetrics : public MetricsGroup {
+public:
+    explicit TestMetrics(const char* inst_name, group_impl_type_t type = group_impl_type_t::rcu)
+        : MetricsGroup("TestGroup", inst_name, type) {
+        REGISTER_COUNTER(test_counter, "Test counter");
+        REGISTER_GAUGE(test_gauge, "Test gauge");
+        REGISTER_HISTOGRAM(test_histogram, "Test histogram");
+        register_me_to_farm();
+    }
+    ~TestMetrics() { deregister_me_from_farm(); }
+};
+
+// Parameterized test fixture for DirectAccess tests
+class DirectAccessTest : public ::testing::TestWithParam< group_impl_type_t > {};
+
+// Test direct access to counter, gauge, and histogram values
+TEST_P(DirectAccessTest, allMetricTypes) {
+    group_impl_type_t impl_type = GetParam();
+    TestMetrics metrics("direct_access_test", impl_type);
+
+    // Test counter
+    COUNTER_INCREMENT(metrics, test_counter, 5);
+    COUNTER_INCREMENT(metrics, test_counter, 10);
+    COUNTER_INCREMENT(metrics, test_counter, 15);
+    int64_t counter_value = COUNTER_VALUE(metrics, test_counter);
+    EXPECT_EQ(counter_value, 30);
+
+    // Test gauge
+    GAUGE_UPDATE(metrics, test_gauge, 100);
+    EXPECT_EQ(GAUGE_VALUE(metrics, test_gauge), 100);
+    GAUGE_UPDATE(metrics, test_gauge, 250);
+    EXPECT_EQ(GAUGE_VALUE(metrics, test_gauge), 250);
+
+    // Test histogram
+    HISTOGRAM_OBSERVE(metrics, test_histogram, 10);
+    HISTOGRAM_OBSERVE(metrics, test_histogram, 20);
+    HISTOGRAM_OBSERVE(metrics, test_histogram, 30);
+    HISTOGRAM_OBSERVE(metrics, test_histogram, 40);
+    HISTOGRAM_OBSERVE(metrics, test_histogram, 50);
+
+    sisl::HistogramStatistics stats = HISTOGRAM_VALUE(metrics, test_histogram);
+    EXPECT_EQ(stats.count, 5);
+    EXPECT_DOUBLE_EQ(stats.average, 30.0);
+    EXPECT_GT(stats.p50, 0.0);
+    EXPECT_GT(stats.p95, 0.0);
+    EXPECT_GT(stats.p99, 0.0);
+}
+
+INSTANTIATE_TEST_SUITE_P(AllImplementations, DirectAccessTest,
+                         ::testing::Values(group_impl_type_t::rcu, group_impl_type_t::atomic,
+                                           group_impl_type_t::thread_buf_signal),
+                         [](const ::testing::TestParamInfo< group_impl_type_t >& info) {
+                             switch (info.param) {
+                             case group_impl_type_t::rcu: return "RCU";
+                             case group_impl_type_t::atomic: return "Atomic";
+                             case group_impl_type_t::thread_buf_signal: return "ThreadLocal";
+                             default: return "Unknown";
+                             }
+                         });
+
 int main(int argc, char* argv[]) {
     ::testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();