@atproto/xrpc-server 0.3.0 → 0.3.2

package/dist/logger.d.ts

@@ -1,2 +1,3 @@
-export declare const logger: import("pino").default.Logger<import("pino").default.LoggerOptions>;
+import { subsystemLogger } from '@atproto/common';
+export declare const logger: ReturnType<typeof subsystemLogger>;
 export default logger;

package/dist/rate-limiter.d.ts

@@ -0,0 +1,31 @@
+import { RateLimiterAbstract, RateLimiterRes } from 'rate-limiter-flexible';
+import { CalcKeyFn, CalcPointsFn, RateLimitExceededError, RateLimiterConsume, RateLimiterI, RateLimiterStatus, XRPCReqContext } from './types';
+export declare type RateLimiterOpts = {
+    keyPrefix: string;
+    durationMs: number;
+    points: number;
+    bypassSecret?: string;
+    bypassIps?: string[];
+    calcKey?: CalcKeyFn;
+    calcPoints?: CalcPointsFn;
+    failClosed?: boolean;
+};
+export declare class RateLimiter implements RateLimiterI {
+    limiter: RateLimiterAbstract;
+    private bypassSecret?;
+    private bypassIps?;
+    private failClosed?;
+    calcKey: CalcKeyFn;
+    calcPoints: CalcPointsFn;
+    constructor(limiter: RateLimiterAbstract, opts: RateLimiterOpts);
+    static memory(opts: RateLimiterOpts): RateLimiter;
+    static redis(storeClient: unknown, opts: RateLimiterOpts): RateLimiter;
+    consume(ctx: XRPCReqContext, opts?: {
+        calcKey?: CalcKeyFn;
+        calcPoints?: CalcPointsFn;
+    }): Promise<RateLimiterStatus | RateLimitExceededError | null>;
+}
+export declare const formatLimiterStatus: (limiter: RateLimiterAbstract, res: RateLimiterRes) => RateLimiterStatus;
+export declare const consumeMany: (ctx: XRPCReqContext, fns: RateLimiterConsume[]) => Promise<RateLimiterStatus | RateLimitExceededError | null>;
+export declare const setResHeaders: (ctx: XRPCReqContext, status: RateLimiterStatus) => void;
+export declare const getTightestLimit: (resps: (RateLimiterStatus | RateLimitExceededError | null)[]) => RateLimiterStatus | RateLimitExceededError | null;

package/dist/server.d.ts

@@ -1,7 +1,7 @@
 import express, { NextFunction, RequestHandler } from 'express';
 import { Lexicons, LexXrpcProcedure, LexXrpcQuery, LexXrpcSubscription } from '@atproto/lexicon';
 import { XrpcStreamServer } from './stream';
-import { XRPCHandler, XRPCHandlerConfig, Options, XRPCStreamHandlerConfig, XRPCStreamHandler } from './types';
+import { XRPCHandler, XRPCHandlerConfig, Options, XRPCStreamHandlerConfig, XRPCStreamHandler, RateLimiterI, RateLimiterConsume } from './types';
 export declare function createServer(lexicons?: unknown[], options?: Options): Server;
 export declare class Server {
     router: import("express-serve-static-core").Express;
@@ -10,6 +10,9 @@ export declare class Server {
     lex: Lexicons;
     options: Options;
     middleware: Record<'json' | 'text', RequestHandler>;
+    globalRateLimiters: RateLimiterI[];
+    sharedRateLimiters: Record<string, RateLimiterI>;
+    routeRateLimiterFns: Record<string, RateLimiterConsume[]>;
     constructor(lexicons?: unknown[], opts?: Options);
     method(nsid: string, configOrFn: XRPCHandlerConfig | XRPCHandler): void;
     addMethod(nsid: string, configOrFn: XRPCHandlerConfig | XRPCHandler): void;
@@ -22,4 +25,5 @@ export declare class Server {
     createHandler(nsid: string, def: LexXrpcQuery | LexXrpcProcedure, handler: XRPCHandler): RequestHandler;
     protected addSubscription(nsid: string, def: LexXrpcSubscription, config: XRPCStreamHandlerConfig): Promise<void>;
     private enableStreamingOnListen;
+    private setupRouteRateLimits;
 }

package/dist/stream/logger.d.ts

@@ -1,2 +1,3 @@
-export declare const logger: import("pino").default.Logger<import("pino").default.LoggerOptions>;
+import { subsystemLogger } from '@atproto/common';
+export declare const logger: ReturnType<typeof subsystemLogger>;
 export default logger;

package/dist/stream/stream.d.ts

@@ -1,5 +1,8 @@
 /// <reference types="node" />
 import { DuplexOptions } from 'stream';
 import { WebSocket } from 'ws';
-export declare function byFrame(ws: WebSocket, options?: DuplexOptions): AsyncGenerator<import("./frames").MessageFrame<unknown> | import("./frames").ErrorFrame<string>, void, unknown>;
-export declare function byMessage(ws: WebSocket, options?: DuplexOptions): AsyncGenerator<import("./frames").MessageFrame<unknown>, void, unknown>;
+import { MessageFrame } from './frames';
+export declare function streamByteChunks(ws: WebSocket, options?: DuplexOptions): import("stream").Duplex;
+export declare function byFrame(ws: WebSocket, options?: DuplexOptions): AsyncGenerator<MessageFrame<unknown> | import("./frames").ErrorFrame<string>, void, unknown>;
+export declare function byMessage(ws: WebSocket, options?: DuplexOptions): AsyncGenerator<MessageFrame<unknown>, void, unknown>;
+export declare function ensureChunkIsMessage(chunk: Uint8Array): MessageFrame<unknown>;

package/dist/stream/subscription.d.ts

@@ -4,6 +4,7 @@ export declare class Subscription<T = unknown> {
         service: string;
         method: string;
         maxReconnectSeconds?: number;
+        heartbeatIntervalMs?: number;
         signal?: AbortSignal;
         validate: (obj: unknown) => T | undefined;
         onReconnectError?: (error: unknown, n: number, initialSetup: boolean) => void;
@@ -13,12 +14,12 @@ export declare class Subscription<T = unknown> {
         service: string;
         method: string;
         maxReconnectSeconds?: number;
+        heartbeatIntervalMs?: number;
         signal?: AbortSignal;
         validate: (obj: unknown) => T | undefined;
         onReconnectError?: (error: unknown, n: number, initialSetup: boolean) => void;
         getParams?: () => Record<string, unknown> | Promise<Record<string, unknown> | undefined> | undefined;
     });
     [Symbol.asyncIterator](): AsyncGenerator<T>;
-    private getSocket;
 }
 export default Subscription;

package/dist/stream/websocket-keepalive.d.ts

@@ -0,0 +1,23 @@
+import { WebSocket, ClientOptions } from 'ws';
+export declare class WebSocketKeepAlive {
+    opts: ClientOptions & {
+        getUrl: () => Promise<string>;
+        maxReconnectSeconds?: number;
+        signal?: AbortSignal;
+        heartbeatIntervalMs?: number;
+        onReconnectError?: (error: unknown, n: number, initialSetup: boolean) => void;
+    };
+    ws: WebSocket | null;
+    initialSetup: boolean;
+    reconnects: number | null;
+    constructor(opts: ClientOptions & {
+        getUrl: () => Promise<string>;
+        maxReconnectSeconds?: number;
+        signal?: AbortSignal;
+        heartbeatIntervalMs?: number;
+        onReconnectError?: (error: unknown, n: number, initialSetup: boolean) => void;
+    });
+    [Symbol.asyncIterator](): AsyncGenerator<Uint8Array>;
+    startHeartbeat(ws: WebSocket): void;
+}
+export default WebSocketKeepAlive;

package/dist/types.d.ts

@@ -10,6 +10,11 @@ export declare type Options = {
         blobLimit?: number;
         textLimit?: number;
     };
+    rateLimits?: {
+        creator: RateLimiterCreator;
+        global?: ServerRateLimitDescription[];
+        shared?: ServerRateLimitDescription[];
+    };
 };
 export declare type UndecodedParams = typeof express.request['query'];
 export declare type Primitive = string | number | boolean;
@@ -65,13 +70,14 @@ export declare const handlerError: zod.ZodObject<{
 }>;
 export declare type HandlerError = zod.infer<typeof handlerError>;
 export declare type HandlerOutput = HandlerSuccess | HandlerError;
-export declare type XRPCHandler = (ctx: {
+export declare type XRPCReqContext = {
     auth: HandlerAuth | undefined;
     params: Params;
     input: HandlerInput | undefined;
     req: express.Request;
     res: express.Response;
-}) => Promise<HandlerOutput> | HandlerOutput | undefined;
+};
+export declare type XRPCHandler = (ctx: XRPCReqContext) => Promise<HandlerOutput> | HandlerOutput | undefined;
 export declare type XRPCStreamHandler = (ctx: {
     auth: HandlerAuth | undefined;
     params: Params;
@@ -86,7 +92,52 @@ export declare type AuthVerifier = (ctx: {
 export declare type StreamAuthVerifier = (ctx: {
     req: IncomingMessage;
 }) => Promise<AuthOutput> | AuthOutput;
+export declare type CalcKeyFn = (ctx: XRPCReqContext) => string;
+export declare type CalcPointsFn = (ctx: XRPCReqContext) => number;
+export interface RateLimiterI {
+    consume: RateLimiterConsume;
+}
+export declare type RateLimiterConsume = (ctx: XRPCReqContext, opts?: {
+    calcKey?: CalcKeyFn;
+    calcPoints?: CalcPointsFn;
+}) => Promise<RateLimiterStatus | RateLimitExceededError | null>;
+export declare type RateLimiterCreator = (opts: {
+    keyPrefix: string;
+    durationMs: number;
+    points: number;
+    calcKey?: (ctx: XRPCReqContext) => string;
+    calcPoints?: (ctx: XRPCReqContext) => number;
+}) => RateLimiterI;
+export declare type ServerRateLimitDescription = {
+    name: string;
+    durationMs: number;
+    points: number;
+    calcKey?: (ctx: XRPCReqContext) => string;
+    calcPoints?: (ctx: XRPCReqContext) => number;
+};
+export declare type SharedRateLimitOpts = {
+    name: string;
+    calcKey?: (ctx: XRPCReqContext) => string;
+    calcPoints?: (ctx: XRPCReqContext) => number;
+};
+export declare type RouteRateLimitOpts = {
+    durationMs: number;
+    points: number;
+    calcKey?: (ctx: XRPCReqContext) => string;
+    calcPoints?: (ctx: XRPCReqContext) => number;
+};
+export declare type HandlerRateLimitOpts = SharedRateLimitOpts | RouteRateLimitOpts;
+export declare const isShared: (opts: HandlerRateLimitOpts) => opts is SharedRateLimitOpts;
+export declare type RateLimiterStatus = {
+    limit: number;
+    duration: number;
+    remainingPoints: number;
+    msBeforeNext: number;
+    consumedPoints: number;
+    isFirstInDuration: boolean;
+};
 export declare type XRPCHandlerConfig = {
+    rateLimit?: HandlerRateLimitOpts | HandlerRateLimitOpts[];
     auth?: AuthVerifier;
     handler: XRPCHandler;
 };
@@ -117,13 +168,17 @@ export declare class AuthRequiredError extends XRPCError {
 export declare class ForbiddenError extends XRPCError {
     constructor(errorMessage?: string, customErrorName?: string);
 }
+export declare class RateLimitExceededError extends XRPCError {
+    status: RateLimiterStatus;
+    constructor(status: RateLimiterStatus, errorMessage?: string, customErrorName?: string);
+}
 export declare class InternalServerError extends XRPCError {
     constructor(errorMessage?: string, customErrorName?: string);
 }
 export declare class UpstreamFailureError extends XRPCError {
     constructor(errorMessage?: string, customErrorName?: string);
 }
-export declare class NotEnoughResoucesError extends XRPCError {
+export declare class NotEnoughResourcesError extends XRPCError {
     constructor(errorMessage?: string, customErrorName?: string);
 }
 export declare class UpstreamTimeoutError extends XRPCError {

package/package.json

@@ -1,47 +1,47 @@
 {
   "name": "@atproto/xrpc-server",
-  "version": "0.3.0",
-  "main": "dist/index.js",
-  "scripts": {
-    "test": "jest",
-    "prettier": "prettier --check src/ tests/",
-    "prettier:fix": "prettier --write src/ tests/",
-    "lint": "eslint . --ext .ts,.tsx",
-    "lint:fix": "yarn lint --fix",
-    "verify": "run-p prettier lint",
-    "verify:fix": "yarn prettier:fix && yarn lint:fix",
-    "build": "node ./build.js",
-    "postbuild": "tsc --build tsconfig.build.json",
-    "update-main-to-dist": "node ./update-pkg.js --update-main-to-dist",
-    "update-main-to-src": "node ./update-pkg.js --update-main-to-src",
-    "prepublish": "npm run update-main-to-dist",
-    "postpublish": "npm run update-main-to-src"
-  },
+  "version": "0.3.2",
   "license": "MIT",
+  "description": "atproto HTTP API (XRPC) server library",
+  "keywords": [
+    "atproto",
+    "xrpc"
+  ],
+  "homepage": "https://atproto.com",
   "repository": {
     "type": "git",
-    "url": "https://github.com/bluesky-social/atproto.git",
+    "url": "https://github.com/bluesky-social/atproto",
     "directory": "packages/xrpc-server"
   },
+  "main": "dist/index.js",
   "dependencies": {
-    "@atproto/common": "*",
-    "@atproto/crypto": "*",
-    "@atproto/lexicon": "*",
     "cbor-x": "^1.5.1",
     "express": "^4.17.2",
     "http-errors": "^2.0.0",
     "mime-types": "^2.1.35",
+    "rate-limiter-flexible": "^2.4.1",
     "uint8arrays": "3.0.0",
     "ws": "^8.12.0",
-    "zod": "^3.21.4"
+    "zod": "^3.21.4",
+    "@atproto/common": "^0.3.1",
+    "@atproto/crypto": "^0.2.2",
+    "@atproto/lexicon": "^0.2.2"
   },
   "devDependencies": {
-    "@atproto/crypto": "*",
-    "@atproto/xrpc": "*",
     "@types/express": "^4.17.13",
+    "@types/express-serve-static-core": "^4.17.36",
     "@types/http-errors": "^2.0.1",
     "@types/ws": "^8.5.4",
     "get-port": "^6.1.2",
-    "multiformats": "^9.6.4"
-  }
-}
+    "multiformats": "^9.9.0",
+    "@atproto/crypto": "^0.2.2",
+    "@atproto/xrpc": "^0.3.2"
+  },
+  "scripts": {
+    "test": "jest",
+    "build": "node ./build.js",
+    "postbuild": "tsc --build tsconfig.build.json",
+    "update-main-to-dist": "node ../../update-main-to-dist.js packages/xrpc-server"
+  },
+  "types": "dist/index.d.ts"
+}

package/src/index.ts

@@ -2,6 +2,7 @@ export * from './types'
 export * from './auth'
 export * from './server'
 export * from './stream'
+export * from './rate-limiter'
 
 export type { ServerTiming } from './util'
 export { serverTimingHeader, ServerTimer } from './util'

package/src/logger.ts

@@ -1,5 +1,6 @@
 import { subsystemLogger } from '@atproto/common'
 
-export const logger = subsystemLogger('xrpc-server')
+export const logger: ReturnType<typeof subsystemLogger> =
+  subsystemLogger('xrpc-server')
 
 export default logger

package/src/rate-limiter.ts

@@ -0,0 +1,173 @@
+import {
+  RateLimiterAbstract,
+  RateLimiterMemory,
+  RateLimiterRedis,
+  RateLimiterRes,
+} from 'rate-limiter-flexible'
+import { logger } from './logger'
+import {
+  CalcKeyFn,
+  CalcPointsFn,
+  RateLimitExceededError,
+  RateLimiterConsume,
+  RateLimiterI,
+  RateLimiterStatus,
+  XRPCReqContext,
+} from './types'
+
+export type RateLimiterOpts = {
+  keyPrefix: string
+  durationMs: number
+  points: number
+  bypassSecret?: string
+  bypassIps?: string[]
+  calcKey?: CalcKeyFn
+  calcPoints?: CalcPointsFn
+  failClosed?: boolean
+}
+
+export class RateLimiter implements RateLimiterI {
+  public limiter: RateLimiterAbstract
+  private bypassSecret?: string
+  private bypassIps?: string[]
+  private failClosed?: boolean
+  public calcKey: CalcKeyFn
+  public calcPoints: CalcPointsFn
+
+  constructor(limiter: RateLimiterAbstract, opts: RateLimiterOpts) {
+    this.limiter = limiter
+    this.bypassSecret = opts.bypassSecret
+    this.bypassIps = opts.bypassIps
+    this.calcKey = opts.calcKey ?? defaultKey
+    this.calcPoints = opts.calcPoints ?? defaultPoints
+  }
+
+  static memory(opts: RateLimiterOpts): RateLimiter {
+    const limiter = new RateLimiterMemory({
+      keyPrefix: opts.keyPrefix,
+      duration: Math.floor(opts.durationMs / 1000),
+      points: opts.points,
+    })
+    return new RateLimiter(limiter, opts)
+  }
+
+  static redis(storeClient: unknown, opts: RateLimiterOpts): RateLimiter {
+    const limiter = new RateLimiterRedis({
+      storeClient,
+      keyPrefix: opts.keyPrefix,
+      duration: Math.floor(opts.durationMs / 1000),
+      points: opts.points,
+    })
+    return new RateLimiter(limiter, opts)
+  }
+
+  async consume(
+    ctx: XRPCReqContext,
+    opts?: { calcKey?: CalcKeyFn; calcPoints?: CalcPointsFn },
+  ): Promise<RateLimiterStatus | RateLimitExceededError | null> {
+    if (
+      this.bypassSecret &&
+      ctx.req.header('x-ratelimit-bypass') === this.bypassSecret
+    ) {
+      return null
+    }
+    if (this.bypassIps && this.bypassIps.includes(ctx.req.ip)) {
+      return null
+    }
+    const key = opts?.calcKey ? opts.calcKey(ctx) : this.calcKey(ctx)
+    const points = opts?.calcPoints
+      ? opts.calcPoints(ctx)
+      : this.calcPoints(ctx)
+    if (points < 1) {
+      return null
+    }
+    try {
+      const res = await this.limiter.consume(key, points)
+      return formatLimiterStatus(this.limiter, res)
+    } catch (err) {
+      // yes this library rejects with a res not an error
+      if (err instanceof RateLimiterRes) {
+        const status = formatLimiterStatus(this.limiter, err)
+        return new RateLimitExceededError(status)
+      } else {
+        if (this.failClosed) {
+          throw err
+        }
+        logger.error(
+          {
+            err,
+            keyPrefix: this.limiter.keyPrefix,
+            points: this.limiter.points,
+            duration: this.limiter.duration,
+          },
+          'rate limiter failed to consume points',
+        )
+        return null
+      }
+    }
+  }
+}
+
+export const formatLimiterStatus = (
+  limiter: RateLimiterAbstract,
+  res: RateLimiterRes,
+): RateLimiterStatus => {
+  return {
+    limit: limiter.points,
+    duration: limiter.duration,
+    remainingPoints: res.remainingPoints,
+    msBeforeNext: res.msBeforeNext,
+    consumedPoints: res.consumedPoints,
+    isFirstInDuration: res.isFirstInDuration,
+  }
+}
+
+export const consumeMany = async (
+  ctx: XRPCReqContext,
+  fns: RateLimiterConsume[],
+): Promise<RateLimiterStatus | RateLimitExceededError | null> => {
+  if (fns.length === 0) return null
+  const results = await Promise.all(fns.map((fn) => fn(ctx)))
+  const tightestLimit = getTightestLimit(results)
+  if (tightestLimit === null) {
+    return null
+  } else if (tightestLimit instanceof RateLimitExceededError) {
+    setResHeaders(ctx, tightestLimit.status)
+    return tightestLimit
+  } else {
+    setResHeaders(ctx, tightestLimit)
+    return tightestLimit
+  }
+}
+
+export const setResHeaders = (
+  ctx: XRPCReqContext,
+  status: RateLimiterStatus,
+) => {
+  ctx.res.setHeader('RateLimit-Limit', status.limit)
+  ctx.res.setHeader('RateLimit-Remaining', status.remainingPoints)
+  ctx.res.setHeader(
+    'RateLimit-Reset',
+    Math.floor((Date.now() + status.msBeforeNext) / 1000),
+  )
+  ctx.res.setHeader('RateLimit-Policy', `${status.limit};w=${status.duration}`)
+}
+
+export const getTightestLimit = (
+  resps: (RateLimiterStatus | RateLimitExceededError | null)[],
+): RateLimiterStatus | RateLimitExceededError | null => {
+  let lowest: RateLimiterStatus | null = null
+  for (const resp of resps) {
+    if (resp === null) continue
+    if (resp instanceof RateLimitExceededError) return resp
+    if (lowest === null || resp.remainingPoints < lowest.remainingPoints) {
+      lowest = resp
+    }
+  }
+  return lowest
+}
+
+// when using a proxy, ensure headers are getting forwarded correctly: `app.set('trust proxy', true)`
+// https://expressjs.com/en/guide/behind-proxies.html
+const defaultKey: CalcKeyFn = (ctx: XRPCReqContext) => ctx.req.ip
+const defaultPoints: CalcPointsFn = () => 1

package/src/server.ts

@@ -30,6 +30,11 @@ import {
   XRPCStreamHandler,
   Params,
   InternalServerError,
+  XRPCReqContext,
+  RateLimiterI,
+  RateLimiterConsume,
+  isShared,
+  RateLimitExceededError,
 } from './types'
 import {
   decodeQueryParams,
@@ -38,6 +43,7 @@ import {
   validateOutput,
 } from './util'
 import log from './logger'
+import { consumeMany } from './rate-limiter'
 
 export function createServer(lexicons?: unknown[], options?: Options) {
   return new Server(lexicons, options)
@@ -50,6 +56,9 @@ export class Server {
   lex = new Lexicons()
   options: Options
   middleware: Record<'json' | 'text', RequestHandler>
+  globalRateLimiters: RateLimiterI[]
+  sharedRateLimiters: Record<string, RateLimiterI>
+  routeRateLimiterFns: Record<string, RateLimiterConsume[]>
 
   constructor(lexicons?: unknown[], opts?: Options) {
     if (lexicons) {
@@ -66,6 +75,27 @@ export class Server {
       json: express.json({ limit: opts?.payload?.jsonLimit }),
       text: express.text({ limit: opts?.payload?.textLimit }),
     }
+    this.globalRateLimiters = []
+    this.sharedRateLimiters = {}
+    this.routeRateLimiterFns = {}
+    if (opts?.rateLimits?.global) {
+      for (const limit of opts.rateLimits.global) {
+        const rateLimiter = opts.rateLimits.creator({
+          ...limit,
+          keyPrefix: `rl-${limit.name}`,
+        })
+        this.globalRateLimiters.push(rateLimiter)
+      }
+    }
+    if (opts?.rateLimits?.shared) {
+      for (const limit of opts.rateLimits.shared) {
+        const rateLimiter = opts.rateLimits.creator({
+          ...limit,
+          keyPrefix: `rl-${limit.name}`,
+        })
+        this.sharedRateLimiters[limit.name] = rateLimiter
+      }
+    }
   }
 
   // handlers
@@ -138,6 +168,7 @@ export class Server {
       middleware.push(this.middleware.json)
       middleware.push(this.middleware.text)
     }
+    this.setupRouteRateLimits(nsid, config)
     this.routes[verb](
       `/xrpc/${nsid}`,
       ...middleware,
@@ -185,6 +216,10 @@ export class Server {
             validateOutput(nsid, def, output, this.lex)
     const assertValidXrpcParams = (params: unknown) =>
       this.lex.assertValidXrpcParams(nsid, params)
+    const rlFns = this.routeRateLimiterFns[nsid] ?? []
+    const consumeRateLimit = (reqCtx: XRPCReqContext) =>
+      consumeMany(reqCtx, rlFns)
+
     return async function (req, res, next) {
       try {
         // validate request
@@ -203,14 +238,24 @@ export class Server {
 
         const locals: RequestLocals = req[kRequestLocals]
 
-        // run the handler
-        const outputUnvalidated = await handler({
+        const reqCtx: XRPCReqContext = {
           params,
           input,
           auth: locals.auth,
           req,
           res,
-        })
+        }
+
+        // handle rate limits
+        if (consumeRateLimit) {
+          const result = await consumeRateLimit(reqCtx)
+          if (result instanceof RateLimitExceededError) {
+            return next(result)
+          }
+        }
+
+        // run the handler
+        const outputUnvalidated = await handler(reqCtx)
 
         if (isHandlerError(outputUnvalidated)) {
           throw XRPCError.fromError(outputUnvalidated)
@@ -345,6 +390,56 @@ export class Server {
       return httpServer
     }
   }
+
+  private setupRouteRateLimits(nsid: string, config: XRPCHandlerConfig) {
+    this.routeRateLimiterFns[nsid] = []
+    for (const limit of this.globalRateLimiters) {
+      const consumeFn = async (ctx: XRPCReqContext) => {
+        return limit.consume(ctx)
+      }
+      this.routeRateLimiterFns[nsid].push(consumeFn)
+    }
+
+    if (config.rateLimit) {
+      const limits = Array.isArray(config.rateLimit)
+        ? config.rateLimit
+        : [config.rateLimit]
+      this.routeRateLimiterFns[nsid] = []
+      for (let i = 0; i < limits.length; i++) {
+        const limit = limits[i]
+        const { calcKey, calcPoints } = limit
+        if (isShared(limit)) {
+          const rateLimiter = this.sharedRateLimiters[limit.name]
+          if (rateLimiter) {
+            const consumeFn = (ctx: XRPCReqContext) =>
+              rateLimiter.consume(ctx, {
+                calcKey,
+                calcPoints,
+              })
+            this.routeRateLimiterFns[nsid].push(consumeFn)
+          }
+        } else {
+          const { durationMs, points } = limit
+          const rateLimiter = this.options.rateLimits?.creator({
+            keyPrefix: `nsid-${i}`,
+            durationMs,
+            points,
+            calcKey,
+            calcPoints,
+          })
+          if (rateLimiter) {
+            this.sharedRateLimiters[nsid] = rateLimiter
+            const consumeFn = (ctx: XRPCReqContext) =>
+              rateLimiter.consume(ctx, {
+                calcKey,
+                calcPoints,
+              })
+            this.routeRateLimiterFns[nsid].push(consumeFn)
+          }
+        }
+      }
+    }
+  }
 }
 
 function isHandlerSuccess(v: HandlerOutput): v is HandlerSuccess {
@@ -385,14 +480,23 @@ function createAuthMiddleware(verifier: AuthVerifier): RequestHandler {
 const errorMiddleware: ErrorRequestHandler = function (err, req, res, next) {
   const locals: RequestLocals | undefined = req[kRequestLocals]
   const methodSuffix = locals ? ` method ${locals.nsid}` : ''
-  if (err instanceof XRPCError) {
-    log.error(err, `error in xrpc${methodSuffix}`)
-  } else {
+  const xrpcError = XRPCError.fromError(err)
+  if (xrpcError instanceof InternalServerError) {
+    // log trace for unhandled exceptions
     log.error(err, `unhandled exception in xrpc${methodSuffix}`)
+  } else {
+    // do not log trace for known xrpc errors
+    log.error(
+      {
+        status: xrpcError.type,
+        message: xrpcError.message,
+        name: xrpcError.customErrorName,
+      },
+      `error in xrpc${methodSuffix}`,
+    )
   }
   if (res.headersSent) {
     return next(err)
   }
-  const xrpcError = XRPCError.fromError(err)
   return res.status(xrpcError.type).json(xrpcError.payload)
 }