219 lines
7.1 KiB
C++
219 lines
7.1 KiB
C++
#include "Stats.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <cstdio>
|
|
|
|
namespace molo::example::fw {
|
|
|
|
namespace {
|
|
|
|
// Upper bounds in microseconds; the last bucket is open-ended.
|
|
constexpr std::array<long, 7> kBounds = {500, 1000, 5000, 10000,
|
|
50000, 100000, 500000};
|
|
|
|
std::string quote(const std::string& s) { return "\"" + json_escape(s) + "\""; }
|
|
|
|
} // namespace
|
|
|
|
Stats::Stats() {
|
|
ring_.reserve(stats_caps::kLatencyRing);
|
|
started_ = now();
|
|
}
|
|
|
|
void Stats::set_clock(long (*now_sec)()) {
|
|
std::lock_guard<std::mutex> lock(mu_);
|
|
clock_ = now_sec;
|
|
}
|
|
|
|
long Stats::now() const {
|
|
if (clock_) return clock_();
|
|
return (long)std::chrono::duration_cast<std::chrono::seconds>(
|
|
std::chrono::system_clock::now().time_since_epoch())
|
|
.count();
|
|
}
|
|
|
|
Stats::Bucket& Stats::bucket_for(long slot) {
|
|
Bucket& b = buckets_[(std::size_t)(slot % (long)stats_caps::kBuckets)];
|
|
if (b.slot != slot) {
|
|
b = Bucket{};
|
|
b.slot = slot;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
void Stats::record_request(const RequestSample& s) {
|
|
std::lock_guard<std::mutex> lock(mu_);
|
|
const bool failed = s.status >= 400;
|
|
++requests_;
|
|
if (failed) ++errors_;
|
|
bytes_in_ += (long)s.bytes_in;
|
|
bytes_out_ += (long)s.bytes_out;
|
|
micros_ += s.micros;
|
|
++by_method_[method_name(s.method)];
|
|
++by_status_[s.status];
|
|
|
|
std::string key = s.route.empty() ? "(unmatched)" : s.route;
|
|
if (!by_route_.count(key) && by_route_.size() >= stats_caps::kMaxRoutes)
|
|
key = "(other)";
|
|
RouteStat& r = by_route_[key];
|
|
++r.count;
|
|
if (failed) ++r.errors;
|
|
r.micros += s.micros;
|
|
r.max_micros = std::max(r.max_micros, s.micros);
|
|
r.bytes_out += (long)s.bytes_out;
|
|
|
|
std::size_t h = 0;
|
|
while (h < kBounds.size() && s.micros >= kBounds[h]) ++h;
|
|
++histogram_[h];
|
|
if (ring_.size() < stats_caps::kLatencyRing) {
|
|
ring_.push_back(s.micros);
|
|
} else {
|
|
ring_[ring_next_] = s.micros;
|
|
ring_next_ = (ring_next_ + 1) % stats_caps::kLatencyRing;
|
|
}
|
|
|
|
Bucket& b = bucket_for(now() / stats_caps::kBucketSec);
|
|
++b.requests;
|
|
if (failed) ++b.errors;
|
|
b.bytes_in += (long)s.bytes_in;
|
|
b.bytes_out += (long)s.bytes_out;
|
|
b.micros += s.micros;
|
|
}
|
|
|
|
void Stats::connection_opened() {
|
|
std::lock_guard<std::mutex> lock(mu_);
|
|
++conn_total_;
|
|
++conn_active_;
|
|
conn_peak_ = std::max(conn_peak_, conn_active_);
|
|
++bucket_for(now() / stats_caps::kBucketSec).connections;
|
|
}
|
|
|
|
void Stats::connection_closed(ConnEnd how, std::size_t in, std::size_t out) {
|
|
std::lock_guard<std::mutex> lock(mu_);
|
|
if (conn_active_ > 0) --conn_active_;
|
|
if (how == ConnEnd::Timeout) ++conn_timeout_;
|
|
if (how == ConnEnd::Malformed) ++conn_malformed_;
|
|
conn_bytes_in_ += (long)in;
|
|
conn_bytes_out_ += (long)out;
|
|
}
|
|
|
|
void Stats::connection_rejected() {
|
|
std::lock_guard<std::mutex> lock(mu_);
|
|
++conn_rejected_;
|
|
}
|
|
|
|
void Stats::set_connection_cap(long cap) {
|
|
std::lock_guard<std::mutex> lock(mu_);
|
|
conn_cap_ = cap;
|
|
}
|
|
|
|
long Stats::total_requests() const {
|
|
std::lock_guard<std::mutex> lock(mu_);
|
|
return requests_;
|
|
}
|
|
|
|
long Stats::total_connections() const {
|
|
std::lock_guard<std::mutex> lock(mu_);
|
|
return conn_total_;
|
|
}
|
|
|
|
long Stats::active_connections() const {
|
|
std::lock_guard<std::mutex> lock(mu_);
|
|
return conn_active_;
|
|
}
|
|
|
|
std::string Stats::to_json() const {
|
|
std::lock_guard<std::mutex> lock(mu_);
|
|
const long t = now();
|
|
auto num = [](long v) { return std::to_string(v); };
|
|
auto dbl = [](double v) {
|
|
char buf[48];
|
|
std::snprintf(buf, sizeof(buf), "%.3f", v);
|
|
return std::string(buf);
|
|
};
|
|
std::string out = "{";
|
|
out += "\"generated_at\":" + num(t) + ",\"uptime_sec\":" + num(t - started_);
|
|
|
|
out += ",\"totals\":{\"requests\":" + num(requests_) +
|
|
",\"errors\":" + num(errors_) + ",\"bytes_in\":" + num(bytes_in_) +
|
|
",\"bytes_out\":" + num(bytes_out_) + ",\"avg_ms\":" +
|
|
dbl(requests_ ? micros_ / 1000.0 / (double)requests_ : 0.0) + "}";
|
|
|
|
out += ",\"by_method\":{";
|
|
bool first = true;
|
|
for (const auto& [k, v] : by_method_) {
|
|
out += (first ? "" : ",") + quote(k) + ":" + num(v);
|
|
first = false;
|
|
}
|
|
out += "},\"by_status\":{";
|
|
first = true;
|
|
for (const auto& [k, v] : by_status_) {
|
|
out += (first ? "" : ",") + quote(std::to_string(k)) + ":" + num(v);
|
|
first = false;
|
|
}
|
|
out += "},\"by_route\":[";
|
|
std::vector<std::pair<std::string, RouteStat>> routes(by_route_.begin(),
|
|
by_route_.end());
|
|
std::sort(routes.begin(), routes.end(), [](const auto& a, const auto& b) {
|
|
return a.second.count > b.second.count;
|
|
});
|
|
first = true;
|
|
for (const auto& [k, r] : routes) {
|
|
out += std::string(first ? "" : ",") + "{\"route\":" + quote(k) +
|
|
",\"count\":" + num(r.count) + ",\"errors\":" + num(r.errors) +
|
|
",\"avg_ms\":" + dbl(r.micros / 1000.0 / (double)r.count) +
|
|
",\"max_ms\":" + dbl(r.max_micros / 1000.0) +
|
|
",\"bytes_out\":" + num(r.bytes_out) + "}";
|
|
first = false;
|
|
}
|
|
out += "]";
|
|
|
|
static const char* kLabels[8] = {"<0.5ms", "<1ms", "<5ms", "<10ms",
|
|
"<50ms", "<100ms", "<500ms", ">=500ms"};
|
|
out += ",\"latency\":{\"histogram\":[";
|
|
for (std::size_t i = 0; i < histogram_.size(); ++i)
|
|
out += std::string(i ? "," : "") + "{\"bucket\":" + quote(kLabels[i]) +
|
|
",\"count\":" + num(histogram_[i]) + "}";
|
|
std::vector<long> sorted = ring_;
|
|
std::sort(sorted.begin(), sorted.end());
|
|
auto pct = [&](double p) {
|
|
if (sorted.empty()) return 0.0;
|
|
std::size_t idx = (std::size_t)(p * (double)(sorted.size() - 1));
|
|
return sorted[idx] / 1000.0;
|
|
};
|
|
out += "],\"p50_ms\":" + dbl(pct(0.50)) + ",\"p95_ms\":" + dbl(pct(0.95)) +
|
|
",\"p99_ms\":" + dbl(pct(0.99)) + ",\"samples\":" +
|
|
num((long)sorted.size()) + "}";
|
|
|
|
out += ",\"connections\":{\"total\":" + num(conn_total_) +
|
|
",\"active\":" + num(conn_active_) + ",\"peak\":" + num(conn_peak_) +
|
|
",\"timeouts\":" + num(conn_timeout_) + ",\"malformed\":" +
|
|
num(conn_malformed_) + ",\"rejected\":" + num(conn_rejected_) +
|
|
",\"cap\":" + num(conn_cap_) + ",\"bytes_in\":" +
|
|
num(conn_bytes_in_) + ",\"bytes_out\":" + num(conn_bytes_out_) + "}";
|
|
|
|
// Oldest first, one entry per bucket slot including empty ones.
|
|
const long cur = t / stats_caps::kBucketSec;
|
|
const long n = (long)stats_caps::kBuckets;
|
|
out += ",\"series\":{\"bucket_sec\":" + num(stats_caps::kBucketSec) +
|
|
",\"points\":[";
|
|
for (long i = n - 1; i >= 0; --i) {
|
|
const long slot = cur - i;
|
|
const Bucket& b = buckets_[(std::size_t)(slot % n)];
|
|
const bool live = b.slot == slot;
|
|
const long reqs = live ? b.requests : 0;
|
|
out += std::string(i == n - 1 ? "" : ",") + "{\"t\":" +
|
|
num(slot * stats_caps::kBucketSec) +
|
|
",\"requests\":" + num(reqs) +
|
|
",\"errors\":" + num(live ? b.errors : 0) +
|
|
",\"bytes_in\":" + num(live ? b.bytes_in : 0) +
|
|
",\"bytes_out\":" + num(live ? b.bytes_out : 0) +
|
|
",\"avg_ms\":" + dbl(reqs ? b.micros / 1000.0 / (double)reqs : 0.0) +
|
|
",\"connections\":" + num(live ? b.connections : 0) + "}";
|
|
}
|
|
out += "]}}";
|
|
return out;
|
|
}
|
|
|
|
} // namespace molo::example::fw
|