NestJS

import { createReplayStackClient, type ReplayStack } from "@replaystack/sdk";

const apiKey = process.env.REPLAYSTACK_API_KEY?.trim();
if (!apiKey) {
  console.error("Missing REPLAYSTACK_API_KEY. Copy .env.example to .env.");
  process.exit(1);
}

/** Shared singleton — import in AppModule providers below. */
export const replayStack: ReplayStack = createReplayStackClient({
  apiKey,
  endpoint: process.env.REPLAYSTACK_ENDPOINT,
  serviceName: process.env.REPLAYSTACK_SERVICE_NAME ?? "nestjs-api",
  environment: process.env.NODE_ENV ?? "development",
  appVersion: process.env.APP_VERSION,
  commitHash: process.env.COMMIT_HASH,
  captureSuccess: true,
});

import { Module } from "@nestjs/common";
import { APP_FILTER, APP_INTERCEPTOR } from "@nestjs/core";
import {
  createReplayStackNestExceptionFilter,
  createReplayStackNestInterceptor,
} from "@replaystack/sdk/nestjs";
import { replayStack } from "./replaystack.instance";

function endpointPath(url: string | undefined): string {
  if (!url) return "";
  try {
    const p = url.startsWith("http") ? new URL(url).pathname : url;
    return p.split("?")[0] ?? "";
  } catch {
    return url.split("?")[0] ?? "";
  }
}

@Module({
  imports: [],
  providers: [
    {
      provide: APP_INTERCEPTOR,
      useClass: createReplayStackNestInterceptor({
        client: replayStack,
        captureRequestBody: true,
        captureResponseBody: true,
        captureHeaders: true,
        shouldCapture: ({ endpoint }) => endpointPath(endpoint) !== "/health",
      }),
    },
    {
      provide: APP_FILTER,
      useClass: createReplayStackNestExceptionFilter({
        client: replayStack,
        captureRequestBody: true,
        captureResponseBody: true,
        captureHeaders: true,
      }),
    },
  ],
})
export class AppModule {}

import { Module, Global } from "@nestjs/common";
import { createReplayStackClient } from "@replaystack/sdk";

@Global()
@Module({
  providers: [
    {
      provide: "REPLAYSTACK_CLIENT",
      useFactory: () =>
        createReplayStackClient({
          apiKey: process.env.REPLAYSTACK_API_KEY!,
          endpoint: process.env.REPLAYSTACK_ENDPOINT!,
          serviceName: process.env.REPLAYSTACK_SERVICE_NAME || "nestjs-api",
          environment: process.env.NODE_ENV || "development",
          appVersion: process.env.APP_VERSION,
          commitHash: process.env.COMMIT_HASH,
          ignoredPaths: ["/health", "/metrics"],
          sampleRate: 1,
        }),
    },
  ],
  exports: ["REPLAYSTACK_CLIENT"],
})
export class ReplayStackModule {}

import {
  CallHandler,
  ExecutionContext,
  Inject,
  Injectable,
  NestInterceptor,
} from "@nestjs/common";
import { Observable, tap, catchError, throwError } from "rxjs";
import type { ReplayStack } from "@replaystack/sdk";

/** Advanced: manual capture. Prefer createReplayStackNestInterceptor from @replaystack/sdk/nestjs in production. */
@Injectable()
export class ReplayStackInterceptor implements NestInterceptor {
  constructor(
    @Inject("REPLAYSTACK_CLIENT")
    private readonly replayStack: ReplayStack
  ) {}

  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
    const startedAt = Date.now();
    const http = context.switchToHttp();
    const req = http.getRequest();

    return next.handle().pipe(
      tap(async (responseBody) => {
        await this.replayStack.captureEvent({
          eventType: "api",
          method: req.method,
          endpoint: req.originalUrl || req.url,
          requestHeaders: req.headers,
          requestPayload: req.body,
          responsePayload: responseBody,
          status: "success",
          statusCode: 200,
          executionTimeMs: Date.now() - startedAt,
          sourceIp: req.ip,
          userAgent: req.headers["user-agent"],
        });
      }),
      catchError((error) => throwError(() => error))
    );
  }
}

import {
  ArgumentsHost,
  Catch,
  ExceptionFilter,
  HttpException,
  Inject,
} from "@nestjs/common";
import type { ReplayStack } from "@replaystack/sdk";

@Catch()
export class ReplayStackExceptionFilter implements ExceptionFilter {
  constructor(
    @Inject("REPLAYSTACK_CLIENT")
    private readonly replayStack: ReplayStack
  ) {}

  async catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const req = ctx.getRequest();
    const res = ctx.getResponse();

    const statusCode =
      exception instanceof HttpException ? exception.getStatus() : 500;

    const error = exception as Error;

    await this.replayStack.captureException(error, {
      eventType: "api",
      method: req.method,
      endpoint: req.originalUrl || req.url,
      requestHeaders: req.headers,
      requestPayload: req.body,
      responsePayload: {
        message: error.message || "Internal Server Error",
      },
      statusCode,
      executionTimeMs: 0,
      sourceIp: req.ip,
      userAgent: req.headers["user-agent"],
    });

    res.status(statusCode).json({
      statusCode,
      message: error.message || "Internal Server Error",
    });
  }
}

import { Module } from "@nestjs/common";
import { APP_FILTER, APP_INTERCEPTOR } from "@nestjs/core";
import { ReplayStackModule } from "./replaystack.module";
import { ReplayStackInterceptor } from "./replaystack.interceptor";
import { ReplayStackExceptionFilter } from "./replaystack-exception.filter";

@Module({
  imports: [ReplayStackModule],
  providers: [
    { provide: APP_INTERCEPTOR, useClass: ReplayStackInterceptor },
    { provide: APP_FILTER, useClass: ReplayStackExceptionFilter },
  ],
})
export class AppModule {}