1// app/api/healthz/route.ts — liveness probe (always fast)
2export async function GET() {
3  // ONLY checks if the process is running. No DB. No Redis.
4  // If this fails: the process is dead — Kubernetes should restart it.
5  return Response.json({ status: 'ok', ts: Date.now() }, { status: 200 });
6}
7 
8// app/api/readyz/route.ts — readiness probe (checks dependencies)
9import { db } from '@/lib/db';
10import { redis } from '@/lib/redis';
11 
12export async function GET() {
13  const checks: Record<string, boolean> = {};
14 
15  // DB check: can we execute a query? (with timeout)
16  try {
17    await Promise.race([
18      db.$queryRaw`SELECT 1`,
19      new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 2000)),
20    ]);
21    checks.db = true;
22  } catch {
23    checks.db = false;
24  }
25 
26  // Redis check: can we ping?
27  try {
28    await redis.ping();
29    checks.redis = true;
30  } catch {
31    checks.redis = false;
32  }
33 
34  const ready = Object.values(checks).every(Boolean);
35  // Return 503 if NOT ready — Kubernetes removes pod from load balancer
36  return Response.json({ status: ready ? 'ready' : 'not ready', checks }, {
37    status: ready ? 200 : 503,
38  });
39}
40 
41// OpenTelemetry trace around createApplication
42import { trace, SpanStatusCode } from '@opentelemetry/api';
43 
44const tracer = trace.getTracer('job-board-api');
45 
46export async function createApplication(data: CreateApplicationInput) {
47  return tracer.startActiveSpan('createApplication', async (span) => {
48    span.setAttributes({
49      'app.userId': data.userId,
50      'app.jobId': data.jobId,
51    });
52    try {
53      const application = await db.application.create({ data });
54      span.setStatus({ code: SpanStatusCode.OK });
55      return application;
56    } catch (error) {
57      span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
58      span.recordException(error as Error);
59      throw error;
60    } finally {
61      span.end();
62    }
63  });
64}
65// Structured log output:
66// { traceId: "abc123", spanId: "def456", userId: "user_789",
67//   operation: "createApplication", error: "Foreign key constraint...", duration: 84 }

1# .github/workflows/deploy.yml
2name: Deploy to Fly.io
3 
4on:
5  push:
6    branches: [main]
7 
8jobs:
9  test:
10    runs-on: ubuntu-latest
11    steps:
12      - uses: actions/checkout@v4
13      - uses: actions/setup-node@v4
14        with: { node-version: '20' }
15      - run: npm ci && npm test
16 
17  deploy:
18    needs: test
19    runs-on: ubuntu-latest
20    steps:
21      - uses: actions/checkout@v4
22      - uses: superfly/flyctl-actions/setup-flyctl@master
23      - run: flyctl deploy --remote-only
24        env:
25          FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}
26 
27# fly.toml — health checks + rolling deploy
28# [http_service]
29#   internal_port = 3000
30#   [http_service.checks]
31#     [http_service.checks.health]
32#       grace_period = "5s"
33#       interval = "15s"
34#       method = "GET"
35#       path = "/api/healthz"
36#       timeout = "2s"
37#     [http_service.checks.ready]
38#       grace_period = "10s"
39#       interval = "15s"
40#       method = "GET"
41#       path = "/api/readyz"
42#       timeout = "5s"
43 
44# Rate limiting middleware — Upstash Redis sliding window
45# middleware.ts
46import { Ratelimit } from '@upstash/ratelimit';
47import { Redis } from '@upstash/redis';
48 
49const ratelimit = new Ratelimit({
50  redis: Redis.fromEnv(),
51  limiter: Ratelimit.slidingWindow(10, '1 h'), // 10 per user per hour
52});
53 
54export async function middleware(req: NextRequest) {
55  const userId = req.headers.get('x-user-id') ?? req.ip ?? 'anonymous';
56  const { success, reset } = await ratelimit.limit(`apply:${userId}`);
57  if (!success) {
58    return new NextResponse('Too Many Requests', {
59      status: 429,
60      headers: { 'Retry-After': String(Math.ceil((reset - Date.now()) / 1000)) },
61    });
62  }
63}

1// instrumentation.ts — Next.js OTel initialization
2import { NodeSDK } from '@opentelemetry/sdk-node';
3import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
4import { PrismaInstrumentation } from '@prisma/instrumentation';
5 
6export function register() {
7  const sdk = new NodeSDK({
8    traceExporter: new OTLPTraceExporter({
9      url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT, // Jaeger, Honeycomb, etc.
10    }),
11    instrumentations: [
12      new PrismaInstrumentation(), // Auto-traces all Prisma queries
13    ],
14    serviceName: 'job-board-api',
15  });
16  sdk.start();
17}
18 
19// Complete production additions summary:
20// 1. instrumentation.ts → OTel SDK (traces all Next.js routes + Prisma)
21// 2. app/api/healthz/route.ts → return 200 immediately (liveness)
22// 3. app/api/readyz/route.ts → check DB + Redis (readiness)
23// 4. middleware.ts → Upstash rate limiting (10 apps/user/hour)
24// 5. fly.toml → http_checks for /api/healthz + /api/readyz
25// 6. .github/workflows/deploy.yml → test → deploy on merge to main
26 
27// Zero-downtime deploy sequence (Fly.io rolling update):
28// 1. flyctl deploy starts → new container image built
29// 2. New pod starts → /api/healthz returns 200 → Fly marks it healthy
30// 3. /api/readyz returns 200 → Fly adds pod to load balancer
31// 4. Old pod drains (finishes in-flight requests, max 30s)
32// 5. Old pod terminated — zero dropped requests throughout
33 
34// If new pod fails /api/readyz: Fly never adds it to load balancer.
35// If new pod fails /api/healthz: Fly terminates it, rolls back to previous.