milestone 26: upstream health answers for the selected period
This commit is contained in:
@@ -52,6 +52,15 @@ pub const Input = struct {
|
||||
upstreams_total: u32 = 0,
|
||||
queries_dropped: u64 = 0,
|
||||
writer_failed: bool = false,
|
||||
/// Current state, not a count: the upstream-history flush is failing right
|
||||
/// now. Cleared by the next flush that succeeds (m26 ruling 7).
|
||||
///
|
||||
/// `rows_dropped` deliberately does not appear here. It is cumulative, and
|
||||
/// a rollup that is computed statelessly cannot ask whether a counter grew
|
||||
/// — so feeding it in would latch `/api/health` to degraded forever after
|
||||
/// one overflow. Drops surface through the metric and through the API's
|
||||
/// per-window `complete` instead.
|
||||
history_flush_failing: bool = false,
|
||||
refreshes_gated: u64 = 0,
|
||||
snapshot_generation: ?u64 = null,
|
||||
};
|
||||
@@ -59,11 +68,15 @@ pub const Input = struct {
|
||||
pub const status_ok = "ok";
|
||||
pub const status_degraded = "degraded";
|
||||
|
||||
/// Ruling 22's three conditions. Each one is something an operator must act on:
|
||||
/// a disk that is filling stops the query log, a pool with nothing available
|
||||
/// stops resolution, and a failed writer means rows are being lost right now.
|
||||
/// Conditions an operator must act on, and every one of them is a fact about
|
||||
/// now rather than a count of the past: a disk that is filling stops the query
|
||||
/// log, a pool with nothing available stops resolution, a failed writer means
|
||||
/// rows are being lost right now, and a failing history flush means the
|
||||
/// dashboard's upstream numbers are not being recorded. Each clears itself when
|
||||
/// the underlying condition does.
|
||||
pub fn degraded(input: Input) bool {
|
||||
return input.disk_state != .ok or input.upstreams_available == 0 or input.writer_failed;
|
||||
return input.disk_state != .ok or input.upstreams_available == 0 or
|
||||
input.writer_failed or input.history_flush_failing;
|
||||
}
|
||||
|
||||
pub fn rollup(input: Input) Body {
|
||||
@@ -115,6 +128,10 @@ pub fn collect(state: *server.WebState, io: std.Io) Input {
|
||||
input.writer_failed = logger.writer_failed.load(.monotonic);
|
||||
}
|
||||
|
||||
if (state.history) |history| {
|
||||
input.history_flush_failing = history.snapshotStats(io).last_flush_failed;
|
||||
}
|
||||
|
||||
if (state.manager) |manager| {
|
||||
input.refreshes_gated = manager.refreshesGated();
|
||||
if (manager.acquire(io)) |acquired| {
|
||||
@@ -130,7 +147,10 @@ pub fn collect(state: *server.WebState, io: std.Io) Input {
|
||||
// tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const db = @import("../../storage/db.zig");
|
||||
const history_mod = @import("../../upstream/history.zig");
|
||||
const logger_mod = @import("../../storage/logger.zig");
|
||||
const upstream_history_repo = @import("../../storage/repositories/upstream_history_repo.zig");
|
||||
const testing = std.testing;
|
||||
|
||||
/// A box with nothing wrong with it: one upstream up, disk ok, writer alive.
|
||||
@@ -148,6 +168,10 @@ test "the degraded matrix covers disk state, availability and the writer" {
|
||||
.{ .input = withDisk(healthy, .critical), .degraded = true },
|
||||
.{ .input = withAvailable(healthy, 0), .degraded = true },
|
||||
.{ .input = withWriterFailed(healthy), .degraded = true },
|
||||
// A failing upstream-history flush is losing the dashboard's numbers
|
||||
// right now, and it recovers on its own the moment a flush succeeds.
|
||||
.{ .input = withHistoryFailing(healthy, true), .degraded = true },
|
||||
.{ .input = withHistoryFailing(healthy, false), .degraded = false },
|
||||
// Two faults at once still report one status.
|
||||
.{ .input = withWriterFailed(withDisk(healthy, .critical)), .degraded = true },
|
||||
// Some upstreams down is not degraded while one still answers.
|
||||
@@ -182,6 +206,48 @@ fn withWriterFailed(input: Input) Input {
|
||||
return out;
|
||||
}
|
||||
|
||||
fn withHistoryFailing(input: Input, failing: bool) Input {
|
||||
var out = input;
|
||||
out.history_flush_failing = failing;
|
||||
return out;
|
||||
}
|
||||
|
||||
test "a history overflow that already happened does not degrade the rollup" {
|
||||
// `rows_dropped` is cumulative and the rollup is stateless, so the only
|
||||
// thing it could do with a drop count is latch on it. The accumulator's
|
||||
// drops reach an operator through `/metrics` and through the per-window
|
||||
// `complete` flag, and never through this.
|
||||
const dropped: Input = .{
|
||||
.upstreams_available = 1,
|
||||
.upstreams_total = 1,
|
||||
.history_flush_failing = false,
|
||||
};
|
||||
try testing.expect(!degraded(dropped));
|
||||
try testing.expectEqualStrings(status_ok, rollup(dropped).status);
|
||||
}
|
||||
|
||||
test "collect reads the accumulator's current flush state" {
|
||||
var threaded: std.Io.Threaded = .init(testing.allocator, .{});
|
||||
defer threaded.deinit();
|
||||
const io = threaded.io();
|
||||
|
||||
const acc = try testing.allocator.create(history_mod.Accumulator);
|
||||
defer testing.allocator.destroy(acc);
|
||||
acc.* = .init;
|
||||
|
||||
var state: server.WebState = .{ .gpa = testing.allocator, .history = acc };
|
||||
try testing.expect(!collect(&state, io).history_flush_failing);
|
||||
|
||||
var database = try db.Db.open(":memory:", .{ .mode = .memory });
|
||||
defer database.close();
|
||||
acc.recordSuccess(io, "https://a.example", 60);
|
||||
// No schema in this database, so the real write fails and the flag is set
|
||||
// by the production path rather than by a test poking a field.
|
||||
acc.flushOnce(io, &database, upstream_history_repo.flush);
|
||||
try testing.expect(collect(&state, io).history_flush_failing);
|
||||
try testing.expectEqualStrings("degraded", rollup(collect(&state, io)).status);
|
||||
}
|
||||
|
||||
test "the body reports every input verbatim" {
|
||||
const body = rollup(.{
|
||||
.disk_state = .warn,
|
||||
|
||||
@@ -1,52 +1,116 @@
|
||||
//! `GET /api/upstream/health` — the pool's own view of its upstreams.
|
||||
//! `GET /api/upstream/health?period=` — the pool's upstreams over the window
|
||||
//! the dashboard's period picker selected (milestone-26 ruling 6).
|
||||
//!
|
||||
//! The rows are `Pool.Snapshot` with the borrowed strings copied. `last_error`
|
||||
//! points into the entry that produced it and is rewritten by that entry's next
|
||||
//! failure, so it is duplicated into the request arena before the pool's mutex
|
||||
//! is out of sight.
|
||||
//! Two kinds of fact, kept apart on the wire because they answer different
|
||||
//! questions. `enabled`/`available` are live routing state, read from the pool
|
||||
//! under its mutex: what the resolver would do with this upstream right now.
|
||||
//! Everything under `period` is history, aggregated out of `upstream_minute`
|
||||
//! over `[since, until)` — the same window `/api/stats` reports, so a page
|
||||
//! cannot show a rate that disagrees with the chart beside it.
|
||||
//!
|
||||
//! No timestamps: the health fields are stamped on the `awake` clock, which
|
||||
//! stops while the box is suspended and means nothing to a client reading wall
|
||||
//! time. What an operator needs — is it up, how often does it fail, what did it
|
||||
//! say last — is here without them.
|
||||
//! Nothing here reads a process-lifetime counter. The lifetime totals, the
|
||||
//! last-32-exchange window and the consecutive-failure count still live in
|
||||
//! `health.State` for routing and in `/metrics`; they are not this response's
|
||||
//! business, because a number that starts at process start cannot be scoped to
|
||||
//! a period and a dashboard that shows one beside a picker lies about it.
|
||||
//!
|
||||
//! The aggregation runs on the web task's own query-log connection (m7 ruling
|
||||
//! 21) and this file owns no SQL: `upstream_history_repo` does.
|
||||
|
||||
const std = @import("std");
|
||||
const Allocator = std.mem.Allocator;
|
||||
|
||||
const db = @import("../../storage/db.zig");
|
||||
const history_mod = @import("../../upstream/history.zig");
|
||||
const http_util = @import("../http_util.zig");
|
||||
const metrics = @import("../metrics.zig");
|
||||
const pool_mod = @import("../../upstream/pool.zig");
|
||||
const server = @import("../server.zig");
|
||||
const stats = @import("stats.zig");
|
||||
const upstream_history_repo = @import("../../storage/repositories/upstream_history_repo.zig");
|
||||
|
||||
const log = std.log.scoped(.web_upstream_health);
|
||||
|
||||
/// One upstream's outcomes inside the selected window.
|
||||
pub const PeriodStats = struct {
|
||||
attempts: u64,
|
||||
successes: u64,
|
||||
failures: u64,
|
||||
/// Null when `attempts == 0`. No observations is not perfect reliability,
|
||||
/// and a `100.0%` from an idle upstream is the exact misreading this
|
||||
/// milestone exists to remove.
|
||||
success_rate: ?f32,
|
||||
/// The newest failure inside the window, on the wall clock the minute rows
|
||||
/// are stamped with. Null when the window holds no failure, even if the
|
||||
/// upstream failed before it.
|
||||
last_failure_at: ?i64,
|
||||
/// The error name belonging to `last_failure_at`; null exactly when it is.
|
||||
last_failure_error: ?[]const u8,
|
||||
};
|
||||
|
||||
pub const Upstream = struct {
|
||||
url: []const u8,
|
||||
/// Live: configuration, not history.
|
||||
enabled: bool,
|
||||
/// Live: false while the upstream is backing off.
|
||||
available: bool,
|
||||
consecutive_failures: u32,
|
||||
total_successes: u64,
|
||||
total_failures: u64,
|
||||
success_rate: f32,
|
||||
/// "" when the upstream has never failed.
|
||||
last_error: []const u8,
|
||||
period: PeriodStats,
|
||||
};
|
||||
|
||||
pub const Body = struct {
|
||||
upstreams: []const Upstream,
|
||||
period: []const u8,
|
||||
since: i64,
|
||||
until: i64,
|
||||
available: u32,
|
||||
total: u32,
|
||||
/// See `isComplete`.
|
||||
complete: bool,
|
||||
upstreams: []const Upstream,
|
||||
};
|
||||
|
||||
/// The same text `/api/stats` sends (`stats.zig`'s `badPeriod`). One period
|
||||
/// grammar serves the whole dashboard, so the two routes must not disagree
|
||||
/// about what a typo means.
|
||||
pub const bad_period_message = "period must be one of 1h, 24h, 7d, 30d";
|
||||
|
||||
pub fn handle(
|
||||
state: *server.WebState,
|
||||
io: std.Io,
|
||||
request: *http_util.Request,
|
||||
) http_util.HandlerError!void {
|
||||
const period = stats.periodParam(request.query) catch
|
||||
return http_util.respondError(request, .bad_request, bad_period_message);
|
||||
const pool = state.pool orelse
|
||||
return http_util.respondError(request, .service_unavailable, "no upstream pool");
|
||||
return http_util.respondJson(request, .ok, try collect(pool, io, request.arena), &.{});
|
||||
const database = state.querylog_db orelse
|
||||
return http_util.respondError(request, .service_unavailable, "query log unavailable");
|
||||
|
||||
const now = std.Io.Clock.real.now(io).toSeconds();
|
||||
const body = collect(request.arena, io, pool, state.history, database, period, now) catch |err| {
|
||||
if (err == error.OutOfMemory) return error.OutOfMemory;
|
||||
// A failed aggregate is a fault in the box, not a property of the
|
||||
// request (ruling 8, PLAN §19).
|
||||
log.warn("upstream health window failed: {s}", .{@errorName(err)});
|
||||
return http_util.respondError(request, .internal_server_error, "internal error");
|
||||
};
|
||||
return http_util.respondJson(request, .ok, body, &.{});
|
||||
}
|
||||
|
||||
pub fn collect(pool: *pool_mod.Pool, io: std.Io, arena: Allocator) Allocator.Error!Body {
|
||||
/// `db.Error` already carries `OutOfMemory`, so the arena's failures and
|
||||
/// SQLite's share one set.
|
||||
pub const Error = Allocator.Error || db.Error;
|
||||
|
||||
pub fn collect(
|
||||
arena: Allocator,
|
||||
io: std.Io,
|
||||
pool: *pool_mod.Pool,
|
||||
history: ?*history_mod.Accumulator,
|
||||
database: *db.Db,
|
||||
period: stats.Period,
|
||||
now_unix: i64,
|
||||
) Error!Body {
|
||||
const span = stats.window(period, now_unix);
|
||||
|
||||
var raw: [metrics.max_upstreams]pool_mod.Snapshot = undefined;
|
||||
const count = metrics.poolSnapshot(pool, io, &raw);
|
||||
|
||||
@@ -54,25 +118,76 @@ pub fn collect(pool: *pool_mod.Pool, io: std.Io, arena: Allocator) Allocator.Err
|
||||
var available: u32 = 0;
|
||||
for (raw[0..count], out) |entry, *slot| {
|
||||
if (entry.available) available += 1;
|
||||
|
||||
// Rows come from the current pool only: an upstream deleted from the
|
||||
// configuration keeps its history in storage until retention takes it,
|
||||
// and nothing joins it back into this response.
|
||||
const window_stats = try upstream_history_repo.windowStats(
|
||||
database,
|
||||
entry.url,
|
||||
span.since,
|
||||
span.until,
|
||||
);
|
||||
|
||||
slot.* = .{
|
||||
.url = try arena.dupe(u8, entry.url),
|
||||
.enabled = entry.enabled,
|
||||
.available = entry.available,
|
||||
.consecutive_failures = entry.consecutive_failures,
|
||||
.total_successes = entry.total_successes,
|
||||
.total_failures = entry.total_failures,
|
||||
.success_rate = entry.success_rate,
|
||||
.last_error = try arena.dupe(u8, entry.last_error),
|
||||
.period = .{
|
||||
.attempts = window_stats.attempts,
|
||||
.successes = window_stats.successes,
|
||||
.failures = window_stats.failures,
|
||||
.success_rate = successRate(window_stats),
|
||||
.last_failure_at = window_stats.last_failure_ts,
|
||||
// `WindowStats` carries its error name by value, in storage this
|
||||
// loop is done with as soon as the iteration ends. The copy into
|
||||
// the arena is what keeps the response from pointing at bytes
|
||||
// the next upstream's row overwrites.
|
||||
.last_failure_error = if (window_stats.last_failure_ts == null)
|
||||
null
|
||||
else
|
||||
try arena.dupe(u8, window_stats.lastFailureError()),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
return .{ .upstreams = out, .available = available, .total = @intCast(count) };
|
||||
return .{
|
||||
.period = period.label(),
|
||||
.since = span.since,
|
||||
.until = span.until,
|
||||
.available = available,
|
||||
.total = @intCast(count),
|
||||
.complete = isComplete(history, io, span.since),
|
||||
.upstreams = out,
|
||||
};
|
||||
}
|
||||
|
||||
fn successRate(window_stats: upstream_history_repo.WindowStats) ?f32 {
|
||||
if (window_stats.attempts == 0) return null;
|
||||
const successes: f32 = @floatFromInt(window_stats.successes);
|
||||
const attempts: f32 = @floatFromInt(window_stats.attempts);
|
||||
return successes / attempts;
|
||||
}
|
||||
|
||||
/// Per-window and stateless (ruling 6): false iff capacity has cost this
|
||||
/// process a minute that falls inside the window. A window that starts after
|
||||
/// the newest such minute is complete again, so one historical overflow does
|
||||
/// not mark every later response.
|
||||
///
|
||||
/// It says nothing about the newest outcomes, which may not have flushed yet,
|
||||
/// and nothing about an unclean shutdown, which is not detectable here — the
|
||||
/// openapi description spells both out.
|
||||
fn isComplete(history: ?*history_mod.Accumulator, io: std.Io, since: i64) bool {
|
||||
const accumulator = history orelse return true;
|
||||
const dropped = accumulator.snapshotStats(io).last_drop_minute orelse return true;
|
||||
return dropped < since;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const querylog_schema = @import("../../storage/querylog_schema.zig");
|
||||
const transport = @import("../../upstream/transport.zig");
|
||||
const testing = std.testing;
|
||||
|
||||
@@ -94,83 +209,377 @@ fn testPool(entries: []pool_mod.Entry) pool_mod.Pool {
|
||||
}, 1);
|
||||
}
|
||||
|
||||
test "every upstream is copied, counted and owned by the arena" {
|
||||
fn openLog() !db.Db {
|
||||
var database = try db.Db.open(":memory:", .{ .mode = .memory });
|
||||
errdefer database.close();
|
||||
try db.applyPragmas(&database, .{});
|
||||
try database.exec(querylog_schema.ddl);
|
||||
return database;
|
||||
}
|
||||
|
||||
const url_a = "https://a.test/dns-query";
|
||||
const url_b = "https://b.test/dns-query";
|
||||
|
||||
/// A minute-aligned instant, so a window derived from it lands on round
|
||||
/// numbers the assertions below can name.
|
||||
const aligned_now: i64 = 1_699_999_980;
|
||||
|
||||
test "the window sums the minutes inside it and nothing outside" {
|
||||
var threaded: std.Io.Threaded = .init(testing.allocator, .{});
|
||||
defer threaded.deinit();
|
||||
const io = threaded.io();
|
||||
|
||||
var entries = [_]pool_mod.Entry{
|
||||
testEntry("https://a.test/dns-query", true),
|
||||
testEntry("https://b.test/dns-query", false),
|
||||
};
|
||||
var database = try openLog();
|
||||
defer database.close();
|
||||
|
||||
const span = stats.window(.@"1h", aligned_now);
|
||||
try upstream_history_repo.flush(&database, &.{
|
||||
// One minute before the window.
|
||||
.{ .url = url_a, .minute_ts = span.since - 60, .successes = 100, .failures = 100, .last_failure_ts = span.since - 30, .last_error = "Outside" },
|
||||
.{ .url = url_a, .minute_ts = span.since, .successes = 3, .failures = 1, .last_failure_ts = span.since + 10, .last_error = "Timeout" },
|
||||
.{ .url = url_a, .minute_ts = span.until - 60, .successes = 5, .failures = 0, .last_failure_ts = null, .last_error = "" },
|
||||
// The window's exclusive end.
|
||||
.{ .url = url_a, .minute_ts = span.until, .successes = 200, .failures = 200, .last_failure_ts = span.until + 5, .last_error = "After" },
|
||||
});
|
||||
|
||||
var entries = [_]pool_mod.Entry{testEntry(url_a, true)};
|
||||
var pool = testPool(&entries);
|
||||
|
||||
var arena: std.heap.ArenaAllocator = .init(testing.allocator);
|
||||
defer arena.deinit();
|
||||
|
||||
const body = try collect(&pool, io, arena.allocator());
|
||||
try testing.expectEqual(@as(u32, 2), body.total);
|
||||
const body = try collect(arena.allocator(), io, &pool, null, &database, .@"1h", aligned_now);
|
||||
try testing.expectEqualStrings("1h", body.period);
|
||||
try testing.expectEqual(span.since, body.since);
|
||||
try testing.expectEqual(span.until, body.until);
|
||||
try testing.expectEqual(@as(u32, 1), body.total);
|
||||
try testing.expectEqual(@as(u32, 1), body.available);
|
||||
|
||||
const period = body.upstreams[0].period;
|
||||
try testing.expectEqual(@as(u64, 8), period.successes);
|
||||
try testing.expectEqual(@as(u64, 1), period.failures);
|
||||
try testing.expectEqual(@as(u64, 9), period.attempts);
|
||||
try testing.expectEqual(@as(?i64, span.since + 10), period.last_failure_at);
|
||||
try testing.expectEqualStrings("Timeout", period.last_failure_error.?);
|
||||
}
|
||||
|
||||
test "an upstream with no attempts in the window reports null, never a perfect rate" {
|
||||
var threaded: std.Io.Threaded = .init(testing.allocator, .{});
|
||||
defer threaded.deinit();
|
||||
const io = threaded.io();
|
||||
|
||||
var database = try openLog();
|
||||
defer database.close();
|
||||
|
||||
const span = stats.window(.@"1h", aligned_now);
|
||||
// Only `b` has history, and only outside the window.
|
||||
try upstream_history_repo.flush(&database, &.{
|
||||
.{ .url = url_b, .minute_ts = span.since - 600, .successes = 4, .failures = 0, .last_failure_ts = null, .last_error = "" },
|
||||
});
|
||||
|
||||
var entries = [_]pool_mod.Entry{ testEntry(url_a, true), testEntry(url_b, true) };
|
||||
var pool = testPool(&entries);
|
||||
|
||||
var arena: std.heap.ArenaAllocator = .init(testing.allocator);
|
||||
defer arena.deinit();
|
||||
|
||||
const body = try collect(arena.allocator(), io, &pool, null, &database, .@"1h", aligned_now);
|
||||
for (body.upstreams) |upstream| {
|
||||
try testing.expectEqual(@as(u64, 0), upstream.period.attempts);
|
||||
try testing.expectEqual(@as(u64, 0), upstream.period.successes);
|
||||
try testing.expectEqual(@as(u64, 0), upstream.period.failures);
|
||||
try testing.expectEqual(@as(?f32, null), upstream.period.success_rate);
|
||||
try testing.expectEqual(@as(?i64, null), upstream.period.last_failure_at);
|
||||
try testing.expectEqual(@as(?[]const u8, null), upstream.period.last_failure_error);
|
||||
}
|
||||
}
|
||||
|
||||
test "the success rate is the window's own, not a lifetime one" {
|
||||
var threaded: std.Io.Threaded = .init(testing.allocator, .{});
|
||||
defer threaded.deinit();
|
||||
const io = threaded.io();
|
||||
|
||||
var database = try openLog();
|
||||
defer database.close();
|
||||
|
||||
const span = stats.window(.@"1h", aligned_now);
|
||||
try upstream_history_repo.flush(&database, &.{
|
||||
// A clean past that a lifetime rate would average into the window.
|
||||
.{ .url = url_a, .minute_ts = span.since - 600, .successes = 1000, .failures = 0, .last_failure_ts = null, .last_error = "" },
|
||||
.{ .url = url_a, .minute_ts = span.since, .successes = 1, .failures = 3, .last_failure_ts = span.since + 1, .last_error = "Timeout" },
|
||||
});
|
||||
|
||||
var entries = [_]pool_mod.Entry{testEntry(url_a, true)};
|
||||
var pool = testPool(&entries);
|
||||
|
||||
var arena: std.heap.ArenaAllocator = .init(testing.allocator);
|
||||
defer arena.deinit();
|
||||
|
||||
const body = try collect(arena.allocator(), io, &pool, null, &database, .@"1h", aligned_now);
|
||||
try testing.expectEqual(@as(?f32, 0.25), body.upstreams[0].period.success_rate);
|
||||
}
|
||||
|
||||
test "the newest failure inside the window wins over an older one outside it" {
|
||||
var threaded: std.Io.Threaded = .init(testing.allocator, .{});
|
||||
defer threaded.deinit();
|
||||
const io = threaded.io();
|
||||
|
||||
var database = try openLog();
|
||||
defer database.close();
|
||||
|
||||
const span = stats.window(.@"1h", aligned_now);
|
||||
try upstream_history_repo.flush(&database, &.{
|
||||
.{ .url = url_a, .minute_ts = span.since - 120, .successes = 0, .failures = 1, .last_failure_ts = span.since - 100, .last_error = "Older" },
|
||||
.{ .url = url_a, .minute_ts = span.since, .successes = 0, .failures = 1, .last_failure_ts = span.since + 5, .last_error = "Newer" },
|
||||
// A later minute with no failure at all must not blank the error.
|
||||
.{ .url = url_a, .minute_ts = span.since + 60, .successes = 2, .failures = 0, .last_failure_ts = null, .last_error = "" },
|
||||
});
|
||||
|
||||
var entries = [_]pool_mod.Entry{testEntry(url_a, true)};
|
||||
var pool = testPool(&entries);
|
||||
|
||||
var arena: std.heap.ArenaAllocator = .init(testing.allocator);
|
||||
defer arena.deinit();
|
||||
|
||||
const body = try collect(arena.allocator(), io, &pool, null, &database, .@"1h", aligned_now);
|
||||
try testing.expectEqual(@as(?i64, span.since + 5), body.upstreams[0].period.last_failure_at);
|
||||
try testing.expectEqualStrings("Newer", body.upstreams[0].period.last_failure_error.?);
|
||||
}
|
||||
|
||||
test "two upstreams keep their own last-failure errors" {
|
||||
// The by-value `WindowStats` buffer is reused per iteration, so a response
|
||||
// that borrowed it would show the second upstream's error on the first, or
|
||||
// point at stack storage that is gone by the time it is serialized.
|
||||
var threaded: std.Io.Threaded = .init(testing.allocator, .{});
|
||||
defer threaded.deinit();
|
||||
const io = threaded.io();
|
||||
|
||||
var database = try openLog();
|
||||
defer database.close();
|
||||
|
||||
const span = stats.window(.@"1h", aligned_now);
|
||||
try upstream_history_repo.flush(&database, &.{
|
||||
.{ .url = url_a, .minute_ts = span.since, .successes = 1, .failures = 1, .last_failure_ts = span.since + 1, .last_error = "ConnectFailed" },
|
||||
.{ .url = url_b, .minute_ts = span.since, .successes = 0, .failures = 2, .last_failure_ts = span.since + 2, .last_error = "TlsHandshakeFailed" },
|
||||
});
|
||||
|
||||
var entries = [_]pool_mod.Entry{ testEntry(url_a, true), testEntry(url_b, true) };
|
||||
var pool = testPool(&entries);
|
||||
|
||||
var arena: std.heap.ArenaAllocator = .init(testing.allocator);
|
||||
defer arena.deinit();
|
||||
|
||||
const body = try collect(arena.allocator(), io, &pool, null, &database, .@"1h", aligned_now);
|
||||
try testing.expectEqual(@as(usize, 2), body.upstreams.len);
|
||||
try testing.expectEqualStrings("https://a.test/dns-query", body.upstreams[0].url);
|
||||
try testing.expect(body.upstreams[0].enabled);
|
||||
try testing.expect(body.upstreams[0].available);
|
||||
try testing.expectEqualStrings(url_a, body.upstreams[0].url);
|
||||
try testing.expectEqualStrings("ConnectFailed", body.upstreams[0].period.last_failure_error.?);
|
||||
try testing.expectEqualStrings(url_b, body.upstreams[1].url);
|
||||
try testing.expectEqualStrings("TlsHandshakeFailed", body.upstreams[1].period.last_failure_error.?);
|
||||
|
||||
// Serializing after every row is read is what a real response does; the
|
||||
// texts must still be the ones their own rows carried.
|
||||
var allocating: std.Io.Writer.Allocating = .init(testing.allocator);
|
||||
defer allocating.deinit();
|
||||
try std.json.Stringify.value(body, .{}, &allocating.writer);
|
||||
const text = allocating.written();
|
||||
try testing.expect(std.mem.containsAtLeast(u8, text, 1, "\"last_failure_error\":\"ConnectFailed\""));
|
||||
try testing.expect(std.mem.containsAtLeast(u8, text, 1, "\"last_failure_error\":\"TlsHandshakeFailed\""));
|
||||
}
|
||||
|
||||
test "a disabled upstream is not counted available and still gets its window" {
|
||||
var threaded: std.Io.Threaded = .init(testing.allocator, .{});
|
||||
defer threaded.deinit();
|
||||
const io = threaded.io();
|
||||
|
||||
var database = try openLog();
|
||||
defer database.close();
|
||||
|
||||
const span = stats.window(.@"24h", aligned_now);
|
||||
try upstream_history_repo.flush(&database, &.{
|
||||
.{ .url = url_b, .minute_ts = span.since, .successes = 2, .failures = 0, .last_failure_ts = null, .last_error = "" },
|
||||
});
|
||||
|
||||
var entries = [_]pool_mod.Entry{ testEntry(url_a, true), testEntry(url_b, false) };
|
||||
var pool = testPool(&entries);
|
||||
|
||||
var arena: std.heap.ArenaAllocator = .init(testing.allocator);
|
||||
defer arena.deinit();
|
||||
|
||||
const body = try collect(arena.allocator(), io, &pool, null, &database, .@"24h", aligned_now);
|
||||
try testing.expectEqual(@as(u32, 2), body.total);
|
||||
try testing.expectEqual(@as(u32, 1), body.available);
|
||||
try testing.expect(!body.upstreams[1].enabled);
|
||||
try testing.expect(!body.upstreams[1].available);
|
||||
// A disabled upstream is not available, so it is not counted.
|
||||
try testing.expectEqual(@as(u32, 1), body.available);
|
||||
try testing.expectEqualStrings("", body.upstreams[0].last_error);
|
||||
try testing.expectEqual(@as(u64, 2), body.upstreams[1].period.attempts);
|
||||
}
|
||||
|
||||
test "the copied strings survive the entry they came from" {
|
||||
/// Fills the accumulator and then overflows it, so `last_drop_minute` is
|
||||
/// `minute` — the only way to set it, because the accumulator's fields are
|
||||
/// private to its module and `snapshotStats` is the read surface.
|
||||
fn accumulatorDroppingAt(
|
||||
io: std.Io,
|
||||
minute: i64,
|
||||
names: *[history_mod.max_pending][8]u8,
|
||||
) !*history_mod.Accumulator {
|
||||
const accumulator = try testing.allocator.create(history_mod.Accumulator);
|
||||
accumulator.* = .init;
|
||||
for (names, 0..) |*name, i| {
|
||||
const url = std.fmt.bufPrint(name, "u{d:0>6}", .{i}) catch unreachable;
|
||||
accumulator.recordSuccess(io, url, minute);
|
||||
}
|
||||
// One more cell than capacity: the oldest minute goes, and every cell above
|
||||
// holds `minute`.
|
||||
accumulator.recordSuccess(io, "https://overflow.test", minute + 60);
|
||||
return accumulator;
|
||||
}
|
||||
|
||||
test "complete is false only while a dropped minute falls inside the window" {
|
||||
var threaded: std.Io.Threaded = .init(testing.allocator, .{});
|
||||
defer threaded.deinit();
|
||||
const io = threaded.io();
|
||||
|
||||
var entries = [_]pool_mod.Entry{testEntry("https://a.test/dns-query", true)};
|
||||
var pool = testPool(&entries);
|
||||
var database = try openLog();
|
||||
defer database.close();
|
||||
|
||||
const at = std.Io.Clock.awake.now(io);
|
||||
entries[0].health.recordFailure(at, "ConnectFailed", .{}, 0);
|
||||
var entries = [_]pool_mod.Entry{testEntry(url_a, true)};
|
||||
var pool = testPool(&entries);
|
||||
|
||||
var arena: std.heap.ArenaAllocator = .init(testing.allocator);
|
||||
defer arena.deinit();
|
||||
const body = try collect(&pool, io, arena.allocator());
|
||||
try testing.expectEqualStrings("ConnectFailed", body.upstreams[0].last_error);
|
||||
|
||||
// The entry rewrites its buffer; the copy must not change with it.
|
||||
entries[0].health.recordFailure(at, "Timeout", .{}, 0);
|
||||
try testing.expectEqualStrings("ConnectFailed", body.upstreams[0].last_error);
|
||||
// Two `now`s one minute apart, so the same drop is inside the first
|
||||
// window and one minute before the second.
|
||||
const inside_now = aligned_now;
|
||||
const inside = stats.window(.@"1h", inside_now);
|
||||
const after = stats.window(.@"1h", inside_now + 60);
|
||||
try testing.expectEqual(inside.since + 60, after.since);
|
||||
|
||||
var names: [history_mod.max_pending][8]u8 = undefined;
|
||||
const accumulator = try accumulatorDroppingAt(io, inside.since, &names);
|
||||
defer testing.allocator.destroy(accumulator);
|
||||
try testing.expectEqual(@as(?i64, inside.since), accumulator.snapshotStats(io).last_drop_minute);
|
||||
|
||||
const flagged = try collect(arena.allocator(), io, &pool, accumulator, &database, .@"1h", inside_now);
|
||||
try testing.expect(!flagged.complete);
|
||||
|
||||
const recovered = try collect(arena.allocator(), io, &pool, accumulator, &database, .@"1h", inside_now + 60);
|
||||
try testing.expect(recovered.complete);
|
||||
|
||||
// No accumulator at all is no known drop, not an incomplete window.
|
||||
const unwired = try collect(arena.allocator(), io, &pool, null, &database, .@"1h", inside_now);
|
||||
try testing.expect(unwired.complete);
|
||||
}
|
||||
|
||||
test "the body serializes with snake_case field names" {
|
||||
const upstreams = [_]Upstream{.{
|
||||
.url = "https://a.test/dns-query",
|
||||
test "a drop with no overflow leaves every window complete" {
|
||||
var threaded: std.Io.Threaded = .init(testing.allocator, .{});
|
||||
defer threaded.deinit();
|
||||
const io = threaded.io();
|
||||
|
||||
var database = try openLog();
|
||||
defer database.close();
|
||||
|
||||
var entries = [_]pool_mod.Entry{testEntry(url_a, true)};
|
||||
var pool = testPool(&entries);
|
||||
|
||||
const accumulator = try testing.allocator.create(history_mod.Accumulator);
|
||||
defer testing.allocator.destroy(accumulator);
|
||||
accumulator.* = .init;
|
||||
accumulator.recordFailure(io, url_a, aligned_now, "Timeout");
|
||||
|
||||
var arena: std.heap.ArenaAllocator = .init(testing.allocator);
|
||||
defer arena.deinit();
|
||||
|
||||
const body = try collect(arena.allocator(), io, &pool, accumulator, &database, .@"1h", aligned_now);
|
||||
try testing.expect(body.complete);
|
||||
}
|
||||
|
||||
test "the route's period grammar and its 400 text are the ones /api/stats serves" {
|
||||
// The picker scopes the whole page, so one bad spelling must mean the same
|
||||
// thing on every route it drives.
|
||||
try testing.expectEqual(stats.default_period, try stats.periodParam(""));
|
||||
try testing.expectEqual(stats.Period.@"24h", try stats.periodParam(""));
|
||||
try testing.expectEqual(stats.Period.@"7d", try stats.periodParam("period=7d"));
|
||||
try testing.expectError(error.BadPeriod, stats.periodParam("period=12h"));
|
||||
try testing.expectError(error.BadPeriod, stats.periodParam("period=1hhhhhhhhhh"));
|
||||
try testing.expectEqualStrings("period must be one of 1h, 24h, 7d, 30d", bad_period_message);
|
||||
}
|
||||
|
||||
test "every period the grammar accepts produces the window that period names" {
|
||||
var threaded: std.Io.Threaded = .init(testing.allocator, .{});
|
||||
defer threaded.deinit();
|
||||
const io = threaded.io();
|
||||
|
||||
var database = try openLog();
|
||||
defer database.close();
|
||||
|
||||
var entries = [_]pool_mod.Entry{testEntry(url_a, true)};
|
||||
var pool = testPool(&entries);
|
||||
|
||||
var arena: std.heap.ArenaAllocator = .init(testing.allocator);
|
||||
defer arena.deinit();
|
||||
|
||||
for (std.enums.values(stats.Period)) |period| {
|
||||
const span = stats.window(period, aligned_now);
|
||||
const body = try collect(arena.allocator(), io, &pool, null, &database, period, aligned_now);
|
||||
try testing.expectEqualStrings(period.label(), body.period);
|
||||
try testing.expectEqual(span.since, body.since);
|
||||
try testing.expectEqual(span.until, body.until);
|
||||
}
|
||||
}
|
||||
|
||||
test "the body serializes exactly the ranged field set" {
|
||||
const upstreams = [_]Upstream{ .{
|
||||
.url = url_a,
|
||||
.enabled = true,
|
||||
.available = false,
|
||||
.consecutive_failures = 3,
|
||||
.total_successes = 10,
|
||||
.total_failures = 4,
|
||||
.success_rate = 0.5,
|
||||
.last_error = "ConnectFailed",
|
||||
}};
|
||||
.period = .{
|
||||
.attempts = 8,
|
||||
.successes = 6,
|
||||
.failures = 2,
|
||||
.success_rate = 0.75,
|
||||
.last_failure_at = 1_700_000_000,
|
||||
.last_failure_error = "ConnectFailed",
|
||||
},
|
||||
}, .{
|
||||
.url = url_b,
|
||||
.enabled = false,
|
||||
.available = false,
|
||||
.period = .{
|
||||
.attempts = 0,
|
||||
.successes = 0,
|
||||
.failures = 0,
|
||||
.success_rate = null,
|
||||
.last_failure_at = null,
|
||||
.last_failure_error = null,
|
||||
},
|
||||
} };
|
||||
|
||||
var allocating: std.Io.Writer.Allocating = .init(testing.allocator);
|
||||
defer allocating.deinit();
|
||||
try std.json.Stringify.value(
|
||||
Body{ .upstreams = &upstreams, .available = 0, .total = 1 },
|
||||
.{},
|
||||
&allocating.writer,
|
||||
);
|
||||
const text = allocating.written();
|
||||
try std.json.Stringify.value(Body{
|
||||
.period = "1h",
|
||||
.since = 1_699_996_400,
|
||||
.until = 1_700_000_000,
|
||||
.available = 0,
|
||||
.total = 2,
|
||||
.complete = true,
|
||||
.upstreams = &upstreams,
|
||||
}, .{}, &allocating.writer);
|
||||
|
||||
try testing.expectEqualStrings(
|
||||
\\{"period":"1h","since":1699996400,"until":1700000000,"available":0,"total":2,"complete":true,"upstreams":[{"url":"https://a.test/dns-query","enabled":true,"available":false,"period":{"attempts":8,"successes":6,"failures":2,"success_rate":0.75,"last_failure_at":1700000000,"last_failure_error":"ConnectFailed"}},{"url":"https://b.test/dns-query","enabled":false,"available":false,"period":{"attempts":0,"successes":0,"failures":0,"success_rate":null,"last_failure_at":null,"last_failure_error":null}}]}
|
||||
, allocating.written());
|
||||
|
||||
// The lifetime fields m26 removed. They still exist in `health.State` and in
|
||||
// `/metrics`; a client of this route must not find them here and start
|
||||
// reading them as if they were scoped to the period.
|
||||
for ([_][]const u8{
|
||||
"\"consecutive_failures\":3",
|
||||
"\"total_successes\":10",
|
||||
"\"total_failures\":4",
|
||||
"\"last_error\":\"ConnectFailed\"",
|
||||
"\"available\":0",
|
||||
"\"total\":1",
|
||||
}) |fragment| {
|
||||
try testing.expect(std.mem.containsAtLeast(u8, text, 1, fragment));
|
||||
"consecutive_failures",
|
||||
"total_successes",
|
||||
"total_failures",
|
||||
"last_error_age_s",
|
||||
"\"last_error\"",
|
||||
}) |gone| {
|
||||
try testing.expect(!std.mem.containsAtLeast(u8, allocating.written(), 1, gone));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -30,6 +30,7 @@ const dns_cache = @import("../cache/dns_cache.zig");
|
||||
const dns_handler = @import("../server/handler.zig");
|
||||
const disk_monitor = @import("../storage/disk_monitor.zig");
|
||||
const dot_server = @import("../server/dot_server.zig");
|
||||
const history_mod = @import("../upstream/history.zig");
|
||||
const http_util = @import("http_util.zig");
|
||||
const logging = @import("../platform/logging.zig");
|
||||
const pool_mod = @import("../upstream/pool.zig");
|
||||
@@ -125,6 +126,9 @@ pub const Sample = struct {
|
||||
tracker: ?TrackerSample = null,
|
||||
client_names: ?client_names.Resolver.Stats = null,
|
||||
retention: ?retention_mod.Stats = null,
|
||||
/// The upstream-history flush loop's counters (m26 ruling 7). Absent while
|
||||
/// no accumulator is wired, like every other collaborator.
|
||||
history: ?history_mod.Accumulator.Stats = null,
|
||||
blocklist: ?BlocklistSample = null,
|
||||
disk: ?DiskSample = null,
|
||||
/// One entry per enabled TLS endpoint (milestone-10 ruling 10). Rendered
|
||||
@@ -199,6 +203,8 @@ pub fn collect(state: *server.WebState, io: std.Io, arena: Allocator) Allocator.
|
||||
|
||||
if (state.retention) |retention| sample.retention = retention.snapshotStats();
|
||||
|
||||
if (state.history) |history| sample.history = history.snapshotStats(io);
|
||||
|
||||
if (state.manager) |manager| {
|
||||
const generation: ?u64 = if (manager.acquire(io)) |acquired| gen: {
|
||||
defer acquired.release(io);
|
||||
@@ -352,6 +358,36 @@ pub fn render(w: *std.Io.Writer, sample: Sample) std.Io.Writer.Error!void {
|
||||
try counterGroup(w, "nxdns_retention_", "Query log retention counter", retention);
|
||||
}
|
||||
|
||||
if (sample.history) |history| {
|
||||
// Written out rather than reflected over `Accumulator.Stats`: three of
|
||||
// its fields are counters, one is a gauge, and two — the drop watermark
|
||||
// and the current flush state — are not exposition numbers at all.
|
||||
try counter(
|
||||
w,
|
||||
"nxdns_upstream_history_flushes_total",
|
||||
"Upstream history flush transactions that committed.",
|
||||
history.flushes,
|
||||
);
|
||||
try counter(
|
||||
w,
|
||||
"nxdns_upstream_history_flush_failures_total",
|
||||
"Upstream history flush attempts that failed; the rows are retried on the next pass.",
|
||||
history.flush_failures,
|
||||
);
|
||||
try counter(
|
||||
w,
|
||||
"nxdns_upstream_history_rows_dropped_total",
|
||||
"Upstream history minutes dropped because the accumulator was full.",
|
||||
history.rows_dropped,
|
||||
);
|
||||
try gauge(
|
||||
w,
|
||||
"nxdns_upstream_history_pending",
|
||||
"Upstream history minutes recorded but not yet flushed.",
|
||||
history.pending,
|
||||
);
|
||||
}
|
||||
|
||||
if (sample.blocklist) |blocklist| {
|
||||
try counter(
|
||||
w,
|
||||
@@ -720,6 +756,31 @@ test "a full sample renders the whole exposition, byte for byte" {
|
||||
));
|
||||
}
|
||||
|
||||
test "the upstream-history family renders three counters and one gauge" {
|
||||
const text = try renderToString(testing.allocator, .{
|
||||
.history = .{
|
||||
.flushes = 12,
|
||||
.flush_failures = 2,
|
||||
.rows_dropped = 5,
|
||||
.pending = 3,
|
||||
.last_drop_minute = 1_700_000_040,
|
||||
.last_flush_failed = true,
|
||||
},
|
||||
});
|
||||
defer testing.allocator.free(text);
|
||||
|
||||
try testing.expect(std.mem.containsAtLeast(u8, text, 1, "nxdns_upstream_history_flushes_total 12\n"));
|
||||
try testing.expect(std.mem.containsAtLeast(u8, text, 1, "nxdns_upstream_history_flush_failures_total 2\n"));
|
||||
try testing.expect(std.mem.containsAtLeast(u8, text, 1, "nxdns_upstream_history_rows_dropped_total 5\n"));
|
||||
try testing.expect(std.mem.containsAtLeast(u8, text, 1, "# TYPE nxdns_upstream_history_pending gauge\n"));
|
||||
try testing.expect(std.mem.containsAtLeast(u8, text, 1, "nxdns_upstream_history_pending 3\n"));
|
||||
|
||||
// No accumulator is an absent family, not a family of zeros.
|
||||
const bare = try renderToString(testing.allocator, .{});
|
||||
defer testing.allocator.free(bare);
|
||||
try testing.expect(!std.mem.containsAtLeast(u8, bare, 1, "nxdns_upstream_history_"));
|
||||
}
|
||||
|
||||
test "every HELP line has a TYPE line and a sample, and every sample a name" {
|
||||
const text = try renderToString(testing.allocator, .{});
|
||||
defer testing.allocator.free(text);
|
||||
|
||||
+69
-14
@@ -342,7 +342,15 @@ paths:
|
||||
|
||||
/api/upstream/health:
|
||||
get:
|
||||
summary: Upstream pool health
|
||||
summary: Upstream pool health for a period
|
||||
description: |
|
||||
Each upstream's live routing state beside its recorded outcomes over
|
||||
the period's window, which is the same UTC-aligned window `/api/stats`
|
||||
reports for that period. The outcome counts come from per-minute
|
||||
history in the query log, not from process-lifetime counters, so they
|
||||
scope to the period and survive a restart.
|
||||
parameters:
|
||||
- $ref: "#/components/parameters/Period"
|
||||
responses:
|
||||
"200":
|
||||
description: Per-upstream state and the availability rollup.
|
||||
@@ -350,10 +358,14 @@ paths:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/UpstreamHealth"
|
||||
"400":
|
||||
$ref: "#/components/responses/BadRequest"
|
||||
"401":
|
||||
$ref: "#/components/responses/Unauthorized"
|
||||
"429":
|
||||
$ref: "#/components/responses/RateLimited"
|
||||
"500":
|
||||
$ref: "#/components/responses/Internal"
|
||||
"503":
|
||||
$ref: "#/components/responses/Unavailable"
|
||||
|
||||
@@ -1826,28 +1838,71 @@ components:
|
||||
type: string
|
||||
nullable: true
|
||||
|
||||
UpstreamPeriodStats:
|
||||
type: object
|
||||
required: [attempts, successes, failures, success_rate, last_failure_at, last_failure_error]
|
||||
properties:
|
||||
attempts:
|
||||
type: integer
|
||||
description: Exchanges recorded against this upstream inside the window.
|
||||
successes: { type: integer }
|
||||
failures: { type: integer }
|
||||
success_rate:
|
||||
type: number
|
||||
nullable: true
|
||||
description: >
|
||||
`successes / attempts`, from 0 to 1. Null when `attempts` is 0: no
|
||||
observations is not perfect reliability.
|
||||
last_failure_at:
|
||||
type: integer
|
||||
nullable: true
|
||||
description: >
|
||||
The newest failure inside the window, unix seconds. Null when the
|
||||
window holds no failure, even if the upstream failed before it.
|
||||
last_failure_error:
|
||||
type: string
|
||||
nullable: true
|
||||
description: The error name belonging to `last_failure_at`; null exactly when it is.
|
||||
|
||||
UpstreamHealth:
|
||||
type: object
|
||||
required: [upstreams, available, total]
|
||||
required: [period, since, until, available, total, complete, upstreams]
|
||||
properties:
|
||||
period:
|
||||
type: string
|
||||
enum: [1h, 24h, 7d, 30d]
|
||||
since:
|
||||
type: integer
|
||||
description: Window start, unix seconds, inclusive.
|
||||
until:
|
||||
type: integer
|
||||
description: Window end, unix seconds, exclusive.
|
||||
available:
|
||||
type: integer
|
||||
description: How many upstreams the pool would route to right now.
|
||||
total: { type: integer }
|
||||
complete:
|
||||
type: boolean
|
||||
description: >
|
||||
No capacity drops known in this process within the selected window;
|
||||
up to about a minute of the newest outcomes may not have flushed
|
||||
yet, and outcomes lost in an unclean shutdown are not detectable.
|
||||
upstreams:
|
||||
type: array
|
||||
description: The upstreams configured now; a deleted upstream's history is not returned.
|
||||
items:
|
||||
type: object
|
||||
required: [url, enabled, available, consecutive_failures, total_successes, total_failures, success_rate, last_error]
|
||||
required: [url, enabled, available, period]
|
||||
properties:
|
||||
url: { type: string }
|
||||
enabled: { type: boolean }
|
||||
available: { type: boolean }
|
||||
consecutive_failures: { type: integer }
|
||||
total_successes: { type: integer }
|
||||
total_failures: { type: integer }
|
||||
success_rate: { type: number }
|
||||
last_error:
|
||||
type: string
|
||||
description: Empty when the upstream never failed.
|
||||
available: { type: integer }
|
||||
total: { type: integer }
|
||||
enabled:
|
||||
type: boolean
|
||||
description: Live configuration, not history.
|
||||
available:
|
||||
type: boolean
|
||||
description: Live state, not history; false while the upstream is backing off.
|
||||
period:
|
||||
$ref: "#/components/schemas/UpstreamPeriodStats"
|
||||
|
||||
Group:
|
||||
type: object
|
||||
|
||||
@@ -39,6 +39,7 @@ const logger_mod = @import("../storage/logger.zig");
|
||||
const manager_mod = @import("../filter/manager.zig");
|
||||
const model = @import("../config/model.zig");
|
||||
const pause_mod = @import("../server/pause.zig");
|
||||
const history_mod = @import("../upstream/history.zig");
|
||||
const pool_mod = @import("../upstream/pool.zig");
|
||||
const query_sink = @import("../server/query_sink.zig");
|
||||
const retention_mod = @import("../storage/retention.zig");
|
||||
@@ -135,6 +136,10 @@ pub const WebState = struct {
|
||||
client_names: ?*client_names.Resolver = null,
|
||||
manager: ?*manager_mod.Manager = null,
|
||||
pool: ?*pool_mod.Pool = null,
|
||||
/// The upstream-outcome accumulator, for `metrics.collect` and the
|
||||
/// `/api/health` rollup (m26 ruling 7). The ranged endpoint reads the
|
||||
/// flushed rows through `querylog_db`, not through this.
|
||||
history: ?*history_mod.Accumulator = null,
|
||||
monitor: ?*disk_monitor.Monitor = null,
|
||||
/// The local records and forward zones the DNS path reads. The
|
||||
/// local-records and forward-zones handlers rebuild and swap them
|
||||
|
||||
Reference in New Issue
Block a user