@rip-lang/server 1.3.111 → 1.3.112

package/control/lifecycle.rip

@@ -0,0 +1,71 @@
+# ==============================================================================
+# control/lifecycle.rip — startup, shutdown, reporting, and event logging
+# ==============================================================================
+
+# --- Structured event logging ---
+
+_jsonMode = false
+
+export setEventJsonMode = (enabled) -> _jsonMode = enabled
+
+export logEvent = (event, data = {}) ->
+  if _jsonMode
+    entry = Object.assign { t: new Date().toISOString(), event }, data
+    p JSON.stringify(entry)
+  else
+    parts = ["rip-server: #{event}"]
+    for key, val of data
+      parts.push "#{key}=#{val}" if val?
+    p parts.join(' ')
+
+# --- Startup reporting ---
+
+export computeHideUrls = (appEntry, joinFn, dirnameFn, existsSyncFn) ->
+  setupFile = joinFn(dirnameFn(appEntry), 'setup.rip')
+  existsSyncFn(setupFile)
+
+export logStartupSummary = (server, flags, buildRipdevUrlFn, formatPortFn) ->
+  httpOnly = flags.httpsPort is null
+  protocol = if httpOnly then 'http' else 'https'
+  port = flags.httpsPort or flags.httpPort or 80
+  url = buildRipdevUrlFn(flags.appName, protocol, port, formatPortFn)
+  p "rip-server: rip=#{server.ripVersion} server=#{server.serverVersion} app=#{flags.appName} workers=#{flags.workers} url=#{url}/server"
+
+FORCED_EXIT_MS = 35000
+
+export createCleanup = (pidFile, server, manager, unlinkSyncFn, fetchFn, processObj) ->
+  called = false
+  ->
+    return if called
+    called = true
+    p 'rip-server: shutting down...'
+
+    # Safety net: force exit if graceful shutdown stalls
+    setTimeout (-> processObj.exit(1)), FORCED_EXIT_MS
+
+    # Stop accepting new work before anything else
+    manager.shuttingDown = true
+
+    # Stop ACME renewal loop
+    try server.acmeManager?.stopRenewalLoop()
+
+    # Drain connections and stop listeners
+    server.stop()
+    manager.stop!
+
+    # Shutdown DB if we started it
+    try fetchFn!(manager.dbUrl + '/shutdown', { method: 'POST' }) if manager.dbUrl
+
+    # PID file cleanup last — only after everything has stopped
+    try unlinkSyncFn(pidFile)
+    processObj.exit(0)
+
+export installShutdownHandlers = (cleanup, processObj) ->
+  processObj.on 'SIGTERM', cleanup
+  processObj.on 'SIGINT', cleanup
+  processObj.on 'uncaughtException', (err) ->
+    console.error 'rip-server: uncaught exception:', err
+    cleanup()
+  processObj.on 'unhandledRejection', (err) ->
+    console.error 'rip-server: unhandled rejection:', err
+    cleanup()

package/control/mdns.rip

@@ -0,0 +1,53 @@
+# ==============================================================================
+# control/mdns.rip — mDNS and LAN detection helpers
+# ==============================================================================
+
+export getLanIP = (networkInterfacesFn) ->
+  try
+    nets = networkInterfacesFn()
+    for name, addrs of nets
+      for addr in addrs
+        continue if addr.internal or addr.family isnt 'IPv4'
+        continue if addr.address.startsWith('169.254.')  # Link-local
+        return addr.address
+  null
+
+export stopMdnsAdvertisements = (mdnsProcesses) ->
+  for [host, proc] as mdnsProcesses
+    try
+      proc.kill()
+      p "rip-server: stopped advertising #{host} via mDNS"
+  mdnsProcesses.clear()
+
+export startMdnsAdvertisement = (host, mdnsProcesses, getLanIP, flags, formatPort, publishUrl) ->
+  return unless host.endsWith('.local')
+  return if mdnsProcesses.has(host)
+
+  lanIP = getLanIP()
+  unless lanIP
+    p "rip-server: unable to detect LAN IP for mDNS advertisement of #{host}"
+    return
+
+  port = flags.httpsPort or flags.httpPort or 80
+  protocol = if flags.httpsPort then 'https' else 'http'
+  serviceType = if flags.httpsPort then '_https._tcp' else '_http._tcp'
+  serviceName = host.replace('.local', '')
+
+  try
+    proc = Bun.spawn [
+      'dns-sd', '-P'
+      serviceName
+      serviceType
+      'local'
+      String(port)
+      host
+      lanIP
+    ],
+      stdout: 'ignore'
+      stderr: 'ignore'
+
+    mdnsProcesses.set(host, proc)
+    url = "#{protocol}://#{host}#{formatPort(protocol, port)}"
+    publishUrl(url)
+  catch e
+    console.error "rip-server: failed to advertise #{host} via mDNS:", e.message

package/control/watchers.rip

@@ -0,0 +1,68 @@
+# ==============================================================================
+# control/watchers.rip — SSE watch groups and app directory watchers
+# ==============================================================================
+
+import { watch } from 'node:fs'
+
+# --- SSE watch groups ---
+
+export registerWatchGroup = (watchGroups, prefix) ->
+  return if watchGroups.has(prefix)
+  watchGroups.set prefix, { sseClients: new Set() }
+
+export handleWatchGroup = (watchGroups, prefix) ->
+  group = watchGroups.get(prefix)
+  return new Response('not-found', { status: 404 }) unless group
+  encoder = new TextEncoder()
+  client = null
+  new Response new ReadableStream(
+    start: (controller) ->
+      send = (type) ->
+        try controller.enqueue encoder.encode("event: #{if type is 'connected' then 'connected' else 'reload'}\ndata: #{type}\n\n")
+      client = { send }
+      group.sseClients.add(client)
+      send('connected')
+    cancel: ->
+      group.sseClients.delete(client) if client
+  ),
+    headers:
+      'Content-Type': 'text/event-stream'
+      'Cache-Control': 'no-cache'
+      'Connection': 'keep-alive'
+
+export broadcastWatchChange = (watchGroups, prefix, type = 'page') ->
+  group = watchGroups.get(prefix)
+  return unless group
+  dead = []
+  for client as group.sseClients
+    try client.send(type)
+    catch then dead.push(client)
+  group.sseClients.delete(c) for c in dead
+
+# --- App directory watchers ---
+
+export registerAppWatchDirs = (appWatchers, prefix, dirs, server, cwdFn) ->
+  return if appWatchers.has(prefix)
+  timer = null
+  pending = null
+  watchers = []
+  broadcast = (type = 'page') =>
+    pending = if type is 'page' or pending is 'page' then 'page' else 'styles'
+    clearTimeout(timer) if timer
+    timer = setTimeout =>
+      timer = null
+      server?.broadcastChange(prefix, pending)
+      pending = null
+    , 300
+  for dir in dirs
+    try
+      w = watch dir, { recursive: true }, (event, filename) ->
+        if filename?.endsWith('.rip') or filename?.endsWith('.html')
+          broadcast('page')
+        else if filename?.endsWith('.css')
+          broadcast('styles')
+      watchers.push(w)
+    catch e
+      rel = dir.replace(cwdFn() + '/', '')
+      warn "rip-server: watch skipped (#{e.code or 'error'}): #{rel}"
+  appWatchers.set prefix, { watchers, timer }

package/control/worker.rip

@@ -0,0 +1,136 @@
+# ==============================================================================
+# control/worker.rip — setup and worker child process runtime
+# ==============================================================================
+
+import { getControlSocketPath } from './control.rip'
+
+SHUTDOWN_TIMEOUT_MS = 30000   # Max time to wait for in-flight requests on shutdown
+
+export runSetupMode = ->
+  setupFile = process.env.RIP_SETUP_FILE
+  try
+    mod = import!(setupFile)
+    await Promise.resolve()
+    fn = mod?.setup or mod?.default
+    if typeof fn is 'function'
+      await fn()
+  catch e
+    console.error "rip-server: setup failed:", e
+    exit 1
+
+export runWorkerMode = ->
+  workerId = parseInt(process.env.WORKER_ID or '0')
+  maxRequests = parseInt(process.env.MAX_REQUESTS or '10000')
+  maxSeconds = parseInt(process.env.MAX_SECONDS or '0')
+  appEntry = process.env.APP_ENTRY
+  appId = process.env.APP_ID or 'default'
+  socketPath = process.env.SOCKET_PATH
+  socketPrefix = process.env.SOCKET_PREFIX
+  version = parseInt(process.env.RIP_VERSION or '1')
+
+  startedAtMs = Date.now()
+  # Use object to avoid Rip closure scoping issues with mutable variables
+  workerState =
+    appReady: false
+    inflight: false
+    handled: 0
+    handler: null
+
+  getHandler = ->
+    return workerState.handler if workerState.handler
+
+    try
+      mod = import!(appEntry)
+
+      # Ensure module has fully executed by yielding to microtask queue
+      await Promise.resolve()
+
+      fresh = mod.default or mod
+
+      if typeof fresh is 'function'
+        h = fresh
+      else if fresh?.fetch?
+        h = fresh.fetch.bind(fresh)
+      else
+        h = globalThis.__ripHandler  # Handler set by start() in rip-server mode
+
+      unless h
+        try
+          api = import!('@rip-lang/server')
+          h = api?.startHandler?.()
+
+      workerState.handler = h if h
+      workerState.handler or (-> new Response('not ready', { status: 503 }))
+    catch e
+      console.error "[worker #{workerId}] import failed:", e
+      workerState.handler or (-> new Response('not ready', { status: 503 }))
+
+  selfJoin = ->
+    try
+      payload = { op: 'join', workerId, pid: process.pid, socket: socketPath, version, appId }
+      body = JSON.stringify(payload)
+      ctl = getControlSocketPath(socketPrefix)
+      fetch!('http://localhost/worker', { method: 'POST', body, headers: { 'content-type': 'application/json' }, unix: ctl })
+
+  selfQuit = ->
+    try
+      payload = { op: 'quit', workerId, appId }
+      body = JSON.stringify(payload)
+      ctl = getControlSocketPath(socketPrefix)
+      fetch!('http://localhost/worker', { method: 'POST', body, headers: { 'content-type': 'application/json' }, unix: ctl })
+
+  # Preload handler
+  try
+    initial = getHandler!
+    workerState.appReady = typeof initial is 'function'
+
+  server = Bun.serve
+    unix: socketPath
+    maxRequestBodySize: 100 * 1024 * 1024
+    fetch: (req) ->
+      url = new URL(req.url)
+      return new Response(if workerState.appReady then 'ok' else 'not-ready') if url.pathname is '/ready'
+
+      if workerState.inflight
+        return new Response 'busy',
+          status: 503
+          headers: { 'Rip-Worker-Busy': '1', 'Retry-After': '0', 'Rip-Worker-Id': String(workerId) }
+
+      handlerFn = getHandler!
+      workerState.appReady = typeof handlerFn is 'function'
+      workerState.inflight = true
+
+      try
+        return new Response('not ready', { status: 503 }) unless typeof handlerFn is 'function'
+        res = handlerFn!(req)
+        res = res!(req) if typeof res is 'function'
+        if res instanceof Response then res else new Response(String(res))
+      catch err
+        console.error "[worker #{workerId}] ERROR:", err
+        new Response('error', { status: 500 })
+      finally
+        workerState.inflight = false
+        workerState.handled++
+        exceededReqs = workerState.handled >= maxRequests
+        exceededTime = maxSeconds > 0 and (Date.now() - startedAtMs) / 1000 >= maxSeconds
+        setTimeout (-> exit 0), 10 if exceededReqs or exceededTime
+
+  selfJoin!
+
+  shutdown = ->
+    # Wait for in-flight request to complete (with timeout)
+    start = Date.now()
+    while workerState.inflight and Date.now() - start < SHUTDOWN_TIMEOUT_MS
+      await new Promise (r) -> setTimeout(r, 10)
+    try server.stop()
+    selfQuit!
+    exit 0
+
+  process.on 'SIGTERM', shutdown
+  process.on 'SIGINT', shutdown
+  process.on 'uncaughtException', (err) ->
+    console.error "[worker #{workerId}] uncaught exception:", err
+    shutdown()
+  process.on 'unhandledRejection', (err) ->
+    console.error "[worker #{workerId}] unhandled rejection:", err
+    shutdown()

package/control/workers.rip

@@ -0,0 +1,53 @@
+# ==============================================================================
+# control/workers.rip — manager-side worker spawn, health, and control
+# ==============================================================================
+
+import { unlinkSync } from 'node:fs'
+import { getWorkerSocketPath, getControlSocketPath } from './control.rip'
+
+# --- Spawn ---
+
+export spawnTrackedWorker = (flags, workerId, version, nowMsFn, importMetaPath, appId) ->
+  socketPath = getWorkerSocketPath(flags.socketPrefix, workerId)
+  try unlinkSync(socketPath)
+
+  workerEnv = Object.assign {}, process.env,
+    RIP_WORKER_MODE: '1'
+    WORKER_ID: String(workerId)
+    SOCKET_PATH: socketPath
+    SOCKET_PREFIX: flags.socketPrefix
+    APP_ID: String(appId or flags.appName or 'default')
+    APP_ENTRY: flags.appEntry
+    APP_BASE_DIR: flags.appBaseDir
+    MAX_REQUESTS: String(flags.maxRequestsPerWorker)
+    MAX_SECONDS: String(flags.maxSecondsPerWorker)
+    RIP_LOG_JSON: if flags.jsonLogging then '1' else '0'
+    RIP_VERSION: String(version)
+
+  proc = Bun.spawn ['rip', importMetaPath],
+    stdout: 'inherit'
+    stderr: 'inherit'
+    stdin: 'ignore'
+    cwd: process.cwd()
+    env: workerEnv
+
+  { id: workerId, process: proc, socketPath, restartCount: 0, backoffMs: 1000, startedAt: nowMsFn() }
+
+# --- Health and control notifications ---
+
+export postWorkerQuit = (socketPrefix, workerId) ->
+  try
+    ctl = getControlSocketPath(socketPrefix)
+    body = JSON.stringify({ op: 'quit', workerId })
+    fetch!('http://localhost/worker', { method: 'POST', body, headers: { 'content-type': 'application/json' }, unix: ctl })
+
+export waitForWorkerReady = (socketPath, timeoutMs = 5000) ->
+  start = Date.now()
+  while Date.now() - start < timeoutMs
+    try
+      res = fetch!('http://localhost/ready', { unix: socketPath, method: 'GET' })
+      if res.ok
+        txt = res.text!
+        return true if txt is 'ok'
+    await new Promise (r) -> setTimeout(r, 30)
+  false

package/edge/config.rip

@@ -0,0 +1,75 @@
+# ==============================================================================
+# edge/config.rip — declarative multi-app configuration loader
+# ==============================================================================
+#
+# Loads config.rip from the app directory and registers apps in the registry.
+#
+# Example config.rip:
+#
+#   export default
+#     apps:
+#       main:
+#         entry: './index.rip'
+#         hosts: ['example.com', 'www.example.com']
+#         workers: 4
+#       api:
+#         entry: './api/index.rip'
+#         hosts: ['api.example.com']
+#         workers: 2
+#         maxQueue: 1024
+
+import { existsSync } from 'node:fs'
+import { join, dirname, resolve } from 'node:path'
+
+export loadConfig = (configPath) ->
+  return null unless existsSync(configPath)
+  try
+    mod = import!(configPath)
+    await Promise.resolve()
+    config = mod?.default or mod
+    return null unless config and typeof config is 'object'
+    config
+  catch e
+    console.error "rip-server: failed to load config.rip:", e.message
+    null
+
+export normalizeAppConfig = (appId, appConfig, baseDir) ->
+  entry = if appConfig.entry
+    if appConfig.entry.startsWith('/') then appConfig.entry else resolve(baseDir, appConfig.entry)
+  else
+    null
+  hosts = appConfig.hosts or []
+  workers = appConfig.workers or null
+  maxQueue = appConfig.maxQueue or 512
+  queueTimeoutMs = appConfig.queueTimeoutMs or 30000
+  readTimeoutMs = appConfig.readTimeoutMs or 30000
+
+  {
+    id: appId
+    entry
+    hosts
+    workers
+    maxQueue
+    queueTimeoutMs
+    readTimeoutMs
+    env: appConfig.env or {}
+  }
+
+export findConfigFile = (appEntry) ->
+  dir = dirname(appEntry)
+  configPath = join(dir, 'config.rip')
+  if existsSync(configPath) then configPath else null
+
+export applyConfig = (config, registry, registerAppFn, baseDir) ->
+  apps = config.apps or {}
+  registered = []
+  for appId, appConfig of apps
+    normalized = normalizeAppConfig(appId, appConfig, baseDir)
+    registerAppFn(registry, appId,
+      hosts: normalized.hosts
+      maxQueue: normalized.maxQueue
+      queueTimeoutMs: normalized.queueTimeoutMs
+      readTimeoutMs: normalized.readTimeoutMs
+    )
+    registered.push(normalized)
+  registered

package/edge/forwarding.rip

@@ -0,0 +1,149 @@
+# ==============================================================================
+# edge/forwarding.rip — helpers, responses, forwarding, and proxy
+# ==============================================================================
+
+import { randomBytes } from 'node:crypto'
+
+# --- Edge utilities ---
+
+export generateRequestId = ->
+  "req-#{randomBytes(6).toString('hex')}"
+
+export formatPort = (protocol, port) ->
+  if (protocol is 'https' and port is 443) or (protocol is 'http' and port is 80)
+    ''
+  else
+    ":#{port}"
+
+export maybeAddSecurityHeaders = (httpsActive, hstsEnabled, headers) ->
+  if httpsActive and hstsEnabled
+    headers.set('strict-transport-security', 'max-age=31536000; includeSubDomains') unless headers.has('strict-transport-security')
+
+export buildStatusBody = (startedAt, workerCount, hostIndex, serverVersion, appName, httpPort, httpsPort, nowMsFn) ->
+  uptime = Math.floor((nowMsFn() - startedAt) / 1000)
+  healthy = workerCount > 0
+  hosts = Array.from(hostIndex.keys())
+  JSON.stringify
+    status: if healthy then 'healthy' else 'degraded'
+    version: serverVersion
+    app: appName
+    workers: workerCount
+    ports: { http: httpPort or undefined, https: httpsPort or undefined }
+    uptime: uptime
+    hosts: hosts
+
+export buildRipdevUrl = (appName, protocol, port, formatPortFn) ->
+  "#{protocol}://#{appName}.ripdev.io#{formatPortFn(protocol, port)}"
+
+# --- Responses ---
+
+export watchUnavailableResponse = ->
+  new Response('', { status: 503, headers: { 'Retry-After': '2' } })
+
+export serverBusyResponse = ->
+  new Response('Server busy', { status: 503, headers: { 'Retry-After': '1' } })
+
+export serviceUnavailableResponse = ->
+  new Response('Service unavailable', { status: 503, headers: { 'Retry-After': '1' } })
+
+export gatewayTimeoutResponse = ->
+  new Response('Gateway timeout', { status: 504 })
+
+export queueTimeoutResponse = ->
+  new Response('Queue timeout', { status: 504 })
+
+export buildUpstreamResponse = (res, req, totalSeconds, workerSeconds, maybeAddSecurityHeaders, logAccess, stripInternalHeaders) ->
+  silent = res.headers.get('rip-no-log') is '1'
+  headers = stripInternalHeaders(res.headers)
+  headers.delete('date')
+  maybeAddSecurityHeaders(headers)
+  logAccess(req, res, totalSeconds, workerSeconds) unless silent
+  new Response(res.body, { status: res.status, statusText: res.statusText, headers })
+
+# --- Reverse proxy to external upstream ---
+
+HOP_HEADERS = new Set([
+  'connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization'
+  'te', 'trailer', 'transfer-encoding', 'upgrade'
+])
+
+export proxyToUpstream = (req, upstreamBase, options = {}) ->
+  inUrl = new URL(req.url)
+  target = "#{upstreamBase}#{inUrl.pathname}#{inUrl.search}"
+  timeoutMs = options.timeoutMs or 30000
+  clientIp = options.clientIp or '127.0.0.1'
+
+  # Forward headers, set X-Forwarded-* (overwrite, not append — prevents spoofing)
+  headers = new Headers()
+  for [key, val] as req.headers.entries()
+    headers.set(key, val) unless HOP_HEADERS.has(key.toLowerCase())
+  headers.set('X-Forwarded-For', clientIp)
+  headers.set('X-Forwarded-Proto', if inUrl.protocol is 'https:' then 'https' else 'http')
+  headers.set('X-Forwarded-Host', inUrl.host)
+
+  timer = null
+  try
+    fetchPromise = fetch target,
+      method: req.method
+      headers: headers
+      body: req.body
+      redirect: 'manual'
+    readGuard = new Promise (_, rej) ->
+      timer = setTimeout (-> rej(new Error('Upstream timeout'))), timeoutMs
+    res = Promise.race!([fetchPromise, readGuard])
+    clearTimeout(timer)
+
+    # Strip hop-by-hop headers from response
+    resHeaders = new Headers()
+    for [key, val] as res.headers.entries()
+      resHeaders.set(key, val) unless HOP_HEADERS.has(key.toLowerCase())
+    new Response(res.body, { status: res.status, statusText: res.statusText, headers: resHeaders })
+  catch err
+    clearTimeout(timer)
+    if err.message is 'Upstream timeout'
+      return new Response('Gateway timeout', { status: 504 })
+    new Response("Bad gateway: #{err.message}", { status: 502 })
+
+# --- WebSocket passthrough to external upstream ---
+
+export createWsPassthrough = (clientWs, upstreamUrl) ->
+  upstream = new WebSocket(upstreamUrl)
+
+  upstream.addEventListener 'open', ->
+    null  # upstream connected
+
+  upstream.addEventListener 'message', (event) ->
+    try clientWs.send(event.data)
+
+  upstream.addEventListener 'close', ->
+    try clientWs.close()
+
+  upstream.addEventListener 'error', (err) ->
+    console.error "ws-passthrough: upstream error:", err.message or err
+    try clientWs.close()
+
+  # Return object for client-side event wiring
+  sendToUpstream: (data) ->
+    try upstream.send(data) if upstream.readyState is WebSocket.OPEN
+  close: ->
+    try upstream.close() if upstream.readyState is WebSocket.OPEN
+
+# --- Worker forwarding ---
+
+export forwardOnceWithTimeout = (req, socketPath, readTimeoutMs, gatewayTimeoutResponse) ->
+  inUrl = new URL(req.url)
+  forwardUrl = "http://localhost#{inUrl.pathname}#{inUrl.search}"
+  timer = null
+
+  try
+    fetchPromise = fetch(forwardUrl, { method: req.method, headers: req.headers, body: req.body, unix: socketPath, decompress: false })
+    readGuard = new Promise (_, rej) ->
+      timer = setTimeout (-> rej(new Error('Upstream timeout'))), readTimeoutMs
+    res = Promise.race!([fetchPromise, readGuard])
+    clearTimeout(timer)
+    res
+  catch err
+    clearTimeout(timer)
+    if err.message is 'Upstream timeout'
+      return gatewayTimeoutResponse()
+    throw err

package/edge/metrics.rip

@@ -0,0 +1,85 @@
+# ==============================================================================
+# edge/metrics.rip — lightweight in-process metrics collector
+# ==============================================================================
+
+LATENCY_WINDOW = 1000
+
+export createMetrics = ->
+  latencies = []
+  latencyIdx = 0
+
+  m =
+    # Counters (monotonically increasing)
+    requests: 0
+    responses2xx: 0
+    responses4xx: 0
+    responses5xx: 0
+    forwarded: 0
+    queued: 0
+    queueTimeouts: 0
+    queueShed: 0
+    workerRestarts: 0
+    acmeRenewals: 0
+    acmeFailures: 0
+    wsConnections: 0
+    wsMessages: 0
+    wsDeliveries: 0
+
+    # Record a request latency (seconds)
+    recordLatency: (seconds) ->
+      if latencies.length < LATENCY_WINDOW
+        latencies.push(seconds)
+      else
+        latencies[latencyIdx] = seconds
+      latencyIdx = (latencyIdx + 1) % LATENCY_WINDOW
+
+    # Record a response by status code class
+    recordStatus: (status) ->
+      if status >= 200 and status < 300
+        m.responses2xx++
+      else if status >= 400 and status < 500
+        m.responses4xx++
+      else if status >= 500
+        m.responses5xx++
+
+    # Compute latency percentiles from the rolling window
+    percentiles: ->
+      return { p50: 0, p95: 0, p99: 0 } if latencies.length is 0
+      sorted = [...latencies].sort((a, b) -> a - b)
+      n = sorted.length
+      pick = (p) -> sorted[Math.min(Math.floor(n * p), n - 1)]
+      { p50: pick(0.50), p95: pick(0.95), p99: pick(0.99) }
+
+    # Full snapshot of all metrics
+    snapshot: (startedAt, appRegistry) ->
+      totalInflight = 0
+      totalQueueDepth = 0
+      apps = []
+      if appRegistry
+        for [appId, app] as appRegistry.apps
+          totalInflight += app.inflightTotal
+          totalQueueDepth += app.queue.length
+          apps.push
+            id: appId
+            workers: app.sockets.length
+            inflight: app.inflightTotal
+            queueDepth: app.queue.length
+      uptimeSeconds = if startedAt then Math.floor((Date.now() - startedAt) / 1000) else 0
+
+      uptime: uptimeSeconds
+      apps: apps
+      counters:
+        requests: m.requests
+        responses: { '2xx': m.responses2xx, '4xx': m.responses4xx, '5xx': m.responses5xx }
+        forwarded: m.forwarded
+        queue: { queued: m.queued, timeouts: m.queueTimeouts, shed: m.queueShed }
+        workers: { restarts: m.workerRestarts }
+        acme: { renewals: m.acmeRenewals, failures: m.acmeFailures }
+        websocket: { connections: m.wsConnections, messages: m.wsMessages, deliveries: m.wsDeliveries }
+      gauges:
+        workersActive: apps.reduce(((sum, a) -> sum + a.workers), 0)
+        inflight: totalInflight
+        queueDepth: totalQueueDepth
+      latency: m.percentiles()
+
+  m