const std = @import("std"); const Allocator = std.mem.Allocator; const runtime = @import("../runtime.zig"); const wap = @import("wap"); const db = @import("../db/sqlite.zig"); const uuid_util = @import("../utilities/uuid.zig"); const logging = @import("../logging.zig"); const broker = @import("../broker.zig"); const log_broadcaster = @import("../services/log_broadcaster.zig"); const auth_util = @import("auth.zig"); const text_search = @import("../utilities/text_search.zig"); pub const LOGS_TOPIC = "logs"; // ===== typed bodies ===== const LogCreate = struct { name: []const u8, message: []const u8, timestamp: []const u8, level: ?i64 = null, flow_run_id: ?[]const u8 = null, task_run_id: ?[]const u8 = null, }; const LogFilterBody = struct { limit: ?usize = null, offset: ?usize = null, sort: ?[]const u8 = null, logs: ?std.json.Value = null, }; fn sendJson(res: *wap.Response, body: []const u8) !void { _ = res.setHeader("content-type", "application/json") .setHeader("access-control-allow-origin", "*"); try res.sendBody(body); } fn sendError(res: *wap.Response, status: std.http.Status, detail: []const u8) !void { _ = res.setStatus(status); _ = res.setHeader("access-control-allow-origin", "*"); try res.writeJson(.{ .detail = detail }); } pub fn handle(req: *wap.Request, res: *wap.Response) !void { const target = req.path; const method = @tagName(req.method); // POST /logs/ - create logs (batch) if (std.mem.eql(u8, method, "POST")) { if (std.mem.endsWith(u8, target, "/filter")) { try filterLogs(req, res); } else { try createLogs(req, res); } } else { try sendJson(res, "[]"); } } fn createLogs(req: *wap.Request, res: *wap.Response) !void { const alloc = req.arena; // The /logs/ endpoint takes a JSON array of LogCreate objects. // parseJson(T) handles `[]const LogCreate` natively — std.json's array // decoding into a slice does the right thing. const logs: []const LogCreate = req.parseJson([]const LogCreate) catch |err| { logging.err("logs", "rejected payload fd={d} path={s} bytes={d} parse_error={}", .{ req.connection_fd, req.path, req.body.len, err }); return switch (err) { error.UnknownField => sendError(res, .unprocessable_entity, "unknown field in log entry"), else => sendError(res, .bad_request, "invalid logs payload"), }; }; var inserted: usize = 0; for (logs) |log_entry| { const level = log_entry.level orelse 20; var id_buf: [36]u8 = undefined; const id = uuid_util.generate(runtime.appIo(), &id_buf); db.logs.insert(id, log_entry.name, level, log_entry.message, log_entry.timestamp, log_entry.flow_run_id, log_entry.task_run_id) catch |err| { logging.err("logs", "insert error: {}", .{err}); continue; }; inserted += 1; // Publish to log_broadcaster topic. Dropped silently if no broker. if (broker.getBroker()) |b| { const owned_id = alloc.dupe(u8, id) catch continue; const log_json = formatLogJson(alloc, owned_id, log_entry.name, level, log_entry.message, log_entry.timestamp, log_entry.flow_run_id, log_entry.task_run_id) catch continue; b.publish(LOGS_TOPIC, owned_id, log_json) catch |err| { logging.warn("logs", "publish error: {}", .{err}); }; } } _ = res.setStatus(.created); try sendJson(res, "[]"); } fn formatLogJson( alloc: Allocator, id: []const u8, name: []const u8, level: i64, message: []const u8, timestamp: []const u8, flow_run_id: ?[]const u8, task_run_id: ?[]const u8, ) ![]const u8 { var out: std.Io.Writer.Allocating = .init(alloc); var jw: std.json.Stringify = .{ .writer = &out.writer }; try jw.beginObject(); try jw.objectField("id"); try jw.write(id); try jw.objectField("name"); try jw.write(name); try jw.objectField("level"); try jw.write(level); try jw.objectField("message"); try jw.write(message); try jw.objectField("timestamp"); try jw.write(timestamp); try jw.objectField("flow_run_id"); if (flow_run_id) |v| try jw.write(v) else try jw.write(null); try jw.objectField("task_run_id"); if (task_run_id) |v| try jw.write(v) else try jw.write(null); try jw.endObject(); return out.toOwnedSlice(); } fn filterLogs(req: *wap.Request, res: *wap.Response) !void { const alloc = req.arena; const body = req.parseJson(LogFilterBody) catch |err| { return switch (err) { error.UnknownField => sendError(res, .unprocessable_entity, "unknown field in request body"), else => sendError(res, .bad_request, "invalid filter body"), }; }; const limit: usize = if (body.limit) |l| @max(1, @min(1000, l)) else 200; const offset: usize = body.offset orelse 0; const sort_asc = if (body.sort) |s| std.mem.eql(u8, s, "TIMESTAMP_ASC") else true; var filter_opts = db.logs.FilterOptions{ .limit = limit, .offset = offset, .sort_asc = sort_asc, }; // Filter sub-blob is still freeform — walk its known sub-paths. if (body.logs) |logs_obj| { if (logs_obj == .object) { const lf = logs_obj.object; // flow_run_id filter if (lf.get("flow_run_id")) |frf| { if (frf == .object) { if (frf.object.get("any_")) |any_arr| { if (any_arr == .array and any_arr.array.items.len > 0) { if (any_arr.array.items[0] == .string) { filter_opts.flow_run_id = any_arr.array.items[0].string; } } } } } // task_run_id filter if (lf.get("task_run_id")) |trf| { if (trf == .object) { if (trf.object.get("any_")) |any_arr| { if (any_arr == .array and any_arr.array.items.len > 0) { if (any_arr.array.items[0] == .string) { filter_opts.task_run_id = any_arr.array.items[0].string; } } } } } // level filter if (lf.get("level")) |level_obj| { if (level_obj == .object) { if (level_obj.object.get("ge_")) |ge| { if (ge == .integer) filter_opts.level_ge = ge.integer; } if (level_obj.object.get("le_")) |le| { if (le == .integer) filter_opts.level_le = le.integer; } } } // timestamp filter if (lf.get("timestamp")) |ts_obj| { if (ts_obj == .object) { if (ts_obj.object.get("after_")) |after| { if (after == .string) filter_opts.timestamp_after = after.string; } if (ts_obj.object.get("before_")) |before| { if (before == .string) filter_opts.timestamp_before = before.string; } } } if (lf.get("text")) |text| { const query = text_search.queryFromJson(text) catch return sendError(res, .unprocessable_entity, "invalid text filter"); if (query) |q| filter_opts.text = try text_search.parse(alloc, q); } } } // query logs const rows = db.logs.filter(alloc, filter_opts) catch |err| { logging.err("logs", "filter error: {}", .{err}); try sendError(res, .internal_server_error, "database error"); return; }; // build JSON response using std.json.Stringify var output: std.Io.Writer.Allocating = .init(alloc); errdefer output.deinit(); var jw: std.json.Stringify = .{ .writer = &output.writer }; try jw.beginArray(); for (rows) |log_row| { try jw.beginObject(); try jw.objectField("id"); try jw.write(log_row.id); try jw.objectField("created"); try jw.write(log_row.created); try jw.objectField("updated"); try jw.write(log_row.updated); try jw.objectField("name"); try jw.write(log_row.name); try jw.objectField("level"); try jw.write(log_row.level); try jw.objectField("message"); try jw.write(log_row.message); try jw.objectField("timestamp"); try jw.write(log_row.timestamp); try jw.objectField("flow_run_id"); try jw.write(log_row.flow_run_id); try jw.objectField("task_run_id"); try jw.write(log_row.task_run_id); try jw.endObject(); } try jw.endArray(); try sendJson(res, try output.toOwnedSlice()); } // ============================================================================ // WebSocket `/logs/out` — live-tail log subscription. Same handshake shape as // `/events/out`: client sends `{"type":"auth"}` then `{"type":"filter","filter":{...}}`. // ============================================================================ const SubState = enum { waiting_auth, waiting_filter, subscribed }; const OutState = struct { conn: *wap.ws.Conn, allocator: Allocator, state: SubState = .waiting_auth, registered: bool = false, }; fn outFactory(allocator: Allocator, _: std.Io, _: *const wap.ws.Handshake, conn: *wap.ws.Conn) anyerror!*anyopaque { const state = try allocator.create(OutState); state.* = .{ .conn = conn, .allocator = allocator }; logging.debug("logs-out", "subscriber connected", .{}); return @ptrCast(state); } fn outOnMessage(state_ptr: *anyopaque, data: []const u8, _: bool) anyerror!void { const s: *OutState = @ptrCast(@alignCast(state_ptr)); var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); defer arena.deinit(); const alloc = arena.allocator(); const parsed = std.json.parseFromSlice(std.json.Value, alloc, data, .{}) catch { logging.err("logs-out", "invalid json from subscriber", .{}); s.conn.close(.{}) catch {}; return; }; const obj = parsed.value.object; const msg_type = if (obj.get("type")) |v| switch (v) { .string => |str| str, else => null, } else null; if (msg_type == null) { s.conn.close(.{}) catch {}; return; } switch (s.state) { .waiting_auth => { if (!std.mem.eql(u8, msg_type.?, "auth")) { s.conn.close(.{}) catch {}; return; } if (!auth_util.validateSocketAuthFrame(alloc, data, true)) { s.conn.close(.{ .code = 1008, .reason = "authentication_failed" }) catch {}; return; } s.conn.writeText("{\"type\":\"auth_success\"}") catch return; s.state = .waiting_filter; }, .waiting_filter => { if (!std.mem.eql(u8, msg_type.?, "filter")) { s.conn.close(.{}) catch {}; return; } const filter = log_broadcaster.LogFilter.parseFromJson(std.heap.page_allocator, data) catch { s.conn.close(.{}) catch {}; return; }; log_broadcaster.addSubscriber(s.conn, filter) catch |err| { switch (err) { error.BroadcasterNotRunning => logging.err("logs-out", "broadcaster not running", .{}), error.AtCapacity => logging.err("logs-out", "at capacity, rejecting subscriber", .{}), } var f = filter; f.deinit(); s.conn.close(.{}) catch {}; return; }; s.registered = true; s.state = .subscribed; logging.info("logs-out", "subscriber registered, total: {d}", .{log_broadcaster.getSubscriberCount()}); }, .subscribed => {}, } } fn outOnClose(state_ptr: *anyopaque) void { const s: *OutState = @ptrCast(@alignCast(state_ptr)); if (s.registered) log_broadcaster.removeSubscriber(s.conn); logging.debug("logs-out", "subscriber disconnected", .{}); } const routes_table = [_]wap.ws.Route{ .{ .path = "/logs/out", .factory = outFactory, .on_message = outOnMessage, .on_close = outOnClose }, .{ .path = "/api/logs/out", .factory = outFactory, .on_message = outOnMessage, .on_close = outOnClose }, }; pub fn wapRoutes() []const wap.ws.Route { return &routes_table; }