Commit 1ad6f58

Health routes are exempt from rate limiting. Each returns `200` when healthy and `503` otherwise. Source: `src/api/routers/health.router.ts`, `src/api/services/health.service.ts`. Each dependency check is cached for 5 s per process, and concurrent callers share one check. A failed check returns no error text. The reason goes to the server log as a `Health check failed` warning. The `rest-api` container healthcheck reads `/health/database`, so a Redis stall does not mark the replicas unhealthy ([#405](https://github.com/docs-plus/docs.plus/issues/405)).

"database": { "status": "healthy", "lastCheck": "..." },

Liveness only. Answers `200` while the process is up. It calls no dependency, so it never answers `503`. The Traefik probe reads it. Use it for a load-balancer check.

Database connectivity (`SELECT 1`).

- **REST health checks are cached, and their bodies carry no error text.**

Each database, Redis and Supabase check is cached for 5 s per process. A

`/health` flood then costs at most one call per dependency every 5 s on

each replica. A failed check no longer returns driver error text. The

server logs the reason instead. The `rest-api` container healthcheck now

reads `/health/database`, so a Redis stall no longer marks both replicas

unhealthy and drops every `/api` route

([#405](https://github.com/docs-plus/docs.plus/issues/405)).

- **The `rest-api` Docker healthcheck reads `/health/database` on purpose ([#405](https://github.com/docs-plus/docs.plus/issues/405)).** Do not point it back at `/health`. Both replicas share one Redis, so a Redis stall marks both unhealthy, and Traefik then has no server for any `/api` route. Do not point it at `/health/live` either. The deploy waits on this status, so it needs a real dependency. Each REST health check is cached for 5 s per process, and a failure body carries no error text. The Settled rule against a Docker HEALTHCHECK change covers only the webapp Next probe.

import { restApiLogger } from '../../lib/logger'

const HEALTH_CACHE_MS = 5000

const cache = new Map<string, { at: number; result: Promise<HealthCheckResult> }>()

export const clearHealthCache = (): void => cache.clear()

const memo = (check: string, run: () => Promise<HealthCheckResult>): Promise<HealthCheckResult> => {

const hit = cache.get(check)

if (hit && Date.now() - hit.at < HEALTH_CACHE_MS) return hit.result

const result = run()

cache.set(check, { at: Date.now(), result })

return result

const unhealthy = (check: string, error: unknown): HealthCheckResult => {

restApiLogger.warn({ err: error, check }, 'Health check failed')

return { status: 'unhealthy', lastCheck: new Date() }

const runDatabaseCheck = async (prisma: PrismaClient): Promise<HealthCheckResult> => {

return unhealthy('database', error)

const runRedisCheck = async (redis: RedisClient | null): Promise<HealthCheckResult> => {

return unhealthy('redis', error)

const runSupabaseCheck = async (): Promise<HealthCheckResult> => {

return unhealthy('supabase', error)

export const checkDatabaseHealth = (prisma: PrismaClient): Promise<HealthCheckResult> =>

memo('database', () => runDatabaseCheck(prisma))

export const checkRedisHealth = (redis: RedisClient | null): Promise<HealthCheckResult> =>

memo('redis', () => runRedisCheck(redis))

export const checkSupabaseHealth = (): Promise<HealthCheckResult> =>

memo('supabase', runSupabaseCheck)

get: probe('getHealthDatabase', 'Database health', 'Connectivity (`SELECT 1`).')

import { clearHealthCache } from '../../src/api/services/health.service'

// Each test swaps the mocks, so a cached result would read the last test.

clearHealthCache()

expect(data).not.toHaveProperty('error')

test('should share one database query across calls inside the cache window', async () => {

let calls = 0

calls += 1

return [{ '?column?': 1 }]

await testServer.get('/health/database')

await testServer.get('/health/database')

expect(calls).toBe(1)

expect(data).not.toHaveProperty('error')

expect(data).not.toHaveProperty('error')

"fetch('http://localhost:4000/health/database').then(r => r.ok ? process.exit(0) : process.exit(1)).catch(() => process.exit(1))"