Skip to content

Rallly is an open-source scheduling and collaboration tool designed to make organizing events and meetings easier.

✨ Add wide event logging to private API requests (RAL-1264) (#2654)

Luke Vellaa6391fa9f83e
diff --git a/apps/web/src/app/api/private/[...route]/route.ts b/apps/web/src/app/api/private/[...route]/route.ts
index eef74b336..1cbffbdf3 100644
--- a/apps/web/src/app/api/private/[...route]/route.ts
+++ b/apps/web/src/app/api/private/[...route]/route.ts
@@ -31,6 +31,7 @@ import {
generateTimeSlots,
parseStartTime,
} from "../utils/time-slots";
+import { wideEvent } from "../utils/wide-event";
type Env = {
Variables: {
@@ -45,6 +46,8 @@ type Env = {
const app = new Hono<Env>().basePath("/api/private");
+app.use("*", wideEvent);
+
app.use("*", async (c, next) => {
if (isMaintenanceModeEnabled()) {
return c.json(
diff --git a/apps/web/src/app/api/private/utils/wide-event.test.ts b/apps/web/src/app/api/private/utils/wide-event.test.ts
new file mode 100644
index 000000000..65c19ec3c
--- /dev/null
+++ b/apps/web/src/app/api/private/utils/wide-event.test.ts
@@ -0,0 +1,124 @@
+import { Hono } from "hono";
+import { bearerAuth } from "hono/bearer-auth";
+import { rateLimiter } from "hono-rate-limiter";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const info = vi.fn();
+const warn = vi.fn();
+const error = vi.fn();
+
+vi.mock("@rallly/logger", () => ({
+ logger: {
+ info: (event: unknown) => info(event),
+ warn: (event: unknown) => warn(event),
+ error: (event: unknown) => error(event),
+ },
+ createWideEvent: (event: Record<string, unknown>) => ({
+ timestamp: "2026-01-01T00:00:00.000Z",
+ ...event,
+ }),
+}));
+
+import { wideEvent } from "./wide-event";
+
+type TestEnv = {
+ Variables: {
+ apiAuth?: { spaceId: string; apiKeyId: string };
+ };
+};
+
+const buildApp = () => {
+ const app = new Hono<TestEnv>();
+ app.use("*", wideEvent);
+
+ app.get(
+ "/ok",
+ async (c, next) => {
+ c.set("apiAuth", { spaceId: "space-1", apiKeyId: "key-1" });
+ await next();
+ },
+ rateLimiter({
+ windowMs: 60_000,
+ limit: 5,
+ keyGenerator: () => "space-1",
+ }),
+ (c) => c.json({ ok: true }),
+ );
+
+ app.get(
+ "/unauthorized",
+ bearerAuth({ verifyToken: async () => false }),
+ (c) => c.json({ ok: true }),
+ );
+
+ app.get("/boom", () => {
+ throw new Error("kaboom");
+ });
+
+ return app;
+};
+
+describe("wideEvent middleware", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it("emits a single info event with request, auth and rate-limit context on success", async () => {
+ const res = await buildApp().request("/ok");
+
+ expect(res.status).toBe(200);
+ expect(info).toHaveBeenCalledTimes(1);
+ expect(warn).not.toHaveBeenCalled();
+ expect(error).not.toHaveBeenCalled();
+
+ const event = info.mock.calls[0][0];
+ expect(event).toMatchObject({
+ service: "private-api",
+ method: "GET",
+ path: "/ok",
+ statusCode: 200,
+ spaceId: "space-1",
+ apiKeyId: "key-1",
+ rateLimiter: "private-api",
+ rateLimiterConsumedPoints: 1,
+ rateLimiterRemainingPoints: 4,
+ });
+ expect(typeof event.durationMs).toBe("number");
+ });
+
+ it("warns and captures a 401 without auth context", async () => {
+ const res = await buildApp().request("/unauthorized");
+
+ expect(res.status).toBe(401);
+ expect(warn).toHaveBeenCalledTimes(1);
+ expect(info).not.toHaveBeenCalled();
+
+ const event = warn.mock.calls[0][0];
+ expect(event).toMatchObject({ statusCode: 401, path: "/unauthorized" });
+ expect(event.spaceId).toBeUndefined();
+ expect(event.apiKeyId).toBeUndefined();
+ expect(event.rateLimiter).toBeUndefined();
+ });
+
+ it("logs an error event with error details on an unhandled throw", async () => {
+ const res = await buildApp().request("/boom");
+
+ expect(res.status).toBe(500);
+ expect(error).toHaveBeenCalledTimes(1);
+
+ const event = error.mock.calls[0][0];
+ expect(event).toMatchObject({
+ statusCode: 500,
+ errorType: "Error",
+ errorMessage: "kaboom",
+ });
+ });
+
+ it("propagates the request id from x-vercel-id", async () => {
+ await buildApp().request("/ok", {
+ headers: { "x-vercel-id": "req-123" },
+ });
+
+ expect(info.mock.calls[0][0].requestId).toBe("req-123");
+ });
+});
diff --git a/apps/web/src/app/api/private/utils/wide-event.ts b/apps/web/src/app/api/private/utils/wide-event.ts
new file mode 100644
index 000000000..522541fc4
--- /dev/null
+++ b/apps/web/src/app/api/private/utils/wide-event.ts
@@ -0,0 +1,73 @@
+import { createWideEvent, logger } from "@rallly/logger";
+import { createMiddleware } from "hono/factory";
+import type { RateLimitInfo } from "hono-rate-limiter";
+
+type WideEventEnv = {
+ Variables: {
+ apiAuth?: {
+ spaceId: string;
+ apiKeyId: string;
+ };
+ rateLimit?: RateLimitInfo;
+ };
+};
+
+/**
+ * Emits a single wide event per request, following the "one event per request"
+ * pattern in `packages/logger/src/wide-event.ts`. Registered first so it wraps
+ * every outcome, including maintenance (503), auth (401/403), and rate limit
+ * (429) short-circuits from downstream middleware.
+ */
+export const wideEvent = createMiddleware<WideEventEnv>(async (c, next) => {
+ const startTime = Date.now();
+ const event = createWideEvent({
+ service: "private-api",
+ requestId:
+ c.req.header("x-vercel-id") ?? c.req.header("x-request-id") ?? undefined,
+ method: c.req.method,
+ path: c.req.path,
+ ip: c.req.header("x-vercel-forwarded-for") ?? undefined,
+ ja4Digest: c.req.header("x-vercel-ja4-digest") ?? undefined,
+ });
+
+ try {
+ await next();
+
+ // `c.res.status` is authoritative: Hono's error handler has already
+ // resolved thrown HTTPExceptions (e.g. the 401 from bearer auth) into the
+ // correct status. `c.error` is still set for those, so enrich error fields
+ // from it but never let it override the resolved status.
+ event.statusCode = c.res.status;
+
+ if (c.error) {
+ event.errorType = c.error.name;
+ event.errorMessage = c.error.message;
+ }
+ } finally {
+ // `apiAuth` and `rateLimit` are populated by downstream middleware, so they
+ // are only available once `next()` has run — and stay absent when the
+ // request is rejected before they run (401 unauthenticated, 403 non-pro).
+ const apiAuth = c.get("apiAuth");
+ if (apiAuth) {
+ event.spaceId = apiAuth.spaceId;
+ event.apiKeyId = apiAuth.apiKeyId;
+ }
+
+ const rateLimit = c.get("rateLimit");
+ if (rateLimit) {
+ event.rateLimiter = "private-api";
+ event.rateLimiterConsumedPoints = rateLimit.used;
+ event.rateLimiterRemainingPoints = rateLimit.remaining;
+ }
+
+ event.durationMs = Date.now() - startTime;
+
+ if (event.statusCode && event.statusCode >= 500) {
+ logger.error(event);
+ } else if (event.statusCode && event.statusCode >= 400) {
+ logger.warn(event);
+ } else {
+ logger.info(event);
+ }
+ }
+});