milestone 27: diagnostics — operational failures land in one curated log, resolved history purgeable

src/web/web_integration_test.zig

@@ -31,6 +31,7 @@ const auth = @import("auth.zig");
 const clients_repo = @import("../storage/repositories/clients_repo.zig");
 const db = @import("../storage/db.zig");
 const dns_handler = @import("../server/handler.zig");
+const events_mod = @import("../storage/events.zig");
 const fetcher = @import("../filter/fetcher.zig");
 const groups_repo = @import("../storage/repositories/groups_repo.zig");
 const header = @import("../dns/header.zig");
@@ -58,6 +59,7 @@ const upstreams_repo = @import("../storage/repositories/upstreams_repo.zig");
 
 const handlers_blocklists = @import("handlers/blocklists.zig");
 const handlers_certs = @import("handlers/certs.zig");
+const handlers_diagnostics = @import("handlers/diagnostics.zig");
 const handlers_health = @import("handlers/health.zig");
 const handlers_live = @import("handlers/live.zig");
 const handlers_lookup = @import("handlers/lookup.zig");
@@ -277,6 +279,10 @@ const Env = struct {
     tmp: testing.TmpDir,
     config_db: db.Db,
     querylog_db: db.Db,
+    /// The diagnostics store's own connection, as in production: the store
+    /// serializes every access through its mutex and shares it with nobody.
+    events_db: db.Db,
+    events_store: events_mod.Store,
     http_client: std.http.Client,
     transfer_buf: [fetcher.min_transfer_buf]u8,
     redirect_buf: [fetcher.redirect_buffer_len]u8,
@@ -317,6 +323,13 @@ const Env = struct {
         try self.querylog_db.exec(querylog_schema.ddl);
         try seedQueryLog(&self.querylog_db);
 
+        self.events_db = try db.Db.open(":memory:", .{ .mode = .memory });
+        errdefer self.events_db.close();
+        try db.applyPragmas(&self.events_db, .{});
+        _ = try migrations.migrate(&self.events_db);
+        self.events_store = try events_mod.Store.init(ioh, &self.events_db, seeded_now);
+        seedEvents(ioh, &self.events_store);
+
         // Real fetcher wiring; nothing in this suite downloads (the one
         // refreshAll in the contract walk runs with zero source rows).
         self.http_client = .{ .allocator = gpa, .io = ioh };
@@ -388,6 +401,7 @@ const Env = struct {
             .hub = self.hub,
             .config_db = &self.config_db,
             .querylog_db = &self.querylog_db,
+            .events = &self.events_store,
             .version = "w10-test",
             .started_unix = std.Io.Clock.real.now(ioh).toSeconds(),
             .fallback = options.fallback,
@@ -419,6 +433,7 @@ const Env = struct {
         self.limiter.deinit();
         self.mgr.deinit(ioh);
         self.http_client.deinit();
+        self.events_db.close();
         self.querylog_db.close();
         self.config_db.close();
         self.tmp.cleanup();
@@ -480,6 +495,21 @@ fn seedQueryLog(database: *db.Db) !void {
     }
 }
 
+/// A fixed instant, like every other seeded timestamp here: the contract
+/// samples are byte-compared, so nothing the walk writes may come from a clock.
+const seeded_now: i64 = 1_787_118_000;
+
+/// One active episode and one resolved one, so `/api/diagnostics` answers with
+/// both states and the committed contract sample describes a real page rather
+/// than an empty one.
+fn seedEvents(io: std.Io, store: *events_mod.Store) void {
+    store.report(io, seeded_now, .blocklist_refresh, "https://lists.example/ads.txt", "StevenBlack", .warning, "download failed: ConnectionTimedOut");
+    store.report(io, seeded_now + 300, .blocklist_refresh, "https://lists.example/ads.txt", "StevenBlack", .warning, "download failed: ConnectionTimedOut");
+
+    store.report(io, seeded_now + 60, .upstream_history_write, "history", "history", .warning, "Busy");
+    store.resolve(io, seeded_now + 120, .upstream_history_write, "history");
+}
+
 // ---------------------------------------------------------------------------
 // the contract table (ruling 23)
 // ---------------------------------------------------------------------------
@@ -627,6 +657,15 @@ const contract = [_]Contract{
     .{ .method = .GET, .pattern = "/api/stats/timeseries", .auth = .session, .policy = .read, .target = "/api/stats/timeseries?period=1h", .status = 200, .check = jsonShape(handlers_stats.TimeseriesBody) },
     .{ .method = .GET, .pattern = "/api/upstream/health", .auth = .session, .policy = .read, .target = "/api/upstream/health", .status = 200, .check = jsonShape(handlers_upstream_health.Body) },
 
+    // Diagnostics. The seeded store holds one active episode (id 1) and one
+    // resolved one, so both the page and the detail answer with real rows.
+    .{ .method = .GET, .pattern = "/api/diagnostics", .auth = .session, .policy = .read, .target = "/api/diagnostics?limit=10", .status = 200, .check = jsonShape(events_mod.EventsPage) },
+    .{ .method = .GET, .pattern = "/api/diagnostics/{id}", .auth = .session, .policy = .read, .target = "/api/diagnostics/1", .status = 200, .check = jsonShape(events_mod.Event) },
+    // The purges follow the reads: id 2 is the seeded resolved episode, and the
+    // sweep after it takes whatever resolved history is left (none).
+    .{ .method = .DELETE, .pattern = "/api/diagnostics/{id}", .auth = .session, .policy = .runtime_action, .target = "/api/diagnostics/2", .status = 204, .kind = .none },
+    .{ .method = .DELETE, .pattern = "/api/diagnostics", .auth = .session, .policy = .runtime_action, .target = "/api/diagnostics", .status = 200, .check = jsonShape(handlers_diagnostics.PurgeResult) },
+
     // Groups. The migrated schema seeds `default` as id 1; the POST creates
     // id 2, which the delete at the end of the walk removes.
     .{ .method = .GET, .pattern = "/api/groups", .auth = .session, .policy = .read, .target = "/api/groups", .status = 200, .check = jsonShape(GroupsList) },
@@ -1000,6 +1039,157 @@ fn fileModeClasses(io: std.Io, env: *Env) anyerror!void {
     try conn.request("POST", "/api/certs/reload", null, null);
     response = try conn.receive(&body_buf);
     try testing.expectEqual(@as(u16, 200), response.status);
+
+    // Diagnostics are runtime state, not configuration: purging resolved
+    // history is served under file authority like any other runtime action.
+    try conn.request("DELETE", "/api/diagnostics", null, null);
+    response = try conn.receive(&body_buf);
+    try testing.expectEqual(@as(u16, 200), response.status);
+    try testing.expectEqualStrings("{\"purged\":1}", response.body);
+
+    try conn.request("DELETE", "/api/diagnostics/1", null, null);
+    response = try conn.receive(&body_buf);
+    try testing.expectEqual(@as(u16, 409), response.status);
+}
+
+fn diagnosticsRejections(io: std.Io, env: *Env) anyerror!void {
+    var body_buf: [8192]u8 = undefined;
+    var conn: Conn = undefined;
+    try conn.connect(io, env.addr);
+    defer conn.close(io);
+
+    // Every bad parameter is a 400 whose message names the parameter, rather
+    // than a filter silently dropped — which would answer a question the client
+    // did not ask.
+    const bad = [_]struct { target: []const u8, needle: []const u8 }{
+        .{ .target = "/api/diagnostics?state=open", .needle = "state" },
+        .{ .target = "/api/diagnostics?severity=info", .needle = "severity" },
+        .{ .target = "/api/diagnostics?since=yesterday", .needle = "since" },
+        .{ .target = "/api/diagnostics?until=", .needle = "until" },
+        .{ .target = "/api/diagnostics?limit=0", .needle = "limit" },
+        .{ .target = "/api/diagnostics?limit=1001", .needle = "limit" },
+        .{ .target = "/api/diagnostics?before=0", .needle = "before" },
+    };
+    for (bad) |case| {
+        try conn.request("GET", case.target, null, null);
+        const response = try conn.receive(&body_buf);
+        errdefer std.debug.print("{s}: {d} {s}\n", .{ case.target, response.status, response.body });
+        try testing.expectEqual(@as(u16, 400), response.status);
+        try testing.expect(std.mem.containsAtLeast(u8, response.body, 1, case.needle));
+    }
+
+    // The resolved episode the seed left behind is reachable by id, and an id
+    // nothing holds is a 404 rather than an empty object.
+    try conn.request("GET", "/api/diagnostics?state=resolved", null, null);
+    var response = try conn.receive(&body_buf);
+    try testing.expectEqual(@as(u16, 200), response.status);
+    try testing.expect(std.mem.containsAtLeast(u8, response.body, 1, "upstream_history.write"));
+    try testing.expect(std.mem.containsAtLeast(u8, response.body, 1, "\"active\":{\"warnings\":1,\"errors\":0}"));
+
+    try conn.request("GET", "/api/diagnostics/999999", null, null);
+    response = try conn.receive(&body_buf);
+    try testing.expectEqual(@as(u16, 404), response.status);
+}
+
+fn diagnosticsPurge(io: std.Io, env: *Env) anyerror!void {
+    var body_buf: [8192]u8 = undefined;
+    var conn: Conn = undefined;
+    try conn.connect(io, env.addr);
+    defer conn.close(io);
+
+    // Row 1 is the seeded active episode: still the state of the box, so the
+    // purge is refused with a message that says what would change that.
+    try conn.request("DELETE", "/api/diagnostics/1", null, null);
+    var response = try conn.receive(&body_buf);
+    try testing.expectEqual(@as(u16, 409), response.status);
+    try testing.expect(std.mem.containsAtLeast(u8, response.body, 1, "still active"));
+
+    try conn.request("DELETE", "/api/diagnostics/999999", null, null);
+    response = try conn.receive(&body_buf);
+    try testing.expectEqual(@as(u16, 404), response.status);
+
+    // Row 2 is the seeded resolved episode.
+    try conn.request("DELETE", "/api/diagnostics/2", null, null);
+    response = try conn.receive(&body_buf);
+    try testing.expectEqual(@as(u16, 204), response.status);
+    try testing.expectEqualStrings("", response.body);
+
+    // Gone is a different answer from still open, even for a row that existed a
+    // moment ago.
+    try conn.request("DELETE", "/api/diagnostics/2", null, null);
+    response = try conn.receive(&body_buf);
+    try testing.expectEqual(@as(u16, 404), response.status);
+
+    // Nothing resolved is left, and the sweep says so rather than failing.
+    try conn.request("DELETE", "/api/diagnostics", null, null);
+    response = try conn.receive(&body_buf);
+    try testing.expectEqual(@as(u16, 200), response.status);
+    try testing.expectEqualStrings("{\"purged\":0}", response.body);
+
+    // The active episode survived every one of those, counts included.
+    try conn.request("GET", "/api/diagnostics", null, null);
+    response = try conn.receive(&body_buf);
+    try testing.expectEqual(@as(u16, 200), response.status);
+    try testing.expect(std.mem.containsAtLeast(u8, response.body, 1, "blocklist.refresh"));
+    try testing.expect(std.mem.containsAtLeast(u8, response.body, 1, "\"active\":{\"warnings\":1,\"errors\":0}"));
+    try testing.expect(!std.mem.containsAtLeast(u8, response.body, 1, "upstream_history.write"));
+}
+
+test "W10 milestone 27: a purge takes resolved events only, and says which of the three answers it gave" {
+    if (!build_options.integration) return error.SkipZigTest;
+
+    const gpa = testing.allocator;
+    var env = try Env.create(gpa, .{});
+    defer env.destroy();
+
+    try bounded(env.io(), default_budget, diagnosticsPurge, .{ env.io(), env });
+}
+
+fn diagnosticsPurgeAll(io: std.Io, env: *Env) anyerror!void {
+    var body_buf: [8192]u8 = undefined;
+    var conn: Conn = undefined;
+    try conn.connect(io, env.addr);
+    defer conn.close(io);
+
+    // A second resolved episode, so the count the sweep reports is a number it
+    // had to compute rather than the one row the seed leaves.
+    env.events_store.reportResolved(io, seeded_now, .query_log_recreated, "one-shot", "corrupt", .warning, "aside");
+
+    try conn.request("DELETE", "/api/diagnostics", null, null);
+    var response = try conn.receive(&body_buf);
+    try testing.expectEqual(@as(u16, 200), response.status);
+    try testing.expectEqualStrings("{\"purged\":2}", response.body);
+
+    try conn.request("GET", "/api/diagnostics?state=resolved", null, null);
+    response = try conn.receive(&body_buf);
+    try testing.expectEqual(@as(u16, 200), response.status);
+    try testing.expect(std.mem.containsAtLeast(u8, response.body, 1, "\"events\":[]"));
+
+    // And the episode that is still failing is untouched: the operator clearing
+    // the page cannot lose what is still true.
+    try conn.request("GET", "/api/diagnostics?state=active", null, null);
+    response = try conn.receive(&body_buf);
+    try testing.expect(std.mem.containsAtLeast(u8, response.body, 1, "blocklist.refresh"));
+}
+
+test "W10 milestone 27: purging all resolved events counts them and leaves the active ones" {
+    if (!build_options.integration) return error.SkipZigTest;
+
+    const gpa = testing.allocator;
+    var env = try Env.create(gpa, .{});
+    defer env.destroy();
+
+    try bounded(env.io(), default_budget, diagnosticsPurgeAll, .{ env.io(), env });
+}
+
+test "W10 milestone 27: every diagnostics filter names itself in a 400, and an unknown id is a 404" {
+    if (!build_options.integration) return error.SkipZigTest;
+
+    const gpa = testing.allocator;
+    var env = try Env.create(gpa, .{});
+    defer env.destroy();
+
+    try bounded(env.io(), default_budget, diagnosticsRejections, .{ env.io(), env });
 }
 
 test "W10 milestone 20: file authority rejects configuration writes and spares the rest" {
@@ -2197,6 +2387,15 @@ const contract_sample_walk = [_]ContractSample{
     .{ .name = "login", .ts_type = "LoginResponse", .method = "POST", .target = "/api/auth/login", .body = "{\"password\":\"\"}", .status = 200 },
     .{ .name = "logout", .ts_type = "LogoutResponse", .method = "POST", .target = "/api/auth/logout", .body = "{}", .status = 200 },
 
+    // Diagnostics, ahead of every write below: the seeded store holds one
+    // active episode (id 1) and one resolved one, and a later pass that
+    // reported an event of its own would move the page under the golden.
+    .{ .name = "get_diagnostics", .ts_type = "DiagnosticsPage", .method = "GET", .target = "/api/diagnostics?limit=10", .status = 200 },
+    .{ .name = "get_diagnostic", .ts_type = "DiagnosticEvent", .method = "GET", .target = "/api/diagnostics/1", .status = 200 },
+    // The sweep runs after both reads and takes the seeded resolved episode;
+    // the per-id purge answers 204, which has no body to sample.
+    .{ .name = "purge_diagnostics", .ts_type = "DiagnosticsPurge", .method = "DELETE", .target = "/api/diagnostics", .status = 200 },
+
     // Blocklists. The row is created disabled so the refresh below has a status
     // to report and still downloads nothing.
     .{ .name = "create_blocklist", .ts_type = "BlocklistEcho", .method = "POST", .target = "/api/blocklists", .body = "{\"url\":\"https://lists.example/ads.txt\",\"name\":\"ads\",\"enabled\":false}", .status = 201 },