Skip to content

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

3.4 KB
Raw Blame
import { createWideEvent, logger } from "@rallly/logger";
import { createMiddleware } from "hono/factory";
import type { RateLimitFailure, RateLimitInfo } from "./rate-limit";

type WideEventEnv = {
  Variables: {
    apiAuth?: {
      spaceId: string;
      apiKeyId: string;
    };
    rateLimit?: RateLimitInfo;
    rateLimitFailure?: RateLimitFailure;
  };
};

/**
 * 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.
 *
 * `service` labels the route that handled the request (`api-private`,
 * `api-v1`), so migration between versions is a single `group_by` in the
 * logs.
 */
export const wideEvent = ({ service }: { service: string }) =>
  createMiddleware<WideEventEnv>(async (c, next) => {
    const startTime = Date.now();
    const event = createWideEvent({
      service,
      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.minute.used;
        event.rateLimiterRemainingPoints = rateLimit.minute.remaining;
        event.rateLimiterDailyConsumedPoints = rateLimit.day.used;
        event.rateLimiterDailyRemainingPoints = rateLimit.day.remaining;
      }

      // A fail-closed 503 from the rate limiter is returned, not thrown, so
      // `c.error` is empty; carry its cause so an outage is queryable.
      const rateLimitFailure = c.get("rateLimitFailure");
      if (rateLimitFailure) {
        event.rateLimiter = "private-api";
        event.rateLimiterError = rateLimitFailure.reason;
        event.errorType = "RateLimitStoreError";
        event.errorCode = "SERVICE_UNAVAILABLE";
        event.errorMessage = rateLimitFailure.message;
        event.isRetriable = true;
      }

      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);
      }
    }
  });