midline-agent 0.2.0 → 0.4.0

package/dist/esm/redact.js

@@ -0,0 +1,224 @@
+/**
+ * Shared by the Node agent and the browser SDK, so nothing here may touch a
+ * Node-only global (Buffer, process) — TextEncoder and URLSearchParams exist in both.
+ *
+ * Redaction happens in the host process, before an event is queued. Whatever is
+ * removed here never reaches a socket, a log line or the Midline server.
+ *
+ * Matching is on a normalised key — lower-cased with punctuation stripped — so
+ * `X-API-Key`, `api_key` and `apiKey` are all the same key.
+ */
+export const REDACTED = "[REDACTED]";
+/** Substrings: any key containing one of these is sensitive. */
+const SENSITIVE_KEY_PARTS = [
+    "password",
+    "passwd",
+    "passphrase",
+    "secret",
+    "token",
+    "apikey",
+    "accesskey",
+    "privatekey",
+    "authorization",
+    "cookie",
+    "session",
+    "credential",
+    "csrf",
+    "xsrf",
+    "signature",
+    "creditcard",
+    "cardnumber",
+    "cvv",
+    "cvc",
+    "ssn",
+    "socialsecurity",
+];
+/** Whole keys only — as substrings these would hit words like "author" or "spinner". */
+const SENSITIVE_KEYS_EXACT = new Set(["auth", "pwd", "pin", "otp", "sid", "jwt", "bearer"]);
+/** Always redacted by name, even if a user-supplied list somehow unmatched them. */
+export const DEFAULT_SENSITIVE_HEADERS = [
+    "authorization",
+    "proxy-authorization",
+    "cookie",
+    "set-cookie",
+    "x-api-key",
+    "api-key",
+    "x-auth-token",
+    "x-access-token",
+    "x-refresh-token",
+    "x-csrf-token",
+    "x-xsrf-token",
+    "x-amz-security-token",
+];
+const VALUE_PATTERNS = [
+    [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, REDACTED],
+    [/\b(Bearer|Basic|Digest|Token)\s+[A-Za-z0-9._~+\/=-]{8,}/gi, `$1 ${REDACTED}`],
+    [/\beyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}/g, REDACTED],
+    [/\bak_[A-Fa-f0-9]{16,}\b/g, REDACTED],
+    [/\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{10,}\b/g, REDACTED],
+    [/\bAKIA[0-9A-Z]{16}\b/g, REDACTED],
+    [/(\b[a-z][a-z0-9+.-]*:\/\/)[^\s\/@:]+:[^\s\/@]+@/gi, `$1${REDACTED}@`],
+];
+/** `key=value` / `key: value` in query strings, log lines and error messages. */
+const KEY_VALUE_PAIR = /(^|[?&;,\s(\[{])([A-Za-z0-9_.%-]{1,64})(\s*[=:]\s*)("[^"]*"|'[^']*'|[^\s&#,;)\]}]+)/g;
+/** `"key": value` in JSON text, including JSON that was cut off mid-value. */
+const JSON_PAIR = /"([^"\\]{1,100})"\s*:\s*("(?:[^"\\]|\\.)*"?|-?\d+(?:\.\d+)?|true|false|null)/g;
+export function normalizeKey(key) {
+    return key.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+export class Redactor {
+    constructor(extraFields = [], extraHeaders = []) {
+        this.extraKeys = extraFields.map(normalizeKey).filter(Boolean);
+        this.headerNames = new Set([...DEFAULT_SENSITIVE_HEADERS, ...extraHeaders].map((name) => name.toLowerCase()));
+    }
+    isSensitiveKey(key) {
+        const normalized = normalizeKey(key);
+        if (!normalized)
+            return false;
+        if (SENSITIVE_KEYS_EXACT.has(normalized))
+            return true;
+        if (SENSITIVE_KEY_PARTS.some((part) => normalized.includes(part)))
+            return true;
+        return this.extraKeys.some((part) => normalized.includes(part));
+    }
+    /** Masks credentials embedded in free text: bearer tokens, JWTs, key formats, URL userinfo and query params. */
+    string(value, maxLength = 2048) {
+        let out = value.length > maxLength * 4 ? value.slice(0, maxLength * 4) : value;
+        for (const [pattern, replacement] of VALUE_PATTERNS) {
+            out = out.replace(pattern, replacement);
+        }
+        if (out.includes("=") || out.includes(":")) {
+            out = out.replace(KEY_VALUE_PAIR, (match, sep, key, delimiter) => {
+                let decoded = key;
+                try {
+                    decoded = decodeURIComponent(key);
+                }
+                catch {
+                    // keep the raw key
+                }
+                return this.isSensitiveKey(decoded) ? `${sep}${key}${delimiter}${REDACTED}` : match;
+            });
+        }
+        if (out.includes('"')) {
+            out = out.replace(JSON_PAIR, (match, key) => this.isSensitiveKey(key) ? `"${key}":"${REDACTED}"` : match);
+        }
+        // The ellipsis counts toward the limit: servers validate these lengths exactly.
+        return out.length > maxLength ? `${out.slice(0, Math.max(0, maxLength - 1))}…` : out;
+    }
+    /** Deep copy with sensitive keys and values masked. Bounded in depth, breadth and string length. */
+    value(input, depth = 0, seen = new WeakSet()) {
+        if (input === null || input === undefined)
+            return input;
+        if (typeof input === "string")
+            return this.string(input);
+        if (typeof input === "number" || typeof input === "boolean")
+            return input;
+        if (typeof input === "bigint")
+            return input.toString();
+        if (typeof input === "function" || typeof input === "symbol")
+            return undefined;
+        if (input instanceof Date)
+            return Number.isNaN(input.getTime()) ? null : input.toISOString();
+        // Buffer is a Uint8Array, so this also covers it without naming a Node-only global.
+        if (ArrayBuffer.isView(input)) {
+            return `[Binary ${input.byteLength} bytes]`;
+        }
+        if (typeof input !== "object")
+            return undefined;
+        if (seen.has(input))
+            return "[Circular]";
+        if (depth >= 8)
+            return "[Truncated]";
+        seen.add(input);
+        if (Array.isArray(input)) {
+            const items = input.slice(0, 100).map((item) => this.value(item, depth + 1, seen));
+            if (input.length > 100)
+                items.push(`[${input.length - 100} more]`);
+            return items;
+        }
+        const out = {};
+        let count = 0;
+        for (const [key, nested] of Object.entries(input)) {
+            if (count++ >= 200) {
+                out["[truncated]"] = "too many keys";
+                break;
+            }
+            out[key] = this.isSensitiveKey(key) ? REDACTED : this.value(nested, depth + 1, seen);
+        }
+        return out;
+    }
+    headers(headers) {
+        if (!headers)
+            return undefined;
+        const out = {};
+        for (const [rawName, rawValue] of Object.entries(headers)) {
+            if (rawValue === undefined)
+                continue;
+            const name = rawName.toLowerCase();
+            if (this.headerNames.has(name) || this.isSensitiveKey(name)) {
+                out[name] = REDACTED;
+                continue;
+            }
+            const joined = Array.isArray(rawValue) ? rawValue.join(", ") : String(rawValue);
+            out[name] = this.string(joined, 1024);
+        }
+        return out;
+    }
+    query(search) {
+        if (!search)
+            return undefined;
+        const out = {};
+        const params = new URLSearchParams(search.startsWith("?") ? search.slice(1) : search);
+        for (const key of new Set(params.keys())) {
+            const values = params.getAll(key).map((value) => this.isSensitiveKey(key) ? REDACTED : this.string(value, 512));
+            out[key] = values.length === 1 ? values[0] : values;
+        }
+        return out;
+    }
+    /**
+     * Redacts a captured body. Structured content is parsed and redacted by key;
+     * text that cannot be parsed (usually because it was truncated) gets key/value
+     * pattern masking instead, so a cut-off JSON body still loses its passwords.
+     */
+    body(raw, contentType, maxBytes) {
+        if (raw === undefined || raw === null || maxBytes <= 0)
+            return {};
+        const type = (contentType || "").toLowerCase();
+        if (typeof raw === "object" && !ArrayBuffer.isView(raw)) {
+            return this.fit(this.value(raw), maxBytes);
+        }
+        const text = ArrayBuffer.isView(raw)
+            ? new TextDecoder().decode(raw)
+            : String(raw);
+        if (type.includes("json")) {
+            try {
+                return this.fit(this.value(JSON.parse(text)), maxBytes);
+            }
+            catch {
+                return this.cut(this.string(text, text.length), maxBytes);
+            }
+        }
+        if (type.includes("application/x-www-form-urlencoded")) {
+            return this.fit(this.query(text) ?? {}, maxBytes);
+        }
+        if (!type || type.startsWith("text/") || type.includes("xml") || type.includes("graphql")) {
+            return this.cut(this.string(text, maxBytes * 2), maxBytes);
+        }
+        return { omitted: `content-type ${type.split(";")[0]}` };
+    }
+    fit(value, maxBytes) {
+        const serialized = JSON.stringify(value) ?? "";
+        if (new TextEncoder().encode(serialized).length <= maxBytes) {
+            return { body: value };
+        }
+        return this.cut(serialized, maxBytes);
+    }
+    cut(text, maxBytes) {
+        const bytes = new TextEncoder().encode(text);
+        if (bytes.length <= maxBytes) {
+            return { body: text };
+        }
+        // Slicing bytes can split a multi-byte character; the replacement char is harmless here.
+        return { body: new TextDecoder().decode(bytes.subarray(0, maxBytes)), truncated: true };
+    }
+}

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/redact.d.ts

@@ -1,4 +1,7 @@
 /**
+ * Shared by the Node agent and the browser SDK, so nothing here may touch a
+ * Node-only global (Buffer, process) — TextEncoder and URLSearchParams exist in both.
+ *
  * Redaction happens in the host process, before an event is queued. Whatever is
  * removed here never reaches a socket, a log line or the Midline server.
  *

package/dist/redact.js

@@ -1,5 +1,8 @@
 "use strict";
 /**
+ * Shared by the Node agent and the browser SDK, so nothing here may touch a
+ * Node-only global (Buffer, process) — TextEncoder and URLSearchParams exist in both.
+ *
  * Redaction happens in the host process, before an event is queued. Whatever is
  * removed here never reaches a socket, a log line or the Midline server.
  *
@@ -120,7 +123,8 @@ class Redactor {
             return undefined;
         if (input instanceof Date)
             return Number.isNaN(input.getTime()) ? null : input.toISOString();
-        if (Buffer.isBuffer(input) || ArrayBuffer.isView(input)) {
+        // Buffer is a Uint8Array, so this also covers it without naming a Node-only global.
+        if (ArrayBuffer.isView(input)) {
             return `[Binary ${input.byteLength} bytes]`;
         }
         if (typeof input !== "object")
@@ -184,10 +188,12 @@ class Redactor {
         if (raw === undefined || raw === null || maxBytes <= 0)
             return {};
         const type = (contentType || "").toLowerCase();
-        if (typeof raw === "object" && !Buffer.isBuffer(raw)) {
+        if (typeof raw === "object" && !ArrayBuffer.isView(raw)) {
             return this.fit(this.value(raw), maxBytes);
         }
-        const text = Buffer.isBuffer(raw) ? raw.toString("utf8") : String(raw);
+        const text = ArrayBuffer.isView(raw)
+            ? new TextDecoder().decode(raw)
+            : String(raw);
         if (type.includes("json")) {
             try {
                 return this.fit(this.value(JSON.parse(text)), maxBytes);
@@ -206,18 +212,18 @@ class Redactor {
     }
     fit(value, maxBytes) {
         const serialized = JSON.stringify(value) ?? "";
-        if (Buffer.byteLength(serialized) <= maxBytes) {
+        if (new TextEncoder().encode(serialized).length <= maxBytes) {
             return { body: value };
         }
         return this.cut(serialized, maxBytes);
     }
     cut(text, maxBytes) {
-        const bytes = Buffer.from(text);
+        const bytes = new TextEncoder().encode(text);
         if (bytes.length <= maxBytes) {
             return { body: text };
         }
         // Slicing bytes can split a multi-byte character; the replacement char is harmless here.
-        return { body: bytes.subarray(0, maxBytes).toString("utf8"), truncated: true };
+        return { body: new TextDecoder().decode(bytes.subarray(0, maxBytes)), truncated: true };
     }
 }
 exports.Redactor = Redactor;

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 /** A PEM string, PEM bytes, a path to a PEM file, or several of those. */
 export type CaInput = string | Buffer | Array<string | Buffer>;
-export type EventType = "request" | "error" | "security" | "performance" | "custom";
+export type EventType = "request" | "error" | "security" | "performance" | "custom" | "console";
 export type EventSeverity = "low" | "medium" | "high" | "critical";
 export type EventCategory = "application" | "infrastructure" | "security" | "performance" | "business";
 /**
@@ -55,6 +55,13 @@ export interface MidlineConfig {
     redactHeaders?: string[];
     /** What to capture beyond method/path/status/timing. Defaults to nothing. */
     capture?: CaptureOptions;
+    /**
+     * Also send what the process prints — `console.log`, Nest's logger, anything
+     * written to stdout or stderr — as `console` events, one per line, redacted like
+     * any other text. Initialise the agent before creating the app to include its
+     * startup lines. Off by default. Env fallback: `MIDLINE_CAPTURE_CONSOLE`.
+     */
+    captureConsole?: boolean;
     /** Set to false to keep the agent inert. Env fallback: `MIDLINE_ENABLED`. */
     enabled?: boolean;
     /**
@@ -128,5 +135,5 @@ export interface MidlineEvent {
     errorCode?: string;
     /** Set when the client disconnected before the response finished. */
     aborted?: boolean;
-    integration?: "express" | "node-http" | "proxy" | "manual";
+    integration?: "express" | "node-http" | "proxy" | "console" | "manual";
 }

package/package.json

@@ -1,9 +1,29 @@
 {
   "name": "midline-agent",
-  "version": "0.2.0",
-  "description": "Midline — request & error monitoring with security detection",
+  "version": "0.4.0",
+  "description": "Midline — request, error and security monitoring for Node, and error, network and Web Vitals monitoring for browsers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser/index.d.ts",
+      "import": "./dist/esm/browser/index.js",
+      "default": "./dist/browser/index.js"
+    },
+    "./package.json": "./package.json",
+    "./dist/*": "./dist/*"
+  },
+  "typesVersions": {
+    "*": {
+      "browser": [
+        "dist/browser/index.d.ts"
+      ]
+    }
+  },
   "bin": {
     "midline-agent": "dist/cli.js"
   },
@@ -11,7 +31,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsc -p tsconfig.esm.json && node scripts/mark-esm.js",
     "prepare": "npm run build",
     "clean": "rm -rf dist",
     "test": "npm run build && node --test test/*.test.js"
@@ -24,7 +44,10 @@
     "security",
     "request",
     "errors",
-    "proxy"
+    "proxy",
+    "browser",
+    "web-vitals",
+    "frontend"
   ],
   "author": "Your Name",
   "license": "MIT",

package/scripts/mark-esm.js

@@ -0,0 +1,6 @@
+// dist/esm holds the browser build as ES modules. Marking the folder as a module
+// scope lets bundlers and Node treat those .js files as ESM without renaming them.
+const fs = require("fs");
+const path = require("path");
+
+fs.writeFileSync(path.join(__dirname, "..", "dist", "esm", "package.json"), '{ "type": "module" }\n');

package/src/agent.ts

@@ -1,4 +1,5 @@
 import { ConfigError, ResolvedCapture, ResolvedConfig, envFlag, resolveConfig } from "./config";
+import { ConsoleCapture, ConsoleLevel, ConsoleLine, MAX_LINE_CHARS, withoutConsoleCapture } from "./console";
 import type { RequestContext } from "./context";
 import { Redactor } from "./redact";
 import { Transport } from "./transport";
@@ -16,6 +17,11 @@ const MAX_REQUEST_BYTES = 512 * 1024;
 const MIN_REQUEST_BYTES = 16 * 1024;
 const MAX_QUEUE_BYTES = 16 * 1024 * 1024;
 
+/** Console lines: a startup burst (Nest mapping every route) fits, a log storm can't crowd out requests. */
+const CONSOLE_BURST_LINES = 1000;
+const CONSOLE_LINES_PER_SECOND = 100;
+const CONSOLE_SEVERITY: Record<ConsoleLevel, EventSeverity> = { info: "low", warn: "medium", error: "high" };
+
 /** Verification failures. Retrying is still right: they clear once the server is fixed. */
 const TLS_ERROR_REASONS: Record<string, string> = {
   DEPTH_ZERO_SELF_SIGNED_CERT: "presented a self-signed certificate",
@@ -76,7 +82,7 @@ export interface ExchangeMessage {
 }
 
 /**
- * Ships request/error events to the Midline server.
+ * Ships request, error and console events to the Midline server.
  *
  * The contract with the host application is that the agent is never allowed to
  * affect it: an unreachable, untrusted, slow or misconfigured Midline server costs a
@@ -126,6 +132,11 @@ export class MidlineAgent {
   private dropped = 0;
   private maxRequestBytes = MAX_REQUEST_BYTES;
   private batchLimit = Number.MAX_SAFE_INTEGER;
+  private consoleCapture: ConsoleCapture | null = null;
+  private consoleTokens = CONSOLE_BURST_LINES;
+  private consoleRefilledAt = Date.now();
+  /** The server refused a console event: it predates them, so no more are sent. */
+  private consoleUnsupported = false;
 
   constructor(config: MidlineConfig = {}) {
     this.onErrorHook = config.onError;
@@ -162,10 +173,16 @@ export class MidlineAgent {
     });
 
     this.timer = setInterval(() => {
+      this.consoleCapture?.flushPending();
       void this.drain(false);
     }, resolved.flushIntervalMs);
     // Telemetry must never be the reason a process refuses to exit.
     this.timer.unref?.();
+
+    if (resolved.captureConsole) {
+      this.consoleCapture = new ConsoleCapture((line) => this.recordConsole(line));
+      this.consoleCapture.install();
+    }
   }
 
   /** False when the agent is off: no key, bad config, disabled, rejected key, or closed. */
@@ -229,9 +246,52 @@ export class MidlineAgent {
     }
   }
 
+  private recordConsole(line: ConsoleLine): void {
+    if (!this.active || this.consoleUnsupported) return;
+    if (!this.takeConsoleToken()) {
+      this.dropped += 1;
+      this.report(
+        "console-rate",
+        `midline: console output is arriving faster than ${CONSOLE_LINES_PER_SECOND} lines/s; the extra lines still print but are not sent.`,
+      );
+      return;
+    }
+    try {
+      this.enqueue(
+        this.toWire(
+          {
+            type: "console",
+            path: line.stream,
+            message: line.text,
+            timestamp: line.timestamp,
+            severity: CONSOLE_SEVERITY[line.level],
+            category: "application",
+            integration: "console",
+          },
+          false,
+        ),
+      );
+    } catch (err) {
+      this.report("event-build", `midline: could not record a console line (${(err as Error)?.message}); skipped it.`);
+    }
+  }
+
+  private takeConsoleToken(): boolean {
+    const now = Date.now();
+    this.consoleTokens = Math.min(
+      CONSOLE_BURST_LINES,
+      this.consoleTokens + ((now - this.consoleRefilledAt) / 1000) * CONSOLE_LINES_PER_SECOND,
+    );
+    this.consoleRefilledAt = now;
+    if (this.consoleTokens < 1) return false;
+    this.consoleTokens -= 1;
+    return true;
+  }
+
   /** Sends whatever is buffered now, ignoring backoff, and keeps the process alive until done. */
   async flush(): Promise<void> {
     if (!this.active) return;
+    this.consoleCapture?.flushPending(true);
     this.retryAfter = 0;
     if (this.drainPromise) {
       await this.drainPromise;
@@ -261,6 +321,8 @@ export class MidlineAgent {
       clearInterval(this.timer);
       this.timer = null;
     }
+    this.consoleCapture?.uninstall();
+    this.consoleCapture = null;
     this.queue = [];
     this.queueBytes = 0;
     this.transport?.destroy();
@@ -306,6 +368,7 @@ export class MidlineAgent {
   private toWire(event: MidlineEvent, preRedacted: boolean): Record<string, unknown> {
     const config = this.config!;
     const type = event.type;
+    const isConsole = type === "console";
     const statusCode = Number.isInteger(event.statusCode) && event.statusCode! >= 100 && event.statusCode! <= 599
       ? event.statusCode
       : type === "error" ? 500 : undefined;
@@ -313,7 +376,9 @@ export class MidlineAgent {
     const route = this.redactor.string(stripQuery(event.path) || "/", 2048);
 
     const payload: Record<string, unknown> = {};
-    if (type === "error" || event.message) {
+    if (isConsole) {
+      payload.message = this.redactor.string(event.message ?? "", MAX_LINE_CHARS);
+    } else if (type === "error" || event.message) {
       payload.error = event.message ? this.redactor.string(event.message, 1024) : type === "error" ? "Unknown error" : undefined;
     }
     if (event.stack) payload.stack = this.redactor.string(event.stack, 16 * 1024);
@@ -349,9 +414,10 @@ export class MidlineAgent {
       apiKey: config.apiKey,
       eventType: type,
       route,
-      method: (event.method || "GET").toUpperCase().slice(0, 16),
+      // A printed line has no method or timing; defaults here would make it look like a request.
+      method: isConsole ? undefined : (event.method || "GET").toUpperCase().slice(0, 16),
       statusCode,
-      responseTime: Math.min(Math.max(0, Math.round(Number(event.duration) || 0)), 86_400_000),
+      responseTime: isConsole ? undefined : Math.min(Math.max(0, Math.round(Number(event.duration) || 0)), 86_400_000),
       timestamp: validTimestamp(event.timestamp),
       // Clamped to the server's validation limits: one over-long field would
       // otherwise get every event rejected.
@@ -470,6 +536,7 @@ export class MidlineAgent {
       }
       if (outcome.kind === "rejected") {
         if (batch.length === 1) {
+          if (this.refusedConsole(batch[0], outcome.detail)) continue;
           this.dropped += 1;
           this.report(`rejected:${outcome.detail}`, `midline: the Midline server rejected an event (${outcome.detail}); dropped it.`);
           continue;
@@ -490,12 +557,14 @@ export class MidlineAgent {
   /** Returns false if delivery should stop for this drain. */
   private async sendIndividually(batch: QueuedEvent[], keepProcessAlive: boolean): Promise<boolean> {
     for (let index = 0; index < batch.length; index++) {
+      if (this.consoleUnsupported && batch[index].wire.eventType === "console") continue;
       const outcome = await this.send([batch[index]], keepProcessAlive);
       if (outcome.kind === "ok") {
         this.onSuccess();
       } else if (outcome.kind === "rejected" || outcome.kind === "tooLarge") {
-        this.dropped += 1;
         const detail = outcome.kind === "rejected" ? outcome.detail : "HTTP 413";
+        if (outcome.kind === "rejected" && this.refusedConsole(batch[index], detail)) continue;
+        this.dropped += 1;
         this.report(`rejected:${detail}`, `midline: the Midline server rejected an event (${detail}); dropped it.`);
       } else if (outcome.kind === "stop") {
         this.disable();
@@ -565,6 +634,27 @@ export class MidlineAgent {
     return { kind: "rejected", detail: `HTTP ${status}${serverMessage(result.body)}` };
   }
 
+  /**
+   * True when a rejected event is a console line the server has no event type for,
+   * i.e. the server predates console capture. Capture switches itself off rather
+   * than paying a refused request for every line printed from then on.
+   */
+  private refusedConsole(item: QueuedEvent, detail: string): boolean {
+    if (item.wire.eventType !== "console" || !detail.includes("eventType")) return false;
+    if (!this.consoleUnsupported) {
+      this.consoleUnsupported = true;
+      this.consoleCapture?.uninstall();
+      this.consoleCapture = null;
+      this.queue = this.queue.filter((queued) => queued.wire.eventType !== "console");
+      this.queueBytes = this.queue.reduce((sum, queued) => sum + queued.bytes, 0);
+      this.log(
+        "warn",
+        "midline: this Midline server does not accept console events yet (it needs updating), so console capture is off. Request and error monitoring carry on.",
+      );
+    }
+    return true;
+  }
+
   /** One line per distinct fault, not one per failed event. */
   private report(signature: string, message: string): void {
     if (this.lastNotice === signature && !this.debugLogs) {
@@ -638,17 +728,21 @@ export class MidlineAgent {
   }
 
   private log(level: "info" | "warn" | "error", message: string): void {
-    if (this.onErrorHook) {
-      try {
-        this.onErrorHook(message);
-      } catch {
-        // A broken logging hook must not become the host application's problem.
+    // The agent's own diagnostics are never the application's console output,
+    // including when a hook hands them to a logger that prints them.
+    withoutConsoleCapture(() => {
+      if (this.onErrorHook) {
+        try {
+          this.onErrorHook(message);
+        } catch {
+          // A broken logging hook must not become the host application's problem.
+        }
+        if (!this.debugLogs) return;
       }
-      if (!this.debugLogs) return;
-    }
-    if (level === "error") console.error(message);
-    else if (level === "warn") console.warn(message);
-    else console.info(message);
+      if (level === "error") console.error(message);
+      else if (level === "warn") console.warn(message);
+      else console.info(message);
+    });
   }
 }
 
@@ -667,6 +761,8 @@ function classify(event: MidlineEvent, statusCode: number | undefined): { severi
     category = "security";
   } else if (event.type === "custom") {
     category = "business";
+  } else if (event.type === "console") {
+    category = "application";
   } else if (statusCode && statusCode >= 500) {
     severity = "high";
     category = "application";