X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=metrics.cpp;h=86c3d591872a4a38d53d34a55216b66e4d6d1405;hb=9e47a2f661b9d292598ef0277e507458e3dad62f;hp=f44ced2c15a66715977b352736122442c9ba4541;hpb=ba675cdb4f3156d9906c72746b535f54a1aff800;p=nageru diff --git a/metrics.cpp b/metrics.cpp index f44ced2..86c3d59 100644 --- a/metrics.cpp +++ b/metrics.cpp @@ -63,10 +63,11 @@ void Metrics::add(const string &name, const vector> &labels types[name] = type; } -void Metrics::add(const string &name, const vector> &labels, Histogram *location) +void Metrics::add(const string &name, const vector> &labels, Histogram *location, Laziness laziness) { Metric metric; metric.data_type = DATA_TYPE_HISTOGRAM; + metric.laziness = laziness; metric.location_histogram = location; lock_guard lock(mu); @@ -75,6 +76,19 @@ void Metrics::add(const string &name, const vector> &labels types[name] = TYPE_HISTOGRAM; } +void Metrics::add(const string &name, const vector> &labels, Summary *location, Laziness laziness) +{ + Metric metric; + metric.data_type = DATA_TYPE_SUMMARY; + metric.laziness = laziness; + metric.location_summary = location; + + lock_guard lock(mu); + metrics.emplace(MetricKey(name, labels), metric); + assert(types.count(name) == 0 || types[name] == TYPE_SUMMARY); + types[name] = TYPE_SUMMARY; +} + void Metrics::remove(const string &name, const vector> &labels) { lock_guard lock(mu); @@ -111,6 +125,8 @@ string Metrics::serialize() const ss << "# TYPE nageru_" << type_it->first << " gauge\n"; } else if (type_it->second == TYPE_HISTOGRAM) { ss << "# TYPE nageru_" << type_it->first << " histogram\n"; + } else if (type_it->second == TYPE_SUMMARY) { + ss << "# TYPE nageru_" << type_it->first << " summary\n"; } ++type_it; } @@ -118,9 +134,17 @@ string Metrics::serialize() const if (metric.data_type == DATA_TYPE_INT64) { ss << name << " " << metric.location_int64->load() << "\n"; } else if (metric.data_type == DATA_TYPE_DOUBLE) { - ss << name << " " << metric.location_double->load() << "\n"; + double val = metric.location_double->load(); + if (isnan(val)) { + // Prometheus can't handle “-nan”. + ss << name << " NaN\n"; + } else { + ss << name << " " << val << "\n"; + } + } else if (metric.data_type == DATA_TYPE_HISTOGRAM) { + ss << metric.location_histogram->serialize(metric.laziness, key_and_metric.first.name, key_and_metric.first.labels); } else { - ss << metric.location_histogram->serialize(key_and_metric.first.name, key_and_metric.first.labels); + ss << metric.location_summary->serialize(metric.laziness, key_and_metric.first.name, key_and_metric.first.labels); } } @@ -169,8 +193,22 @@ void Histogram::count_event(double val) sum = sum + val; } -string Histogram::serialize(const string &name, const vector> &labels) const +string Histogram::serialize(Metrics::Laziness laziness, const string &name, const vector> &labels) const { + // Check if the histogram is empty and should not be serialized. + if (laziness == Metrics::PRINT_WHEN_NONEMPTY && count_after_last_bucket.load() == 0) { + bool empty = true; + for (size_t bucket_idx = 0; bucket_idx < num_buckets; ++bucket_idx) { + if (buckets[bucket_idx].count.load() != 0) { + empty = false; + break; + } + } + if (empty) { + return ""; + } + } + stringstream ss; ss.imbue(locale("C")); ss.precision(20); @@ -195,3 +233,100 @@ string Histogram::serialize(const string &name, const vector &quantiles, double window_seconds) +{ + this->quantiles = quantiles; + window = duration(window_seconds); +} + +void Summary::count_event(double val) +{ + steady_clock::time_point now = steady_clock::now(); + steady_clock::time_point cutoff = now - duration_cast(window); + + lock_guard lock(mu); + values.emplace_back(now, val); + while (!values.empty() && values.front().first < cutoff) { + values.pop_front(); + } + + // Non-atomic add, but that's fine, since there are no concurrent writers. + sum = sum + val; + ++count; +} + +string Summary::serialize(Metrics::Laziness laziness, const string &name, const vector> &labels) +{ + steady_clock::time_point now = steady_clock::now(); + steady_clock::time_point cutoff = now - duration_cast(window); + + vector values_copy; + { + lock_guard lock(mu); + while (!values.empty() && values.front().first < cutoff) { + values.pop_front(); + } + values_copy.reserve(values.size()); + for (const auto &time_and_value : values) { + values_copy.push_back(time_and_value.second); + } + } + + vector> answers; + if (values_copy.size() == 0) { + if (laziness == Metrics::PRINT_WHEN_NONEMPTY) { + return ""; + } + for (double quantile : quantiles) { + answers.emplace_back(quantile, 0.0 / 0.0); + } + } else if (values_copy.size() == 1) { + for (double quantile : quantiles) { + answers.emplace_back(quantile, values_copy[0]); + } + } else { + // We could probably do repeated nth_element, but the constant factor + // gets a bit high, so just sorting probably is about as fast. + sort(values_copy.begin(), values_copy.end()); + for (double quantile : quantiles) { + double idx = quantile * (values_copy.size() - 1); + size_t idx_floor = size_t(floor(idx)); + const double v0 = values_copy[idx_floor]; + + if (idx_floor == values_copy.size() - 1) { + answers.emplace_back(quantile, values_copy[idx_floor]); + } else { + // Linear interpolation. + double t = idx - idx_floor; + const double v1 = values_copy[idx_floor + 1]; + answers.emplace_back(quantile, v0 + t * (v1 - v0)); + } + } + } + + stringstream ss; + ss.imbue(locale("C")); + ss.precision(20); + + for (const auto &quantile_and_value : answers) { + stringstream quantile_ss; + quantile_ss.imbue(locale("C")); + quantile_ss.precision(3); + quantile_ss << quantile_and_value.first; + vector> quantile_labels = labels; + quantile_labels.emplace_back("quantile", quantile_ss.str()); + + double val = quantile_and_value.second;; + if (isnan(val)) { + // Prometheus can't handle “-nan”. + ss << Metrics::serialize_name(name, quantile_labels) << " NaN\n"; + } else { + ss << Metrics::serialize_name(name, quantile_labels) << " " << val << "\n"; + } + } + + ss << Metrics::serialize_name(name + "_sum", labels) << " " << sum.load() << "\n"; + ss << Metrics::serialize_name(name + "_count", labels) << " " << count.load() << "\n"; + return ss.str(); +}