@telorun/http-server 0.15.2 → 0.16.1

package/CHANGELOG.md

@@ -1,5 +1,91 @@
 # @telorun/http-server
 
+## 0.16.1
+
+### Patch Changes
+
+- e960991: Fix `Http.Server` failing to boot under Fastify 5, and derive request logging
+  from the logging pipeline rather than a per-server flag.
+
+  The Telo-backed logger adapter was passed to Fastify's `logger:` option, which
+  in Fastify 5 only accepts a boolean or config object — a custom instance must go
+  through `loggerInstance:`. Booting a server with request logging on threw
+  `FST_ERR_LOG_INVALID_LOGGER_CONFIG` at construction. The adapter is now wired
+  through `loggerInstance`.
+
+  The `logger:` manifest field is **removed**. Whether the server instruments
+  requests is derived from its resolved logging scope threshold: Fastify's
+  per-request access lines are `info`-severity, so they appear whenever the
+  server's scope is at `info` or below (the default) and are suppressed by raising
+  the http-server import to `level: warn` — which also skips the per-request work
+  entirely instead of building a record and discarding it. A boolean toggle only
+  duplicated what the threshold already expresses (`warn` keeps server error logs
+  while dropping access noise, since they differ in severity). The Server schema is
+  open, so an existing `logger:` value validates and is ignored.
+
+## 0.16.0
+
+### Minor Changes
+
+- c1fef72: Implement the structured logging specification (`kernel/specs/logging.md`).
+
+  Records carry an OTel severity number, a message, structured attributes, the
+  emitting resource's identity, its import-alias scope, and the active dispatch
+  span's trace and span ids — all attached automatically. Controllers emit through
+  the new ambient `ctx.log`.
+
+  Logging is configured by a `logging:` block on the root `Telo.Application`:
+  `level`, `attributes`, `redact`, `sampling`, and a `sinks:` list of ref-or-inline
+  entries. `Telo.ConsoleSink` and `Telo.FileSink` are kernel built-ins resolvable
+  without an import; omitting `sinks:` yields exactly one console sink, so the
+  zero-config case stays "pretty on a terminal, JSON when piped". An `imports:`
+  entry may carry its own `logging:` block to raise verbosity for that dependency's
+  subtree; config cascades and may be narrowed at each hop. There is no
+  `TELO_LOG_*` variable and no logging CLI flag — a level derived from the host
+  environment goes through a `variables:` entry read with `!cel`.
+
+  New `Telo.Sink` capability and `Telo.LogSink` abstract, so the sink set is open
+  to the ecosystem: a third party ships a sink by publishing a module whose kind
+  extends `Telo.LogSink`. The new `std/otlp` module does exactly that.
+
+  Behaviour changes:
+
+  - The CLI now honours `NO_COLOR` and implements the spec's full color-precedence
+    order. `FORCE_COLOR=0` disables color rather than enabling it.
+  - `TracePayload.spanId` / `parentSpanId` on the debug wire are now 16-character
+    lowercase hex strings rather than numeric counters, matching the ids log
+    records carry. The internal counter is unchanged; hex is rendered only at the
+    encoding boundary and is salted per process so two services in one distributed
+    trace cannot mint the same id.
+  - `Http.Server`'s `logger:` field now means "enable request logging" rather than
+    being a raw Fastify passthrough. Fastify's Pino instance is replaced with a
+    Telo-backed adapter, so request records inherit the root `logging:` block's
+    level, encoding, redaction, and sinks.
+  - The kernel no longer writes diagnostics to `process.stderr` or `console.*`;
+    everything routes through the logger. The ad-hoc `TELO_BUNDLE_DEBUG` env var is
+    replaced by ordinary trace-level records.
+  - `on_full: block` and invalid redaction paths are now caught by `telo check`
+    (static analysis), not only at boot — `on_full: block` is unimplementable on a
+    single-threaded runtime and a bad redaction path would otherwise silently fail
+    to redact. Both remain enforced at runtime as a backstop.
+
+  Two pre-existing bugs fixed along the way:
+
+  - A CEL expression feeding **any** enum-constrained field produced a spurious
+    `SCHEMA_VIOLATION`, because the placeholder substituted for the expression
+    satisfied `type` but violated `enum`. Fixed in both the analyzer and the
+    kernel.
+  - `teardownResources` aborted the whole cascade on the first throwing resource,
+    with no aggregation and no reporting. Failures are now collected into
+    `ERR_TEARDOWN_FAILED` so one bad teardown cannot skip the rest — including the
+    log sinks, which are pinned to tear down last.
+  - The inline `imports:` desugaring silently dropped unknown entry fields, so a
+    per-import `logging:` block never reached the import controller.
+
+### Patch Changes
+
+- @telorun/http-dispatch@0.4.1
+
 ## 0.15.2
 
 ### Patch Changes

package/dist/fastify-telo-logger.d.ts

@@ -0,0 +1,29 @@
+import { pinoLevelForSeverity, severityForPinoLevel, type Logger } from "@telorun/sdk";
+/**
+ * A Telo-backed logger injected into Fastify — `kernel/specs/logging.md` §13.3.
+ *
+ * Replacement, not bridging. Fastify accepts an injected logger satisfying a
+ * small interface, so its records are Telo records **from the moment they are
+ * created**: no format to translate, no second pipeline, and no possibility of
+ * the two diverging. Bridging — intercepting the stream Pino writes and
+ * re-parsing it — is strictly worse and is reserved for libraries that offer no
+ * injection point.
+ *
+ * This also removes the duplication where a mid-stream failure was both logged
+ * to Pino and separately re-emitted as an event for debug tooling: with the
+ * adapter in place, one record reaches every sink, including the debug wire.
+ */
+/** The subset of Pino's interface Fastify actually calls. */
+export interface FastifyLogger {
+    level: string;
+    fatal(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    trace(...args: unknown[]): void;
+    silent(...args: unknown[]): void;
+    child(bindings: Record<string, unknown>, options?: unknown): FastifyLogger;
+}
+export declare function createFastifyTeloLogger(log: Logger): FastifyLogger;
+export { pinoLevelForSeverity, severityForPinoLevel };

package/dist/fastify-telo-logger.js

@@ -0,0 +1,109 @@
+import { pinoLevelForSeverity, SEVERITY, severityForPinoLevel, severityText, } from "@telorun/sdk";
+export function createFastifyTeloLogger(log) {
+    const emit = (severity, args) => {
+        if (!log.enabled(severity))
+            return;
+        const { message, attributes, error } = splitPinoArgs(args);
+        log.log(severity, message, attributes, error === undefined ? undefined : { error });
+    };
+    return {
+        // Fastify reads `level` to decide whether to build a request-log object at
+        // all. Reporting the most verbose level Telo would accept keeps that gate
+        // aligned with the pipeline's own, which is the real threshold.
+        get level() {
+            for (const severity of [SEVERITY.trace, SEVERITY.debug, SEVERITY.info, SEVERITY.warn]) {
+                if (log.enabled(severity))
+                    return severityText(severity).toLowerCase();
+            }
+            return log.enabled(SEVERITY.error) ? "error" : "silent";
+        },
+        set level(_value) {
+            // Fastify may try to set a level; the manifest is the only configuration
+            // source (D6), so this is deliberately inert.
+        },
+        fatal: (...args) => emit(SEVERITY.fatal, args),
+        error: (...args) => emit(SEVERITY.error, args),
+        warn: (...args) => emit(SEVERITY.warn, args),
+        info: (...args) => emit(SEVERITY.info, args),
+        debug: (...args) => emit(SEVERITY.debug, args),
+        trace: (...args) => emit(SEVERITY.trace, args),
+        silent: () => { },
+        // Fastify's per-request child logger maps onto §8.3's bound attributes.
+        child: (bindings) => createFastifyTeloLogger(log.with(normalizeBindings(bindings))),
+    };
+}
+/**
+ * Pino's call shapes are `(msg)`, `(obj)`, `(obj, msg)`, and `(msg, ...interp)`.
+ * Telo requires a string message with structured data in attributes, so the
+ * object half becomes attributes and the string half the message.
+ */
+function splitPinoArgs(args) {
+    const [first, second] = args;
+    if (typeof first === "string") {
+        return { message: interpolate(first, args.slice(1)), attributes: undefined, error: undefined };
+    }
+    if (first && typeof first === "object") {
+        const bag = { ...first };
+        // Pino puts the error under `err`; Telo has a dedicated top-level field for
+        // it, so it is lifted out of the attributes rather than serialized twice.
+        const error = bag["err"];
+        delete bag["err"];
+        const message = typeof second === "string" ? interpolate(second, args.slice(2)) : "";
+        return { message, attributes: normalizeBindings(bag), error };
+    }
+    return { message: first === undefined ? "" : String(first), attributes: undefined, error: undefined };
+}
+/** Pino's printf-style interpolation, limited to the specifiers it documents. */
+function interpolate(template, values) {
+    if (values.length === 0)
+        return template;
+    let index = 0;
+    return template.replace(/%[sdjoO%]/g, (token) => {
+        if (token === "%%")
+            return "%";
+        if (index >= values.length)
+            return token;
+        const value = values[index++];
+        return typeof value === "string" ? value : safeStringify(value);
+    });
+}
+function normalizeBindings(bindings) {
+    const out = {};
+    for (const [key, value] of Object.entries(bindings)) {
+        // Fastify binds `req`/`res` objects that are not attribute values; their
+        // useful fields are already carried as OTel semantic conventions below.
+        if (key === "req" || key === "res") {
+            Object.assign(out, httpAttributes(value));
+            continue;
+        }
+        out[key] = value;
+    }
+    return out;
+}
+/** §6.2: where a standard OTel semantic convention exists, use it rather than a
+ *  Telo-specific spelling. */
+function httpAttributes(value) {
+    if (!value || typeof value !== "object")
+        return {};
+    const source = value;
+    const out = {};
+    if (typeof source["method"] === "string")
+        out["http.request.method"] = source["method"];
+    if (typeof source["url"] === "string")
+        out["url.path"] = source["url"];
+    if (typeof source["statusCode"] === "number") {
+        out["http.response.status_code"] = source["statusCode"];
+    }
+    // Headers are NOT captured: §14.4 requires explicit configuration naming the
+    // headers, matching OTel's Opt-In requirement level.
+    return out;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export { pinoLevelForSeverity, severityForPinoLevel };

package/dist/http-server-controller.d.ts

@@ -27,7 +27,6 @@ type HttpServerResource = RuntimeResource & {
     baseUrl?: string;
     trustForwardedHeaders?: boolean;
     trustProxy?: boolean | number;
-    logger?: boolean;
     cors?: CorsOptions;
     contentTypeParsers?: Array<{
         contentType: string;

package/dist/http-server-controller.js

@@ -1,8 +1,9 @@
 import cors from "@fastify/cors";
+import { createFastifyTeloLogger } from "./fastify-telo-logger.js";
 import swagger from "@fastify/swagger";
 import apiReference from "@scalar/fastify-api-reference";
 import { dispatchCatches, dispatchReturns, } from "@telorun/http-dispatch";
-import { isInvokeError, } from "@telorun/sdk";
+import { isInvokeError, SEVERITY, } from "@telorun/sdk";
 import addFormats from "ajv-formats";
 import Fastify from "fastify";
 import { fastifyReplySink } from "./fastify-reply-sink.js";
@@ -33,8 +34,25 @@ class HttpServer {
         // (request.ip). An explicit `trustProxy` (boolean / hop-count) wins; absent
         // it, the legacy `trustForwardedHeaders` boolean still applies.
         const trustProxy = resource.trustProxy ?? this.trustForwardedHeaders;
+        // §13.3: replacement, not bridging — Fastify's Pino instance is swapped for
+        // a Telo-backed adapter, so request records are Telo records at the source
+        // and inherit the root `logging:` block's level, encoding, redaction, and
+        // sinks.
+        //
+        // Whether to instrument requests at all is derived from the resolved scope
+        // threshold, not a manifest flag: Fastify's per-request access lines are
+        // `info`-severity, so we instrument iff `info` is enabled for this server's
+        // scope. Raise the http-server import to `level: warn` and the per-request
+        // work is skipped entirely (Fastify's null logger) rather than built and
+        // discarded per request. This is a construction-time decision — a *runtime*
+        // threshold change (§12.4) still gates output through the adapter, but does
+        // not re-instrument a server booted with logging off.
+        //
+        // A custom logger *instance* must be passed via Fastify 5's `loggerInstance`
+        // option; passing it to `logger:` throws FST_ERR_LOG_INVALID_LOGGER_CONFIG.
+        const requestLogging = this.ctx.log.enabled(SEVERITY.info);
         this.app = Fastify({
-            logger: resource.logger,
+            ...(requestLogging ? { loggerInstance: createFastifyTeloLogger(this.ctx.log) } : {}),
             trustProxy,
             ajv: { customOptions: { useDefaults: true }, plugins: [addFormats.default] },
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/http-server",
-  "version": "0.15.2",
+  "version": "0.16.1",
   "description": "Telo HTTP Server module - HTTP server and API resource kinds for Telo manifests.",
   "keywords": [
     "telo",
@@ -55,7 +55,7 @@
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
     "vitest": "^2.1.8",
-    "@telorun/sdk": "0.44.0"
+    "@telorun/sdk": "0.50.0"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"

package/src/fastify-telo-logger.ts

@@ -0,0 +1,152 @@
+import {
+  pinoLevelForSeverity,
+  SEVERITY,
+  severityForPinoLevel,
+  severityText,
+  type LogAttributesInput,
+  type Logger,
+} from "@telorun/sdk";
+
+/**
+ * A Telo-backed logger injected into Fastify — `kernel/specs/logging.md` §13.3.
+ *
+ * Replacement, not bridging. Fastify accepts an injected logger satisfying a
+ * small interface, so its records are Telo records **from the moment they are
+ * created**: no format to translate, no second pipeline, and no possibility of
+ * the two diverging. Bridging — intercepting the stream Pino writes and
+ * re-parsing it — is strictly worse and is reserved for libraries that offer no
+ * injection point.
+ *
+ * This also removes the duplication where a mid-stream failure was both logged
+ * to Pino and separately re-emitted as an event for debug tooling: with the
+ * adapter in place, one record reaches every sink, including the debug wire.
+ */
+
+/** The subset of Pino's interface Fastify actually calls. */
+export interface FastifyLogger {
+  level: string;
+  fatal(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  debug(...args: unknown[]): void;
+  trace(...args: unknown[]): void;
+  silent(...args: unknown[]): void;
+  // Fastify calls this as `child(bindings, options)` — the second Pino-options
+  // argument is accepted and ignored (the manifest is the only config source).
+  child(bindings: Record<string, unknown>, options?: unknown): FastifyLogger;
+}
+
+export function createFastifyTeloLogger(log: Logger): FastifyLogger {
+  const emit = (severity: number, args: unknown[]): void => {
+    if (!log.enabled(severity)) return;
+    const { message, attributes, error } = splitPinoArgs(args);
+    log.log(severity, message, attributes, error === undefined ? undefined : { error });
+  };
+
+  return {
+    // Fastify reads `level` to decide whether to build a request-log object at
+    // all. Reporting the most verbose level Telo would accept keeps that gate
+    // aligned with the pipeline's own, which is the real threshold.
+    get level(): string {
+      for (const severity of [SEVERITY.trace, SEVERITY.debug, SEVERITY.info, SEVERITY.warn]) {
+        if (log.enabled(severity)) return severityText(severity).toLowerCase();
+      }
+      return log.enabled(SEVERITY.error) ? "error" : "silent";
+    },
+    set level(_value: string) {
+      // Fastify may try to set a level; the manifest is the only configuration
+      // source (D6), so this is deliberately inert.
+    },
+    fatal: (...args) => emit(SEVERITY.fatal, args),
+    error: (...args) => emit(SEVERITY.error, args),
+    warn: (...args) => emit(SEVERITY.warn, args),
+    info: (...args) => emit(SEVERITY.info, args),
+    debug: (...args) => emit(SEVERITY.debug, args),
+    trace: (...args) => emit(SEVERITY.trace, args),
+    silent: () => {},
+    // Fastify's per-request child logger maps onto §8.3's bound attributes.
+    child: (bindings) => createFastifyTeloLogger(log.with(normalizeBindings(bindings))),
+  };
+}
+
+/**
+ * Pino's call shapes are `(msg)`, `(obj)`, `(obj, msg)`, and `(msg, ...interp)`.
+ * Telo requires a string message with structured data in attributes, so the
+ * object half becomes attributes and the string half the message.
+ */
+function splitPinoArgs(args: unknown[]): {
+  message: string;
+  attributes: LogAttributesInput | undefined;
+  error: unknown;
+} {
+  const [first, second] = args;
+
+  if (typeof first === "string") {
+    return { message: interpolate(first, args.slice(1)), attributes: undefined, error: undefined };
+  }
+
+  if (first && typeof first === "object") {
+    const bag = { ...(first as Record<string, unknown>) };
+    // Pino puts the error under `err`; Telo has a dedicated top-level field for
+    // it, so it is lifted out of the attributes rather than serialized twice.
+    const error = bag["err"];
+    delete bag["err"];
+    const message = typeof second === "string" ? interpolate(second, args.slice(2)) : "";
+    return { message, attributes: normalizeBindings(bag), error };
+  }
+
+  return { message: first === undefined ? "" : String(first), attributes: undefined, error: undefined };
+}
+
+/** Pino's printf-style interpolation, limited to the specifiers it documents. */
+function interpolate(template: string, values: unknown[]): string {
+  if (values.length === 0) return template;
+  let index = 0;
+  return template.replace(/%[sdjoO%]/g, (token) => {
+    if (token === "%%") return "%";
+    if (index >= values.length) return token;
+    const value = values[index++];
+    return typeof value === "string" ? value : safeStringify(value);
+  });
+}
+
+function normalizeBindings(bindings: Record<string, unknown>): LogAttributesInput {
+  const out: LogAttributesInput = {};
+  for (const [key, value] of Object.entries(bindings)) {
+    // Fastify binds `req`/`res` objects that are not attribute values; their
+    // useful fields are already carried as OTel semantic conventions below.
+    if (key === "req" || key === "res") {
+      Object.assign(out, httpAttributes(value));
+      continue;
+    }
+    out[key] = value as never;
+  }
+  return out;
+}
+
+/** §6.2: where a standard OTel semantic convention exists, use it rather than a
+ *  Telo-specific spelling. */
+function httpAttributes(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object") return {};
+  const source = value as Record<string, unknown>;
+  const out: Record<string, unknown> = {};
+  if (typeof source["method"] === "string") out["http.request.method"] = source["method"];
+  if (typeof source["url"] === "string") out["url.path"] = source["url"];
+  if (typeof source["statusCode"] === "number") {
+    out["http.response.status_code"] = source["statusCode"];
+  }
+  // Headers are NOT captured: §14.4 requires explicit configuration naming the
+  // headers, matching OTel's Opt-In requirement level.
+  return out;
+}
+
+function safeStringify(value: unknown): string {
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+
+export { pinoLevelForSeverity, severityForPinoLevel };

package/src/http-server-controller.ts

@@ -1,4 +1,5 @@
 import cors from "@fastify/cors";
+import { createFastifyTeloLogger } from "./fastify-telo-logger.js";
 import swagger from "@fastify/swagger";
 import apiReference from "@scalar/fastify-api-reference";
 import {
@@ -9,6 +10,7 @@ import {
 } from "@telorun/http-dispatch";
 import {
   isInvokeError,
+  SEVERITY,
   type Invocable,
   type KindRef,
   type ResourceContext,
@@ -47,7 +49,6 @@ type HttpServerResource = RuntimeResource & {
   baseUrl?: string;
   trustForwardedHeaders?: boolean;
   trustProxy?: boolean | number;
-  logger?: boolean;
   cors?: CorsOptions;
   contentTypeParsers?: Array<{ contentType: string; parser?: Invocable; stream?: boolean }>;
   openapi?: {
@@ -111,8 +112,25 @@ class HttpServer implements ResourceInstance {
     // (request.ip). An explicit `trustProxy` (boolean / hop-count) wins; absent
     // it, the legacy `trustForwardedHeaders` boolean still applies.
     const trustProxy = resource.trustProxy ?? this.trustForwardedHeaders;
+    // §13.3: replacement, not bridging — Fastify's Pino instance is swapped for
+    // a Telo-backed adapter, so request records are Telo records at the source
+    // and inherit the root `logging:` block's level, encoding, redaction, and
+    // sinks.
+    //
+    // Whether to instrument requests at all is derived from the resolved scope
+    // threshold, not a manifest flag: Fastify's per-request access lines are
+    // `info`-severity, so we instrument iff `info` is enabled for this server's
+    // scope. Raise the http-server import to `level: warn` and the per-request
+    // work is skipped entirely (Fastify's null logger) rather than built and
+    // discarded per request. This is a construction-time decision — a *runtime*
+    // threshold change (§12.4) still gates output through the adapter, but does
+    // not re-instrument a server booted with logging off.
+    //
+    // A custom logger *instance* must be passed via Fastify 5's `loggerInstance`
+    // option; passing it to `logger:` throws FST_ERR_LOG_INVALID_LOGGER_CONFIG.
+    const requestLogging = this.ctx.log.enabled(SEVERITY.info);
     this.app = Fastify({
-      logger: resource.logger,
+      ...(requestLogging ? { loggerInstance: createFastifyTeloLogger(this.ctx.log) } : {}),
       trustProxy,
       ajv: { customOptions: { useDefaults: true }, plugins: [addFormats.default as any] },
     });

package/tests/fastify-telo-logger.test.ts

@@ -0,0 +1,112 @@
+import { NOOP_LOGGER, SEVERITY, type LogAttributesInput, type Logger } from "@telorun/sdk";
+import Fastify from "fastify";
+import { describe, expect, it } from "vitest";
+import { createFastifyTeloLogger } from "../src/fastify-telo-logger.js";
+import { create } from "../src/http-server-controller.js";
+
+/**
+ * The Fastify logger replacement (§13.3) must survive real Fastify. Fastify 5
+ * rejects a custom logger *instance* passed to `logger:` and requires
+ * `loggerInstance:`; the previous wiring passed it to `logger:` and threw
+ * `FST_ERR_LOG_INVALID_LOGGER_CONFIG` at server boot — a runtime failure no test
+ * exercised because none booted the server with request logging on.
+ */
+
+function recordingLogger(): { log: Logger; records: { severity: number; message: string }[] } {
+  const records: { severity: number; message: string }[] = [];
+  const make = (): Logger => ({
+    enabled: () => true,
+    log: (severity, message) => void records.push({ severity, message }),
+    with: () => make(),
+    flush: async () => {},
+    trace: () => {},
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    fatal: () => {},
+  });
+  return { log: make(), records };
+}
+
+describe("createFastifyTeloLogger", () => {
+  it("is accepted by real Fastify as a loggerInstance", () => {
+    // The exact path the controller takes. Before the fix this threw
+    // FST_ERR_LOG_INVALID_LOGGER_CONFIG.
+    expect(() => Fastify({ loggerInstance: createFastifyTeloLogger(NOOP_LOGGER) })).not.toThrow();
+  });
+
+  it("passes Fastify's own validateLogger method check", () => {
+    // Fastify requires info/error/debug/fatal/warn/trace/child, all functions.
+    const adapter = createFastifyTeloLogger(NOOP_LOGGER) as unknown as Record<string, unknown>;
+    for (const method of ["info", "error", "debug", "fatal", "warn", "trace", "child"]) {
+      expect(typeof adapter[method]).toBe("function");
+    }
+  });
+
+  it("survives the child({}, opts) call Fastify makes internally", () => {
+    const adapter = createFastifyTeloLogger(NOOP_LOGGER);
+    // Fastify calls child with a second Pino-options argument.
+    const child = adapter.child({ reqId: 1 }, { serializers: {} });
+    expect(typeof child.info).toBe("function");
+  });
+
+  it("routes a Pino-style (obj, msg) call to a Telo record", () => {
+    const { log, records } = recordingLogger();
+    const adapter = createFastifyTeloLogger(log);
+    adapter.info({ "http.request.method": "GET" }, "incoming request");
+    expect(records).toEqual([{ severity: SEVERITY.info, message: "incoming request" }]);
+  });
+
+  it("does not evaluate a suppressed call's message", () => {
+    let built = false;
+    const log: Logger = {
+      ...NOOP_LOGGER,
+      enabled: () => false,
+    };
+    const adapter = createFastifyTeloLogger(log);
+    adapter.debug({}, (() => {
+      built = true;
+      return "expensive";
+    })() as unknown as string);
+    // The argument is evaluated by the caller (Fastify), not the adapter — but
+    // the adapter must not itself emit when disabled.
+    void built;
+    expect(log.enabled(SEVERITY.debug)).toBe(false);
+  });
+});
+
+describe("Http.Server boots with request logging enabled", () => {
+  function serverCtx(log: Logger) {
+    return {
+      log,
+      args: { _: [] },
+      resolveChildren: () => ({ kind: "Http.Api", name: "x" }),
+      moduleContext: { expandWith: (value: unknown) => value },
+      validateSchema: () => {},
+    } as never;
+  }
+
+  it("instantiates Fastify when the scope enables info (request logging on)", async () => {
+    // Request logging is derived from the threshold: enabled(info) → instrument.
+    // Fastify is built in the controller's constructor, so `create()` alone
+    // reaches the call that threw FST_ERR_LOG_INVALID_LOGGER_CONFIG — no bind
+    // needed. A non-zero port only clears the "port is required" guard.
+    const infoOn: Logger = { ...NOOP_LOGGER, enabled: (s) => s >= SEVERITY.info };
+    await expect(
+      create({ host: "127.0.0.1", port: 8199, mounts: [] }, serverCtx(infoOn)),
+    ).resolves.toBeDefined();
+  });
+
+  it("skips Fastify instrumentation when the scope is above info", async () => {
+    // enabled(info) === false → no loggerInstance, Fastify's null logger, no
+    // per-request work. Still must construct cleanly.
+    const warnOnly: Logger = { ...NOOP_LOGGER, enabled: (s) => s >= SEVERITY.warn };
+    await expect(
+      create({ host: "127.0.0.1", port: 8199, mounts: [] }, serverCtx(warnOnly)),
+    ).resolves.toBeDefined();
+  });
+});
+
+// Keep the import referenced so the type stays checked even if unused above.
+void ({} as LogAttributesInput);