128 lines
4.3 KiB
C++
128 lines
4.3 KiB
C++
// Copyright 2022 Memgraph Ltd.
|
|
//
|
|
// Use of this software is governed by the Business Source License
|
|
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
|
|
// License, and you may not use this file except in compliance with the Business Source License.
|
|
//
|
|
// As of the Change Date specified in that file, in accordance with
|
|
// the Business Source License, use of this software will be governed
|
|
// by the Apache License, Version 2.0, included in the file
|
|
// licenses/APL.txt.
|
|
|
|
#pragma once
|
|
|
|
#include <chrono>
|
|
#include <cmath>
|
|
#include <unordered_map>
|
|
|
|
#include <boost/core/demangle.hpp>
|
|
|
|
#include "io/time.hpp"
|
|
#include "utils/histogram.hpp"
|
|
#include "utils/logging.hpp"
|
|
#include "utils/print_helpers.hpp"
|
|
#include "utils/type_info_ref.hpp"
|
|
|
|
namespace memgraph::io {
|
|
|
|
struct LatencyHistogramSummary {
|
|
uint64_t count;
|
|
Duration p0;
|
|
Duration p50;
|
|
Duration p75;
|
|
Duration p90;
|
|
Duration p95;
|
|
Duration p975;
|
|
Duration p99;
|
|
Duration p999;
|
|
Duration p9999;
|
|
Duration p100;
|
|
Duration sum;
|
|
|
|
friend std::ostream &operator<<(std::ostream &in, const LatencyHistogramSummary &histo) {
|
|
in << "{ \"count\": " << histo.count;
|
|
in << ", \"p0\": " << histo.p0.count();
|
|
in << ", \"p50\": " << histo.p50.count();
|
|
in << ", \"p75\": " << histo.p75.count();
|
|
in << ", \"p90\": " << histo.p90.count();
|
|
in << ", \"p95\": " << histo.p95.count();
|
|
in << ", \"p975\": " << histo.p975.count();
|
|
in << ", \"p99\": " << histo.p99.count();
|
|
in << ", \"p999\": " << histo.p999.count();
|
|
in << ", \"p9999\": " << histo.p9999.count();
|
|
in << ", \"p100\": " << histo.p100.count();
|
|
in << ", \"sum\": " << histo.sum.count();
|
|
in << " }";
|
|
|
|
return in;
|
|
}
|
|
};
|
|
|
|
struct LatencyHistogramSummaries {
|
|
std::unordered_map<std::string, LatencyHistogramSummary> latencies;
|
|
|
|
std::string SummaryTable() {
|
|
std::string output;
|
|
|
|
const auto row = [&output](const auto &c1, const auto &c2, const auto &c3, const auto &c4, const auto &c5,
|
|
const auto &c6, const auto &c7) {
|
|
output +=
|
|
fmt::format("{: >50} | {: >8} | {: >8} | {: >8} | {: >8} | {: >8} | {: >8}\n", c1, c2, c3, c4, c5, c6, c7);
|
|
};
|
|
row("name", "count", "min (μs)", "med (μs)", "p99 (μs)", "max (μs)", "sum (ms)");
|
|
|
|
for (const auto &[name, histo] : latencies) {
|
|
row(name, histo.count, histo.p0.count(), histo.p50.count(), histo.p99.count(), histo.p100.count(),
|
|
histo.sum.count() / 1000);
|
|
}
|
|
|
|
output += "\n";
|
|
return output;
|
|
}
|
|
|
|
friend std::ostream &operator<<(std::ostream &in, const LatencyHistogramSummaries &histo) {
|
|
using memgraph::utils::print_helpers::operator<<;
|
|
in << histo.latencies;
|
|
return in;
|
|
}
|
|
};
|
|
|
|
class MessageHistogramCollector {
|
|
std::unordered_map<utils::TypeInfoRef, utils::Histogram, utils::TypeInfoHasher, utils::TypeInfoEqualTo> histograms_;
|
|
|
|
public:
|
|
void Measure(const std::type_info &type_info, const Duration &duration) {
|
|
auto &histo = histograms_[type_info];
|
|
histo.Measure(duration.count());
|
|
}
|
|
|
|
LatencyHistogramSummaries ResponseLatencies() {
|
|
std::unordered_map<std::string, LatencyHistogramSummary> ret{};
|
|
|
|
for (const auto &[type_id, histo] : histograms_) {
|
|
std::string demangled_name = "\"" + boost::core::demangle(type_id.get().name()) + "\"";
|
|
|
|
LatencyHistogramSummary latency_histogram_summary{
|
|
.count = histo.Count(),
|
|
.p0 = Duration(static_cast<int64_t>(histo.Percentile(0.0))),
|
|
.p50 = Duration(static_cast<int64_t>(histo.Percentile(50.0))),
|
|
.p75 = Duration(static_cast<int64_t>(histo.Percentile(75.0))),
|
|
.p90 = Duration(static_cast<int64_t>(histo.Percentile(90.0))),
|
|
.p95 = Duration(static_cast<int64_t>(histo.Percentile(95.0))),
|
|
.p975 = Duration(static_cast<int64_t>(histo.Percentile(97.5))),
|
|
.p99 = Duration(static_cast<int64_t>(histo.Percentile(99.0))),
|
|
.p999 = Duration(static_cast<int64_t>(histo.Percentile(99.9))),
|
|
.p9999 = Duration(static_cast<int64_t>(histo.Percentile(99.99))),
|
|
.p100 = Duration(static_cast<int64_t>(histo.Percentile(100.0))),
|
|
.sum = Duration(histo.Sum()),
|
|
};
|
|
|
|
ret.emplace(demangled_name, latency_histogram_summary);
|
|
}
|
|
|
|
return LatencyHistogramSummaries{.latencies = ret};
|
|
}
|
|
};
|
|
|
|
} // namespace memgraph::io
|