X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=metrics.cpp;h=86c3d591872a4a38d53d34a55216b66e4d6d1405;hb=e284d1c7a2e18ee7e4aea082c4a57a3504a0f5e8;hp=5079acb2064e5515a1a549af00c35924edcc57dd;hpb=da648fc65da0b5f8e96ff39ce52bdd00fa29b5dc;p=nageru

diff --git a/metrics.cpp b/metrics.cpp
index 5079acb..86c3d59 100644
--- a/metrics.cpp
+++ b/metrics.cpp
@@ -76,6 +76,19 @@ void Metrics::add(const string &name, const vector<pair<string, string>> &labels
 	types[name] = TYPE_HISTOGRAM;
 }
 
+void Metrics::add(const string &name, const vector<pair<string, string>> &labels, Summary *location, Laziness laziness)
+{
+	Metric metric;
+	metric.data_type = DATA_TYPE_SUMMARY;
+	metric.laziness = laziness;
+	metric.location_summary = location;
+
+	lock_guard<mutex> 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<pair<string, string>> &labels)
 {
 	lock_guard<mutex> lock(mu);
@@ -112,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;
 		}
@@ -126,8 +141,10 @@ string Metrics::serialize() const
 			} else {
 				ss << name << " " << val << "\n";
 			}
-		} else {
+		} 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_summary->serialize(metric.laziness, key_and_metric.first.name, key_and_metric.first.labels);
 		}
 	}
 
@@ -216,3 +233,100 @@ string Histogram::serialize(Metrics::Laziness laziness, const string &name, cons
 
 	return ss.str();
 }
+
+void Summary::init(const vector<double> &quantiles, double window_seconds)
+{
+	this->quantiles = quantiles;
+	window = duration<double>(window_seconds);
+}
+
+void Summary::count_event(double val)
+{
+	steady_clock::time_point now = steady_clock::now();
+	steady_clock::time_point cutoff = now - duration_cast<steady_clock::duration>(window);
+
+	lock_guard<mutex> 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<pair<string, string>> &labels)
+{
+	steady_clock::time_point now = steady_clock::now();
+	steady_clock::time_point cutoff = now - duration_cast<steady_clock::duration>(window);
+
+	vector<double> values_copy;
+	{
+		lock_guard<mutex> 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<pair<double, double>> 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<pair<string, string>> 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();
+}