Files
aevolution/src/server/ops.cpp
T
dingo c625a4cb68
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 2m24s
Foundation / checks (network) (push) Successful in 20m44s
Foundation / checks (client) (push) Successful in 22m3s
Foundation / checks (tsan) (push) Successful in 23m1s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (checks) (push) Canceled after 24m7s
Foundation / checks (postgres) (push) Canceled after 24m3s
M12.4: retain migration source freezes and explicit aborts
2026-10-18 09:08:50 -04:00

131 lines
6.6 KiB
C++

#include "evo/server/ops.hpp"
#include <string_view>
namespace evo::server {
const char* phase_name(HostPhase phase) noexcept {
switch (phase) {
case HostPhase::acquiring:
return "acquiring";
case HostPhase::running:
return "running";
case HostPhase::resolving:
return "resolving";
case HostPhase::draining:
return "draining";
case HostPhase::stopped:
return "stopped";
case HostPhase::quarantined:
return "quarantined";
}
return "unknown";
}
const char* unacknowledged_name(Unacknowledged reason) noexcept {
switch (reason) {
case Unacknowledged::refused:
return "refused";
case Unacknowledged::drained:
return "drained";
case Unacknowledged::fenced:
return "fenced";
case Unacknowledged::quarantined:
return "quarantined";
}
return "unknown";
}
namespace {
void metric(std::string& out, std::string_view name, std::string_view type, std::string_view help,
std::uint64_t value) {
out.append("# HELP ").append(name).append(" ").append(help).append("\n");
out.append("# TYPE ").append(name).append(" ").append(type).append("\n");
out.append(name).append(" ").append(std::to_string(value)).append("\n");
}
} // namespace
std::string render_metrics(const HostStatus& s, const OpsCounters& c) {
std::string out;
out.reserve(4096);
metric(out, "evo_region_ready", "gauge",
"1 only while this host holds current authority and may originate output", s.ready);
out.append("# HELP evo_region_phase Current host phase (one-hot)\n");
out.append("# TYPE evo_region_phase gauge\n");
for (std::size_t i = 0; i < host_phase_count; ++i) {
const auto phase = static_cast<HostPhase>(i);
out.append("evo_region_phase{phase=\"")
.append(phase_name(phase))
.append("\"} ")
.append(phase == s.phase ? "1" : "0")
.append("\n");
}
metric(out, "evo_region_lease_epoch", "gauge", "Lease epoch held or last held", s.epoch);
metric(out, "evo_region_lease_remaining_milliseconds", "gauge",
"Local time until this host must stop originating (0 without a lease)",
s.lease_remaining_ms);
metric(out, "evo_region_simulated_tick", "gauge", "Last simulated tick", s.simulated_tick);
metric(out, "evo_region_committed_tick", "gauge", "End tick of the committed head",
s.committed_tick);
metric(out, "evo_region_committed_sequence", "gauge", "Commit sequence of the head",
s.committed_sequence);
metric(out, "evo_region_commit_lag_ticks", "gauge",
"Simulated but not yet durably committed ticks",
s.simulated_tick >= s.committed_tick ? s.simulated_tick - s.committed_tick : 0);
metric(out, "evo_region_checkpoint_age_milliseconds", "gauge",
"Time since the last confirmed commit or recovery", c.checkpoint_age_ms);
metric(out, "evo_region_tick_debt", "gauge", "Due ticks not yet simulated", s.tick_debt);
metric(out, "evo_region_ecological_pending_ticks", "gauge", "Durable admitted ecological ticks",
s.ecological_pending_ticks);
metric(out, "evo_region_migration_frozen", "gauge", "Known durable biological source freeze",
s.migration_frozen ? 1 : 0);
metric(out, "evo_region_tick_debt_max", "gauge", "Largest tick debt since recovery",
s.max_tick_debt);
metric(out, "evo_region_queued_inputs", "gauge", "Admitted inputs awaiting a tick", s.queued);
metric(out, "evo_region_queued_bytes", "gauge", "Accounted bytes of queued inputs",
s.queued_bytes);
metric(out, "evo_region_queue_capacity_inputs", "gauge", "Input backlog bound",
c.queue_capacity_inputs);
metric(out, "evo_region_queue_capacity_bytes", "gauge", "Input backlog byte bound",
c.queue_capacity_bytes);
metric(out, "evo_region_objects_available_bytes", "gauge",
"Free bytes on the object volume available to the host", c.objects_available_bytes);
metric(out, "evo_region_objects_reserve_bytes", "gauge",
"Free-space reserve below which new objects are refused", c.objects_reserve_bytes);
metric(out, "evo_region_commits_total", "counter", "Confirmed commits", s.commits);
metric(out, "evo_region_store_failures_total", "counter",
"Storage or database failures that paused progress", s.store_failures);
metric(out, "evo_region_unknown_outcomes_total", "counter",
"Commits whose outcome had to be resolved", s.unknown_outcomes);
metric(out, "evo_region_fences_total", "counter", "Times this host lost authority", s.fences);
metric(out, "evo_region_acknowledgements_total", "counter", "Final acknowledgements emitted",
c.acks);
metric(out, "evo_region_outcomes_total", "counter", "Final permanent outcomes emitted",
c.outcomes);
out.append("# HELP evo_region_dropped_total Accepted inputs that will never be acknowledged\n");
out.append("# TYPE evo_region_dropped_total counter\n");
for (std::size_t i = 0; i < unacknowledged_count; ++i)
out.append("evo_region_dropped_total{reason=\"")
.append(unacknowledged_name(static_cast<Unacknowledged>(i)))
.append("\"} ")
.append(std::to_string(c.dropped[i]))
.append("\n");
if (c.m10_enabled) {
metric(out, "evo_m10_sessions", "gauge", "Open M10 sessions", c.m10_sessions);
metric(out, "evo_m10_refusing", "gauge", "1 while new logins are refused for load",
c.m10_load.refusing);
metric(out, "evo_m10_shed_level", "gauge", "Replication shed level (0-3)", c.m10_load.shed);
metric(out, "evo_m10_tick_work_p95_microseconds", "gauge",
"p95 per-tick region work over the last 40 ticks", c.m10_load.p95_us);
metric(out, "evo_m10_tick_work_p99_microseconds", "gauge",
"p99 per-tick region work over the last 40 ticks", c.m10_load.p99_us);
metric(out, "evo_m10_tick_work_max_microseconds", "gauge",
"Largest per-tick region work over the last 40 ticks", c.m10_load.max_us);
metric(out, "evo_m10_session_work_p95_microseconds", "gauge",
"p95 per-tick session-layer work over the last 40 ticks", c.m10_load.session_p95_us);
metric(out, "evo_m10_session_work_p99_microseconds", "gauge",
"p99 per-tick session-layer work over the last 40 ticks", c.m10_load.session_p99_us);
metric(out, "evo_m10_refused_logins_total", "counter", "Logins refused for load",
c.m10_refused_logins);
}
return out;
}
} // namespace evo::server