diff --git a/scripts/base/frameworks/telemetry/main.zeek b/scripts/base/frameworks/telemetry/main.zeek index beb4ca3c1f..6f335c8d4a 100644 --- a/scripts/base/frameworks/telemetry/main.zeek +++ b/scripts/base/frameworks/telemetry/main.zeek @@ -19,7 +19,7 @@ export { ## :zeek:see:`Telemetry::counter_with`. To modify counters directly ## use :zeek:see:`Telemetry::counter_family_inc`. type CounterFamily: record { - __family: opaque of dbl_counter_metric_family; + __family: opaque of counter_metric_family; __labels: vector of string; }; @@ -32,7 +32,7 @@ export { ## per :zeek:see:`Log::Stream` or number connections broken down ## by protocol and service. type Counter: record { - __metric: opaque of dbl_counter_metric; + __metric: opaque of counter_metric; }; ## Register a counter family. @@ -103,7 +103,7 @@ export { ## :zeek:see:`Telemetry::gauge_family_inc` or ## :zeek:see:`Telemetry::gauge_family_set` directly. type GaugeFamily: record { - __family: opaque of dbl_gauge_metric_family; + __family: opaque of gauge_metric_family; __labels: vector of string; }; @@ -115,7 +115,7 @@ export { ## or footprints of long-lived values as determined by ## :zeek:see:`val_footprint`. type Gauge: record { - __metric: opaque of dbl_gauge_metric; + __metric: opaque of gauge_metric; }; ## Register a gauge family. @@ -204,14 +204,14 @@ export { ## :zeek:see:`Telemetry::histogram_with` or use ## :zeek:see:`Telemetry::histogram_family_observe` directly. type HistogramFamily: record { - __family: opaque of dbl_histogram_metric_family; + __family: opaque of histogram_metric_family; __labels: vector of string; }; ## Type representing a histogram metric with initialized label values. ## Use :zeek:see:`Telemetry::histogram_observe` to make observations. type Histogram: record { - __metric: opaque of dbl_histogram_metric; + __metric: opaque of histogram_metric; }; ## Register a histogram family. @@ -292,7 +292,7 @@ function make_labels(keys: vector of string, values: labels_vector): table[strin function register_counter_family(opts: MetricOpts): CounterFamily { - local f = Telemetry::__dbl_counter_family( + local f = Telemetry::__counter_family( opts$prefix, opts$name, opts$labels, @@ -320,24 +320,24 @@ function counter_with(cf: CounterFamily, label_values: labels_vector): Counter } local labels = make_labels(cf$__labels, label_values); - local m = Telemetry::__dbl_counter_metric_get_or_add(cf$__family, labels); + local m = Telemetry::__counter_metric_get_or_add(cf$__family, labels); return Counter($__metric=m); } function counter_inc(c: Counter, amount: double): bool { - return Telemetry::__dbl_counter_inc(c$__metric, amount); + return Telemetry::__counter_inc(c$__metric, amount); } function counter_set(c: Counter, value: double): bool { - local cur_value: double = Telemetry::__dbl_counter_value(c$__metric); + local cur_value: double = Telemetry::__counter_value(c$__metric); if (value < cur_value) { Reporter::error(fmt("Attempted to set lower counter value=%s cur_value=%s", value, cur_value)); return F; } - return Telemetry::__dbl_counter_inc(c$__metric, value - cur_value); + return Telemetry::__counter_inc(c$__metric, value - cur_value); } function counter_family_inc(cf: CounterFamily, label_values: labels_vector, amount: double): bool @@ -352,7 +352,7 @@ function counter_family_set(cf: CounterFamily, label_values: labels_vector, valu function register_gauge_family(opts: MetricOpts): GaugeFamily { - local f = Telemetry::__dbl_gauge_family( + local f = Telemetry::__gauge_family( opts$prefix, opts$name, opts$labels, @@ -379,29 +379,29 @@ function gauge_with(gf: GaugeFamily, label_values: labels_vector): Gauge return gauge_with(error_gauge_cf); } local labels = make_labels(gf$__labels, label_values); - local m = Telemetry::__dbl_gauge_metric_get_or_add(gf$__family, labels); + local m = Telemetry::__gauge_metric_get_or_add(gf$__family, labels); return Gauge($__metric=m); } function gauge_inc(g: Gauge, amount: double &default=1.0): bool { - return Telemetry::__dbl_gauge_inc(g$__metric, amount); + return Telemetry::__gauge_inc(g$__metric, amount); } function gauge_dec(g: Gauge, amount: double &default=1.0): bool { - return Telemetry::__dbl_gauge_dec(g$__metric, amount); + return Telemetry::__gauge_dec(g$__metric, amount); } function gauge_set(g: Gauge, value: double): bool { - # Telemetry currently does not implement __dbl_gauge_set(), do + # Telemetry currently does not implement __gauge_set(), do # it by hand here. - local cur_value: double = Telemetry::__dbl_gauge_value(g$__metric); + local cur_value: double = Telemetry::__gauge_value(g$__metric); if (value > cur_value) - return Telemetry::__dbl_gauge_inc(g$__metric, value - cur_value); + return Telemetry::__gauge_inc(g$__metric, value - cur_value); - return Telemetry::__dbl_gauge_dec(g$__metric, cur_value - value); + return Telemetry::__gauge_dec(g$__metric, cur_value - value); } function gauge_family_inc(gf: GaugeFamily, label_values: labels_vector, value: double): bool @@ -421,7 +421,7 @@ function gauge_family_set(gf: GaugeFamily, label_values: labels_vector, value: d function register_histogram_family(opts: MetricOpts): HistogramFamily { - local f = Telemetry::__dbl_histogram_family( + local f = Telemetry::__histogram_family( opts$prefix, opts$name, opts$labels, @@ -450,13 +450,13 @@ function histogram_with(hf: HistogramFamily, label_values: labels_vector): Histo } local labels = make_labels(hf$__labels, label_values); - local m = Telemetry::__dbl_histogram_metric_get_or_add(hf$__family, labels); + local m = Telemetry::__histogram_metric_get_or_add(hf$__family, labels); return Histogram($__metric=m); } function histogram_observe(h: Histogram, measurement: double): bool { - return Telemetry::__dbl_histogram_observe(h$__metric, measurement); + return Telemetry::__histogram_observe(h$__metric, measurement); } function histogram_family_observe(hf: HistogramFamily, label_values: labels_vector, measurement: double): bool diff --git a/scripts/base/init-bare.zeek b/scripts/base/init-bare.zeek index 769bc372f2..dd47c55aad 100644 --- a/scripts/base/init-bare.zeek +++ b/scripts/base/init-bare.zeek @@ -5775,12 +5775,9 @@ module Telemetry; export { type MetricType: enum { - DOUBLE_COUNTER, - INT_COUNTER, - DOUBLE_GAUGE, - INT_GAUGE, - DOUBLE_HISTOGRAM, - INT_HISTOGRAM, + COUNTER, + GAUGE, + HISTOGRAM, }; ## Type that captures options used to create metrics. @@ -5822,13 +5819,6 @@ export { ## describes the number and bounds of the individual buckets. bounds: vector of double &optional; - ## The same meaning as *bounds*, but as :zeek:type:`count`. - ## Only set in the return value of - ## :zeek:see:`Telemetry::collect_histogram_metrics`. - ## for histograms when the underlying type is ``int64_t``, - ## otherwise ignored. - count_bounds: vector of count &optional; - ## Describes the underlying metric type. ## Only set in the return value of ## :zeek:see:`Telemetry::collect_metrics` or @@ -5850,11 +5840,6 @@ export { ## This value is set for all counter and gauge metrics, ## it is unset for histograms. value: double &optional; - - ## The integer value of underlying instrument if the metric type - ## is INT_COUNTER or INT_GAUGE. This will be unset if the type - ## is DOUBLE_COUNTER or DOUBLE_GAUGE. - count_value: count &optional; }; ## Histograms returned by the :zeek:see:`Telemetry::collect_histogram_metrics` function. @@ -5869,26 +5854,11 @@ export { ## described by the *bounds* field in *opts*; values: vector of double; - ## Integer values for the individual counters for each of the - ## bckets as described in the ``bounds`` field in ``opts``. This - ## value will be unset if the metric type is DOUBLE_HISTOGRAM. - count_values: vector of count &optional; - ## The number of observations made for this histogram. observations: double; ## The sum of all observations for this histogram. sum: double; - - ## The integer value of the number of observations made for this - ## histogram. This value will be unset if the metric type is - ## DOUBLE_HISTOGRAM. - count_observations: count &optional; - - ## The integer value of the sum of all observations for this - ## histogram. This value will be unset if the metric type is - ## DOUBLE_HISTOGRAM. - count_sum: count &optional; }; type MetricVector : vector of Metric; diff --git a/scripts/policy/frameworks/telemetry/log.zeek b/scripts/policy/frameworks/telemetry/log.zeek index d3a51d5db9..935b92cefa 100644 --- a/scripts/policy/frameworks/telemetry/log.zeek +++ b/scripts/policy/frameworks/telemetry/log.zeek @@ -119,17 +119,17 @@ function do_log() local m = metrics[i]; # Histograms don't have single values, skip over them. - if ( m$opts$metric_type == DOUBLE_HISTOGRAM || m$opts$metric_type == INT_HISTOGRAM ) + if ( m$opts$metric_type == HISTOGRAM ) next; # Render the metric_type as a short string. Unknown # shouldn't really happen, but lets have a fallback. local metric_type = "unknown"; switch ( m$opts$metric_type ) { - case DOUBLE_COUNTER, INT_COUNTER: + case COUNTER: metric_type = "counter"; break; - case DOUBLE_GAUGE, INT_GAUGE: + case GAUGE: metric_type = "gauge"; break; } diff --git a/src/EventHandler.h b/src/EventHandler.h index b062db6bfb..ef647a7c6e 100644 --- a/src/EventHandler.h +++ b/src/EventHandler.h @@ -17,7 +17,7 @@ extern double network_time; } // namespace run_state namespace telemetry { -class IntCounter; +class Counter; } class Func; @@ -78,7 +78,7 @@ private: bool generate_always; // Initialize this lazy, so we don't expose metrics for 0 values. - std::shared_ptr call_count; + std::shared_ptr call_count; std::unordered_set auto_publish; }; diff --git a/src/Type.h b/src/Type.h index 71fe57ea46..7261a445f4 100644 --- a/src/Type.h +++ b/src/Type.h @@ -1042,15 +1042,9 @@ extern zeek::OpaqueTypePtr bloomfilter_type; extern zeek::OpaqueTypePtr x509_opaque_type; extern zeek::OpaqueTypePtr ocsp_resp_opaque_type; extern zeek::OpaqueTypePtr paraglob_type; -extern zeek::OpaqueTypePtr int_counter_metric_type; -extern zeek::OpaqueTypePtr int_counter_metric_family_type; -extern zeek::OpaqueTypePtr dbl_counter_metric_type; -extern zeek::OpaqueTypePtr dbl_counter_metric_family_type; -extern zeek::OpaqueTypePtr int_gauge_metric_type; -extern zeek::OpaqueTypePtr int_gauge_metric_family_type; -extern zeek::OpaqueTypePtr dbl_gauge_metric_type; -extern zeek::OpaqueTypePtr dbl_gauge_metric_family_type; -extern zeek::OpaqueTypePtr int_histogram_metric_type; -extern zeek::OpaqueTypePtr int_histogram_metric_family_type; -extern zeek::OpaqueTypePtr dbl_histogram_metric_type; -extern zeek::OpaqueTypePtr dbl_histogram_metric_family_type; +extern zeek::OpaqueTypePtr counter_metric_type; +extern zeek::OpaqueTypePtr counter_metric_family_type; +extern zeek::OpaqueTypePtr gauge_metric_type; +extern zeek::OpaqueTypePtr gauge_metric_family_type; +extern zeek::OpaqueTypePtr histogram_metric_type; +extern zeek::OpaqueTypePtr histogram_metric_family_type; diff --git a/src/logging/Manager.cc b/src/logging/Manager.cc index 515ba829ce..b3b3f2213e 100644 --- a/src/logging/Manager.cc +++ b/src/logging/Manager.cc @@ -223,9 +223,9 @@ struct Manager::WriterInfo { bool hook_initialized = false; string instantiating_filter; - std::shared_ptr total_writes; + std::shared_ptr total_writes; - WriterInfo(std::shared_ptr total_writes) : total_writes(std::move(total_writes)) {} + WriterInfo(std::shared_ptr total_writes) : total_writes(std::move(total_writes)) {} }; struct Manager::Stream { @@ -244,7 +244,7 @@ struct Manager::Stream { bool enable_remote = false; - std::shared_ptr total_writes; // Initialized on first write. + std::shared_ptr total_writes; // Initialized on first write. // State about delayed writes for this Stream. detail::DelayQueue delay_queue; diff --git a/src/logging/Manager.h b/src/logging/Manager.h index 863bd1307a..43b13892aa 100644 --- a/src/logging/Manager.h +++ b/src/logging/Manager.h @@ -403,8 +403,8 @@ private: FuncPtr rotation_format_func; FuncPtr log_stream_policy_hook; - std::shared_ptr total_log_stream_writes_family; - std::shared_ptr total_log_writer_writes_family; + std::shared_ptr total_log_stream_writes_family; + std::shared_ptr total_log_writer_writes_family; zeek_uint_t last_delay_token = 0; std::vector active_writes; diff --git a/src/script_opt/FuncInfo.cc b/src/script_opt/FuncInfo.cc index efce28a613..fd39c4779b 100644 --- a/src/script_opt/FuncInfo.cc +++ b/src/script_opt/FuncInfo.cc @@ -151,32 +151,19 @@ static std::unordered_map func_attrs = { {"Supervisor::__stem_pid", ATTR_NO_SCRIPT_SIDE_EFFECTS}, {"Telemetry::__collect_histogram_metrics", ATTR_NO_SCRIPT_SIDE_EFFECTS}, {"Telemetry::__collect_metrics", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__dbl_counter_family", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__dbl_counter_inc", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__dbl_counter_metric_get_or_add", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__dbl_counter_value", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__dbl_gauge_dec", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__dbl_gauge_family", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__dbl_gauge_inc", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__dbl_gauge_metric_get_or_add", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__dbl_gauge_value", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__dbl_histogram_family", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__dbl_histogram_metric_get_or_add", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__dbl_histogram_observe", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__dbl_histogram_sum", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__int_counter_family", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__int_counter_inc", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__int_counter_metric_get_or_add", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__int_counter_value", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__int_gauge_dec", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__int_gauge_family", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__int_gauge_inc", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__int_gauge_metric_get_or_add", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__int_gauge_value", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__int_histogram_family", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__int_histogram_metric_get_or_add", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__int_histogram_observe", ATTR_NO_SCRIPT_SIDE_EFFECTS}, - {"Telemetry::__int_histogram_sum", ATTR_NO_SCRIPT_SIDE_EFFECTS}, + {"Telemetry::__counter_family", ATTR_NO_SCRIPT_SIDE_EFFECTS}, + {"Telemetry::__counter_inc", ATTR_NO_SCRIPT_SIDE_EFFECTS}, + {"Telemetry::__counter_metric_get_or_add", ATTR_NO_SCRIPT_SIDE_EFFECTS}, + {"Telemetry::__counter_value", ATTR_NO_SCRIPT_SIDE_EFFECTS}, + {"Telemetry::__gauge_dec", ATTR_NO_SCRIPT_SIDE_EFFECTS}, + {"Telemetry::__gauge_family", ATTR_NO_SCRIPT_SIDE_EFFECTS}, + {"Telemetry::__gauge_inc", ATTR_NO_SCRIPT_SIDE_EFFECTS}, + {"Telemetry::__gauge_metric_get_or_add", ATTR_NO_SCRIPT_SIDE_EFFECTS}, + {"Telemetry::__gauge_value", ATTR_NO_SCRIPT_SIDE_EFFECTS}, + {"Telemetry::__histogram_family", ATTR_NO_SCRIPT_SIDE_EFFECTS}, + {"Telemetry::__histogram_metric_get_or_add", ATTR_NO_SCRIPT_SIDE_EFFECTS}, + {"Telemetry::__histogram_observe", ATTR_NO_SCRIPT_SIDE_EFFECTS}, + {"Telemetry::__histogram_sum", ATTR_NO_SCRIPT_SIDE_EFFECTS}, {"WebSocket::__configure_analyzer", ATTR_NO_SCRIPT_SIDE_EFFECTS}, {"__init_primary_bifs", ATTR_NO_SCRIPT_SIDE_EFFECTS}, {"__init_secondary_bifs", ATTR_NO_SCRIPT_SIDE_EFFECTS}, diff --git a/src/session/Manager.cc b/src/session/Manager.cc index f6ec7c6275..cd10740fba 100644 --- a/src/session/Manager.cc +++ b/src/session/Manager.cc @@ -32,12 +32,12 @@ namespace detail { class ProtocolStats { public: struct Protocol { - std::shared_ptr active; - std::shared_ptr total; + std::shared_ptr active; + std::shared_ptr total; ssize_t max = 0; - Protocol(const std::shared_ptr& active_family, - const std::shared_ptr& total_family, std::string protocol) + Protocol(const std::shared_ptr& active_family, + const std::shared_ptr& total_family, std::string protocol) : active(active_family->GetOrAdd({{"protocol", protocol}})), total(total_family->GetOrAdd({{"protocol", protocol}})) {} }; diff --git a/src/telemetry/CMakeLists.txt b/src/telemetry/CMakeLists.txt index 92983f2930..d61cbdb671 100644 --- a/src/telemetry/CMakeLists.txt +++ b/src/telemetry/CMakeLists.txt @@ -1,6 +1,9 @@ zeek_add_subdir_library( telemetry SOURCES + Counter.cc + Gauge.cc + Histogram.cc Manager.cc Opaques.cc ProcessStats.cc diff --git a/src/telemetry/Counter.cc b/src/telemetry/Counter.cc new file mode 100644 index 0000000000..5abb624f20 --- /dev/null +++ b/src/telemetry/Counter.cc @@ -0,0 +1,41 @@ +#include "zeek/telemetry/Counter.h" + +using namespace zeek::telemetry; + +Counter::Counter(FamilyType* family, const prometheus::Labels& labels, prometheus::CollectCallbackPtr callback) noexcept + : handle(family->Add(labels)), labels(labels) { + if ( callback ) { + handle.AddCollectCallback(callback); + has_callback = true; + } +} + +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; + } + + return handle.Value(); +} + +std::shared_ptr CounterFamily::GetOrAdd(Span labels, + prometheus::CollectCallbackPtr callback) { + prometheus::Labels p_labels = detail::BuildPrometheusLabels(labels); + + auto check = [&](const std::shared_ptr& counter) { return counter->CompareLabels(p_labels); }; + + if ( auto it = std::find_if(counters.begin(), counters.end(), check); it != counters.end() ) + return *it; + + auto counter = std::make_shared(family, p_labels, callback); + counters.push_back(counter); + return counter; +} + +std::shared_ptr CounterFamily::GetOrAdd(std::initializer_list labels, + prometheus::CollectCallbackPtr callback) { + return GetOrAdd(Span{labels.begin(), labels.size()}, callback); +} diff --git a/src/telemetry/Counter.h b/src/telemetry/Counter.h index 49404147c5..9152236116 100644 --- a/src/telemetry/Counter.h +++ b/src/telemetry/Counter.h @@ -15,12 +15,19 @@ namespace zeek::telemetry { -template -class BaseCounter { +/** + * A handle to a metric that can only go up. + */ +class Counter { public: + static inline const char* OpaqueName = "CounterMetricVal"; + using Handle = prometheus::Counter; using FamilyType = prometheus::Family; + explicit Counter(FamilyType* family, const prometheus::Labels& labels, + prometheus::CollectCallbackPtr callback = nullptr) noexcept; + /** * Increments the value by 1. */ @@ -30,151 +37,54 @@ public: * Increments the value by @p amount. * @pre `amount >= 0` */ - void Inc(BaseType amount) noexcept { handle.Increment(amount); } + void Inc(double amount) noexcept { handle.Increment(amount); } /** * Increments the value by 1. * @return The new value. */ - BaseType operator++() noexcept { + double operator++() noexcept { Inc(1); return Value(); } - BaseType Value() const noexcept { - if ( has_callback ) { - // Use Collect() here instead of Value() to correctly handle metrics with - // callbacks. - auto metric = handle.Collect(); - return static_cast(metric.counter.value); - } + double Value() const noexcept; - return handle.Value(); - } - - bool operator==(const BaseCounter& rhs) const noexcept { return &handle == &rhs.handle; } - bool operator!=(const BaseCounter& rhs) const noexcept { return &handle != &rhs.handle; } + bool operator==(const Counter& rhs) const noexcept { return &handle == &rhs.handle; } + bool operator!=(const Counter& rhs) const noexcept { return &handle != &rhs.handle; } bool CompareLabels(const prometheus::Labels& lbls) const { return labels == lbls; } -protected: - explicit BaseCounter(FamilyType* family, const prometheus::Labels& labels, - prometheus::CollectCallbackPtr callback = nullptr) noexcept - : handle(family->Add(labels)), labels(labels) { - if ( callback ) { - handle.AddCollectCallback(callback); - has_callback = true; - } - } - +private: Handle& handle; prometheus::Labels labels; bool has_callback = false; }; -/** - * A handle to a metric that represents an integer value that can only go up. - */ -class IntCounter final : public BaseCounter { +class CounterFamily : public MetricFamily, public std::enable_shared_from_this { public: - static inline const char* OpaqueName = "IntCounterMetricVal"; - explicit IntCounter(FamilyType* family, const prometheus::Labels& labels, - prometheus::CollectCallbackPtr callback = nullptr) noexcept - : BaseCounter(family, labels, callback) {} -}; + static inline const char* OpaqueName = "CounterMetricFamilyVal"; -/** - * A handle to a metric that represents a double value that can only go up. - */ -class DblCounter final : public BaseCounter { -public: - static inline const char* OpaqueName = "DblCounterMetricVal"; - explicit DblCounter(FamilyType* family, const prometheus::Labels& labels, - prometheus::CollectCallbackPtr callback = nullptr) noexcept - : BaseCounter(family, labels, callback) {} -}; + CounterFamily(prometheus::Family* family, Span labels) + : MetricFamily(labels), family(family) {} -template -class BaseCounterFamily : public MetricFamily, - public std::enable_shared_from_this> { -public: /** * Returns the metrics handle for given labels, creating a new instance * lazily if necessary. */ - std::shared_ptr GetOrAdd(Span labels, - prometheus::CollectCallbackPtr callback = nullptr) { - prometheus::Labels p_labels = detail::BuildPrometheusLabels(labels); - - auto check = [&](const std::shared_ptr& counter) { return counter->CompareLabels(p_labels); }; - - if ( auto it = std::find_if(counters.begin(), counters.end(), check); it != counters.end() ) - return *it; - - auto counter = std::make_shared(family, p_labels, callback); - counters.push_back(counter); - return counter; - } + std::shared_ptr GetOrAdd(Span labels, prometheus::CollectCallbackPtr callback = nullptr); /** * @copydoc GetOrAdd */ - std::shared_ptr GetOrAdd(std::initializer_list labels, - prometheus::CollectCallbackPtr callback = nullptr) { - return GetOrAdd(Span{labels.begin(), labels.size()}, callback); - } + std::shared_ptr GetOrAdd(std::initializer_list labels, + prometheus::CollectCallbackPtr callback = nullptr); -protected: - BaseCounterFamily(prometheus::Family* family, Span labels) - : MetricFamily(labels), family(family) {} + zeek_int_t MetricType() const noexcept override { return BifEnum::Telemetry::MetricType::COUNTER; } +private: prometheus::Family* family; - std::vector> counters; + std::vector> counters; }; -/** - * Manages a collection of IntCounter metrics. - */ -class IntCounterFamily final : public BaseCounterFamily { -public: - static inline const char* OpaqueName = "IntCounterMetricFamilyVal"; - - explicit IntCounterFamily(prometheus::Family* family, Span labels) - : BaseCounterFamily(family, labels) {} - - zeek_int_t MetricType() const noexcept override { return BifEnum::Telemetry::MetricType::INT_COUNTER; } -}; - -/** - * Manages a collection of DblCounter metrics. - */ -class DblCounterFamily final : public BaseCounterFamily { -public: - static inline const char* OpaqueName = "DblCounterMetricFamilyVal"; - - explicit DblCounterFamily(prometheus::Family* family, Span labels) - : BaseCounterFamily(family, labels) {} - - zeek_int_t MetricType() const noexcept override { return BifEnum::Telemetry::MetricType::DOUBLE_COUNTER; } -}; - -namespace detail { - -template -struct CounterOracle { - static_assert(std::is_same::value, "Counter only supports int64_t and double"); - - using type = IntCounter; -}; - -template<> -struct CounterOracle { - using type = DblCounter; -}; - -} // namespace detail - -template -using Counter = typename detail::CounterOracle::type; - } // namespace zeek::telemetry diff --git a/src/telemetry/Gauge.cc b/src/telemetry/Gauge.cc new file mode 100644 index 0000000000..f3f510b436 --- /dev/null +++ b/src/telemetry/Gauge.cc @@ -0,0 +1,41 @@ +#include "zeek/telemetry/Gauge.h" + +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; + } + + return handle.Value(); +} + + +Gauge::Gauge(FamilyType* family, const prometheus::Labels& labels, prometheus::CollectCallbackPtr callback) noexcept + : handle(family->Add(labels)), labels(labels) { + if ( callback ) { + handle.AddCollectCallback(callback); + has_callback = true; + } +} + +std::shared_ptr GaugeFamily::GetOrAdd(Span labels, prometheus::CollectCallbackPtr callback) { + prometheus::Labels p_labels = detail::BuildPrometheusLabels(labels); + + auto check = [&](const std::shared_ptr& gauge) { return gauge->CompareLabels(p_labels); }; + + if ( auto it = std::find_if(gauges.begin(), gauges.end(), check); it != gauges.end() ) + return *it; + + auto gauge = std::make_shared(family, p_labels, callback); + gauges.push_back(gauge); + return gauge; +} + +std::shared_ptr GaugeFamily::GetOrAdd(std::initializer_list labels, + prometheus::CollectCallbackPtr callback) { + return GetOrAdd(Span{labels.begin(), labels.size()}, callback); +} diff --git a/src/telemetry/Gauge.h b/src/telemetry/Gauge.h index 17daccffea..4617a74f3f 100644 --- a/src/telemetry/Gauge.h +++ b/src/telemetry/Gauge.h @@ -15,12 +15,19 @@ namespace zeek::telemetry { -template -class BaseGauge { +/** + * A handle to a metric that can count up and down. + */ +class Gauge { public: + static inline const char* OpaqueName = "GaugeMetricVal"; + using Handle = prometheus::Gauge; using FamilyType = prometheus::Family; + explicit Gauge(FamilyType* family, const prometheus::Labels& labels, + prometheus::CollectCallbackPtr callback = nullptr) noexcept; + /** * Increments the value by 1. */ @@ -29,13 +36,13 @@ public: /** * Increments the value by @p amount. */ - void Inc(BaseType amount) noexcept { handle.Increment(amount); } + void Inc(double amount) noexcept { handle.Increment(amount); } /** * Increments the value by 1. * @return The new value. */ - BaseType operator++() noexcept { + double operator++() noexcept { Inc(1); return Value(); } @@ -48,164 +55,54 @@ public: /** * Decrements the value by @p amount. */ - void Dec(BaseType amount) noexcept { handle.Decrement(amount); } + void Dec(double amount) noexcept { handle.Decrement(amount); } /** * Decrements the value by 1. * @return The new value. */ - BaseType operator--() noexcept { + double operator--() noexcept { Dec(1); return Value(); } - BaseType Value() const noexcept { - if ( has_callback ) { - // Use Collect() here instead of Value() to correctly handle metrics - // with callbacks. - auto metric = handle.Collect(); - return static_cast(metric.gauge.value); - } + double Value() const noexcept; - return handle.Value(); - } - - /** - * Directly sets the value of the gauge. - */ - void Set(BaseType v) { handle.Set(v); } - - bool operator==(const BaseGauge& rhs) const noexcept { return &handle == &rhs.handle; } - bool operator!=(const BaseGauge& rhs) const noexcept { return &handle != &rhs.handle; } + bool operator==(const Gauge& rhs) const noexcept { return &handle == &rhs.handle; } + bool operator!=(const Gauge& rhs) const noexcept { return &handle != &rhs.handle; } bool CompareLabels(const prometheus::Labels& lbls) const { return labels == lbls; } -protected: - explicit BaseGauge(FamilyType* family, const prometheus::Labels& labels, - prometheus::CollectCallbackPtr callback = nullptr) noexcept - : handle(family->Add(labels)), labels(labels) { - if ( callback ) { - handle.AddCollectCallback(callback); - has_callback = true; - } - } - +private: Handle& handle; prometheus::Labels labels; bool has_callback = false; }; -/** - * A handle to a metric that represents an integer value. Gauges are more - * permissive than counters and also allow decrementing the value. - */ -class IntGauge final : public BaseGauge { +class GaugeFamily : public MetricFamily, public std::enable_shared_from_this { public: - static inline const char* OpaqueName = "IntGaugeMetricVal"; + static inline const char* OpaqueName = "GaugeMetricFamilyVal"; - explicit IntGauge(FamilyType* family, const prometheus::Labels& labels, - prometheus::CollectCallbackPtr callback = nullptr) noexcept - : BaseGauge(family, labels, callback) {} - - IntGauge(const IntGauge&) = delete; - IntGauge& operator=(const IntGauge&) = delete; -}; - -/** - * A handle to a metric that represents a double value. Gauges are more - * permissive than counters and also allow decrementing the value. - */ -class DblGauge final : public BaseGauge { -public: - static inline const char* OpaqueName = "DblGaugeMetricVal"; - - explicit DblGauge(FamilyType* family, const prometheus::Labels& labels, - prometheus::CollectCallbackPtr callback = nullptr) noexcept - : BaseGauge(family, labels, callback) {} - - DblGauge(const DblGauge&) = delete; - DblGauge& operator=(const DblGauge&) = delete; -}; - -template -class BaseGaugeFamily : public MetricFamily, public std::enable_shared_from_this> { -public: /** * Returns the metrics handle for given labels, creating a new instance * lazily if necessary. */ - std::shared_ptr GetOrAdd(Span labels, - prometheus::CollectCallbackPtr callback = nullptr) { - prometheus::Labels p_labels = detail::BuildPrometheusLabels(labels); - - auto check = [&](const std::shared_ptr& gauge) { return gauge->CompareLabels(p_labels); }; - - if ( auto it = std::find_if(gauges.begin(), gauges.end(), check); it != gauges.end() ) - return *it; - - auto gauge = std::make_shared(family, p_labels, callback); - gauges.push_back(gauge); - return gauge; - } + std::shared_ptr GetOrAdd(Span labels, prometheus::CollectCallbackPtr callback = nullptr); /** * @copydoc GetOrAdd */ - std::shared_ptr GetOrAdd(std::initializer_list labels, - prometheus::CollectCallbackPtr callback = nullptr) { - return GetOrAdd(Span{labels.begin(), labels.size()}, callback); - } + std::shared_ptr GetOrAdd(std::initializer_list labels, + prometheus::CollectCallbackPtr callback = nullptr); -protected: - BaseGaugeFamily(prometheus::Family* family, Span labels) + zeek_int_t MetricType() const noexcept override { return BifEnum::Telemetry::MetricType::GAUGE; } + + GaugeFamily(prometheus::Family* family, Span labels) : MetricFamily(labels), family(family) {} +private: prometheus::Family* family; - std::vector> gauges; + std::vector> gauges; }; -/** - * Manages a collection of IntGauge metrics. - */ -class IntGaugeFamily final : public BaseGaugeFamily { -public: - static inline const char* OpaqueName = "IntGaugeMetricFamilyVal"; - - explicit IntGaugeFamily(prometheus::Family* family, Span labels) - : BaseGaugeFamily(family, labels) {} - - zeek_int_t MetricType() const noexcept override { return BifEnum::Telemetry::MetricType::INT_GAUGE; } -}; - -/** - * Manages a collection of DblGauge metrics. - */ -class DblGaugeFamily final : public BaseGaugeFamily { -public: - static inline const char* OpaqueName = "DblGaugeMetricFamilyVal"; - - explicit DblGaugeFamily(prometheus::Family* family, Span labels) - : BaseGaugeFamily(family, labels) {} - - zeek_int_t MetricType() const noexcept override { return BifEnum::Telemetry::MetricType::DOUBLE_GAUGE; } -}; - -namespace detail { - -template -struct GaugeOracle { - static_assert(std::is_same::value, "Gauge only supports int64_t and double"); - using type = IntGauge; -}; - -template<> -struct GaugeOracle { - using type = DblGauge; -}; - -} // namespace detail - -template -using Gauge = typename detail::GaugeOracle::type; - } // namespace zeek::telemetry diff --git a/src/telemetry/Histogram.cc b/src/telemetry/Histogram.cc new file mode 100644 index 0000000000..6ebae60c08 --- /dev/null +++ b/src/telemetry/Histogram.cc @@ -0,0 +1,38 @@ +#include "zeek/telemetry/Histogram.h" + +using namespace zeek::telemetry; + +double Histogram::Sum() const noexcept { + auto metric = handle.Collect(); + return static_cast(metric.histogram.sample_sum); +} + +Histogram::Histogram(FamilyType* family, const prometheus::Labels& labels, + prometheus::Histogram::BucketBoundaries bounds) noexcept + : handle(family->Add(labels, std::move(bounds))), labels(labels) {} + +std::shared_ptr HistogramFamily::GetOrAdd(Span labels) { + prometheus::Labels p_labels = detail::BuildPrometheusLabels(labels); + + auto check = [&](const std::shared_ptr& histo) { return histo->CompareLabels(p_labels); }; + + if ( auto it = std::find_if(histograms.begin(), histograms.end(), check); it != histograms.end() ) + return *it; + + auto histogram = std::make_shared(family, p_labels, boundaries); + histograms.push_back(histogram); + return histogram; +} + +/** + * @copydoc GetOrAdd + */ +std::shared_ptr HistogramFamily::GetOrAdd(std::initializer_list labels) { + return GetOrAdd(Span{labels.begin(), labels.size()}); +} + +HistogramFamily::HistogramFamily(prometheus::Family* family, Span bounds, + Span labels) + : MetricFamily(labels), family(family) { + std::copy(bounds.begin(), bounds.end(), std::back_inserter(boundaries)); +} diff --git a/src/telemetry/Histogram.h b/src/telemetry/Histogram.h index c875b51779..adb3ca2209 100644 --- a/src/telemetry/Histogram.h +++ b/src/telemetry/Histogram.h @@ -15,159 +15,59 @@ namespace zeek::telemetry { -template -class BaseHistogram { +class Histogram { public: + static inline const char* OpaqueName = "HistogramMetricVal"; + using Handle = prometheus::Histogram; using FamilyType = prometheus::Family; + explicit Histogram(FamilyType* family, const prometheus::Labels& labels, + prometheus::Histogram::BucketBoundaries bounds) noexcept; + /** * Increments all buckets with an upper bound less than or equal to @p value * by one and adds @p value to the total sum of all observed values. */ - void Observe(BaseType value) noexcept { handle.Observe(value); } + void Observe(double value) noexcept { handle.Observe(value); } /// @return The sum of all observed values. - BaseType Sum() const noexcept { - auto metric = handle.Collect(); - return static_cast(metric.histogram.sample_sum); - } + double Sum() const noexcept; - bool operator==(const BaseHistogram& rhs) const noexcept { return &handle == &rhs.handle; } - bool operator!=(const BaseHistogram& rhs) const noexcept { return &handle != &rhs.handle; } + bool operator==(const Histogram& rhs) const noexcept { return &handle == &rhs.handle; } + bool operator!=(const Histogram& rhs) const noexcept { return &handle != &rhs.handle; } bool CompareLabels(const prometheus::Labels& lbls) const { return labels == lbls; } -protected: - explicit BaseHistogram(FamilyType* family, const prometheus::Labels& labels, - prometheus::Histogram::BucketBoundaries bounds) noexcept - : handle(family->Add(labels, std::move(bounds))), labels(labels) {} - +private: Handle& handle; prometheus::Labels labels; }; -/** - * A handle to a metric that represents an aggregable distribution of observed - * measurements with integer precision. Sorts individual measurements into - * configurable buckets. - */ -class IntHistogram final : public BaseHistogram { +class HistogramFamily : public MetricFamily, public std::enable_shared_from_this { public: - static inline const char* OpaqueName = "IntHistogramMetricVal"; + static inline const char* OpaqueName = "HistogramMetricFamilyVal"; - explicit IntHistogram(FamilyType* family, const prometheus::Labels& labels, - prometheus::Histogram::BucketBoundaries bounds) noexcept - : BaseHistogram(family, labels, std::move(bounds)) {} + HistogramFamily(prometheus::Family* family, Span bounds, + Span labels); - IntHistogram() = delete; - IntHistogram(const IntHistogram&) noexcept = delete; - IntHistogram& operator=(const IntHistogram&) noexcept = delete; -}; - -/** - * A handle to a metric that represents an aggregable distribution of observed - * measurements with integer precision. Sorts individual measurements into - * configurable buckets. - */ -class DblHistogram final : public BaseHistogram { -public: - static inline const char* OpaqueName = "DblHistogramMetricVal"; - - explicit DblHistogram(FamilyType* family, const prometheus::Labels& labels, - prometheus::Histogram::BucketBoundaries bounds) noexcept - : BaseHistogram(family, labels, std::move(bounds)) {} - - DblHistogram() = delete; - DblHistogram(const DblHistogram&) noexcept = delete; - DblHistogram& operator=(const DblHistogram&) noexcept = delete; -}; - -template -class BaseHistogramFamily : public MetricFamily, - public std::enable_shared_from_this> { -public: /** * Returns the metrics handle for given labels, creating a new instance * lazily if necessary. */ - std::shared_ptr GetOrAdd(Span labels) { - prometheus::Labels p_labels = detail::BuildPrometheusLabels(labels); - - auto check = [&](const std::shared_ptr& histo) { return histo->CompareLabels(p_labels); }; - - if ( auto it = std::find_if(histograms.begin(), histograms.end(), check); it != histograms.end() ) - return *it; - - auto histogram = std::make_shared(family, p_labels, boundaries); - histograms.push_back(histogram); - return histogram; - } + std::shared_ptr GetOrAdd(Span labels); /** * @copydoc GetOrAdd */ - std::shared_ptr GetOrAdd(std::initializer_list labels) { - return GetOrAdd(Span{labels.begin(), labels.size()}); - } + std::shared_ptr GetOrAdd(std::initializer_list labels); -protected: - BaseHistogramFamily(prometheus::Family* family, Span bounds, - Span labels) - : MetricFamily(labels), family(family) { - std::copy(bounds.begin(), bounds.end(), std::back_inserter(boundaries)); - } + zeek_int_t MetricType() const noexcept override { return BifEnum::Telemetry::MetricType::HISTOGRAM; } +private: prometheus::Family* family; prometheus::Histogram::BucketBoundaries boundaries; - std::vector> histograms; + std::vector> histograms; }; -/** - * Manages a collection of IntHistogram metrics. - */ -class IntHistogramFamily final : public BaseHistogramFamily { -public: - static inline const char* OpaqueName = "IntHistogramMetricFamilyVal"; - - explicit IntHistogramFamily(prometheus::Family* family, Span bounds, - Span labels) - : BaseHistogramFamily(family, bounds, labels) {} - - zeek_int_t MetricType() const noexcept override { return BifEnum::Telemetry::MetricType::INT_HISTOGRAM; } -}; - -/** - * Manages a collection of DblHistogram metrics. - */ -class DblHistogramFamily final : public BaseHistogramFamily { -public: - static inline const char* OpaqueName = "DblHistogramMetricFamilyVal"; - - explicit DblHistogramFamily(prometheus::Family* family, Span bounds, - Span labels) - : BaseHistogramFamily(family, bounds, labels) {} - - zeek_int_t MetricType() const noexcept override { return BifEnum::Telemetry::MetricType::DOUBLE_HISTOGRAM; } -}; - -namespace detail { - -template -struct HistogramOracle { - static_assert(std::is_same::value, "Histogram only supports int64_t and double"); - - using type = IntHistogram; -}; - -template<> -struct HistogramOracle { - using type = DblHistogram; -}; - -} // namespace detail - -template -using Histogram = typename detail::HistogramOracle::type; - } // namespace zeek::telemetry diff --git a/src/telemetry/Manager.cc b/src/telemetry/Manager.cc index c06dc4757a..c85177ef43 100644 --- a/src/telemetry/Manager.cc +++ b/src/telemetry/Manager.cc @@ -81,37 +81,37 @@ void Manager::InitPostScript() { return &this->current_process_stats; }; - rss_gauge = GaugeInstance("process", "resident_memory", {}, "Resident memory size", "bytes", false, - []() -> prometheus::ClientMetric { - auto* s = get_stats(); - prometheus::ClientMetric metric; - metric.gauge.value = static_cast(s->rss); - return metric; - }); + rss_gauge = GaugeInstance("process", "resident_memory", {}, "Resident memory size", "bytes", false, + []() -> prometheus::ClientMetric { + auto* s = get_stats(); + prometheus::ClientMetric metric; + metric.gauge.value = static_cast(s->rss); + return metric; + }); - vms_gauge = GaugeInstance("process", "virtual_memory", {}, "Virtual memory size", "bytes", false, - []() -> prometheus::ClientMetric { - auto* s = get_stats(); - prometheus::ClientMetric metric; - metric.gauge.value = static_cast(s->vms); - return metric; - }); + vms_gauge = GaugeInstance("process", "virtual_memory", {}, "Virtual memory size", "bytes", false, + []() -> prometheus::ClientMetric { + auto* s = get_stats(); + prometheus::ClientMetric metric; + metric.gauge.value = static_cast(s->vms); + return metric; + }); - cpu_gauge = GaugeInstance("process", "cpu", {}, "Total user and system CPU time spent", "seconds", false, - []() -> prometheus::ClientMetric { - auto* s = get_stats(); - prometheus::ClientMetric metric; - metric.gauge.value = s->cpu; - return metric; - }); + cpu_gauge = GaugeInstance("process", "cpu", {}, "Total user and system CPU time spent", "seconds", false, + []() -> prometheus::ClientMetric { + auto* s = get_stats(); + prometheus::ClientMetric metric; + metric.gauge.value = s->cpu; + return metric; + }); - fds_gauge = GaugeInstance("process", "open_fds", {}, "Number of open file descriptors", "", false, - []() -> prometheus::ClientMetric { - auto* s = get_stats(); - prometheus::ClientMetric metric; - metric.gauge.value = static_cast(s->fds); - return metric; - }); + fds_gauge = GaugeInstance("process", "open_fds", {}, "Number of open file descriptors", "", false, + []() -> prometheus::ClientMetric { + auto* s = get_stats(); + prometheus::ClientMetric metric; + metric.gauge.value = static_cast(s->fds); + return metric; + }); #endif } @@ -169,13 +169,13 @@ RecordValPtr Manager::GetMetricOptsRecord(const prometheus::MetricFamily& metric // prom-cpp stores everything internally as doubles if ( metric_family.type == prometheus::MetricType::Counter ) record_val->Assign(metric_type_idx, zeek::BifType::Enum::Telemetry::MetricType->GetEnumVal( - BifEnum::Telemetry::MetricType::DOUBLE_COUNTER)); + BifEnum::Telemetry::MetricType::COUNTER)); if ( metric_family.type == prometheus::MetricType::Gauge ) record_val->Assign(metric_type_idx, zeek::BifType::Enum::Telemetry::MetricType->GetEnumVal( - BifEnum::Telemetry::MetricType::DOUBLE_GAUGE)); + BifEnum::Telemetry::MetricType::GAUGE)); if ( metric_family.type == prometheus::MetricType::Histogram ) record_val->Assign(metric_type_idx, zeek::BifType::Enum::Telemetry::MetricType->GetEnumVal( - BifEnum::Telemetry::MetricType::DOUBLE_HISTOGRAM)); + BifEnum::Telemetry::MetricType::HISTOGRAM)); // prometheus-cpp doesn't store label names anywhere other than in each // instrument. this is valid because label names can be different @@ -264,7 +264,6 @@ ValPtr Manager::CollectMetrics(std::string_view prefix_pattern, std::string_view static auto opts_idx = metric_record_type->FieldOffset("opts"); static auto labels_idx = metric_record_type->FieldOffset("labels"); static auto value_idx = metric_record_type->FieldOffset("value"); - static auto count_value_idx = metric_record_type->FieldOffset("count_value"); static auto metric_opts_type = zeek::id::find_type("Telemetry::MetricOpts"); static auto metric_type_idx = metric_opts_type->FieldOffset("metric_type"); @@ -304,17 +303,6 @@ ValPtr Manager::CollectMetrics(std::string_view prefix_pattern, std::string_view else if ( fam.type == prometheus::MetricType::Gauge ) r->Assign(value_idx, zeek::make_intrusive(inst.gauge.value)); - // Use the information from GetMetaricOptsRecord to check whether we need to add the integer - // fields, or if this is a double. - if ( opts_record->GetField(metric_type_idx)->Get() == - BifEnum::Telemetry::MetricType::INT_COUNTER ) { - r->Assign(count_value_idx, val_mgr->Count(static_cast(inst.counter.value))); - } - else if ( opts_record->GetField(metric_type_idx)->Get() == - BifEnum::Telemetry::MetricType::INT_GAUGE ) { - r->Assign(count_value_idx, val_mgr->Count(static_cast(inst.gauge.value))); - } - ret_val->Append(r); } } @@ -339,22 +327,16 @@ ValPtr Manager::CollectHistogramMetrics(std::string_view prefix_pattern, std::st static auto metrics_vector_type = zeek::id::find_type("Telemetry::HistogramMetricVector"); static auto string_vec_type = zeek::id::find_type("string_vec"); static auto double_vec_type = zeek::id::find_type("double_vec"); - static auto count_vec_type = zeek::id::find_type("index_vec"); static auto histogram_metric_type = zeek::id::find_type("Telemetry::HistogramMetric"); static auto labels_idx = histogram_metric_type->FieldOffset("labels"); static auto values_idx = histogram_metric_type->FieldOffset("values"); - static auto count_values_idx = histogram_metric_type->FieldOffset("count_values"); static auto observations_idx = histogram_metric_type->FieldOffset("observations"); - static auto count_observations_idx = histogram_metric_type->FieldOffset("count_observations"); - static auto sum_idx = histogram_metric_type->FieldOffset("sum"); - static auto count_sum_idx = histogram_metric_type->FieldOffset("count_sum"); static auto opts_idx = histogram_metric_type->FieldOffset("opts"); static auto opts_rt = zeek::id::find_type("Telemetry::MetricOpts"); static auto bounds_idx = opts_rt->FieldOffset("bounds"); - static auto count_bounds_idx = opts_rt->FieldOffset("count_bounds"); static auto metric_opts_type = zeek::id::find_type("Telemetry::MetricOpts"); static auto metric_type_idx = metric_opts_type->FieldOffset("metric_type"); @@ -390,32 +372,20 @@ ValPtr Manager::CollectHistogramMetrics(std::string_view prefix_pattern, std::st r->Assign(opts_idx, opts_record); auto double_values_vec = make_intrusive(double_vec_type); - auto count_values_vec = make_intrusive(count_vec_type); std::vector boundaries; uint64_t last = 0.0; for ( const auto& b : inst.histogram.bucket ) { double_values_vec->Append( zeek::make_intrusive(static_cast(b.cumulative_count - last))); - count_values_vec->Append(val_mgr->Count(b.cumulative_count - last)); last = b.cumulative_count; boundaries.push_back(b.upper_bound); } // TODO: these could be stored somehow to avoid recreating them repeatedly auto bounds_vec = make_intrusive(double_vec_type); - auto count_bounds_vec = make_intrusive(count_vec_type); - for ( auto b : boundaries ) { + for ( auto b : boundaries ) bounds_vec->Append(zeek::make_intrusive(b)); - // The boundaries from prom-cpp include the infinite boundary in double. - // This can't be converted safely to int64_t, so check for that case and - // set the int64_t version. - if ( b != std::numeric_limits::infinity() ) - count_bounds_vec->Append(val_mgr->Count(static_cast(b))); - else - count_bounds_vec->Append(val_mgr->Count(std::numeric_limits::infinity())); - } - r->Assign(values_idx, double_values_vec); r->Assign(observations_idx, zeek::make_intrusive(static_cast(inst.histogram.sample_count))); @@ -424,16 +394,6 @@ ValPtr Manager::CollectHistogramMetrics(std::string_view prefix_pattern, std::st RecordValPtr local_opts_record = r->GetField(opts_idx); local_opts_record->Assign(bounds_idx, bounds_vec); - // Use the information from GetMetaricOptsRecord to check whether we need to add the integer - // fields, or if this is a double. - if ( opts_record->GetField(metric_type_idx)->Get() == - BifEnum::Telemetry::MetricType::INT_HISTOGRAM ) { - r->Assign(count_values_idx, count_values_vec); - r->Assign(count_observations_idx, val_mgr->Count(inst.histogram.sample_count)); - r->Assign(count_sum_idx, val_mgr->Count(static_cast(inst.histogram.sample_sum))); - local_opts_record->Assign(count_bounds_idx, count_bounds_vec); - } - ret_val->Append(r); } } @@ -483,6 +443,135 @@ std::string Manager::GetClusterJson() const { return buffer.GetString(); } +std::shared_ptr Manager::CounterFamily(std::string_view prefix, std::string_view name, + Span labels, + std::string_view helptext, std::string_view unit, + bool is_sum) { + auto full_name = detail::BuildFullPrometheusName(prefix, name, unit, is_sum); + + auto& prom_fam = + prometheus::BuildCounter().Name(full_name).Help(std::string{helptext}).Register(*prometheus_registry); + + if ( auto it = families.find(prom_fam.GetName()); it != families.end() ) + return std::static_pointer_cast(it->second); + + auto fam = std::make_shared(&prom_fam, labels); + families.insert({prom_fam.GetName(), fam}); + return fam; +} + +std::shared_ptr Manager::CounterFamily(std::string_view prefix, std::string_view name, + std::initializer_list labels, + std::string_view helptext, std::string_view unit, + bool is_sum) { + auto lbl_span = Span{labels.begin(), labels.size()}; + return CounterFamily(prefix, name, lbl_span, helptext, unit, is_sum); +} + +std::shared_ptr Manager::CounterInstance(std::string_view prefix, std::string_view name, + Span labels, std::string_view helptext, + std::string_view unit, bool is_sum, + prometheus::CollectCallbackPtr callback) { + return WithLabelNames(labels, [&, this](auto labelNames) { + auto family = CounterFamily(prefix, name, labelNames, helptext, unit, is_sum); + return family->GetOrAdd(labels, callback); + }); +} + +std::shared_ptr Manager::CounterInstance(std::string_view prefix, std::string_view name, + std::initializer_list labels, std::string_view helptext, + std::string_view unit, bool is_sum, + prometheus::CollectCallbackPtr callback) { + auto lbl_span = Span{labels.begin(), labels.size()}; + return CounterInstance(prefix, name, lbl_span, helptext, unit, is_sum, std::move(callback)); +} + +std::shared_ptr Manager::GaugeFamily(std::string_view prefix, std::string_view name, + Span labels, + std::string_view helptext, std::string_view unit, + bool is_sum) { + auto full_name = detail::BuildFullPrometheusName(prefix, name, unit, is_sum); + + auto& prom_fam = + prometheus::BuildGauge().Name(full_name).Help(std::string{helptext}).Register(*prometheus_registry); + + if ( auto it = families.find(prom_fam.GetName()); it != families.end() ) + return std::static_pointer_cast(it->second); + + auto fam = std::make_shared(&prom_fam, labels); + families.insert({prom_fam.GetName(), fam}); + return fam; +} + +std::shared_ptr Manager::GaugeFamily(std::string_view prefix, std::string_view name, + std::initializer_list labels, + std::string_view helptext, std::string_view unit, + bool is_sum) { + auto lbl_span = Span{labels.begin(), labels.size()}; + return GaugeFamily(prefix, name, lbl_span, helptext, unit, is_sum); +} + +std::shared_ptr Manager::GaugeInstance(std::string_view prefix, std::string_view name, + Span labels, std::string_view helptext, + std::string_view unit, bool is_sum, + prometheus::CollectCallbackPtr callback) { + return WithLabelNames(labels, [&, this](auto labelNames) { + auto family = GaugeFamily(prefix, name, labelNames, helptext, unit, is_sum); + return family->GetOrAdd(labels, callback); + }); +} + +std::shared_ptr Manager::GaugeInstance(std::string_view prefix, std::string_view name, + std::initializer_list labels, std::string_view helptext, + std::string_view unit, bool is_sum, + prometheus::CollectCallbackPtr callback) { + auto lbl_span = Span{labels.begin(), labels.size()}; + return GaugeInstance(prefix, name, lbl_span, helptext, unit, is_sum, callback); +} + +std::shared_ptr Manager::HistogramFamily(std::string_view prefix, std::string_view name, + Span labels, + ConstSpan bounds, + std::string_view helptext, std::string_view unit) { + auto full_name = detail::BuildFullPrometheusName(prefix, name, unit); + + auto& prom_fam = + prometheus::BuildHistogram().Name(full_name).Help(std::string{helptext}).Register(*prometheus_registry); + + if ( auto it = families.find(prom_fam.GetName()); it != families.end() ) + return std::static_pointer_cast(it->second); + + auto fam = std::make_shared(&prom_fam, bounds, labels); + families.insert({prom_fam.GetName(), fam}); + return fam; +} + +std::shared_ptr Manager::HistogramFamily(std::string_view prefix, std::string_view name, + std::initializer_list labels, + ConstSpan bounds, + std::string_view helptext, std::string_view unit) { + auto lbl_span = Span{labels.begin(), labels.size()}; + return HistogramFamily(prefix, name, lbl_span, bounds, helptext, unit); +} + +std::shared_ptr Manager::HistogramInstance(std::string_view prefix, std::string_view name, + Span labels, ConstSpan bounds, + std::string_view helptext, std::string_view unit) { + return WithLabelNames(labels, [&, this](auto labelNames) { + auto family = HistogramFamily(prefix, name, labelNames, bounds, helptext, unit); + return family->GetOrAdd(labels); + }); +} + +std::shared_ptr Manager::HistogramInstance(std::string_view prefix, std::string_view name, + std::initializer_list labels, + std::initializer_list bounds, std::string_view helptext, + std::string_view unit) { + auto lbls = Span{labels.begin(), labels.size()}; + auto bounds_span = Span{bounds.begin(), bounds.size()}; + return HistogramInstance(prefix, name, lbls, bounds_span, helptext, unit); +} + } // namespace zeek::telemetry // -- unit tests --------------------------------------------------------------- @@ -519,7 +608,7 @@ SCENARIO("telemetry managers provide access to counter families") { } } WHEN("retrieving a DblCounter family") { - auto family = mgr.CounterFamily("zeek", "runtime", {"query"}, "test", "seconds", true); + auto family = mgr.CounterFamily("zeek", "runtime", {"query"}, "test", "seconds", true); THEN("GetOrAdd returns the same metric for the same labels") { auto first = family->GetOrAdd({{"query", "foo"}}); auto second = family->GetOrAdd({{"query", "foo"}}); @@ -551,7 +640,7 @@ SCENARIO("telemetry managers provide access to gauge families") { } } WHEN("retrieving a DblGauge family") { - auto family = mgr.GaugeFamily("zeek", "water-level", {"river"}, "test", "meters"); + auto family = mgr.GaugeFamily("zeek", "water-level", {"river"}, "test", "meters"); THEN("GetOrAdd returns the same metric for the same labels") { auto first = family->GetOrAdd({{"river", "Sacramento"}}); auto second = family->GetOrAdd({{"river", "Sacramento"}}); @@ -570,7 +659,7 @@ SCENARIO("telemetry managers provide access to histogram families") { GIVEN("a telemetry manager") { Manager mgr; WHEN("retrieving an IntHistogram family") { - int64_t buckets[] = {10, 20}; + double buckets[] = {10, 20}; auto family = mgr.HistogramFamily("zeek", "payload-size", {"protocol"}, buckets, "test", "bytes"); THEN("GetOrAdd returns the same metric for the same labels") { auto first = family->GetOrAdd({{"protocol", "tcp"}}); @@ -585,7 +674,7 @@ SCENARIO("telemetry managers provide access to histogram families") { } WHEN("retrieving a DblHistogram family") { double buckets[] = {10.0, 20.0}; - auto family = mgr.HistogramFamily("zeek", "parse-time", {"protocol"}, buckets, "test", "seconds"); + auto family = mgr.HistogramFamily("zeek", "parse-time", {"protocol"}, buckets, "test", "seconds"); THEN("GetOrAdd returns the same metric for the same labels") { auto first = family->GetOrAdd({{"protocol", "tcp"}}); auto second = family->GetOrAdd({{"protocol", "tcp"}}); diff --git a/src/telemetry/Manager.h b/src/telemetry/Manager.h index a08693d005..b43f0a8c01 100644 --- a/src/telemetry/Manager.h +++ b/src/telemetry/Manager.h @@ -70,40 +70,16 @@ public: * @param unit Unit of measurement. * @param is_sum Indicates whether this metric accumulates something, where only the total value is of interest. */ - template - auto CounterFamily(std::string_view prefix, std::string_view name, Span labels, - std::string_view helptext, std::string_view unit = "", bool is_sum = false) { - auto full_name = detail::BuildFullPrometheusName(prefix, name, unit, is_sum); - - auto& prom_fam = - prometheus::BuildCounter().Name(full_name).Help(std::string{helptext}).Register(*prometheus_registry); - - if constexpr ( std::is_same::value ) { - if ( auto it = families.find(prom_fam.GetName()); it != families.end() ) - return std::static_pointer_cast(it->second); - - auto fam = std::make_shared(&prom_fam, labels); - families.insert({prom_fam.GetName(), fam}); - return fam; - } - else { - static_assert(std::is_same::value, "metrics only support int64_t and double values"); - if ( auto it = families.find(prom_fam.GetName()); it != families.end() ) - return std::static_pointer_cast(it->second); - - auto fam = std::make_shared(&prom_fam, labels); - families.insert({prom_fam.GetName(), fam}); - return fam; - } - } + std::shared_ptr CounterFamily(std::string_view prefix, std::string_view name, + Span labels, + std::string_view helptext, std::string_view unit = "", + bool is_sum = false); /// @copydoc CounterFamily - template - auto CounterFamily(std::string_view prefix, std::string_view name, std::initializer_list labels, - std::string_view helptext, std::string_view unit = "", bool is_sum = false) { - auto lbl_span = Span{labels.begin(), labels.size()}; - return CounterFamily(prefix, name, lbl_span, helptext, unit, is_sum); - } + std::shared_ptr CounterFamily(std::string_view prefix, std::string_view name, + std::initializer_list labels, + std::string_view helptext, std::string_view unit = "", + bool is_sum = false); /** * Accesses a counter instance. Creates the hosting metric family as well @@ -117,27 +93,16 @@ public: * @param callback Passing a callback method will enable asynchronous mode. The callback method will be called by * the metrics subsystem whenever data is requested. */ - template - std::shared_ptr> CounterInstance(std::string_view prefix, std::string_view name, - Span labels, std::string_view helptext, - std::string_view unit = "", bool is_sum = false, - prometheus::CollectCallbackPtr callback = nullptr) { - return WithLabelNames(labels, [&, this](auto labelNames) { - auto family = CounterFamily(prefix, name, labelNames, helptext, unit, is_sum); - return family->GetOrAdd(labels, callback); - }); - } + std::shared_ptr CounterInstance(std::string_view prefix, std::string_view name, + Span labels, std::string_view helptext, + std::string_view unit = "", bool is_sum = false, + prometheus::CollectCallbackPtr callback = nullptr); /// @copydoc counterInstance - template - std::shared_ptr> CounterInstance(std::string_view prefix, std::string_view name, - std::initializer_list labels, - std::string_view helptext, std::string_view unit = "", - bool is_sum = false, - prometheus::CollectCallbackPtr callback = nullptr) { - auto lbl_span = Span{labels.begin(), labels.size()}; - return CounterInstance(prefix, name, lbl_span, helptext, unit, is_sum, callback); - } + std::shared_ptr CounterInstance(std::string_view prefix, std::string_view name, + std::initializer_list labels, std::string_view helptext, + std::string_view unit = "", bool is_sum = false, + prometheus::CollectCallbackPtr callback = nullptr); /** * @return A gauge metric family. Creates the family lazily if necessary. @@ -148,40 +113,15 @@ public: * @param unit Unit of measurement. * @param is_sum Indicates whether this metric accumulates something, where only the total value is of interest. */ - template - auto GaugeFamily(std::string_view prefix, std::string_view name, Span labels, - std::string_view helptext, std::string_view unit = "", bool is_sum = false) { - auto full_name = detail::BuildFullPrometheusName(prefix, name, unit, is_sum); - - auto& prom_fam = - prometheus::BuildGauge().Name(full_name).Help(std::string{helptext}).Register(*prometheus_registry); - - if constexpr ( std::is_same::value ) { - if ( auto it = families.find(prom_fam.GetName()); it != families.end() ) - return std::static_pointer_cast(it->second); - - auto fam = std::make_shared(&prom_fam, labels); - families.insert({prom_fam.GetName(), fam}); - return fam; - } - else { - static_assert(std::is_same::value, "metrics only support int64_t and double values"); - if ( auto it = families.find(prom_fam.GetName()); it != families.end() ) - return std::static_pointer_cast(it->second); - - auto fam = std::make_shared(&prom_fam, labels); - families.insert({prom_fam.GetName(), fam}); - return fam; - } - } + std::shared_ptr GaugeFamily(std::string_view prefix, std::string_view name, + Span labels, std::string_view helptext, + std::string_view unit = "", bool is_sum = false); /// @copydoc GaugeFamily - template - auto GaugeFamily(std::string_view prefix, std::string_view name, std::initializer_list labels, - std::string_view helptext, std::string_view unit = "", bool is_sum = false) { - auto lbl_span = Span{labels.begin(), labels.size()}; - return GaugeFamily(prefix, name, lbl_span, helptext, unit, is_sum); - } + std::shared_ptr GaugeFamily(std::string_view prefix, std::string_view name, + std::initializer_list labels, + std::string_view helptext, std::string_view unit = "", + bool is_sum = false); /** * Accesses a gauge instance. Creates the hosting metric family as well @@ -195,26 +135,15 @@ public: * @param callback Passing a callback method will enable asynchronous mode. The callback method will be called by * the metrics subsystem whenever data is requested. */ - template - std::shared_ptr> GaugeInstance(std::string_view prefix, std::string_view name, - Span labels, std::string_view helptext, - std::string_view unit = "", bool is_sum = false, - prometheus::CollectCallbackPtr callback = nullptr) { - return WithLabelNames(labels, [&, this](auto labelNames) { - auto family = GaugeFamily(prefix, name, labelNames, helptext, unit, is_sum); - return family->GetOrAdd(labels, callback); - }); - } + std::shared_ptr GaugeInstance(std::string_view prefix, std::string_view name, Span labels, + std::string_view helptext, std::string_view unit = "", bool is_sum = false, + prometheus::CollectCallbackPtr callback = nullptr); /// @copydoc GaugeInstance - template - std::shared_ptr> GaugeInstance(std::string_view prefix, std::string_view name, - std::initializer_list labels, std::string_view helptext, - std::string_view unit = "", bool is_sum = false, - prometheus::CollectCallbackPtr callback = nullptr) { - auto lbl_span = Span{labels.begin(), labels.size()}; - return GaugeInstance(prefix, name, lbl_span, helptext, unit, is_sum, callback); - } + std::shared_ptr GaugeInstance(std::string_view prefix, std::string_view name, + std::initializer_list labels, std::string_view helptext, + std::string_view unit = "", bool is_sum = false, + prometheus::CollectCallbackPtr callback = nullptr); // Forces the compiler to use the type `Span` instead of trying to // match parameters to a `span`. @@ -245,40 +174,16 @@ public: * different bucket settings. Users may also override * @p bounds via run-time configuration. */ - template - auto HistogramFamily(std::string_view prefix, std::string_view name, Span labels, - ConstSpan bounds, std::string_view helptext, std::string_view unit = "") { - auto full_name = detail::BuildFullPrometheusName(prefix, name, unit); - - auto& prom_fam = - prometheus::BuildHistogram().Name(full_name).Help(std::string{helptext}).Register(*prometheus_registry); - - if constexpr ( std::is_same::value ) { - if ( auto it = families.find(prom_fam.GetName()); it != families.end() ) - return std::static_pointer_cast(it->second); - - auto fam = std::make_shared(&prom_fam, bounds, labels); - families.insert({prom_fam.GetName(), fam}); - return fam; - } - else { - static_assert(std::is_same::value, "metrics only support int64_t and double values"); - if ( auto it = families.find(prom_fam.GetName()); it != families.end() ) - return std::static_pointer_cast(it->second); - - auto fam = std::make_shared(&prom_fam, bounds, labels); - families.insert({prom_fam.GetName(), fam}); - return fam; - } - } + std::shared_ptr HistogramFamily(std::string_view prefix, std::string_view name, + Span labels, + ConstSpan bounds, std::string_view helptext, + std::string_view unit = ""); /// @copydoc HistogramFamily - template - auto HistogramFamily(std::string_view prefix, std::string_view name, std::initializer_list labels, - ConstSpan bounds, std::string_view helptext, std::string_view unit = "") { - auto lbl_span = Span{labels.begin(), labels.size()}; - return HistogramFamily(prefix, name, lbl_span, bounds, helptext, unit); - } + std::shared_ptr HistogramFamily(std::string_view prefix, std::string_view name, + std::initializer_list labels, + ConstSpan bounds, std::string_view helptext, + std::string_view unit = ""); /** * Returns a histogram. Creates the family lazily if necessary. @@ -297,26 +202,15 @@ public: * different bucket settings. Users may also override * @p bounds via run-time configuration. */ - template - std::shared_ptr> HistogramInstance(std::string_view prefix, std::string_view name, - Span labels, ConstSpan bounds, - std::string_view helptext, std::string_view unit = "") { - return WithLabelNames(labels, [&, this](auto labelNames) { - auto family = HistogramFamily(prefix, name, labelNames, bounds, helptext, unit); - return family->GetOrAdd(labels); - }); - } + std::shared_ptr HistogramInstance(std::string_view prefix, std::string_view name, + Span labels, ConstSpan bounds, + std::string_view helptext, std::string_view unit = ""); /// @copdoc HistogramInstance - template - std::shared_ptr> HistogramInstance(std::string_view prefix, std::string_view name, - std::initializer_list labels, - std::initializer_list bounds, - std::string_view helptext, std::string_view unit = "") { - auto lbls = Span{labels.begin(), labels.size()}; - auto bounds_span = Span{bounds.begin(), bounds.size()}; - return HistogramInstance(prefix, name, lbls, bounds_span, helptext, unit); - } + std::shared_ptr HistogramInstance(std::string_view prefix, std::string_view name, + std::initializer_list labels, + std::initializer_list bounds, std::string_view helptext, + std::string_view unit = ""); /** * @return A JSON description of the cluster configuration for reporting @@ -359,10 +253,10 @@ private: detail::process_stats current_process_stats; double process_stats_last_updated = 0.0; - std::shared_ptr rss_gauge; - std::shared_ptr vms_gauge; - std::shared_ptr cpu_gauge; - std::shared_ptr fds_gauge; + std::shared_ptr rss_gauge; + std::shared_ptr vms_gauge; + std::shared_ptr cpu_gauge; + std::shared_ptr fds_gauge; std::string endpoint_name; std::vector export_prefixes; diff --git a/src/telemetry/Opaques.cc b/src/telemetry/Opaques.cc index d5a7af9e55..d5f1c50de5 100644 --- a/src/telemetry/Opaques.cc +++ b/src/telemetry/Opaques.cc @@ -2,43 +2,21 @@ using namespace zeek; -TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(int_counter_metric_type) {} +TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(counter_metric_type) {} -TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(int_counter_metric_family_type) {} +TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(counter_metric_family_type) {} -TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(dbl_counter_metric_type) {} +TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(gauge_metric_type) {} -TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(dbl_counter_metric_family_type) {} +TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(gauge_metric_family_type) {} -TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(int_gauge_metric_type) {} +TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(histogram_metric_type) {} -TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(int_gauge_metric_family_type) {} +TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(histogram_metric_family_type) {} -TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(dbl_gauge_metric_type) {} - -TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(dbl_gauge_metric_family_type) {} - -TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(int_histogram_metric_type) {} - -TelemetryVal::TelemetryVal(std::shared_ptr) - : OpaqueVal(int_histogram_metric_family_type) {} - -TelemetryVal::TelemetryVal(std::shared_ptr) : OpaqueVal(dbl_histogram_metric_type) {} - -TelemetryVal::TelemetryVal(std::shared_ptr) - : OpaqueVal(dbl_histogram_metric_family_type) {} - -// TelemetryVal::TelemetryVal(prometheus::Counter&) : OpaqueVal( - -IMPLEMENT_OPAQUE_VALUE(IntCounterMetricVal) -IMPLEMENT_OPAQUE_VALUE(IntCounterMetricFamilyVal) -IMPLEMENT_OPAQUE_VALUE(DblCounterMetricVal) -IMPLEMENT_OPAQUE_VALUE(DblCounterMetricFamilyVal) -IMPLEMENT_OPAQUE_VALUE(IntGaugeMetricVal) -IMPLEMENT_OPAQUE_VALUE(IntGaugeMetricFamilyVal) -IMPLEMENT_OPAQUE_VALUE(DblGaugeMetricVal) -IMPLEMENT_OPAQUE_VALUE(DblGaugeMetricFamilyVal) -IMPLEMENT_OPAQUE_VALUE(IntHistogramMetricVal) -IMPLEMENT_OPAQUE_VALUE(IntHistogramMetricFamilyVal) -IMPLEMENT_OPAQUE_VALUE(DblHistogramMetricVal) -IMPLEMENT_OPAQUE_VALUE(DblHistogramMetricFamilyVal) +IMPLEMENT_OPAQUE_VALUE(CounterMetricVal) +IMPLEMENT_OPAQUE_VALUE(CounterMetricFamilyVal) +IMPLEMENT_OPAQUE_VALUE(GaugeMetricVal) +IMPLEMENT_OPAQUE_VALUE(GaugeMetricFamilyVal) +IMPLEMENT_OPAQUE_VALUE(HistogramMetricVal) +IMPLEMENT_OPAQUE_VALUE(HistogramMetricFamilyVal) diff --git a/src/telemetry/Opaques.h b/src/telemetry/Opaques.h index 324c11348f..6b9cbd1bef 100644 --- a/src/telemetry/Opaques.h +++ b/src/telemetry/Opaques.h @@ -15,18 +15,12 @@ namespace zeek { */ class TelemetryVal : public OpaqueVal { protected: - explicit TelemetryVal(std::shared_ptr); - explicit TelemetryVal(std::shared_ptr); - explicit TelemetryVal(std::shared_ptr); - explicit TelemetryVal(std::shared_ptr); - explicit TelemetryVal(std::shared_ptr); - explicit TelemetryVal(std::shared_ptr); - explicit TelemetryVal(std::shared_ptr); - explicit TelemetryVal(std::shared_ptr); - explicit TelemetryVal(std::shared_ptr); - explicit TelemetryVal(std::shared_ptr); - explicit TelemetryVal(std::shared_ptr); - explicit TelemetryVal(std::shared_ptr); + explicit TelemetryVal(std::shared_ptr); + explicit TelemetryVal(std::shared_ptr); + explicit TelemetryVal(std::shared_ptr); + explicit TelemetryVal(std::shared_ptr); + explicit TelemetryVal(std::shared_ptr); + explicit TelemetryVal(std::shared_ptr); std::optional DoSerializeData() const override { return std::nullopt; } bool DoUnserializeData(BrokerDataView data) override { return false; } @@ -55,17 +49,11 @@ private: HandleType hdl; }; -using IntCounterMetricVal = TelemetryValImpl; -using IntCounterMetricFamilyVal = TelemetryValImpl; -using DblCounterMetricVal = TelemetryValImpl; -using DblCounterMetricFamilyVal = TelemetryValImpl; -using IntGaugeMetricVal = TelemetryValImpl; -using IntGaugeMetricFamilyVal = TelemetryValImpl; -using DblGaugeMetricVal = TelemetryValImpl; -using DblGaugeMetricFamilyVal = TelemetryValImpl; -using IntHistogramMetricVal = TelemetryValImpl; -using IntHistogramMetricFamilyVal = TelemetryValImpl; -using DblHistogramMetricVal = TelemetryValImpl; -using DblHistogramMetricFamilyVal = TelemetryValImpl; +using CounterMetricVal = TelemetryValImpl; +using CounterMetricFamilyVal = TelemetryValImpl; +using GaugeMetricVal = TelemetryValImpl; +using GaugeMetricFamilyVal = TelemetryValImpl; +using HistogramMetricVal = TelemetryValImpl; +using HistogramMetricFamilyVal = TelemetryValImpl; } // namespace zeek diff --git a/src/telemetry/Timer.h b/src/telemetry/Timer.h index 02048325c0..910d32800b 100644 --- a/src/telemetry/Timer.h +++ b/src/telemetry/Timer.h @@ -1,3 +1,4 @@ + // See the file "COPYING" in the main distribution directory for copyright. #pragma once @@ -15,7 +16,7 @@ class [[nodiscard]] Timer { public: using Clock = std::chrono::steady_clock; - explicit Timer(std::shared_ptr h) : h_(std::move(h)) { start_ = Clock::now(); } + explicit Timer(std::shared_ptr h) : h_(std::move(h)) { start_ = Clock::now(); } Timer(const Timer&) = delete; @@ -30,14 +31,14 @@ public: auto Started() const noexcept { return start_; } /// Calls `h.Observe` with the time passed since `start`. - static void Observe(const std::shared_ptr& h, Clock::time_point start) { - using DblSec = std::chrono::duration; + static void Observe(const std::shared_ptr& h, Clock::time_point start) { + using Sec = std::chrono::duration; if ( auto end = Clock::now(); end > start ) - h->Observe(std::chrono::duration_cast(end - start).count()); + h->Observe(std::chrono::duration_cast(end - start).count()); } private: - std::shared_ptr h_; + std::shared_ptr h_; Clock::time_point start_; }; diff --git a/src/telemetry/telemetry.bif b/src/telemetry/telemetry.bif index 2e99648605..610509f1d8 100644 --- a/src/telemetry/telemetry.bif +++ b/src/telemetry/telemetry.bif @@ -3,12 +3,9 @@ module Telemetry; enum MetricType %{ - DOUBLE_COUNTER, - INT_COUNTER, - DOUBLE_GAUGE, - INT_GAUGE, - DOUBLE_HISTOGRAM, - INT_HISTOGRAM, + COUNTER, + GAUGE, + HISTOGRAM, %} %%{ @@ -108,379 +105,192 @@ auto to_std_vec(zeek::Val* xs) } %%} -# -- IntCounter ---------------------------------------------------------------- +# -- Counter ---------------------------------------------------------------- -function Telemetry::__int_counter_family%(prefix: string, +function Telemetry::__counter_family%(prefix: string, name: string, labels: string_vec, helptext: string &default = "Zeek Script Metric", unit: string &default = "", - is_sum: bool &default = F%): opaque of int_counter_metric_family + is_sum: bool &default = F%): opaque of counter_metric_family %{ auto lbl_vec = sv_vec(labels->AsVectorVal()); auto hdl = telemetry_mgr->CounterFamily(sv(prefix), sv(name), lbl_vec, sv(helptext), sv(unit), is_sum); - return zeek::make_intrusive(hdl); + return zeek::make_intrusive(hdl); %} -function Telemetry::__int_counter_metric_get_or_add%(family: opaque of int_counter_metric_family, - labels: table_string_of_string%): opaque of int_counter_metric +function Telemetry::__counter_metric_get_or_add%(family: opaque of counter_metric_family, + labels: table_string_of_string%): opaque of counter_metric %{ - using ResultType = zeek::IntrusivePtr; - if ( auto ptr = dynamic_cast(family) ) + using ResultType = zeek::IntrusivePtr; + if ( auto ptr = dynamic_cast(family) ) { auto hdl = ptr->GetHandle(); auto lbl_map = sv_tbl(labels->AsTableVal()); if ( labels_valid(lbl_map, hdl->LabelNames()) ) { auto res = hdl->GetOrAdd(lbl_map); - return zeek::make_intrusive(res); + return zeek::make_intrusive(res); } else { - zeek::reporter->Error("Telemetry::int_counter_metric_get_or_add: invalid label dimensions."); + zeek::reporter->Error("Telemetry::counter_metric_get_or_add: invalid label dimensions."); return ResultType{nullptr}; } } else { - zeek::reporter->Error("Telemetry::int_counter_metric_get_or_add: invalid handle."); + zeek::reporter->Error("Telemetry::counter_metric_get_or_add: invalid handle."); return ResultType{nullptr}; } %} -function Telemetry::__int_counter_inc%(val: opaque of int_counter_metric, - amount: int &default = 1%): bool +function Telemetry::__counter_inc%(val: opaque of counter_metric, + amount: double &default = 1.0%): bool %{ - return with(val, "Telemetry::int_counter_inc: invalid handle.", [amount](auto hdl) { hdl->Inc(amount); }); + return with(val, "Telemetry::counter_inc: invalid handle.", [amount](auto hdl) { hdl->Inc(amount); }); %} -function Telemetry::__int_counter_value%(val: opaque of int_counter_metric%): int +function Telemetry::__counter_value%(val: opaque of counter_metric%): double %{ - if ( auto ptr = dynamic_cast(val) ) + if ( auto ptr = dynamic_cast(val) ) { - return zeek::val_mgr->Int(ptr->GetHandle()->Value()); + return zeek::make_intrusive(ptr->GetHandle()->Value()); } else { - zeek::reporter->Error("Telemetry::int_counter_value: invalid handle."); - return zeek::val_mgr->Int(0); + zeek::reporter->Error("Telemetry::counter_value: invalid handle."); + return zeek::make_intrusive(0); } %} -# -- DblCounter ---------------------------------------------------------------- +# -- Gauge ------------------------------------------------------------------ -function Telemetry::__dbl_counter_family%(prefix: string, - name: string, - labels: string_vec, - helptext: string &default = "Zeek Script Metric", - unit: string &default = "", - is_sum: bool &default = F%): opaque of dbl_counter_metric_family - %{ - auto lbl_vec = sv_vec(labels->AsVectorVal()); - auto hdl = telemetry_mgr->CounterFamily(sv(prefix), sv(name), lbl_vec, - sv(helptext), sv(unit), is_sum); - return zeek::make_intrusive(hdl); - %} - -function Telemetry::__dbl_counter_metric_get_or_add%(family: opaque of dbl_counter_metric_family, - labels: table_string_of_string%): opaque of dbl_counter_metric - %{ - using ResultType = zeek::IntrusivePtr; - if ( auto ptr = dynamic_cast(family) ) - { - auto hdl = ptr->GetHandle(); - auto lbl_map = sv_tbl(labels->AsTableVal()); - if ( labels_valid(lbl_map, hdl->LabelNames()) ) - { - auto res = hdl->GetOrAdd(lbl_map); - return zeek::make_intrusive(res); - } - else - { - zeek::reporter->Error("Telemetry::dbl_counter_metric_get_or_add: invalid label dimensions."); - return ResultType{nullptr}; - } - } - else - { - zeek::reporter->Error("Telemetry::dbl_counter_metric_get_or_add: invalid handle."); - return ResultType{nullptr}; - } - %} - -function Telemetry::__dbl_counter_inc%(val: opaque of dbl_counter_metric, - amount: double &default = 1.0%): bool - %{ - return with(val, "Telemetry::dbl_counter_inc: invalid handle.", [amount](auto hdl) { hdl->Inc(amount); }); - %} - -function Telemetry::__dbl_counter_value%(val: opaque of dbl_counter_metric%): double - %{ - if ( auto ptr = dynamic_cast(val) ) - { - return zeek::make_intrusive(ptr->GetHandle()->Value()); - } - else - { - zeek::reporter->Error("Telemetry::dbl_counter_value: invalid handle."); - return zeek::make_intrusive(0.0); - } - %} - -# -- IntGauge ------------------------------------------------------------------ - -function Telemetry::__int_gauge_family%(prefix: string, +function Telemetry::__gauge_family%(prefix: string, name: string, labels: string_vec, helptext: string &default = "Zeek Script Metric", unit: string &default = "", - is_sum: bool &default = F%): opaque of int_gauge_metric_family + is_sum: bool &default = F%): opaque of gauge_metric_family %{ auto lbl_vec = sv_vec(labels->AsVectorVal()); auto hdl = telemetry_mgr->GaugeFamily(sv(prefix), sv(name), lbl_vec, sv(helptext), sv(unit), is_sum); - return zeek::make_intrusive(hdl); + return zeek::make_intrusive(hdl); %} -function Telemetry::__int_gauge_metric_get_or_add%(family: opaque of int_gauge_metric_family, - labels: table_string_of_string%): opaque of int_gauge_metric +function Telemetry::__gauge_metric_get_or_add%(family: opaque of gauge_metric_family, + labels: table_string_of_string%): opaque of gauge_metric %{ - using ResultType = zeek::IntrusivePtr; - if ( auto ptr = dynamic_cast(family) ) + using ResultType = zeek::IntrusivePtr; + if ( auto ptr = dynamic_cast(family) ) { auto hdl = ptr->GetHandle(); auto lbl_map = sv_tbl(labels->AsTableVal()); if ( labels_valid(lbl_map, hdl->LabelNames()) ) { auto res = hdl->GetOrAdd(lbl_map); - return zeek::make_intrusive(res); + return zeek::make_intrusive(res); } else { - zeek::reporter->Error("Telemetry::int_gauge_metric_get_or_add: invalid label dimensions."); + zeek::reporter->Error("Telemetry::gauge_metric_get_or_add: invalid label dimensions."); return ResultType{nullptr}; } } else { - zeek::reporter->Error("Telemetry::int_gauge_metric_get_or_add: invalid handle."); + zeek::reporter->Error("Telemetry::gauge_metric_get_or_add: invalid handle."); return ResultType{nullptr}; } %} -function Telemetry::__int_gauge_inc%(val: opaque of int_gauge_metric, - amount: int &default = 1%): bool - %{ - return with(val, "Telemetry::int_gauge_inc: invalid handle.", [amount](auto hdl) { hdl->Inc(amount); }); - %} - -function Telemetry::__int_gauge_dec%(val: opaque of int_gauge_metric, - amount: int &default = 1%): bool - %{ - return with(val, "Telemetry::int_gauge_dec: invalid handle.", [amount](auto hdl) { hdl->Dec(amount); }); - %} - -function Telemetry::__int_gauge_value%(val: opaque of int_gauge_metric%): int - %{ - if ( auto ptr = dynamic_cast(val) ) - { - return zeek::val_mgr->Int(ptr->GetHandle()->Value()); - } - else - { - zeek::reporter->Error("Telemetry::int_gauge_value: invalid handle."); - return zeek::val_mgr->Int(0); - } - %} - -# -- DblGauge ------------------------------------------------------------------ - -function Telemetry::__dbl_gauge_family%(prefix: string, - name: string, - labels: string_vec, - helptext: string &default = "Zeek Script Metric", - unit: string &default = "", - is_sum: bool &default = F%): opaque of dbl_gauge_metric_family - %{ - auto lbl_vec = sv_vec(labels->AsVectorVal()); - auto hdl = telemetry_mgr->GaugeFamily(sv(prefix), sv(name), lbl_vec, - sv(helptext), sv(unit), is_sum); - return zeek::make_intrusive(hdl); - %} - -function Telemetry::__dbl_gauge_metric_get_or_add%(family: opaque of dbl_gauge_metric_family, - labels: table_string_of_string%): opaque of dbl_gauge_metric - %{ - using ResultType = zeek::IntrusivePtr; - if ( auto ptr = dynamic_cast(family) ) - { - auto hdl = ptr->GetHandle(); - auto lbl_map = sv_tbl(labels->AsTableVal()); - if ( labels_valid(lbl_map, hdl->LabelNames()) ) - { - auto res = hdl->GetOrAdd(lbl_map); - return zeek::make_intrusive(res); - } - else - { - zeek::reporter->Error("Telemetry::dbl_gauge_metric_get_or_add: invalid label dimensions."); - return ResultType{nullptr}; - } - } - else - { - zeek::reporter->Error("Telemetry::dbl_gauge_metric_get_or_add: invalid handle."); - return ResultType{nullptr}; - } - %} - -function Telemetry::__dbl_gauge_inc%(val: opaque of dbl_gauge_metric, +function Telemetry::__gauge_inc%(val: opaque of gauge_metric, amount: double &default = 1.0%): bool %{ - return with(val, "Telemetry::dbl_gauge_inc: invalid handle.", [amount](auto hdl) { hdl->Inc(amount); }); + return with(val, "Telemetry::gauge_inc: invalid handle.", [amount](auto hdl) { hdl->Inc(amount); }); %} -function Telemetry::__dbl_gauge_dec%(val: opaque of dbl_gauge_metric, +function Telemetry::__gauge_dec%(val: opaque of gauge_metric, amount: double &default = 1.0%): bool %{ - return with(val, "Telemetry::dbl_gauge_dec: invalid handle.", [amount](auto hdl) { hdl->Dec(amount); }); + return with(val, "Telemetry::gauge_dec: invalid handle.", [amount](auto hdl) { hdl->Dec(amount); }); %} -function Telemetry::__dbl_gauge_value%(val: opaque of dbl_gauge_metric%): double +function Telemetry::__gauge_value%(val: opaque of gauge_metric%): double %{ - if ( auto ptr = dynamic_cast(val) ) + if ( auto ptr = dynamic_cast(val) ) { - return zeek::make_intrusive(ptr->GetHandle()->Value()); + return zeek::make_intrusive(ptr->GetHandle()->Value()); } else { - zeek::reporter->Error("Telemetry::dbl_gauge_value: invalid handle."); - return zeek::make_intrusive(0.0); + zeek::reporter->Error("Telemetry::gauge_value: invalid handle."); + return zeek::make_intrusive(0.0); } %} -# -- IntHistogram -------------------------------------------------------------- +# -- Histogram -------------------------------------------------------------- -function Telemetry::__int_histogram_family%(prefix: string, - name: string, - labels: string_vec, - bounds: int_vec, - helptext: string &default = "Zeek Script Metric", - unit: string &default = ""%): opaque of int_histogram_metric_family - %{ - auto lbl_vec = sv_vec(labels->AsVectorVal()); - auto std_bounds = to_std_vec(bounds); - auto hdl = telemetry_mgr->HistogramFamily(sv(prefix), sv(name), lbl_vec, - std_bounds, sv(helptext), - sv(unit)); - return zeek::make_intrusive(hdl); - %} - -function Telemetry::__int_histogram_metric_get_or_add%(family: opaque of int_histogram_metric_family, - labels: table_string_of_string%): opaque of int_histogram_metric - %{ - using ResultType = zeek::IntrusivePtr; - if ( auto ptr = dynamic_cast(family) ) - { - auto hdl = ptr->GetHandle(); - auto lbl_map = sv_tbl(labels->AsTableVal()); - if ( labels_valid(lbl_map, hdl->LabelNames()) ) - { - auto res = hdl->GetOrAdd(lbl_map); - return zeek::make_intrusive(res); - } - else - { - zeek::reporter->Error("Telemetry::int_histogram_metric_get_or_add: invalid label dimensions."); - return ResultType{nullptr}; - } - } - else - { - zeek::reporter->Error("Telemetry::int_histogram_metric_get_or_add: invalid handle."); - return ResultType{nullptr}; - } - %} - -function Telemetry::__int_histogram_observe%(val: opaque of int_histogram_metric, - measurement: int%): bool - %{ - return with(val, "Telemetry::int_histogram_inc: invalid handle.", [measurement](auto hdl) { hdl->Observe(measurement); }); - %} - -function Telemetry::__int_histogram_sum%(val: opaque of int_histogram_metric%): int - %{ - if ( auto ptr = dynamic_cast(val) ) - { - return zeek::val_mgr->Int(ptr->GetHandle()->Sum()); - } - else - { - zeek::reporter->Error("Telemetry::int_histogram_sum: invalid handle."); - return zeek::val_mgr->Int(0); - } - %} - -# -- DblHistogram -------------------------------------------------------------- - -function Telemetry::__dbl_histogram_family%(prefix: string, +function Telemetry::__histogram_family%(prefix: string, name: string, labels: string_vec, bounds: double_vec, helptext: string &default = "Zeek Script Metric", - unit: string &default = ""%): opaque of dbl_histogram_metric_family + unit: string &default = ""%): opaque of histogram_metric_family %{ auto lbl_vec = sv_vec(labels->AsVectorVal()); auto std_bounds = to_std_vec(bounds); - auto hdl = telemetry_mgr->HistogramFamily(sv(prefix), sv(name), - lbl_vec, std_bounds, - sv(helptext), sv(unit)); - return zeek::make_intrusive(hdl); + auto hdl = telemetry_mgr->HistogramFamily(sv(prefix), sv(name), lbl_vec, + std_bounds, sv(helptext), + sv(unit)); + return zeek::make_intrusive(hdl); %} -function Telemetry::__dbl_histogram_metric_get_or_add%(family: opaque of dbl_histogram_metric_family, - labels: table_string_of_string%): opaque of dbl_histogram_metric +function Telemetry::__histogram_metric_get_or_add%(family: opaque of histogram_metric_family, + labels: table_string_of_string%): opaque of histogram_metric %{ - using ResultType = zeek::IntrusivePtr; - if ( auto ptr = dynamic_cast(family) ) + using ResultType = zeek::IntrusivePtr; + if ( auto ptr = dynamic_cast(family) ) { auto hdl = ptr->GetHandle(); auto lbl_map = sv_tbl(labels->AsTableVal()); if ( labels_valid(lbl_map, hdl->LabelNames()) ) { auto res = hdl->GetOrAdd(lbl_map); - return zeek::make_intrusive(res); + return zeek::make_intrusive(res); } else { - zeek::reporter->Error("Telemetry::dbl_histogram_metric_get_or_add: invalid label dimensions."); + zeek::reporter->Error("Telemetry::histogram_metric_get_or_add: invalid label dimensions."); return ResultType{nullptr}; } } else { - zeek::reporter->Error("Telemetry::dbl_histogram_metric_get_or_add: invalid handle."); + zeek::reporter->Error("Telemetry::histogram_metric_get_or_add: invalid handle."); return ResultType{nullptr}; } %} -function Telemetry::__dbl_histogram_observe%(val: opaque of dbl_histogram_metric, - measurement: double%): bool +function Telemetry::__histogram_observe%(val: opaque of histogram_metric, + measurement: double%): bool %{ - return with(val, "Telemetry::dbl_histogram_inc: invalid handle.", [measurement](auto hdl) { hdl->Observe(measurement); }); + return with(val, "Telemetry::histogram_inc: invalid handle.", + [measurement](auto hdl) { hdl->Observe(measurement); }); %} -function Telemetry::__dbl_histogram_sum%(val: opaque of dbl_histogram_metric%): double +function Telemetry::__histogram_sum%(val: opaque of histogram_metric%): double %{ - if ( auto ptr = dynamic_cast(val) ) + if ( auto ptr = dynamic_cast(val) ) { - return zeek::make_intrusive(ptr->GetHandle()->Sum()); + return zeek::make_intrusive(ptr->GetHandle()->Sum()); } else { - zeek::reporter->Error("Telemetry::dbl_histogram_sum: invalid handle."); - return zeek::make_intrusive(0.0); + zeek::reporter->Error("Telemetry::histogram_sum: invalid handle."); + return make_intrusive(0.0); } %} diff --git a/src/zeek-setup.cc b/src/zeek-setup.cc index cb1b019c74..b05af74f20 100644 --- a/src/zeek-setup.cc +++ b/src/zeek-setup.cc @@ -205,18 +205,12 @@ zeek::OpaqueTypePtr bloomfilter_type; zeek::OpaqueTypePtr x509_opaque_type; zeek::OpaqueTypePtr ocsp_resp_opaque_type; zeek::OpaqueTypePtr paraglob_type; -zeek::OpaqueTypePtr int_counter_metric_type; -zeek::OpaqueTypePtr int_counter_metric_family_type; -zeek::OpaqueTypePtr dbl_counter_metric_type; -zeek::OpaqueTypePtr dbl_counter_metric_family_type; -zeek::OpaqueTypePtr int_gauge_metric_type; -zeek::OpaqueTypePtr int_gauge_metric_family_type; -zeek::OpaqueTypePtr dbl_gauge_metric_type; -zeek::OpaqueTypePtr dbl_gauge_metric_family_type; -zeek::OpaqueTypePtr int_histogram_metric_type; -zeek::OpaqueTypePtr int_histogram_metric_family_type; -zeek::OpaqueTypePtr dbl_histogram_metric_type; -zeek::OpaqueTypePtr dbl_histogram_metric_family_type; +zeek::OpaqueTypePtr counter_metric_type; +zeek::OpaqueTypePtr counter_metric_family_type; +zeek::OpaqueTypePtr gauge_metric_type; +zeek::OpaqueTypePtr gauge_metric_family_type; +zeek::OpaqueTypePtr histogram_metric_type; +zeek::OpaqueTypePtr histogram_metric_family_type; // Keep copy of command line int zeek::detail::zeek_argc; @@ -705,18 +699,12 @@ SetupResult setup(int argc, char** argv, Options* zopts) { x509_opaque_type = make_intrusive("x509"); ocsp_resp_opaque_type = make_intrusive("ocsp_resp"); paraglob_type = make_intrusive("paraglob"); - int_counter_metric_type = make_intrusive("int_counter_metric"); - int_counter_metric_family_type = make_intrusive("int_counter_metric_family"); - dbl_counter_metric_type = make_intrusive("dbl_counter_metric"); - dbl_counter_metric_family_type = make_intrusive("dbl_counter_metric_family"); - int_gauge_metric_type = make_intrusive("int_gauge_metric"); - int_gauge_metric_family_type = make_intrusive("int_gauge_metric_family"); - dbl_gauge_metric_type = make_intrusive("dbl_gauge_metric"); - dbl_gauge_metric_family_type = make_intrusive("dbl_gauge_metric_family"); - int_histogram_metric_type = make_intrusive("int_histogram_metric"); - int_histogram_metric_family_type = make_intrusive("int_histogram_metric_family"); - dbl_histogram_metric_type = make_intrusive("dbl_histogram_metric"); - dbl_histogram_metric_family_type = make_intrusive("dbl_histogram_metric_family"); + counter_metric_type = make_intrusive("counter_metric"); + counter_metric_family_type = make_intrusive("counter_metric_family"); + gauge_metric_type = make_intrusive("gauge_metric"); + gauge_metric_family_type = make_intrusive("gauge_metric_family"); + histogram_metric_type = make_intrusive("histogram_metric"); + histogram_metric_family_type = make_intrusive("histogram_metric_family"); log_delay_token_type = make_intrusive("LogDelayToken"); // After spinning up Broker, we have background threads running now. If diff --git a/testing/btest/Baseline/scripts.base.frameworks.telemetry.basic/out b/testing/btest/Baseline/scripts.base.frameworks.telemetry.basic/out index 7fb9ba5a25..d35b64e3d4 100644 --- a/testing/btest/Baseline/scripts.base.frameworks.telemetry.basic/out +++ b/testing/btest/Baseline/scripts.base.frameworks.telemetry.basic/out @@ -1,25 +1,23 @@ ### BTest baseline data generated by btest-diff. Do not edit. Use "btest -U/-u" to update. Requires BTest >= 0.63. ### zeek_session_metrics |2| -Telemetry::INT_COUNTER, zeek, zeek_total_sessions_total, [protocol], [tcp], 500.0 -count_value, 500 -Telemetry::INT_GAUGE, zeek, zeek_active_sessions, [protocol], [tcp], 500.0 -count_value, 500 +Telemetry::COUNTER, zeek, zeek_total_sessions_total, [protocol], [tcp], 500.0 +Telemetry::GAUGE, zeek, zeek_active_sessions, [protocol], [tcp], 500.0 ### bt* metrics |5| -Telemetry::DOUBLE_COUNTER, btest, btest_a_test_total, [x, y], [a, b], 1.0 -Telemetry::DOUBLE_COUNTER, btest, btest_b_test_total, [x, y], [a, b], 10.0 -Telemetry::DOUBLE_COUNTER, btest, btest_c_test_total, [x, y], [a, b], 200.0 -Telemetry::DOUBLE_COUNTER, btest, btest_a_test_total, [x, y], [a, c], 2.0 -Telemetry::DOUBLE_COUNTER, btest, btest_b_test_total, [x, y], [a, c], 20.0 +Telemetry::COUNTER, btest, btest_a_test_total, [x, y], [a, b], 1.0 +Telemetry::COUNTER, btest, btest_b_test_total, [x, y], [a, b], 10.0 +Telemetry::COUNTER, btest, btest_c_test_total, [x, y], [a, b], 200.0 +Telemetry::COUNTER, btest, btest_a_test_total, [x, y], [a, c], 2.0 +Telemetry::COUNTER, btest, btest_b_test_total, [x, y], [a, c], 20.0 ### btest_a_metrics |2| -Telemetry::DOUBLE_COUNTER, btest, btest_a_test_total, [x, y], [a, b], 1.0 -Telemetry::DOUBLE_COUNTER, btest, btest_a_test_total, [x, y], [a, c], 2.0 +Telemetry::COUNTER, btest, btest_a_test_total, [x, y], [a, b], 1.0 +Telemetry::COUNTER, btest, btest_a_test_total, [x, y], [a, c], 2.0 ### btest_b_metrics |2| -Telemetry::DOUBLE_COUNTER, btest, btest_b_test_total, [x, y], [a, b], 10.0 -Telemetry::DOUBLE_COUNTER, btest, btest_b_test_total, [x, y], [a, c], 20.0 +Telemetry::COUNTER, btest, btest_b_test_total, [x, y], [a, b], 10.0 +Telemetry::COUNTER, btest, btest_b_test_total, [x, y], [a, c], 20.0 ### system_metrics |3| -Telemetry::DOUBLE_GAUGE, system, system_sensor_temperature_celsius, [name], [cpu0], 43.0 -Telemetry::DOUBLE_GAUGE, system, system_sensor_temperature_celsius, [name], [cpu1], 44.1 -Telemetry::DOUBLE_GAUGE, system, system_sensor_temperature_celsius, [name], [cpu3], 42.2 +Telemetry::GAUGE, system, system_sensor_temperature_celsius, [name], [cpu0], 43.0 +Telemetry::GAUGE, system, system_sensor_temperature_celsius, [name], [cpu1], 44.1 +Telemetry::GAUGE, system, system_sensor_temperature_celsius, [name], [cpu3], 42.2 ### btest_histogram_metrics |2| -Telemetry::DOUBLE_HISTOGRAM, btest, btest_sample_histogram, [1.0, 2.0, 3.0, 4.0, 5.0, inf], [dim], [a], [2.0, 2.0, 0.0, 0.0, 0.0, 1.0], 11.5, 5.0 -Telemetry::DOUBLE_HISTOGRAM, btest, btest_sample_histogram, [1.0, 2.0, 3.0, 4.0, 5.0, inf], [dim], [b], [1.0, 0.0, 0.0, 0.0, 0.0, 1.0], 7.5, 2.0 +Telemetry::HISTOGRAM, btest, btest_sample_histogram, [1.0, 2.0, 3.0, 4.0, 5.0, inf], [dim], [a], [2.0, 2.0, 0.0, 0.0, 0.0, 1.0], 11.5, 5.0 +Telemetry::HISTOGRAM, btest, btest_sample_histogram, [1.0, 2.0, 3.0, 4.0, 5.0, inf], [dim], [b], [1.0, 0.0, 0.0, 0.0, 0.0, 1.0], 7.5, 2.0 diff --git a/testing/btest/Baseline/scripts.base.frameworks.telemetry.conn-duration-histogram/out b/testing/btest/Baseline/scripts.base.frameworks.telemetry.conn-duration-histogram/out index bc2bad3ffd..58ee19fc64 100644 --- a/testing/btest/Baseline/scripts.base.frameworks.telemetry.conn-duration-histogram/out +++ b/testing/btest/Baseline/scripts.base.frameworks.telemetry.conn-duration-histogram/out @@ -1,11 +1,11 @@ ### BTest baseline data generated by btest-diff. Do not edit. Use "btest -U/-u" to update. Requires BTest >= 0.63. -Telemetry::DOUBLE_HISTOGRAM, zeek, zeek_connection_duration_seconds +Telemetry::HISTOGRAM, zeek, zeek_connection_duration_seconds [] [] [2.0, 3.0, 4.0, 5.0, 6.0, 10.0, inf] [0.0, 322.0, 90.0, 5.0, 76.0, 7.0, 0.0] 500.0, 1650.264644 -Telemetry::DOUBLE_HISTOGRAM, zeek, zeek_realistic_connection_duration_seconds +Telemetry::HISTOGRAM, zeek, zeek_realistic_connection_duration_seconds [proto] [tcp] [0.1, 1.0, 10.0, 30.0, 60.0, 120.0, 300.0, 900.0, 1800.0, inf] diff --git a/testing/btest/Baseline/scripts.base.frameworks.telemetry.event-handler-invocations/out b/testing/btest/Baseline/scripts.base.frameworks.telemetry.event-handler-invocations/out index 1e5c13eb8e..a4532c002e 100644 --- a/testing/btest/Baseline/scripts.base.frameworks.telemetry.event-handler-invocations/out +++ b/testing/btest/Baseline/scripts.base.frameworks.telemetry.event-handler-invocations/out @@ -1,4 +1,4 @@ ### BTest baseline data generated by btest-diff. Do not edit. Use "btest -U/-u" to update. Requires BTest >= 0.63. -zeek, zeek_event_handler_invocations_total, [connection_state_remove], 500 -zeek, zeek_event_handler_invocations_total, [zeek_done], 1 -zeek, zeek_event_handler_invocations_total, [zeek_init], 1 +zeek, zeek_event_handler_invocations_total, [connection_state_remove], 500.0 +zeek, zeek_event_handler_invocations_total, [zeek_done], 1.0 +zeek, zeek_event_handler_invocations_total, [zeek_init], 1.0 diff --git a/testing/btest/Baseline/scripts.base.utils.json/output b/testing/btest/Baseline/scripts.base.utils.json/output index 59766da08b..129ef4eedb 100644 --- a/testing/btest/Baseline/scripts.base.utils.json/output +++ b/testing/btest/Baseline/scripts.base.utils.json/output @@ -42,7 +42,7 @@ XXXXXXXXXX.XXXXXX {"10.1.1.1":[1,2],"10.2.2.2":[3,5]} {"1":{"s":"test"}} {"opaque_type":"TopkVal"} -{"_metric":{"opaque_type":"DblGaugeMetricVal"}} -{"_family":{"opaque_type":"DblGaugeMetricFamilyVal"},"_labels":["dim_1"]} -{"_metric":{"opaque_type":"DblCounterMetricVal"}} -{"_family":{"opaque_type":"DblCounterMetricFamilyVal"},"_labels":["dim_1"]} +{"_metric":{"opaque_type":"GaugeMetricVal"}} +{"_family":{"opaque_type":"GaugeMetricFamilyVal"},"_labels":["dim_1"]} +{"_metric":{"opaque_type":"CounterMetricVal"}} +{"_family":{"opaque_type":"CounterMetricFamilyVal"},"_labels":["dim_1"]} diff --git a/testing/btest/Baseline/telemetry.counter/output b/testing/btest/Baseline/telemetry.counter/output index 72ca34c137..138a68ac84 100644 --- a/testing/btest/Baseline/telemetry.counter/output +++ b/testing/btest/Baseline/telemetry.counter/output @@ -1,5 +1,3 @@ ### BTest baseline data generated by btest-diff. Do not edit. Use "btest -U/-u" to update. Requires BTest >= 0.63. -cnt1_bar: 1 -cnt2_bar: 42 -cnt3_bar: 1.000000 -cnt4_bar: 42.000000 +cnt1_bar: 1.000000 +cnt2_bar: 42.000000 diff --git a/testing/btest/Baseline/telemetry.gauge/output b/testing/btest/Baseline/telemetry.gauge/output index add597e534..9fd8772f2b 100644 --- a/testing/btest/Baseline/telemetry.gauge/output +++ b/testing/btest/Baseline/telemetry.gauge/output @@ -1,5 +1,3 @@ ### BTest baseline data generated by btest-diff. Do not edit. Use "btest -U/-u" to update. Requires BTest >= 0.63. -gg1_bar: 1 -gg2_bar: 23 -gg3_bar: 1.000000 -gg4_bar: 23.000000 +gg1_bar: 1.000000 +gg2_bar: 23.000000 diff --git a/testing/btest/Baseline/telemetry.histogram/output b/testing/btest/Baseline/telemetry.histogram/output index 59a5447d15..d374260881 100644 --- a/testing/btest/Baseline/telemetry.histogram/output +++ b/testing/btest/Baseline/telemetry.histogram/output @@ -1,5 +1,3 @@ ### BTest baseline data generated by btest-diff. Do not edit. Use "btest -U/-u" to update. Requires BTest >= 0.63. -hst1_bar: 12 -hst2_bar: 31337 -hst3_bar: 6.000000 -hst4_bar: 64.000000 +hst1_bar: 6.000000 +hst2_bar: 64.000000 diff --git a/testing/btest/scripts/base/frameworks/telemetry/basic.zeek b/testing/btest/scripts/base/frameworks/telemetry/basic.zeek index 96dd0f1669..72b675dc0a 100644 --- a/testing/btest/scripts/base/frameworks/telemetry/basic.zeek +++ b/testing/btest/scripts/base/frameworks/telemetry/basic.zeek @@ -58,9 +58,6 @@ function print_metrics(what: string, metrics: vector of Telemetry::Metric) { local m = metrics[i]; print m$opts$metric_type, m$opts$prefix, m$opts$name, m$opts$labels, m$labels, m$value; - - if (m?$count_value) - print "count_value", m$count_value; } } diff --git a/testing/btest/scripts/base/frameworks/telemetry/event-handler-invocations.zeek b/testing/btest/scripts/base/frameworks/telemetry/event-handler-invocations.zeek index 3a013be7e3..5060c357a8 100644 --- a/testing/btest/scripts/base/frameworks/telemetry/event-handler-invocations.zeek +++ b/testing/btest/scripts/base/frameworks/telemetry/event-handler-invocations.zeek @@ -17,6 +17,6 @@ event zeek_done() &priority=-100 for ( _, m in ms ) { if ( /zeek_.*|connection_.*/ in cat(m$labels)) - print m$opts$prefix, m$opts$name, m$labels, m$count_value; + print m$opts$prefix, m$opts$name, m$labels, m$value; } } diff --git a/testing/btest/telemetry/counter.zeek b/testing/btest/telemetry/counter.zeek index 1aee71a813..456a9fd28a 100644 --- a/testing/btest/telemetry/counter.zeek +++ b/testing/btest/telemetry/counter.zeek @@ -3,25 +3,16 @@ # @TEST-EXEC: zeek -b %INPUT >output # @TEST-EXEC: btest-diff output -global cnt1 = Telemetry::__int_counter_family("cnt1", "bar", vector("dim1", "dim2")); -global cnt2 = Telemetry::__int_counter_family("cnt2", "bar", vector()); -global cnt3 = Telemetry::__dbl_counter_family("cnt3", "bar", vector("dim1", "dim2")); -global cnt4 = Telemetry::__dbl_counter_family("cnt4", "bar", vector()); +global cnt1 = Telemetry::__counter_family("cnt1", "bar", vector("dim1", "dim2")); +global cnt2 = Telemetry::__counter_family("cnt2", "bar", vector()); event zeek_init() { - local cnt1_bar = Telemetry::__int_counter_metric_get_or_add(cnt1, table(["dim1"] = "val1", ["dim2"] = "val2")); - Telemetry::__int_counter_inc(cnt1_bar); - local cnt2_bar = Telemetry::__int_counter_metric_get_or_add(cnt2, table()); - Telemetry::__int_counter_inc(cnt2_bar); - Telemetry::__int_counter_inc(cnt2_bar, 41); - print fmt("cnt1_bar: %d", Telemetry::__int_counter_value(cnt1_bar)); - print fmt("cnt2_bar: %d", Telemetry::__int_counter_value(cnt2_bar)); - local cnt3_bar = Telemetry::__dbl_counter_metric_get_or_add(cnt3, table(["dim1"] = "val1", ["dim2"] = "val2")); - Telemetry::__dbl_counter_inc(cnt3_bar); - local cnt4_bar = Telemetry::__dbl_counter_metric_get_or_add(cnt4, table()); - Telemetry::__dbl_counter_inc(cnt4_bar); - Telemetry::__dbl_counter_inc(cnt4_bar, 41.0); - print fmt("cnt3_bar: %f", Telemetry::__dbl_counter_value(cnt3_bar)); - print fmt("cnt4_bar: %f", Telemetry::__dbl_counter_value(cnt4_bar)); + local cnt1_bar = Telemetry::__counter_metric_get_or_add(cnt1, table(["dim1"] = "val1", ["dim2"] = "val2")); + Telemetry::__counter_inc(cnt1_bar); + local cnt2_bar = Telemetry::__counter_metric_get_or_add(cnt2, table()); + Telemetry::__counter_inc(cnt2_bar); + Telemetry::__counter_inc(cnt2_bar, 41); + print fmt("cnt1_bar: %f", Telemetry::__counter_value(cnt1_bar)); + print fmt("cnt2_bar: %f", Telemetry::__counter_value(cnt2_bar)); } diff --git a/testing/btest/telemetry/gauge.zeek b/testing/btest/telemetry/gauge.zeek index 80369f8513..6a2e276584 100644 --- a/testing/btest/telemetry/gauge.zeek +++ b/testing/btest/telemetry/gauge.zeek @@ -3,30 +3,18 @@ # @TEST-EXEC: zeek -b %INPUT >output # @TEST-EXEC: btest-diff output -global gg1 = Telemetry::__int_gauge_family("gg1", "bar", vector("dim1", "dim2")); -global gg2 = Telemetry::__int_gauge_family("gg2", "bar", vector()); -global gg3 = Telemetry::__dbl_gauge_family("gg3", "bar", vector("dim1", "dim2")); -global gg4 = Telemetry::__dbl_gauge_family("gg4", "bar", vector()); +global gg1 = Telemetry::__gauge_family("gg1", "bar", vector("dim1", "dim2")); +global gg2 = Telemetry::__gauge_family("gg2", "bar", vector()); event zeek_init() { - local gg1_bar = Telemetry::__int_gauge_metric_get_or_add(gg1, table(["dim1"] = "val1", ["dim2"] = "val2")); - Telemetry::__int_gauge_inc(gg1_bar); - local gg2_bar = Telemetry::__int_gauge_metric_get_or_add(gg2, table()); - Telemetry::__int_gauge_inc(gg2_bar); - Telemetry::__int_gauge_inc(gg2_bar, 41); - Telemetry::__int_gauge_dec(gg2_bar); - Telemetry::__int_gauge_dec(gg2_bar, 18); - print fmt("gg1_bar: %d", Telemetry::__int_gauge_value(gg1_bar)); - print fmt("gg2_bar: %d", Telemetry::__int_gauge_value(gg2_bar)); - local gg3_bar = Telemetry::__dbl_gauge_metric_get_or_add(gg3, table(["dim1"] = "val1", ["dim2"] = "val2")); - Telemetry::__dbl_gauge_inc(gg3_bar); - local gg4_bar = Telemetry::__dbl_gauge_metric_get_or_add(gg4, table()); - Telemetry::__dbl_gauge_inc(gg4_bar); - Telemetry::__dbl_gauge_inc(gg4_bar, 41.0); - Telemetry::__dbl_gauge_dec(gg4_bar); - Telemetry::__dbl_gauge_dec(gg4_bar, 18.0); - print fmt("gg3_bar: %f", Telemetry::__dbl_gauge_value(gg3_bar)); - print fmt("gg4_bar: %f", Telemetry::__dbl_gauge_value(gg4_bar)); + local gg1_bar = Telemetry::__gauge_metric_get_or_add(gg1, table(["dim1"] = "val1", ["dim2"] = "val2")); + Telemetry::__gauge_inc(gg1_bar); + local gg2_bar = Telemetry::__gauge_metric_get_or_add(gg2, table()); + Telemetry::__gauge_inc(gg2_bar); + Telemetry::__gauge_inc(gg2_bar, 41.0); + Telemetry::__gauge_dec(gg2_bar); + Telemetry::__gauge_dec(gg2_bar, 18.0); + print fmt("gg1_bar: %f", Telemetry::__gauge_value(gg1_bar)); + print fmt("gg2_bar: %f", Telemetry::__gauge_value(gg2_bar)); } - diff --git a/testing/btest/telemetry/histogram.zeek b/testing/btest/telemetry/histogram.zeek index aec7b2a2cd..0dee3ee54b 100644 --- a/testing/btest/telemetry/histogram.zeek +++ b/testing/btest/telemetry/histogram.zeek @@ -3,28 +3,18 @@ # @TEST-EXEC: zeek -b %INPUT >output # @TEST-EXEC: btest-diff output -const int_bounds = vector(+10, +20); const dbl_bounds = vector(10.0, 20.0); -global hst1 = Telemetry::__int_histogram_family("hst1", "bar", vector("dim1", "dim2"), int_bounds); -global hst2 = Telemetry::__int_histogram_family("hst2", "bar", vector(), int_bounds); -global hst3 = Telemetry::__dbl_histogram_family("hst3", "bar", vector("dim1", "dim2"), dbl_bounds); -global hst4 = Telemetry::__dbl_histogram_family("hst4", "bar", vector(), dbl_bounds); +global hst1 = Telemetry::__histogram_family("hst1", "bar", vector("dim1", "dim2"), dbl_bounds); +global hst2 = Telemetry::__histogram_family("hst2", "bar", vector(), dbl_bounds); event zeek_init() { - local hst1_bar = Telemetry::__int_histogram_metric_get_or_add(hst1, table(["dim1"] = "val1", ["dim2"] = "val2")); - Telemetry::__int_histogram_observe(hst1_bar, 1); - Telemetry::__int_histogram_observe(hst1_bar, 11); - local hst2_bar = Telemetry::__int_histogram_metric_get_or_add(hst2, table()); - Telemetry::__int_histogram_observe(hst2_bar, 31337); - print fmt("hst1_bar: %d", Telemetry::__int_histogram_sum(hst1_bar)); - print fmt("hst2_bar: %d", Telemetry::__int_histogram_sum(hst2_bar)); - local hst3_bar = Telemetry::__dbl_histogram_metric_get_or_add(hst3, table(["dim1"] = "val1", ["dim2"] = "val2")); - Telemetry::__dbl_histogram_observe(hst3_bar, 2.0); - Telemetry::__dbl_histogram_observe(hst3_bar, 4.0); - local hst4_bar = Telemetry::__dbl_histogram_metric_get_or_add(hst4, table()); - Telemetry::__dbl_histogram_observe(hst4_bar, 64.0); - print fmt("hst3_bar: %f", Telemetry::__dbl_histogram_sum(hst3_bar)); - print fmt("hst4_bar: %f", Telemetry::__dbl_histogram_sum(hst4_bar)); + local hst1_bar = Telemetry::__histogram_metric_get_or_add(hst1, table(["dim1"] = "val1", ["dim2"] = "val2")); + Telemetry::__histogram_observe(hst1_bar, 2.0); + Telemetry::__histogram_observe(hst1_bar, 4.0); + local hst2_bar = Telemetry::__histogram_metric_get_or_add(hst2, table()); + Telemetry::__histogram_observe(hst2_bar, 64.0); + print fmt("hst1_bar: %f", Telemetry::__histogram_sum(hst1_bar)); + print fmt("hst2_bar: %f", Telemetry::__histogram_sum(hst2_bar)); }