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<double>(dns_mgr->last_cached_stats.hosts);
+                                             value = static_cast<double>(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<double>(dns_mgr->last_cached_stats.addresses);
+                                             value = static_cast<double>(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<double>(dns_mgr->last_cached_stats.texts);
+                                             value = static_cast<double>(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<double>(timer_mgr->CumulativeNum());
-                                                               return metric;
-                                                           });
+    cumulative_num_metric =
+        telemetry_mgr->CounterInstance("zeek", "timers", {}, "Cumulative number of timers", "",
+                                       []() { return static_cast<double>(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<telemetry::GaugeFamily> 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<TimerType>(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<double>(trigger_mgr->pending->size()) : 0.0;
-                                         return metric;
-                                     });
+        telemetry_mgr->GaugeInstance("zeek", "pending_triggers", {}, "Pending number of triggers", "", []() {
+            return trigger_mgr ? static_cast<double>(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<double>(broker_mgr->peer_count);
-                                         return metric;
-                                     });
+                                     []() { return static_cast<double>(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<double>(broker_mgr->data_stores.size());
-                                         return metric;
-                                     });
+                                     []() { return static_cast<double>(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<double>(broker_mgr->pending_queries.size());
-                                         return metric;
-                                     });
+                                     "", []() { return static_cast<double>(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<double>(zeek::detail::killed_by_inactivity);
-            return metric;
-        });
+    ended_by_inactivity_metric = ended_sessions_metric_family->GetOrAdd({{"reason", "inactivity"}}, []() {
+        return static_cast<double>(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<Counter> CounterFamily::GetOrAdd(Span<const LabelView> labels,
-                                                 prometheus::CollectCallbackPtr callback) {
+std::shared_ptr<Counter> CounterFamily::GetOrAdd(Span<const LabelView> labels, detail::CollectCallbackPtr callback) {
     prometheus::Labels p_labels = detail::BuildPrometheusLabels(labels);
 
     auto check = [&](const std::shared_ptr<Counter>& counter) { return counter->CompareLabels(p_labels); };
@@ -36,6 +26,15 @@ std::shared_ptr<Counter> CounterFamily::GetOrAdd(Span<const LabelView> labels,
 }
 
 std::shared_ptr<Counter> CounterFamily::GetOrAdd(std::initializer_list<LabelView> 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 <prometheus/counter.h>
 #include <prometheus/family.h>
-#include <cstdint>
 #include <initializer_list>
 #include <memory>
 
@@ -15,6 +14,12 @@
 
 namespace zeek::telemetry {
 
+namespace detail {
+using CollectCallbackPtr = std::function<double()>;
+}
+
+class CounterFamily;
+
 /**
  * A handle to a metric that can only go up.
  */
@@ -26,7 +31,7 @@ public:
     using FamilyType = prometheus::Family<Handle>;
 
     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<Counter>;
@@ -75,15 +90,17 @@ public:
      * Returns the metrics handle for given labels, creating a new instance
      * lazily if necessary.
      */
-    CounterPtr GetOrAdd(Span<const LabelView> labels, prometheus::CollectCallbackPtr callback = nullptr);
+    CounterPtr GetOrAdd(Span<const LabelView> labels, detail::CollectCallbackPtr callback = nullptr);
 
     /**
      * @copydoc GetOrAdd
      */
-    CounterPtr GetOrAdd(std::initializer_list<LabelView> labels, prometheus::CollectCallbackPtr callback = nullptr);
+    CounterPtr GetOrAdd(std::initializer_list<LabelView> labels, detail::CollectCallbackPtr callback = nullptr);
 
     zeek_int_t MetricType() const noexcept override { return BifEnum::Telemetry::MetricType::COUNTER; }
 
+    void RunCallbacks() override;
+
 private:
     prometheus::Family<prometheus::Counter>* family;
     std::vector<CounterPtr> 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<Gauge> GaugeFamily::GetOrAdd(Span<const LabelView> labels, prometheus::CollectCallbackPtr callback) {
+std::shared_ptr<Gauge> GaugeFamily::GetOrAdd(Span<const LabelView> labels, detail::CollectCallbackPtr callback) {
     prometheus::Labels p_labels = detail::BuildPrometheusLabels(labels);
 
     auto check = [&](const std::shared_ptr<Gauge>& gauge) { return gauge->CompareLabels(p_labels); };
@@ -36,6 +27,13 @@ std::shared_ptr<Gauge> GaugeFamily::GetOrAdd(Span<const LabelView> labels, prome
 }
 
 std::shared_ptr<Gauge> GaugeFamily::GetOrAdd(std::initializer_list<LabelView> 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 <prometheus/family.h>
 #include <prometheus/gauge.h>
-#include <cstdint>
+#include <unistd.h>
 #include <initializer_list>
 #include <memory>
 
@@ -15,6 +15,10 @@
 
 namespace zeek::telemetry {
 
+namespace detail {
+using CollectCallbackPtr = std::function<double()>;
+}
+
 /**
  * A handle to a metric that can count up and down.
  */
@@ -26,7 +30,7 @@ public:
     using FamilyType = prometheus::Family<Handle>;
 
     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<Gauge>;
@@ -90,18 +102,20 @@ public:
      * Returns the metrics handle for given labels, creating a new instance
      * lazily if necessary.
      */
-    GaugePtr GetOrAdd(Span<const LabelView> labels, prometheus::CollectCallbackPtr callback = nullptr);
+    GaugePtr GetOrAdd(Span<const LabelView> labels, detail::CollectCallbackPtr callback = nullptr);
 
     /**
      * @copydoc GetOrAdd
      */
-    GaugePtr GetOrAdd(std::initializer_list<LabelView> labels, prometheus::CollectCallbackPtr callback = nullptr);
+    GaugePtr GetOrAdd(std::initializer_list<LabelView> labels, detail::CollectCallbackPtr callback = nullptr);
 
     zeek_int_t MetricType() const noexcept override { return BifEnum::Telemetry::MetricType::GAUGE; }
 
     GaugeFamily(prometheus::Family<prometheus::Gauge>* family, Span<const std::string_view> labels)
         : MetricFamily(labels), family(family) {}
 
+    void RunCallbacks() override;
+
 private:
     prometheus::Family<prometheus::Gauge>* family;
     std::vector<GaugePtr> 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<prometheus::Histogram>* 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<double>(s->rss);
-                                  return metric;
-                              });
+                              []() { return static_cast<double>(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<double>(s->vms);
-                                  return metric;
-                              });
+                              []() { return static_cast<double>(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<double>(s->fds);
-                                  return metric;
-                              });
+                              []() { return static_cast<double>(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<const LabelView> 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<LabelView> 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<const LabelView> 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<LabelView> 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<double()>;
+}
+
 class ZeekCollectable;
 
 /**
@@ -98,12 +102,12 @@ public:
      */
     CounterPtr CounterInstance(std::string_view prefix, std::string_view name, Span<const LabelView> 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<LabelView> 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<const LabelView> 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<LabelView> 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<const T>` 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<std::string> LabelNames() const { return label_names; }
 
+    virtual void RunCallbacks() = 0;
+
 protected:
     MetricFamily(Span<const std::string_view> 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 <string_view>
 
 #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<double>(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<double>(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<double>(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<double>(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<double>(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<double>(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<double>(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<double>(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<double>(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<double>(s->pending_out.at(upper_limit));
+            });
     }
 }