From 48dd89ef3375efc6bc632f399f59daf0731f9db2 Mon Sep 17 00:00:00 2001 From: Arne Welzel Date: Wed, 11 Sep 2024 17:49:06 +0200 Subject: [PATCH] telemetry: Move callbacks to Zeek Now that we run callbacks on the main loop, we can move callback support for Counter and Gauge instances directly into Zeek and don't need to patch prometheus-cpp anymore. --- src/DNS_Mgr.cc | 28 ++++++++--------- src/Timer.cc | 28 +++++------------ src/Trigger.cc | 10 ++---- src/broker/Manager.cc | 18 ++--------- src/session/Manager.cc | 9 ++---- src/telemetry/Counter.cc | 31 +++++++++---------- src/telemetry/Counter.h | 27 +++++++++++++--- src/telemetry/Gauge.cc | 28 ++++++++--------- src/telemetry/Gauge.h | 24 ++++++++++++--- src/telemetry/Histogram.h | 2 ++ src/telemetry/Manager.cc | 49 ++++++++--------------------- src/telemetry/Manager.h | 12 +++++--- src/telemetry/MetricFamily.h | 2 ++ src/telemetry/Utils.h | 1 - src/threading/Manager.cc | 60 +++++++++++++----------------------- 15 files changed, 143 insertions(+), 186 deletions(-) diff --git a/src/DNS_Mgr.cc b/src/DNS_Mgr.cc index 33da7dd0ae..ba019a589e 100644 --- a/src/DNS_Mgr.cc +++ b/src/DNS_Mgr.cc @@ -557,42 +557,38 @@ void DNS_Mgr::InitPostScript() { cached_hosts_metric = telemetry_mgr->GaugeInstance("zeek", "dnsmgr_cache_entries", {{"type", "host"}}, - "Number of cached hosts in DNS_Mgr", "", []() -> prometheus::ClientMetric { - prometheus::ClientMetric metric; - metric.gauge.value = 0; + "Number of cached hosts in DNS_Mgr", "", []() { + double value = 0; if ( dns_mgr ) { dns_mgr->UpdateCachedStats(false); - metric.gauge.value = static_cast(dns_mgr->last_cached_stats.hosts); + value = static_cast(dns_mgr->last_cached_stats.hosts); } - return metric; + return value; }); cached_addresses_metric = telemetry_mgr->GaugeInstance("zeek", "dnsmgr_cache_entries", {{"type", "address"}}, - "Number of cached addresses in DNS_Mgr", "", []() -> prometheus::ClientMetric { - prometheus::ClientMetric metric; - metric.gauge.value = 0; + "Number of cached addresses in DNS_Mgr", "", []() { + double value = 0; if ( dns_mgr ) { dns_mgr->UpdateCachedStats(false); - metric.gauge.value = - static_cast(dns_mgr->last_cached_stats.addresses); + value = static_cast(dns_mgr->last_cached_stats.addresses); } - return metric; + return value; }); cached_texts_metric = telemetry_mgr->GaugeInstance("zeek", "dnsmgr_cache_entries", {{"type", "text"}}, - "Number of cached texts in DNS_Mgr", "", []() -> prometheus::ClientMetric { - prometheus::ClientMetric metric; - metric.gauge.value = 0; + "Number of cached texts in DNS_Mgr", "", []() { + double value = 0; if ( dns_mgr ) { dns_mgr->UpdateCachedStats(false); - metric.gauge.value = static_cast(dns_mgr->last_cached_stats.texts); + value = static_cast(dns_mgr->last_cached_stats.texts); } - return metric; + return value; }); if ( ! doctest::is_running_in_test ) { diff --git a/src/Timer.cc b/src/Timer.cc index f348731c73..e54c4f6add 100644 --- a/src/Timer.cc +++ b/src/Timer.cc @@ -98,32 +98,20 @@ void TimerMgr::InitPostScript() { dispatch_all_expired = zeek::detail::max_timer_expires == 0; - cumulative_num_metric = telemetry_mgr->CounterInstance("zeek", "timers", {}, "Cumulative number of timers", "", - []() -> prometheus::ClientMetric { - prometheus::ClientMetric metric; - metric.counter.value = - static_cast(timer_mgr->CumulativeNum()); - return metric; - }); + cumulative_num_metric = + telemetry_mgr->CounterInstance("zeek", "timers", {}, "Cumulative number of timers", "", + []() { return static_cast(timer_mgr->CumulativeNum()); }); - lag_time_metric = telemetry_mgr->GaugeInstance("zeek", "timers_lag_time", {}, - "Lag between current network time and last expired timer", "seconds", - []() -> prometheus::ClientMetric { - prometheus::ClientMetric metric; - metric.gauge.value = - run_state::network_time - timer_mgr->last_timestamp; - return metric; - }); + lag_time_metric = + telemetry_mgr->GaugeInstance("zeek", "timers_lag_time", {}, + "Lag between current network time and last expired timer", "seconds", + []() { return run_state::network_time - timer_mgr->last_timestamp; }); std::shared_ptr family = telemetry_mgr->GaugeFamily("zeek", "timers_pending", {"type"}, "Number of timers for a certain type"); for ( int i = 0; i < NUM_TIMER_TYPES; i++ ) { current_timer_metrics[i] = family->GetOrAdd({{"type", timer_type_to_string(static_cast(i))}}, - [i]() -> prometheus::ClientMetric { - prometheus::ClientMetric metric; - metric.gauge.value = TimerMgr::CurrentTimers()[i]; - return metric; - }); + [i]() { return TimerMgr::CurrentTimers()[i]; }); } } diff --git a/src/Trigger.cc b/src/Trigger.cc index d165da7f5a..09718a99f4 100644 --- a/src/Trigger.cc +++ b/src/Trigger.cc @@ -435,13 +435,9 @@ Manager::~Manager() { delete pending; } void Manager::InitPostScript() { trigger_count = telemetry_mgr->CounterInstance("zeek", "triggers", {}, "Total number of triggers scheduled"); trigger_pending = - telemetry_mgr->GaugeInstance("zeek", "pending_triggers", {}, "Pending number of triggers", "", - []() -> prometheus::ClientMetric { - prometheus::ClientMetric metric; - metric.gauge.value = - trigger_mgr ? static_cast(trigger_mgr->pending->size()) : 0.0; - return metric; - }); + telemetry_mgr->GaugeInstance("zeek", "pending_triggers", {}, "Pending number of triggers", "", []() { + return trigger_mgr ? static_cast(trigger_mgr->pending->size()) : 0.0; + }); iosource_mgr->Register(this, true); } diff --git a/src/broker/Manager.cc b/src/broker/Manager.cc index cbf9f55b91..60e37ccf67 100644 --- a/src/broker/Manager.cc +++ b/src/broker/Manager.cc @@ -343,27 +343,15 @@ void Manager::InitPostScript() { num_peers_metric = telemetry_mgr->GaugeInstance("zeek", "broker_peers", {}, "Current number of peers connected via broker", "", - []() -> prometheus::ClientMetric { - prometheus::ClientMetric metric; - metric.gauge.value = static_cast(broker_mgr->peer_count); - return metric; - }); + []() { return static_cast(broker_mgr->peer_count); }); num_stores_metric = telemetry_mgr->GaugeInstance("zeek", "broker_stores", {}, "Current number of stores connected via broker", "", - []() -> prometheus::ClientMetric { - prometheus::ClientMetric metric; - metric.gauge.value = static_cast(broker_mgr->data_stores.size()); - return metric; - }); + []() { return static_cast(broker_mgr->data_stores.size()); }); num_pending_queries_metric = telemetry_mgr->GaugeInstance("zeek", "broker_pending_queries", {}, "Current number of pending broker queries", - "", []() -> prometheus::ClientMetric { - prometheus::ClientMetric metric; - metric.gauge.value = static_cast(broker_mgr->pending_queries.size()); - return metric; - }); + "", []() { return static_cast(broker_mgr->pending_queries.size()); }); num_events_incoming_metric = telemetry_mgr->CounterInstance("zeek", "broker_incoming_events", {}, "Total number of incoming events via broker"); diff --git a/src/session/Manager.cc b/src/session/Manager.cc index d33182a705..ef5ce4a76d 100644 --- a/src/session/Manager.cc +++ b/src/session/Manager.cc @@ -79,12 +79,9 @@ Manager::Manager() { stats = new detail::ProtocolStats(); ended_sessions_metric_family = telemetry_mgr->CounterFamily("zeek", "ended_sessions", {"reason"}, "Number of sessions ended for specific reasons"); - ended_by_inactivity_metric = - ended_sessions_metric_family->GetOrAdd({{"reason", "inactivity"}}, []() -> prometheus::ClientMetric { - prometheus::ClientMetric metric; - metric.counter.value = static_cast(zeek::detail::killed_by_inactivity); - return metric; - }); + ended_by_inactivity_metric = ended_sessions_metric_family->GetOrAdd({{"reason", "inactivity"}}, []() { + return static_cast(zeek::detail::killed_by_inactivity); + }); } Manager::~Manager() { diff --git a/src/telemetry/Counter.cc b/src/telemetry/Counter.cc index ef3679329e..889a17f1a7 100644 --- a/src/telemetry/Counter.cc +++ b/src/telemetry/Counter.cc @@ -2,27 +2,17 @@ using namespace zeek::telemetry; -Counter::Counter(FamilyType* family, const prometheus::Labels& labels, prometheus::CollectCallbackPtr callback) noexcept - : family(family), handle(family->Add(labels)), labels(labels) { - if ( callback ) { - handle.AddCollectCallback(std::move(callback)); - has_callback = true; - } -} +Counter::Counter(FamilyType* family, const prometheus::Labels& labels, detail::CollectCallbackPtr callback) noexcept + : family(family), handle(family->Add(labels)), labels(labels), callback(std::move(callback)) {} double Counter::Value() const noexcept { - if ( has_callback ) { - // Use Collect() here instead of Value() to correctly handle metrics with - // callbacks. - auto metric = handle.Collect(); - return metric.counter.value; - } + if ( callback ) + return callback(); return handle.Value(); } -std::shared_ptr CounterFamily::GetOrAdd(Span labels, - prometheus::CollectCallbackPtr callback) { +std::shared_ptr CounterFamily::GetOrAdd(Span labels, detail::CollectCallbackPtr callback) { prometheus::Labels p_labels = detail::BuildPrometheusLabels(labels); auto check = [&](const std::shared_ptr& counter) { return counter->CompareLabels(p_labels); }; @@ -36,6 +26,15 @@ std::shared_ptr CounterFamily::GetOrAdd(Span labels, } std::shared_ptr CounterFamily::GetOrAdd(std::initializer_list labels, - prometheus::CollectCallbackPtr callback) { + detail::CollectCallbackPtr callback) { return GetOrAdd(Span{labels.begin(), labels.size()}, std::move(callback)); } + +void CounterFamily::RunCallbacks() { + for ( auto& c : counters ) { + if ( c->HasCallback() ) { + double val = c->RunCallback(); + c->Set(val); + } + } +} diff --git a/src/telemetry/Counter.h b/src/telemetry/Counter.h index a0186ad219..c9595c7709 100644 --- a/src/telemetry/Counter.h +++ b/src/telemetry/Counter.h @@ -4,7 +4,6 @@ #include #include -#include #include #include @@ -15,6 +14,12 @@ namespace zeek::telemetry { +namespace detail { +using CollectCallbackPtr = std::function; +} + +class CounterFamily; + /** * A handle to a metric that can only go up. */ @@ -26,7 +31,7 @@ public: using FamilyType = prometheus::Family; explicit Counter(FamilyType* family, const prometheus::Labels& labels, - prometheus::CollectCallbackPtr callback = nullptr) noexcept; + detail::CollectCallbackPtr callback = nullptr) noexcept; /** * Increments the value by 1. @@ -55,11 +60,21 @@ public: bool CompareLabels(const prometheus::Labels& lbls) const { return labels == lbls; } + bool HasCallback() const noexcept { return callback != nullptr; } + double RunCallback() const { return callback(); } + private: + friend class CounterFamily; + void Set(double val) { + // Counter has no Set(), but we can fake it. + handle.Reset(); + handle.Increment(val); + } + FamilyType* family = nullptr; Handle& handle; prometheus::Labels labels; - bool has_callback = false; + detail::CollectCallbackPtr callback; }; using CounterPtr = std::shared_ptr; @@ -75,15 +90,17 @@ public: * Returns the metrics handle for given labels, creating a new instance * lazily if necessary. */ - CounterPtr GetOrAdd(Span labels, prometheus::CollectCallbackPtr callback = nullptr); + CounterPtr GetOrAdd(Span labels, detail::CollectCallbackPtr callback = nullptr); /** * @copydoc GetOrAdd */ - CounterPtr GetOrAdd(std::initializer_list labels, prometheus::CollectCallbackPtr callback = nullptr); + CounterPtr GetOrAdd(std::initializer_list labels, detail::CollectCallbackPtr callback = nullptr); zeek_int_t MetricType() const noexcept override { return BifEnum::Telemetry::MetricType::COUNTER; } + void RunCallbacks() override; + private: prometheus::Family* family; std::vector counters; diff --git a/src/telemetry/Gauge.cc b/src/telemetry/Gauge.cc index 114ada3811..06ddbc95cc 100644 --- a/src/telemetry/Gauge.cc +++ b/src/telemetry/Gauge.cc @@ -3,26 +3,17 @@ using namespace zeek::telemetry; double Gauge::Value() const noexcept { - if ( has_callback ) { - // Use Collect() here instead of Value() to correctly handle metrics - // with callbacks. - auto metric = handle.Collect(); - return metric.gauge.value; - } + if ( callback ) + return callback(); return handle.Value(); } -Gauge::Gauge(FamilyType* family, const prometheus::Labels& labels, prometheus::CollectCallbackPtr callback) noexcept - : family(family), handle(family->Add(labels)), labels(labels) { - if ( callback ) { - handle.AddCollectCallback(std::move(callback)); - has_callback = true; - } -} +Gauge::Gauge(FamilyType* family, const prometheus::Labels& labels, detail::CollectCallbackPtr callback) noexcept + : family(family), handle(family->Add(labels)), labels(labels), callback(std::move(callback)) {} -std::shared_ptr GaugeFamily::GetOrAdd(Span labels, prometheus::CollectCallbackPtr callback) { +std::shared_ptr GaugeFamily::GetOrAdd(Span labels, detail::CollectCallbackPtr callback) { prometheus::Labels p_labels = detail::BuildPrometheusLabels(labels); auto check = [&](const std::shared_ptr& gauge) { return gauge->CompareLabels(p_labels); }; @@ -36,6 +27,13 @@ std::shared_ptr GaugeFamily::GetOrAdd(Span labels, prome } std::shared_ptr GaugeFamily::GetOrAdd(std::initializer_list labels, - prometheus::CollectCallbackPtr callback) { + detail::CollectCallbackPtr callback) { return GetOrAdd(Span{labels.begin(), labels.size()}, std::move(callback)); } + +void GaugeFamily::RunCallbacks() { + for ( const auto& g : gauges ) { + if ( g->HasCallback() ) + g->Set(g->RunCallback()); + } +} diff --git a/src/telemetry/Gauge.h b/src/telemetry/Gauge.h index 652ff72667..22b0e4a0aa 100644 --- a/src/telemetry/Gauge.h +++ b/src/telemetry/Gauge.h @@ -4,7 +4,7 @@ #include #include -#include +#include #include #include @@ -15,6 +15,10 @@ namespace zeek::telemetry { +namespace detail { +using CollectCallbackPtr = std::function; +} + /** * A handle to a metric that can count up and down. */ @@ -26,7 +30,7 @@ public: using FamilyType = prometheus::Family; explicit Gauge(FamilyType* family, const prometheus::Labels& labels, - prometheus::CollectCallbackPtr callback = nullptr) noexcept; + detail::CollectCallbackPtr callback = nullptr) noexcept; /** * Increments the value by 1. @@ -57,6 +61,11 @@ public: */ void Dec(double amount) noexcept { handle.Decrement(amount); } + /** + * Set the value by @p val. + */ + void Set(double val) noexcept { handle.Set(val); } + /** * Decrements the value by 1. * @return The new value. @@ -73,11 +82,14 @@ public: bool CompareLabels(const prometheus::Labels& lbls) const { return labels == lbls; } + bool HasCallback() const noexcept { return callback != nullptr; } + double RunCallback() const { return callback(); } + private: FamilyType* family = nullptr; Handle& handle; prometheus::Labels labels; - bool has_callback = false; + detail::CollectCallbackPtr callback; }; using GaugePtr = std::shared_ptr; @@ -90,18 +102,20 @@ public: * Returns the metrics handle for given labels, creating a new instance * lazily if necessary. */ - GaugePtr GetOrAdd(Span labels, prometheus::CollectCallbackPtr callback = nullptr); + GaugePtr GetOrAdd(Span labels, detail::CollectCallbackPtr callback = nullptr); /** * @copydoc GetOrAdd */ - GaugePtr GetOrAdd(std::initializer_list labels, prometheus::CollectCallbackPtr callback = nullptr); + GaugePtr GetOrAdd(std::initializer_list labels, detail::CollectCallbackPtr callback = nullptr); zeek_int_t MetricType() const noexcept override { return BifEnum::Telemetry::MetricType::GAUGE; } GaugeFamily(prometheus::Family* family, Span labels) : MetricFamily(labels), family(family) {} + void RunCallbacks() override; + private: prometheus::Family* family; std::vector gauges; diff --git a/src/telemetry/Histogram.h b/src/telemetry/Histogram.h index ec8858e463..b2131b40c8 100644 --- a/src/telemetry/Histogram.h +++ b/src/telemetry/Histogram.h @@ -66,6 +66,8 @@ public: zeek_int_t MetricType() const noexcept override { return BifEnum::Telemetry::MetricType::HISTOGRAM; } + void RunCallbacks() override {} + private: prometheus::Family* family; prometheus::Histogram::BucketBoundaries boundaries; diff --git a/src/telemetry/Manager.cc b/src/telemetry/Manager.cc index 7b19affc82..3272641882 100644 --- a/src/telemetry/Manager.cc +++ b/src/telemetry/Manager.cc @@ -122,44 +122,19 @@ void Manager::InitPostScript() { return &telemetry_mgr->current_process_stats; }; rss_gauge = GaugeInstance("process", "resident_memory", {}, "Resident memory size", "bytes", - []() -> prometheus::ClientMetric { - auto* s = get_stats(); - prometheus::ClientMetric metric; - metric.gauge.value = static_cast(s->rss); - return metric; - }); + []() { return static_cast(get_stats()->rss); }); vms_gauge = GaugeInstance("process", "virtual_memory", {}, "Virtual memory size", "bytes", - []() -> prometheus::ClientMetric { - auto* s = get_stats(); - prometheus::ClientMetric metric; - metric.gauge.value = static_cast(s->vms); - return metric; - }); + []() { return static_cast(get_stats()->vms); }); cpu_user_counter = CounterInstance("process", "cpu_user", {}, "Total user CPU time spent", "seconds", - []() -> prometheus::ClientMetric { - auto* s = get_stats(); - prometheus::ClientMetric metric; - metric.gauge.value = s->cpu_user; - return metric; - }); + []() { return get_stats()->cpu_user; }); cpu_system_counter = CounterInstance("process", "cpu_system", {}, "Total system CPU time spent", "seconds", - []() -> prometheus::ClientMetric { - auto* s = get_stats(); - prometheus::ClientMetric metric; - metric.gauge.value = s->cpu_system; - return metric; - }); + []() { return get_stats()->cpu_system; }); fds_gauge = GaugeInstance("process", "open_fds", {}, "Number of open file descriptors", "", - []() -> prometheus::ClientMetric { - auto* s = get_stats(); - prometheus::ClientMetric metric; - metric.gauge.value = static_cast(s->fds); - return metric; - }); + []() { return static_cast(get_stats()->fds); }); #endif if ( ! iosource_mgr->RegisterFd(collector_flare.FD(), this) ) { @@ -501,7 +476,7 @@ CounterFamilyPtr Manager::CounterFamily(std::string_view prefix, std::string_vie CounterPtr Manager::CounterInstance(std::string_view prefix, std::string_view name, Span labels, std::string_view helptext, std::string_view unit, - prometheus::CollectCallbackPtr callback) { + detail::CollectCallbackPtr callback) { return WithLabelNames(labels, [&, this](auto labelNames) { auto family = CounterFamily(prefix, name, labelNames, helptext, unit); return family->GetOrAdd(labels, callback); @@ -510,7 +485,7 @@ CounterPtr Manager::CounterInstance(std::string_view prefix, std::string_view na CounterPtr Manager::CounterInstance(std::string_view prefix, std::string_view name, std::initializer_list labels, std::string_view helptext, - std::string_view unit, prometheus::CollectCallbackPtr callback) { + std::string_view unit, detail::CollectCallbackPtr callback) { auto lbl_span = Span{labels.begin(), labels.size()}; return CounterInstance(prefix, name, lbl_span, helptext, unit, std::move(callback)); } @@ -539,8 +514,7 @@ GaugeFamilyPtr Manager::GaugeFamily(std::string_view prefix, std::string_view na } GaugePtr Manager::GaugeInstance(std::string_view prefix, std::string_view name, Span labels, - std::string_view helptext, std::string_view unit, - prometheus::CollectCallbackPtr callback) { + std::string_view helptext, std::string_view unit, detail::CollectCallbackPtr callback) { return WithLabelNames(labels, [&, this](auto labelNames) { auto family = GaugeFamily(prefix, name, labelNames, helptext, unit); return family->GetOrAdd(labels, callback); @@ -548,8 +522,7 @@ GaugePtr Manager::GaugeInstance(std::string_view prefix, std::string_view name, } GaugePtr Manager::GaugeInstance(std::string_view prefix, std::string_view name, std::initializer_list labels, - std::string_view helptext, std::string_view unit, - prometheus::CollectCallbackPtr callback) { + std::string_view helptext, std::string_view unit, detail::CollectCallbackPtr callback) { auto lbl_span = Span{labels.begin(), labels.size()}; return GaugeInstance(prefix, name, lbl_span, helptext, unit, std::move(callback)); } @@ -598,7 +571,9 @@ void Manager::ProcessFd(int fd, int flags) { collector_flare.Extinguish(); - prometheus_registry->UpdateViaCallbacks(); + for ( const auto& [name, f] : families ) + f->RunCallbacks(); + collector_response_idx = collector_request_idx; lk.unlock(); diff --git a/src/telemetry/Manager.h b/src/telemetry/Manager.h index 26647b7cf7..26e2403f58 100644 --- a/src/telemetry/Manager.h +++ b/src/telemetry/Manager.h @@ -31,6 +31,10 @@ class Registry; namespace zeek::telemetry { +namespace detail { +using CollectCallbackPtr = std::function; +} + class ZeekCollectable; /** @@ -98,12 +102,12 @@ public: */ CounterPtr CounterInstance(std::string_view prefix, std::string_view name, Span labels, std::string_view helptext, std::string_view unit = "", - prometheus::CollectCallbackPtr callback = nullptr); + detail::CollectCallbackPtr callback = nullptr); /// @copydoc counterInstance CounterPtr CounterInstance(std::string_view prefix, std::string_view name, std::initializer_list labels, std::string_view helptext, std::string_view unit = "", - prometheus::CollectCallbackPtr callback = nullptr); + detail::CollectCallbackPtr callback = nullptr); /** * @return A gauge metric family. Creates the family lazily if necessary. @@ -134,12 +138,12 @@ public: */ GaugePtr GaugeInstance(std::string_view prefix, std::string_view name, Span labels, std::string_view helptext, std::string_view unit = "", - prometheus::CollectCallbackPtr callback = nullptr); + detail::CollectCallbackPtr callback = nullptr); /// @copydoc GaugeInstance GaugePtr GaugeInstance(std::string_view prefix, std::string_view name, std::initializer_list labels, std::string_view helptext, std::string_view unit = "", - prometheus::CollectCallbackPtr callback = nullptr); + detail::CollectCallbackPtr callback = nullptr); // Forces the compiler to use the type `Span` instead of trying to // match parameters to a `span`. diff --git a/src/telemetry/MetricFamily.h b/src/telemetry/MetricFamily.h index 942932566e..e10ac608e0 100644 --- a/src/telemetry/MetricFamily.h +++ b/src/telemetry/MetricFamily.h @@ -22,6 +22,8 @@ public: std::vector LabelNames() const { return label_names; } + virtual void RunCallbacks() = 0; + protected: MetricFamily(Span labels) { for ( const auto& lbl : labels ) diff --git a/src/telemetry/Utils.h b/src/telemetry/Utils.h index 8eb0f98d99..77489fc260 100644 --- a/src/telemetry/Utils.h +++ b/src/telemetry/Utils.h @@ -5,7 +5,6 @@ #include #include "zeek/Span.h" -#include "zeek/Val.h" namespace zeek::telemetry { diff --git a/src/threading/Manager.cc b/src/threading/Manager.cc index 8e67676643..12f0fa432e 100644 --- a/src/threading/Manager.cc +++ b/src/threading/Manager.cc @@ -76,13 +76,9 @@ void Manager::InitPostScript() { }; num_threads_metric = - telemetry_mgr->GaugeInstance("zeek", "msgthread_active_threads", {}, "Number of active threads", "", - []() -> prometheus::ClientMetric { - prometheus::ClientMetric metric; - metric.gauge.value = - thread_mgr ? static_cast(thread_mgr->all_threads.size()) : 0.0; - return metric; - }); + telemetry_mgr->GaugeInstance("zeek", "msgthread_active_threads", {}, "Number of active threads", "", []() { + return thread_mgr ? static_cast(thread_mgr->all_threads.size()) : 0.0; + }); total_threads_metric = telemetry_mgr->CounterInstance("zeek", "msgthread_threads", {}, "Total number of threads"); total_messages_in_metric = @@ -91,22 +87,16 @@ void Manager::InitPostScript() { total_messages_out_metric = telemetry_mgr->CounterInstance("zeek", "msgthread_out_messages", {}, "Number of outbound messages sent", ""); - pending_messages_in_metric = - telemetry_mgr->GaugeInstance("zeek", "msgthread_pending_in_messages", {}, "Pending number of inbound messages", - "", []() -> prometheus::ClientMetric { - auto* s = get_message_thread_stats(); - prometheus::ClientMetric metric; - metric.gauge.value = static_cast(s->pending_in_total); - return metric; - }); - pending_messages_out_metric = - telemetry_mgr->GaugeInstance("zeek", "msgthread_pending_out_messages", {}, - "Pending number of outbound messages", "", []() -> prometheus::ClientMetric { - auto* s = get_message_thread_stats(); - prometheus::ClientMetric metric; - metric.gauge.value = static_cast(s->pending_out_total); - return metric; - }); + pending_messages_in_metric = telemetry_mgr->GaugeInstance("zeek", "msgthread_pending_in_messages", {}, + "Pending number of inbound messages", "", []() { + auto* s = get_message_thread_stats(); + return static_cast(s->pending_in_total); + }); + pending_messages_out_metric = telemetry_mgr->GaugeInstance("zeek", "msgthread_pending_out_messages", {}, + "Pending number of outbound messages", "", []() { + auto* s = get_message_thread_stats(); + return static_cast(s->pending_out_total); + }); pending_message_in_buckets_fam = telemetry_mgr->GaugeFamily("zeek", "msgthread_pending_messages_in_buckets", {"le"}, @@ -126,23 +116,15 @@ void Manager::InitPostScript() { current_bucketed_messages.pending_out[upper_limit] = 0; pending_message_in_buckets[upper_limit] = - pending_message_in_buckets_fam->GetOrAdd({{"le", upper_limit_str}}, - [upper_limit]() -> prometheus::ClientMetric { - auto* s = get_message_thread_stats(); - prometheus::ClientMetric metric; - metric.gauge.value = - static_cast(s->pending_in.at(upper_limit)); - return metric; - }); + pending_message_in_buckets_fam->GetOrAdd({{"le", upper_limit_str}}, [upper_limit]() { + auto* s = get_message_thread_stats(); + return static_cast(s->pending_in.at(upper_limit)); + }); pending_message_out_buckets[upper_limit] = - pending_message_out_buckets_fam->GetOrAdd({{"le", upper_limit_str}}, - [upper_limit]() -> prometheus::ClientMetric { - auto* s = get_message_thread_stats(); - prometheus::ClientMetric metric; - metric.gauge.value = - static_cast(s->pending_out.at(upper_limit)); - return metric; - }); + pending_message_out_buckets_fam->GetOrAdd({{"le", upper_limit_str}}, [upper_limit]() { + auto* s = get_message_thread_stats(); + return static_cast(s->pending_out.at(upper_limit)); + }); } }