Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

feat(shared): unified structured logging across CF workers

Gener7bfaaa0c19b9
diff --git a/src/email-worker/src/index.test.ts b/src/email-worker/src/index.test.ts
index 1d5cf02df..61d7e5e28 100644
--- a/src/email-worker/src/index.test.ts
+++ b/src/email-worker/src/index.test.ts
@@ -13,18 +13,29 @@ const mockIsWhitelisted = vi.fn<(db: unknown, agentId: unknown, workspaceId: unk
const mockGetUser = vi.fn<(db: unknown, id: unknown) => unknown>()
const mockCreateDb = vi.fn<(d1: unknown) => Record<string, unknown>>().mockReturnValue({})
-vi.mock("@alook/shared", () => ({
- createDb: (d1: unknown) => mockCreateDb(d1),
- parseEmailHandle: (address: string) => {
- const domain = "@alook.ai"
- return address.endsWith(domain) ? address.slice(0, -domain.length) : ""
- },
- queries: {
- agent: { getAgentByHandle: (db: unknown, handle: unknown) => mockGetAgentByHandle(db, handle) },
- whitelist: { isWhitelisted: (db: unknown, agentId: unknown, workspaceId: unknown, email: unknown) => mockIsWhitelisted(db, agentId, workspaceId, email) },
- user: { getUser: (db: unknown, id: unknown) => mockGetUser(db, id) },
- },
-}))
+vi.mock("@alook/shared", () => {
+ const noopLogger = {
+ debug: () => {},
+ info: () => {},
+ warn: () => {},
+ error: () => {},
+ child: () => noopLogger,
+ }
+ return {
+ createDb: (d1: unknown) => mockCreateDb(d1),
+ createLogger: () => noopLogger,
+ parseEmailHandle: (address: string) => {
+ const domain = "@alook.ai"
+ return address.endsWith(domain) ? address.slice(0, -domain.length) : ""
+ },
+ DEV_WEB_URL: "http://localhost:3000",
+ queries: {
+ agent: { getAgentByHandle: (db: unknown, handle: unknown) => mockGetAgentByHandle(db, handle) },
+ whitelist: { isWhitelisted: (db: unknown, agentId: unknown, workspaceId: unknown, email: unknown) => mockIsWhitelisted(db, agentId, workspaceId, email) },
+ user: { getUser: (db: unknown, id: unknown) => mockGetUser(db, id) },
+ },
+ }
+})
// Import handler after mocks are set up
import handler from "./index"
@@ -121,7 +132,7 @@ describe("R2 storage", () => {
expect(put).toHaveBeenCalledOnce()
const [key, _body, opts] = put.mock.calls[0]
- expect(key).toBe("emails/mock-id-1/raw")
+ expect(key).toBe("emails/mock-id-2/raw")
expect(opts).toEqual({ httpMetadata: { contentType: "message/rfc822" } })
})
@@ -151,7 +162,7 @@ describe("whitelisted path", () => {
const body = JSON.parse(init.body)
expect(body.agentId).toBe("agent-1")
expect(body.workspaceId).toBe("ws-1")
- expect(body.r2Key).toBe("emails/mock-id-1/raw")
+ expect(body.r2Key).toBe("emails/mock-id-2/raw")
expect(body.from).toBe("[email protected]")
expect(body.subject).toBe("Hello")
expect(body.isWhitelisted).toBe(true)
diff --git a/src/email-worker/src/index.ts b/src/email-worker/src/index.ts
index 25b1f7666..9b014f039 100644
--- a/src/email-worker/src/index.ts
+++ b/src/email-worker/src/index.ts
@@ -1,5 +1,7 @@
import { nanoid } from "nanoid"
-import { createDb, queries, parseEmailHandle, DEV_WEB_URL } from "@alook/shared"
+import { createDb, queries, parseEmailHandle, DEV_WEB_URL, createLogger } from "@alook/shared"
+
+const log = createLogger({ service: "email" })
interface EmailEnv {
DB: D1Database
@@ -7,11 +9,13 @@ interface EmailEnv {
WEB_SERVICE: Fetcher
}
-async function notifyWeb(env: EmailEnv, payload: Record<string, unknown>) {
+async function notifyWeb(env: EmailEnv, payload: Record<string, unknown>, traceId: string) {
const body = JSON.stringify(payload)
- const headers = { "Content-Type": "application/json" }
+ const headers: Record<string, string> = {
+ "Content-Type": "application/json",
+ "X-Trace-Id": traceId,
+ }
- // Service bindings may connect in local dev but not route to Next.js — check response status
try {
const res = await env.WEB_SERVICE.fetch("http://internal/api/email/notify", {
method: "POST",
@@ -30,7 +34,10 @@ async function notifyWeb(env: EmailEnv, payload: Record<string, unknown>) {
export default {
async fetch(request: Request, env: EmailEnv): Promise<Response> {
+ const traceId = request.headers.get("X-Trace-Id") ?? nanoid(12)
+ const reqLog = log.child({ traceId })
const url = new URL(request.url)
+
if (url.pathname !== "/simulate" || request.method !== "POST") {
return new Response("POST /simulate to send a test email", { status: 404 })
}
@@ -40,6 +47,8 @@ export default {
return new Response("from and to required", { status: 400 })
}
+ reqLog.info("simulating email", { from: body.from, to: body.to })
+
const raw = [
`From: ${body.from}`,
`To: ${body.to}`,
@@ -64,8 +73,8 @@ export default {
to: body.to,
raw: rawStream,
headers,
- setReject(reason: string) { console.log("Rejected:", reason) },
- forward(_to: string) { console.log("Forwarded to:", _to); return Promise.resolve() },
+ setReject(reason: string) { reqLog.warn("rejected", { reason }) },
+ forward(_to: string) { reqLog.info("forwarded", { forwardTo: _to }); return Promise.resolve() },
} as unknown as ForwardableEmailMessage
try {
@@ -73,21 +82,27 @@ export default {
return Response.json({ ok: true })
} catch (e) {
const msg = e instanceof Error ? e.message : String(e)
- console.error("Simulate error:", msg)
+ reqLog.error("simulate error", { err: msg })
return Response.json({ error: msg }, { status: 500 })
}
},
async email(message: ForwardableEmailMessage, env: EmailEnv): Promise<void> {
+ const traceId = nanoid(12)
+ const emailLog = log.child({ traceId, from: message.from, to: message.to })
+
const db = createDb(env.DB)
const handle = parseEmailHandle(message.to)
const agent = await queries.agent.getAgentByHandle(db, handle)
if (!agent) {
+ emailLog.warn("no agent found", { handle })
message.setReject("No agent found for this address")
return
}
+ emailLog.info("email received", { agentId: agent.id, handle })
+
const whitelisted = await queries.whitelist.isWhitelisted(db, agent.id, agent.workspaceId, message.from)
const rawBytes = await new Response(message.raw).arrayBuffer()
@@ -100,6 +115,7 @@ export default {
const subject = message.headers.get("subject") ?? ""
if (whitelisted) {
+ emailLog.info("whitelisted email, notifying web", { agentId: agent.id })
await notifyWeb(env, {
agentId: agent.id,
workspaceId: agent.workspaceId,
@@ -108,7 +124,7 @@ export default {
to: message.to,
subject,
isWhitelisted: true,
- })
+ }, traceId)
} else {
const forwardToEmail = agent.forwardToEmail ?? ""
let forwardAddress = forwardToEmail
@@ -120,6 +136,7 @@ export default {
const forwarded = !!forwardAddress
+ emailLog.info("non-whitelisted email, notifying web", { agentId: agent.id, forwarded })
await notifyWeb(env, {
agentId: agent.id,
workspaceId: agent.workspaceId,
@@ -129,9 +146,10 @@ export default {
subject,
isWhitelisted: false,
forwarded,
- })
+ }, traceId)
if (forwardAddress) {
+ emailLog.info("forwarding email", { forwardTo: forwardAddress })
await message.forward(forwardAddress)
}
}
diff --git a/src/shared/src/index.ts b/src/shared/src/index.ts
index 8cae9c2af..8030a654c 100644
--- a/src/shared/src/index.ts
+++ b/src/shared/src/index.ts
@@ -111,6 +111,10 @@ export type { Database } from "./db/index";
export * as schema from "./db/schema";
export * as queries from "./db/queries-index";
+// Logger
+export { Logger, createLogger } from "./logger"
+export type { LogLevel, LoggerOptions } from "./logger"
+
// Utils
export { parseEmailHandle, toAlookAddress, isValidHandle } from "./utils/email";
export { isValidToken, isValidEmail } from "./utils/validation";
diff --git a/src/shared/src/logger.test.ts b/src/shared/src/logger.test.ts
new file mode 100644
index 000000000..45e0a33f6
--- /dev/null
+++ b/src/shared/src/logger.test.ts
@@ -0,0 +1,139 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"
+import { Logger } from "./logger"
+
+let logSpy: ReturnType<typeof vi.spyOn>
+let errorSpy: ReturnType<typeof vi.spyOn>
+
+beforeEach(() => {
+ logSpy = vi.spyOn(console, "log").mockImplementation(() => {})
+ errorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+})
+
+afterEach(() => {
+ vi.restoreAllMocks()
+})
+
+function parseLog(spy: ReturnType<typeof vi.spyOn>): Record<string, unknown> {
+ return JSON.parse(spy.mock.calls[0][0] as string)
+}
+
+function allLogs(spy: ReturnType<typeof vi.spyOn>): Record<string, unknown>[] {
+ return spy.mock.calls.map((c: unknown[]) => JSON.parse(c[0] as string))
+}
+
+describe("Logger", () => {
+ it("outputs valid JSON with level, msg, service, ts fields", () => {
+ const logger = new Logger({ service: "test" })
+ logger.info("hello")
+
+ const entry = parseLog(logSpy)
+ expect(entry.level).toBe("info")
+ expect(entry.msg).toBe("hello")
+ expect(entry.service).toBe("test")
+ expect(entry.ts).toMatch(/^\d{4}-\d{2}-\d{2}T/)
+ })
+
+ it("includes extra context fields in output", () => {
+ const logger = new Logger({ service: "test" })
+ logger.info("task done", { taskId: "t1", duration: 42 })
+
+ const entry = parseLog(logSpy)
+ expect(entry.taskId).toBe("t1")
+ expect(entry.duration).toBe(42)
+ })
+
+ it("filters messages below configured level", () => {
+ const logger = new Logger({ service: "test", level: "warn" })
+ logger.debug("hidden")
+ logger.info("hidden")
+ logger.warn("visible")
+ logger.error("also visible")
+
+ expect(logSpy).toHaveBeenCalledTimes(1)
+ expect(errorSpy).toHaveBeenCalledTimes(1)
+ })
+
+ it("writes error to console.error, others to console.log", () => {
+ const logger = new Logger({ service: "test", level: "debug" })
+ logger.debug("d")
+ logger.info("i")
+ logger.warn("w")
+
+ expect(logSpy).toHaveBeenCalledTimes(3)
+ expect(errorSpy).not.toHaveBeenCalled()
+
+ logger.error("e")
+ expect(errorSpy).toHaveBeenCalledTimes(1)
+ })
+
+ it("silent level suppresses all output", () => {
+ const logger = new Logger({ service: "test", level: "silent" })
+ logger.debug("nope")
+ logger.info("nope")
+ logger.warn("nope")
+ logger.error("nope")
+
+ expect(logSpy).not.toHaveBeenCalled()
+ expect(errorSpy).not.toHaveBeenCalled()
+ })
+
+ it("serializes Error objects to { message, stack }", () => {
+ const logger = new Logger({ service: "test", level: "error" })
+ const err = new Error("bad input")
+ logger.error("failed", { err })
+
+ const entry = parseLog(errorSpy)
+ const serialized = entry.err as { message: string; stack: string }
+ expect(serialized.message).toBe("bad input")
+ expect(serialized.stack).toContain("Error: bad input")
+ })
+
+ describe("child()", () => {
+ it("merges fields into every subsequent log entry", () => {
+ const logger = new Logger({ service: "test" })
+ const child = logger.child({ traceId: "abc", userId: "u1" })
+
+ child.info("hello")
+ child.info("world")
+
+ const entries = allLogs(logSpy)
+ expect(entries).toHaveLength(2)
+ expect(entries[0].traceId).toBe("abc")
+ expect(entries[0].userId).toBe("u1")
+ expect(entries[1].traceId).toBe("abc")
+ expect(entries[1].userId).toBe("u1")
+ })
+
+ it("does not mutate parent logger", () => {
+ const parent = new Logger({ service: "test" })
+ parent.child({ traceId: "abc" })
+
+ parent.info("parent log")
+
+ const entry = parseLog(logSpy)
+ expect(entry.traceId).toBeUndefined()
+ })
+
+ it("allows per-call context to override child fields", () => {
+ const logger = new Logger({ service: "test" })
+ const child = logger.child({ requestId: "r1" })
+
+ child.info("override", { requestId: "r2" })
+
+ const entry = parseLog(logSpy)
+ expect(entry.requestId).toBe("r2")
+ })
+
+ it("preserves service and level from parent", () => {
+ const parent = new Logger({ service: "web", level: "warn" })
+ const child = parent.child({ traceId: "t1" })
+
+ child.info("should be filtered")
+ child.warn("should appear")
+
+ expect(logSpy).toHaveBeenCalledTimes(1)
+ const entry = parseLog(logSpy)
+ expect(entry.service).toBe("web")
+ })
+ })
+})
diff --git a/src/shared/src/logger.ts b/src/shared/src/logger.ts
new file mode 100644
index 000000000..dc4b09da0
--- /dev/null
+++ b/src/shared/src/logger.ts
@@ -0,0 +1,92 @@
+export type LogLevel = "debug" | "info" | "warn" | "error" | "silent"
+
+const LEVELS: Record<LogLevel, number> = {
+ debug: 0,
+ info: 1,
+ warn: 2,
+ error: 3,
+ silent: 4,
+}
+
+export interface LoggerOptions {
+ service: string
+ level?: LogLevel
+}
+
+export class Logger {
+ private readonly service: string
+ private readonly level: number
+ private readonly fields: Record<string, unknown>
+
+ constructor(opts: LoggerOptions, fields?: Record<string, unknown>) {
+ this.service = opts.service
+ this.level = LEVELS[opts.level ?? "info"]
+ this.fields = fields ?? {}
+ }
+
+ debug(msg: string, ctx?: Record<string, unknown>): void {
+ this.write("debug", msg, ctx)
+ }
+
+ info(msg: string, ctx?: Record<string, unknown>): void {
+ this.write("info", msg, ctx)
+ }
+
+ warn(msg: string, ctx?: Record<string, unknown>): void {
+ this.write("warn", msg, ctx)
+ }
+
+ error(msg: string, ctx?: Record<string, unknown>): void {
+ this.write("error", msg, ctx)
+ }
+
+ child(fields: Record<string, unknown>): Logger {
+ const merged = { ...this.fields, ...fields }
+ const child = new Logger(
+ { service: this.service, level: this.levelName() },
+ merged,
+ )
+ return child
+ }
+
+ private levelName(): LogLevel {
+ for (const [name, num] of Object.entries(LEVELS)) {
+ if (num === this.level) return name as LogLevel
+ }
+ return "info"
+ }
+
+ private write(
+ level: Exclude<LogLevel, "silent">,
+ msg: string,
+ ctx?: Record<string, unknown>,
+ ): void {
+ if (LEVELS[level] < this.level) return
+
+ const entry: Record<string, unknown> = {
+ level,
+ msg,
+ service: this.service,
+ ...this.fields,
+ ...ctx,
+ ts: new Date().toISOString(),
+ }
+
+ for (const [k, v] of Object.entries(entry)) {
+ if (v instanceof Error) {
+ entry[k] = { message: v.message, stack: v.stack }
+ }
+ }
+
+ const line = JSON.stringify(entry)
+ if (level === "error") {
+ console.error(line)
+ } else {
+ console.log(line)
+ }
+ }
+}
+
+export function createLogger(opts: LoggerOptions): Logger {
+ return new Logger(opts)
+}
diff --git a/src/web/src/lib/logger.test.ts b/src/web/src/lib/logger.test.ts
index 748367c92..2141f0ddb 100644
--- a/src/web/src/lib/logger.test.ts
+++ b/src/web/src/lib/logger.test.ts
@@ -1,86 +1,83 @@
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { Logger } from "./logger";
-
-let stdoutSpy: any;
-
-let stderrSpy: any;
+let logSpy: ReturnType<typeof vi.spyOn>;
+let errorSpy: ReturnType<typeof vi.spyOn>;
beforeEach(() => {
- stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
- stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+ logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+ errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
});
afterEach(() => {
vi.restoreAllMocks();
});
-
-function parseLine(spy: any): Record<string, unknown> {
- const raw = spy.mock.calls[0][0] as string;
- return JSON.parse(raw);
+function parseLine(spy: ReturnType<typeof vi.spyOn>): Record<string, unknown> {
+ return JSON.parse(spy.mock.calls[0][0] as string);
}
describe("Logger", () => {
it("outputs valid JSON with level, msg, ts fields", () => {
- const logger = new Logger("info");
+ const logger = new Logger({ service: "web" });
logger.info("hello");
- const entry = parseLine(stdoutSpy);
+ const entry = parseLine(logSpy);
expect(entry.level).toBe("info");
expect(entry.msg).toBe("hello");
expect(entry.ts).toMatch(/^\d{4}-\d{2}-\d{2}T/);
});
it("includes extra context fields in output", () => {
- const logger = new Logger("info");
+ const logger = new Logger({ service: "web" });
logger.info("task done", { taskId: "t1", duration: 42 });
- const entry = parseLine(stdoutSpy);
+ const entry = parseLine(logSpy);
expect(entry.taskId).toBe("t1");
expect(entry.duration).toBe(42);
});
it("filters messages below configured level", () => {
- const logger = new Logger("warn");
+ const logger = new Logger({ service: "web", level: "warn" });
logger.debug("hidden");
logger.info("hidden");
logger.warn("visible");
logger.error("visible");
- expect(stdoutSpy).toHaveBeenCalledTimes(1);
- expect(stderrSpy).toHaveBeenCalledTimes(1);
+ expect(logSpy).toHaveBeenCalledTimes(1);
+ expect(errorSpy).toHaveBeenCalledTimes(1);
});
- it("writes error to stderr, others to stdout", () => {
- const logger = new Logger("debug");
+ it("writes error to console.error, others to console.log", () => {
+ const logger = new Logger({ service: "web", level: "debug" });
logger.debug("d");
logger.info("i");
logger.warn("w");
- expect(stdoutSpy).toHaveBeenCalledTimes(3);
- expect(stderrSpy).not.toHaveBeenCalled();
+ expect(logSpy).toHaveBeenCalledTimes(3);
+ expect(errorSpy).not.toHaveBeenCalled();
logger.error("e");
- expect(stderrSpy).toHaveBeenCalledTimes(1);
+ expect(errorSpy).toHaveBeenCalledTimes(1);
});
it("extracts error message from Error objects", () => {
- const logger = new Logger("error");
+ const logger = new Logger({ service: "web", level: "error" });
logger.error("failed", { err: new Error("bad input") });
- const entry = parseLine(stderrSpy);
- expect(entry.err).toBe("bad input");
+ const entry = parseLine(errorSpy);
+ const serialized = entry.err as { message: string };
+ expect(serialized.message).toBe("bad input");
});
it("silent level suppresses all output", () => {
- const logger = new Logger("silent");
+ const logger = new Logger({ service: "web", level: "silent" });
logger.debug("nope");
logger.info("nope");
logger.warn("nope");
logger.error("nope");
- expect(stdoutSpy).not.toHaveBeenCalled();
- expect(stderrSpy).not.toHaveBeenCalled();
+ expect(logSpy).not.toHaveBeenCalled();
+ expect(errorSpy).not.toHaveBeenCalled();
});
});
diff --git a/src/web/src/lib/logger.ts b/src/web/src/lib/logger.ts
index b2e6501d7..77dcf3517 100644
--- a/src/web/src/lib/logger.ts
+++ b/src/web/src/lib/logger.ts
@@ -1,62 +1,9 @@
-export type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
+import { Logger, createLogger } from "@alook/shared"
-const LEVELS: Record<LogLevel, number> = {
- debug: 0,
- info: 1,
- warn: 2,
- error: 3,
- silent: 4,
-};
+export type { LogLevel, LoggerOptions } from "@alook/shared"
+export { Logger, createLogger }
-export class Logger {
- private level: number;
-
- constructor(level: LogLevel = "info") {
- this.level = LEVELS[level];
- }
-
- debug(msg: string, ctx?: Record<string, unknown>): void {
- this.write("debug", msg, ctx);
- }
-
- info(msg: string, ctx?: Record<string, unknown>): void {
- this.write("info", msg, ctx);
- }
-
- warn(msg: string, ctx?: Record<string, unknown>): void {
- this.write("warn", msg, ctx);
- }
-
- error(msg: string, ctx?: Record<string, unknown>): void {
- this.write("error", msg, ctx);
- }
-
- private write(
- level: Exclude<LogLevel, "silent">,
- msg: string,
- ctx?: Record<string, unknown>,
- ): void {
- if (LEVELS[level] < this.level) return;
-
- const entry: Record<string, unknown> = {
- level,
- msg,
- ...ctx,
- ts: new Date().toISOString(),
- };
-
- // Serialize Error objects in context
- for (const [k, v] of Object.entries(entry)) {
- if (v instanceof Error) {
- entry[k] = v.message;
- }
- }
-
- const line = JSON.stringify(entry);
- const dest = level === "error" ? process.stderr : process.stdout;
- dest.write(line + "\n");
- }
-}
-
-const envLevel = (process.env.ALOOK_LOG_LEVEL as LogLevel) || "info";
-export const log = new Logger(envLevel);
+export const log = createLogger({
+ service: "web",
+ level: (process.env.ALOOK_LOG_LEVEL as "debug" | "info" | "warn" | "error" | "silent") || "info",
+})
diff --git a/src/web/src/lib/middleware/request-logger.test.ts b/src/web/src/lib/middleware/request-logger.test.ts
index 2d1eeb111..b4b57aaa5 100644
--- a/src/web/src/lib/middleware/request-logger.test.ts
+++ b/src/web/src/lib/middleware/request-logger.test.ts
@@ -1,29 +1,26 @@
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { logRequest } from "./request-logger";
-
-let stdoutSpy: any;
-
-let stderrSpy: any;
+let logSpy: ReturnType<typeof vi.spyOn>;
+let errorSpy: ReturnType<typeof vi.spyOn>;
beforeEach(() => {
- stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
- stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+ logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+ errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
});
afterEach(() => {
vi.restoreAllMocks();
});
-
-function parseLines(spy: any): Record<string, unknown>[] {
- return spy.mock.calls.map((c: any) => JSON.parse(c[0] as string));
+function parseLines(spy: ReturnType<typeof vi.spyOn>): Record<string, unknown>[] {
+ return spy.mock.calls.map((c) => JSON.parse(c[0] as string));
}
describe("logRequest", () => {
it("logs info for 2xx status", () => {
logRequest("GET", "/api/agents", 200, 15);
- const entries = parseLines(stdoutSpy);
+ const entries = parseLines(logSpy);
expect(entries).toHaveLength(1);
expect(entries[0]).toMatchObject({
level: "info",
@@ -36,7 +33,7 @@ describe("logRequest", () => {
it("logs warn for 4xx status", () => {
logRequest("POST", "/api/agents", 400, 5);
- const entries = parseLines(stdoutSpy);
+ const entries = parseLines(logSpy);
expect(entries).toHaveLength(1);
expect(entries[0]).toMatchObject({
level: "warn",
@@ -46,7 +43,7 @@ describe("logRequest", () => {
it("logs error for 5xx status", () => {
logRequest("GET", "/api/agents", 500, 100);
- const entries = parseLines(stderrSpy);
+ const entries = parseLines(errorSpy);
expect(entries).toHaveLength(1);
expect(entries[0]).toMatchObject({
level: "error",
@@ -57,16 +54,16 @@ describe("logRequest", () => {
it("skips /health endpoint", () => {
logRequest("GET", "/health", 200, 1);
logRequest("GET", "/api/health", 200, 1);
- expect(stdoutSpy).not.toHaveBeenCalled();
- expect(stderrSpy).not.toHaveBeenCalled();
+ expect(logSpy).not.toHaveBeenCalled();
+ expect(errorSpy).not.toHaveBeenCalled();
});
it("includes requestId and userId when provided", () => {
logRequest("GET", "/api/test", 200, 10, "req-1", "u1");
- const entries = parseLines(stdoutSpy);
+ const entries = parseLines(logSpy);
expect(entries[0]).toMatchObject({
- request_id: "req-1",
- user_id: "u1",
+ requestId: "req-1",
+ userId: "u1",
});
});
});
diff --git a/src/web/src/lib/middleware/request-logger.ts b/src/web/src/lib/middleware/request-logger.ts
index b3ac648ba..8758a9a1c 100644
--- a/src/web/src/lib/middleware/request-logger.ts
+++ b/src/web/src/lib/middleware/request-logger.ts
@@ -10,16 +10,20 @@ export function logRequest(
): void {
if (path === "/health" || path === "/api/health") return;
+ const fields: Record<string, unknown> = {};
+ if (requestId) fields.requestId = requestId;
+ if (userId) fields.userId = userId;
+
+ const reqLog = Object.keys(fields).length > 0 ? log.child(fields) : log;
+
const ctx: Record<string, unknown> = {
method,
path,
status,
duration: `${durationMs}ms`,
};
- if (requestId) ctx.request_id = requestId;
- if (userId) ctx.user_id = userId;
- if (status >= 500) log.error("http request", ctx);
- else if (status >= 400) log.warn("http request", ctx);
- else log.info("http request", ctx);
+ if (status >= 500) reqLog.error("http request", ctx);
+ else if (status >= 400) reqLog.warn("http request", ctx);
+ else reqLog.info("http request", ctx);
}
diff --git a/src/ws-do/src/index.ts b/src/ws-do/src/index.ts
index f0c701743..2643b03ab 100644
--- a/src/ws-do/src/index.ts
+++ b/src/ws-do/src/index.ts
@@ -1,12 +1,20 @@
+import { createLogger } from "@alook/shared"
+
export { WebSocketDurableObject } from "./ws-durable"
+const log = createLogger({ service: "ws-do" })
+
export default {
async fetch(request: Request, env: Env): Promise<Response> {
const url = new URL(request.url)
+ const traceId = request.headers.get("X-Trace-Id") ?? undefined
const userBroadcast = url.pathname.match(/^\/broadcast\/user\/(.+)$/)
if (userBroadcast && request.method === "POST") {
const userId = userBroadcast[1]
+ const reqLog = log.child({ traceId, userId })
+ reqLog.debug("broadcasting to user")
+
const doId = env.WS_DO.idFromName("user:" + userId)
const stub = env.WS_DO.get(doId)
return stub.fetch(new Request("http://internal/broadcast", { method: "POST", body: request.body, duplex: "half" } as RequestInit))
@@ -14,6 +22,10 @@ export default {
const userId = url.searchParams.get("userId")
if (!userId) return new Response("userId required", { status: 400 })
+
+ const reqLog = log.child({ traceId, userId })
+ reqLog.info("websocket upgrade")
+
const doId = env.WS_DO.idFromName("user:" + userId)
const stub = env.WS_DO.get(doId)
return stub.fetch(request)
diff --git a/src/ws-do/src/ws-durable.test.ts b/src/ws-do/src/ws-durable.test.ts
index bebd45fbb..72b2a6bef 100644
--- a/src/ws-do/src/ws-durable.test.ts
+++ b/src/ws-do/src/ws-durable.test.ts
@@ -65,12 +65,22 @@ vi.mock("cloudflare:workers", () => ({
const mockGetValidSession = vi.fn<(db: unknown, token: string) => Promise<string | null>>()
const mockCreateDb = vi.fn().mockReturnValue({})
-vi.mock("@alook/shared", () => ({
- createDb: (d1: unknown) => mockCreateDb(d1),
- queries: {
- session: { getValidSession: (db: unknown, token: string) => mockGetValidSession(db, token) },
- },
-}))
+vi.mock("@alook/shared", () => {
+ const noopLogger = {
+ debug: () => {},
+ info: () => {},
+ warn: () => {},
+ error: () => {},
+ child: () => noopLogger,
+ }
+ return {
+ createDb: (d1: unknown) => mockCreateDb(d1),
+ createLogger: () => noopLogger,
+ queries: {
+ session: { getValidSession: (db: unknown, token: string) => mockGetValidSession(db, token) },
+ },
+ }
+})
// Import after mocks
import { WebSocketDurableObject } from "./ws-durable"
diff --git a/src/ws-do/src/ws-durable.ts b/src/ws-do/src/ws-durable.ts
index 549f0bfdb..c4772cd6c 100644
--- a/src/ws-do/src/ws-durable.ts
+++ b/src/ws-do/src/ws-durable.ts
@@ -1,5 +1,7 @@
import { DurableObject } from "cloudflare:workers"
-import { createDb, queries } from "@alook/shared"
+import { createDb, queries, createLogger } from "@alook/shared"
+
+const log = createLogger({ service: "ws-do" })
interface ConnectionState {
userId: string
@@ -31,6 +33,10 @@ export class WebSocketDurableObject extends DurableObject<Env> {
: { userId: "", authenticated: false }
server.serializeAttachment(state)
+ if (preAuthUserId) {
+ log.info("websocket connected (pre-auth)", { userId: preAuthUserId })
+ }
+
this.ctx.setWebSocketAutoResponse(
new WebSocketRequestResponsePair("ping", "pong")
)
@@ -49,8 +55,13 @@ export class WebSocketDurableObject extends DurableObject<Env> {
const msg = parsed as { type: string; token?: string }
if (msg.type === "auth") {
const userId = await this.validateToken(msg.token!)
- if (!userId) { ws.close(1008, "Unauthorized"); return }
+ if (!userId) {
+ log.warn("websocket auth failed")
+ ws.close(1008, "Unauthorized")
+ return
+ }
ws.serializeAttachment({ userId, authenticated: true } as ConnectionState)
+ log.info("websocket authenticated", { userId })
ws.send(JSON.stringify({ type: "auth.ok" }))
return
}
@@ -64,7 +75,7 @@ export class WebSocketDurableObject extends DurableObject<Env> {
async webSocketClose(): Promise<void> {}
async webSocketError(ws: WebSocket, error: unknown): Promise<void> {
- console.error("WS error:", error)
+ log.error("websocket error", { err: error instanceof Error ? error : String(error) })
try { ws.close(1011, "Internal error") } catch {}
}