midline-agent 0.1.9 → 0.2.0

package/dist/agent.js

@@ -1,123 +1,684 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MidlineAgent = void 0;
-const cross_fetch_1 = __importDefault(require("cross-fetch"));
+exports.MidlineAgent = exports.SDK_VERSION = void 0;
+const config_1 = require("./config");
+const redact_1 = require("./redact");
+const transport_1 = require("./transport");
+exports.SDK_VERSION = (() => {
+    try {
+        return require("../package.json").version;
+    }
+    catch {
+        return "unknown";
+    }
+})();
+const MAX_REQUEST_BYTES = 512 * 1024;
+const MIN_REQUEST_BYTES = 16 * 1024;
+const MAX_QUEUE_BYTES = 16 * 1024 * 1024;
+/** Verification failures. Retrying is still right: they clear once the server is fixed. */
+const TLS_ERROR_REASONS = {
+    DEPTH_ZERO_SELF_SIGNED_CERT: "presented a self-signed certificate",
+    SELF_SIGNED_CERT_IN_CHAIN: "presented a chain that ends in an untrusted self-signed CA",
+    UNABLE_TO_VERIFY_LEAF_SIGNATURE: "presented a certificate whose issuer could not be verified (missing intermediate, or a private CA)",
+    UNABLE_TO_GET_ISSUER_CERT: "presented a certificate whose issuer could not be found",
+    UNABLE_TO_GET_ISSUER_CERT_LOCALLY: "presented a certificate whose issuer is not in the trust store (missing intermediate, or a private CA)",
+    CERT_HAS_EXPIRED: "presented an expired certificate",
+    CERT_NOT_YET_VALID: "presented a certificate that is not valid yet (check this machine's clock)",
+    CERT_REVOKED: "presented a revoked certificate",
+    CERT_UNTRUSTED: "presented an untrusted certificate",
+    CERT_REJECTED: "presented a rejected certificate",
+    ERR_TLS_CERT_ALTNAME_INVALID: "presented a certificate issued for a different hostname",
+    HOSTNAME_MISMATCH: "presented a certificate issued for a different hostname",
+};
+/**
+ * Ships request/error 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
+ * single explanatory log line and bounded buffered memory — never a crash, never a
+ * stalled request, never a disabled certificate check.
+ */
 class MidlineAgent {
-    static init(config) {
-        this.config = {
-            endpoint: "https://api.usemidline.com/api/api-monitor/events",
-            ...config,
-            // Deliberately after the spread. `password` and `token` are always
-            // masked; a caller-supplied list extends that set rather than replacing
-            // it, which is what happened while this sat above `...config`.
-            maskFields: [...new Set(["password", "token", ...(config.maskFields || [])])],
-        };
-        this.startQueue();
+    /** Creates the process-wide agent used by `midlineMiddleware()` and the static helpers. */
+    static init(config = {}) {
+        MidlineAgent.defaultAgent?.close();
+        MidlineAgent.defaultAgent = new MidlineAgent(config);
+        return MidlineAgent.defaultAgent;
+    }
+    static get current() {
+        return MidlineAgent.defaultAgent;
     }
     static addEvent(event) {
-        if (!this.config) {
+        MidlineAgent.defaultAgent?.addEvent(event);
+    }
+    static flush() {
+        return MidlineAgent.defaultAgent?.flush() ?? Promise.resolve();
+    }
+    static shutdown(timeoutMs) {
+        return MidlineAgent.defaultAgent?.shutdown(timeoutMs) ?? Promise.resolve();
+    }
+    constructor(config = {}) {
+        this.config = null;
+        this.transport = null;
+        this.queue = [];
+        this.queueBytes = 0;
+        this.timer = null;
+        this.drainPromise = null;
+        this.failures = 0;
+        this.retryAfter = 0;
+        this.stopped = false;
+        this.lastNotice = "";
+        this.dropped = 0;
+        this.maxRequestBytes = MAX_REQUEST_BYTES;
+        this.batchLimit = Number.MAX_SAFE_INTEGER;
+        this.onErrorHook = config.onError;
+        this.debugLogs = config.debug ?? (0, config_1.envFlag)("MIDLINE_DEBUG") ?? false;
+        this.redactor = new redact_1.Redactor([...(config.redactFields ?? []), ...(config.maskFields ?? [])], config.redactHeaders);
+        if ((config.enabled ?? (0, config_1.envFlag)("MIDLINE_ENABLED")) === false) {
+            this.stopped = true;
             return;
         }
-        this.queue.push(event);
-    }
-    static transformEvent(event) {
-        const isError = event.type === "error";
-        // Build the payload structure matching the expected API format
-        const transformed = {
-            apiKey: this.config.apiKey,
-            eventType: event.type,
-            route: event.path,
-            method: event.method || "GET",
-            statusCode: event.statusCode || (isError ? 500 : 200),
-            responseTime: event.duration || 0,
-            timestamp: event.timestamp,
-            ip: event.ip,
-            userAgent: event.userAgent,
-            service: this.config.serviceName,
-            metadata: {
-                source: "sdk",
-                version: "0.1.3",
-                integrationType: "express"
-            }
-        };
-        // Add environment, host, region if configured
-        if (this.config.environment) {
-            transformed.environment = this.config.environment;
-        }
-        if (this.config.host) {
-            transformed.host = this.config.host;
-        }
-        if (this.config.region) {
-            transformed.region = this.config.region;
-        }
-        if (this.config.release) {
-            transformed.release = this.config.release;
-        }
-        // For errors, add error-specific fields
-        if (isError) {
-            transformed.severity = "critical";
-            transformed.category = "application";
-            transformed.payload = {
-                error: event.message || "Unknown error",
-                stack: event.stack,
-                context: {
-                    route: event.path,
-                    method: event.method
-                },
-                breadcrumbs: event.breadcrumbs
+        let resolved;
+        try {
+            resolved = (0, config_1.resolveConfig)(config);
+        }
+        catch (err) {
+            this.stopped = true;
+            const detail = err instanceof config_1.ConfigError ? err.message : String(err?.message ?? err);
+            this.log("error", `midline: ${detail} — monitoring is off.`);
+            return;
+        }
+        if (!resolved.apiKey) {
+            this.stopped = true;
+            this.log("warn", "midline: no apiKey (or MIDLINE_API_KEY) — monitoring is off.");
+            return;
+        }
+        this.config = resolved;
+        this.transport = new transport_1.Transport(resolved.ingestUrl, {
+            ca: resolved.ca,
+            connectTimeoutMs: resolved.connectTimeoutMs,
+            timeoutMs: resolved.timeoutMs,
+            userAgent: `midline-agent/${exports.SDK_VERSION} node/${process.version}`,
+        });
+        this.timer = setInterval(() => {
+            void this.drain(false);
+        }, resolved.flushIntervalMs);
+        // Telemetry must never be the reason a process refuses to exit.
+        this.timer.unref?.();
+    }
+    /** False when the agent is off: no key, bad config, disabled, rejected key, or closed. */
+    get active() {
+        return !this.stopped && this.config !== null;
+    }
+    get capture() {
+        return this.config?.capture ?? null;
+    }
+    get queued() {
+        return this.queue.length;
+    }
+    addEvent(event) {
+        if (!this.active)
+            return;
+        try {
+            this.enqueue(this.toWire(event, false));
+        }
+        catch (err) {
+            this.report("event-build", `midline: could not build an event (${err?.message}); skipped it.`);
+        }
+    }
+    /** Records one HTTP exchange. Captured parts are redacted here, before queueing. */
+    recordHttp(exchange) {
+        if (!this.active)
+            return;
+        try {
+            const capture = exchange.capture ?? this.config.capture;
+            const queryIndex = exchange.url.indexOf("?");
+            const path = queryIndex === -1 ? exchange.url : exchange.url.slice(0, queryIndex);
+            const search = queryIndex === -1 ? "" : exchange.url.slice(queryIndex + 1);
+            const failed = Boolean(exchange.errorCode);
+            const event = {
+                type: failed ? "error" : "request",
+                path: path || "/",
+                method: exchange.method,
+                statusCode: exchange.statusCode,
+                duration: exchange.durationMs,
+                ip: exchange.ip,
+                userAgent: exchange.userAgent,
+                requestId: exchange.context.requestId,
+                correlationId: exchange.context.correlationId,
+                traceId: exchange.context.traceId,
+                spanId: exchange.context.spanId,
+                routeTemplate: exchange.routeTemplate,
+                integration: exchange.integration,
+                destination: exchange.destination,
+                errorCode: exchange.errorCode,
+                message: exchange.errorMessage,
+                aborted: exchange.aborted || undefined,
+                severity: failed ? "high" : undefined,
+                category: failed && exchange.integration === "proxy" ? "infrastructure" : undefined,
+                request: this.captureMessage(capture, exchange.request, search),
+                response: this.captureMessage(capture, exchange.response),
             };
+            this.enqueue(this.toWire(event, true));
         }
-        else {
-            // For requests, use appropriate category and severity
-            transformed.category = "performance";
-            // Map status codes to valid severity levels: low, medium, high, critical
-            if (event.statusCode) {
-                if (event.statusCode >= 500) {
-                    transformed.severity = "high";
-                    transformed.category = "application"; // Server errors are application issues
-                }
-                else if (event.statusCode >= 400) {
-                    transformed.severity = "medium";
-                    transformed.category = "application"; // Client errors are application issues
+        catch (err) {
+            this.report("event-build", `midline: could not record a request (${err?.message}); skipped it.`);
+        }
+    }
+    /** Sends whatever is buffered now, ignoring backoff, and keeps the process alive until done. */
+    async flush() {
+        if (!this.active)
+            return;
+        this.retryAfter = 0;
+        if (this.drainPromise) {
+            await this.drainPromise;
+        }
+        await this.drain(true);
+    }
+    /** Flushes with a deadline, then closes. For graceful shutdown. */
+    async shutdown(timeoutMs = 5000) {
+        if (this.active) {
+            let timeout;
+            await Promise.race([
+                this.flush().catch(() => undefined),
+                new Promise((resolve) => {
+                    timeout = setTimeout(resolve, timeoutMs);
+                }),
+            ]);
+            if (timeout)
+                clearTimeout(timeout);
+        }
+        this.close();
+    }
+    /** Stops the timer, drops the buffer and releases sockets. Safe to call more than once. */
+    close() {
+        this.stopped = true;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.queue = [];
+        this.queueBytes = 0;
+        this.transport?.destroy();
+    }
+    captureMessage(capture, message, search) {
+        if (!message && !search)
+            return undefined;
+        const out = {};
+        if (capture.headers && message?.headers) {
+            out.headers = this.redactor.headers(message.headers);
+        }
+        if (capture.query && search) {
+            out.query = this.redactor.query(search);
+        }
+        if (message && message.body !== undefined) {
+            Object.assign(out, this.redactor.body(message.body, message.contentType, capture.maxBodyBytes));
+            if (message.truncated)
+                out.truncated = true;
+        }
+        if (message?.bodyBytes !== undefined && (out.body !== undefined || out.omitted)) {
+            out.bodyBytes = message.bodyBytes;
+        }
+        return Object.keys(out).length ? out : undefined;
+    }
+    redactManualMessage(message) {
+        if (!message)
+            return undefined;
+        const maxBodyBytes = this.config.capture.maxBodyBytes || 4096;
+        return {
+            ...message,
+            headers: this.redactor.headers(message.headers),
+            query: message.query ? this.redactor.value(message.query) : undefined,
+            ...(message.body !== undefined ? this.redactor.body(message.body, undefined, maxBodyBytes) : {}),
+        };
+    }
+    /**
+     * Maps an event onto the ingest schema. Everything beyond the long-standing
+     * top-level fields travels in `metadata` and `payload`, which every Midline
+     * server version accepts — so upgrading the agent never gets events rejected by a
+     * server that hasn't been upgraded yet.
+     */
+    toWire(event, preRedacted) {
+        const config = this.config;
+        const type = event.type;
+        const statusCode = Number.isInteger(event.statusCode) && event.statusCode >= 100 && event.statusCode <= 599
+            ? event.statusCode
+            : type === "error" ? 500 : undefined;
+        const { severity, category } = classify(event, statusCode);
+        const route = this.redactor.string(stripQuery(event.path) || "/", 2048);
+        const payload = {};
+        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);
+        if (event.breadcrumbs?.length) {
+            payload.breadcrumbs = event.breadcrumbs.slice(-20).map((crumb) => ({
+                type: String(crumb.type).slice(0, 32),
+                message: this.redactor.string(String(crumb.message), 256),
+                timestamp: crumb.timestamp,
+            }));
+        }
+        if (type === "error") {
+            payload.context = { route, method: event.method };
+        }
+        const request = preRedacted ? event.request : this.redactManualMessage(event.request);
+        const response = preRedacted ? event.response : this.redactManualMessage(event.response);
+        if (request)
+            payload.request = request;
+        if (response)
+            payload.response = response;
+        if (event.destination)
+            payload.destination = { url: this.redactor.string(event.destination.url, 2048) };
+        if (event.errorCode)
+            payload.code = String(event.errorCode).slice(0, 64);
+        const metadata = {
+            source: "sdk",
+            sdk: "midline-agent",
+            version: exports.SDK_VERSION,
+            integrationType: event.integration ?? "manual",
+        };
+        if (event.requestId)
+            metadata.requestId = event.requestId;
+        if (event.correlationId)
+            metadata.correlationId = event.correlationId;
+        if (event.routeTemplate)
+            metadata.routeTemplate = event.routeTemplate.slice(0, 512);
+        if (event.aborted)
+            metadata.aborted = true;
+        const wire = {
+            apiKey: config.apiKey,
+            eventType: type,
+            route,
+            method: (event.method || "GET").toUpperCase().slice(0, 16),
+            statusCode,
+            responseTime: Math.min(Math.max(0, Math.round(Number(event.duration) || 0)), 86400000),
+            timestamp: validTimestamp(event.timestamp),
+            // Clamped to the server's validation limits: one over-long field would
+            // otherwise get every event rejected.
+            ip: clamp(event.ip, 64),
+            userAgent: clamp(event.userAgent, 512),
+            service: clamp(config.serviceName, 128),
+            environment: clamp(config.environment, 128),
+            host: clamp(config.host, 256),
+            region: clamp(config.region, 64),
+            release: clamp(config.release, 128),
+            severity,
+            category,
+            traceId: clamp(event.traceId, 128),
+            spanId: clamp(event.spanId, 128),
+            ruleId: clamp(event.ruleId, 128),
+            threatDetected: typeof event.threatDetected === "boolean" ? event.threatDetected : undefined,
+            metadata,
+            payload: Object.keys(payload).length ? payload : undefined,
+        };
+        for (const key of Object.keys(wire)) {
+            if (wire[key] === undefined)
+                delete wire[key];
+        }
+        return wire;
+    }
+    enqueue(wire) {
+        const config = this.config;
+        let bytes = Buffer.byteLength(JSON.stringify(wire));
+        if (bytes > config.maxEventBytes) {
+            bytes = shrink(wire, config.maxEventBytes);
+            if (bytes > config.maxEventBytes) {
+                this.dropped += 1;
+                this.report("event-too-large", `midline: an event was larger than maxEventBytes (${config.maxEventBytes}) even without bodies; dropped it.`);
+                return;
+            }
+        }
+        this.queue.push({ wire, bytes });
+        this.queueBytes += bytes;
+        this.trimQueue();
+    }
+    /** Oldest events go first — during an outage the most recent minute is worth more than the first. */
+    trimQueue() {
+        const config = this.config;
+        while (this.queue.length > config.maxQueueSize || (this.queueBytes > MAX_QUEUE_BYTES && this.queue.length > 1)) {
+            const removed = this.queue.shift();
+            this.queueBytes -= removed.bytes;
+            this.dropped += 1;
+        }
+    }
+    requeue(batch) {
+        this.queue.unshift(...batch);
+        this.queueBytes += batch.reduce((sum, item) => sum + item.bytes, 0);
+        this.trimQueue();
+    }
+    takeBatch() {
+        const config = this.config;
+        const batch = [];
+        let bytes = 0;
+        const limit = Math.min(config.maxBatchSize, this.batchLimit);
+        while (this.queue.length && batch.length < limit) {
+            const next = this.queue[0];
+            if (batch.length > 0 && bytes + next.bytes > this.maxRequestBytes)
+                break;
+            batch.push(this.queue.shift());
+            bytes += next.bytes;
+            this.queueBytes -= next.bytes;
+        }
+        return batch;
+    }
+    drain(keepProcessAlive) {
+        if (this.drainPromise)
+            return this.drainPromise;
+        if (!this.active || !this.queue.length || Date.now() < this.retryAfter) {
+            return Promise.resolve();
+        }
+        this.drainPromise = this.runDrain(keepProcessAlive).finally(() => {
+            this.drainPromise = null;
+        });
+        return this.drainPromise;
+    }
+    async runDrain(keepProcessAlive) {
+        while (this.queue.length && this.active) {
+            // Taken off the queue while in flight, so overflow trimming can't remove
+            // events that are mid-send and then be confused about what was accepted.
+            const batch = this.takeBatch();
+            const outcome = await this.send(batch, keepProcessAlive);
+            if (outcome.kind === "ok") {
+                this.onSuccess();
+                continue;
+            }
+            if (outcome.kind === "stop") {
+                this.disable();
+                return;
+            }
+            if (outcome.kind === "tooLarge") {
+                if (batch.length > 1) {
+                    // Halve by count as well as bytes: a byte floor alone would resend the
+                    // same batch of small events forever. The server's limit doesn't move,
+                    // so the smaller size sticks.
+                    const batchBytes = batch.reduce((sum, item) => sum + item.bytes, 0);
+                    this.batchLimit = Math.max(1, Math.floor(batch.length / 2));
+                    this.maxRequestBytes = Math.max(MIN_REQUEST_BYTES, Math.min(this.maxRequestBytes, Math.floor(batchBytes / 2)));
+                    this.requeue(batch);
                 }
                 else {
-                    transformed.severity = "low";
+                    this.dropped += 1;
+                    this.report("http-413", "midline: the Midline server rejected an event as too large (HTTP 413); dropped it.");
+                }
+                continue;
+            }
+            if (outcome.kind === "rejected") {
+                if (batch.length === 1) {
+                    this.dropped += 1;
+                    this.report(`rejected:${outcome.detail}`, `midline: the Midline server rejected an event (${outcome.detail}); dropped it.`);
+                    continue;
                 }
+                // One malformed event fails validation for the whole batch. Send them one
+                // at a time so it only costs that event.
+                const isolated = await this.sendIndividually(batch, keepProcessAlive);
+                if (!isolated)
+                    return;
+                continue;
+            }
+            this.requeue(batch);
+            this.onFailure(outcome.retryAfterMs);
+            return;
+        }
+    }
+    /** Returns false if delivery should stop for this drain. */
+    async sendIndividually(batch, keepProcessAlive) {
+        for (let index = 0; index < batch.length; index++) {
+            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";
+                this.report(`rejected:${detail}`, `midline: the Midline server rejected an event (${detail}); dropped it.`);
+            }
+            else if (outcome.kind === "stop") {
+                this.disable();
+                return false;
             }
             else {
-                transformed.severity = "low";
+                this.requeue(batch.slice(index));
+                this.onFailure(outcome.retryAfterMs);
+                return false;
             }
         }
-        return transformed;
+        return true;
     }
-    static startQueue() {
-        this.timer = setInterval(async () => {
-            if (!this.queue.length)
-                return;
-            const batch = [...this.queue];
-            this.queue = [];
-            // Transform events to match the expected API format
-            const transformedBatch = batch.map(event => this.transformEvent(event));
-            // Send each event individually (or as a batch if API supports it)
-            for (const event of transformedBatch) {
-                try {
-                    const response = await (0, cross_fetch_1.default)(this.config.endpoint, {
-                        method: "POST",
-                        headers: {
-                            "Content-Type": "application/json"
-                        },
-                        body: JSON.stringify(event)
-                    });
-                }
-                catch (err) {
-                    console.error("MidlineAgent send error:", err);
-                }
+    async send(batch, keepProcessAlive) {
+        const config = this.config;
+        const body = JSON.stringify({ events: batch.map((item) => item.wire) });
+        let result;
+        try {
+            result = await this.transport.post(config.batchUrl, body, { "x-api-key": config.apiKey }, keepProcessAlive);
+        }
+        catch (err) {
+            this.report(`transport:${errorCode(err)}`, this.describe(err, batch.length));
+            return { kind: "retry" };
+        }
+        const { status } = result;
+        if (status >= 200 && status < 300) {
+            // Servers that predate 401-on-bad-key answer 201 and count the rejects.
+            const summary = parseJson(result.body);
+            const failed = typeof summary?.failed === "number" ? summary.failed : 0;
+            if (failed >= batch.length && batch.length > 0) {
+                this.log("error", "midline: the Midline server did not accept this API key. Monitoring is now off — retrying wouldn't help. Check apiKey / MIDLINE_API_KEY.");
+                return { kind: "stop" };
+            }
+            if (failed > 0) {
+                this.dropped += failed;
+                this.report("partial", `midline: the Midline server rejected ${failed} of ${batch.length} events.`);
             }
-        }, 1500);
+            return { kind: "ok" };
+        }
+        if (status === 401 || status === 403) {
+            this.log("error", `midline: the Midline server rejected the API key (HTTP ${status}). ` +
+                "Monitoring is now off — retrying wouldn't help. Check apiKey / MIDLINE_API_KEY.");
+            return { kind: "stop" };
+        }
+        if (status === 413) {
+            return { kind: "tooLarge" };
+        }
+        if (status === 408 || status === 429 || status >= 500) {
+            const retryAfterMs = parseRetryAfter(result.headers["retry-after"]);
+            this.report(`http-${status}`, `midline: the Midline server returned HTTP ${status}; events are buffered and will be retried.`);
+            return { kind: "retry", retryAfterMs };
+        }
+        if (status >= 300 && status < 400) {
+            // Never followed: that would hand the API key to wherever the redirect points.
+            const location = String(result.headers.location ?? "").slice(0, 200);
+            this.report(`http-${status}`, `midline: the Midline endpoint redirected (HTTP ${status}${location ? ` to ${location}` : ""}). ` +
+                "Redirects are not followed; set MIDLINE_ENDPOINT to the final URL.");
+            return { kind: "retry" };
+        }
+        return { kind: "rejected", detail: `HTTP ${status}${serverMessage(result.body)}` };
+    }
+    /** One line per distinct fault, not one per failed event. */
+    report(signature, message) {
+        if (this.lastNotice === signature && !this.debugLogs) {
+            return;
+        }
+        this.lastNotice = signature;
+        this.log("warn", message);
+    }
+    describe(err, inFlight) {
+        const config = this.config;
+        const origin = config.ingestUrl.origin;
+        const code = errorCode(err);
+        const buffered = ` ${this.queue.length + inFlight} event(s) buffered; your application is unaffected.`;
+        if (TLS_ERROR_REASONS[code] || code.startsWith("ERR_SSL") || code === "EPROTO") {
+            const reason = TLS_ERROR_REASONS[code] ?? "failed the TLS handshake";
+            return (`midline: ${origin} ${reason} (${code}), so the connection was refused. Certificate verification stays on. ` +
+                (config.hasCustomCa
+                    ? "The configured ca / MIDLINE_CUSTOM_CA did not validate it either. "
+                    : "If this is the Midline server, its HTTPS certificate needs fixing on the server; for a self-hosted server behind a private CA, set ca / MIDLINE_CUSTOM_CA. ") +
+                `Delivery resumes on its own once a trusted certificate is served.${buffered}`);
+        }
+        if (code === "ETIMEDOUT") {
+            return `midline: ${origin} did not answer within ${config.timeoutMs}ms; retrying with backoff.${buffered}`;
+        }
+        if (code === "ECONNECT_TIMEOUT") {
+            return `midline: could not connect to ${origin} within ${config.connectTimeoutMs}ms; retrying with backoff.${buffered}`;
+        }
+        if (code === "ENOTFOUND" || code === "EAI_AGAIN") {
+            return `midline: cannot resolve ${config.ingestUrl.hostname} (${code}) — check MIDLINE_ENDPOINT and DNS; retrying with backoff.${buffered}`;
+        }
+        if (code === "ECONNREFUSED") {
+            return `midline: ${origin} refused the connection; retrying with backoff.${buffered}`;
+        }
+        if (code === "ECONNRESET" || code === "EPIPE") {
+            return `midline: the connection to ${origin} was reset; retrying with backoff.${buffered}`;
+        }
+        return `midline: could not reach ${origin} (${code || err?.message || "unknown error"}); retrying with backoff.${buffered}`;
+    }
+    onSuccess() {
+        if (this.failures > 0) {
+            const lost = this.dropped;
+            this.log("info", `midline: delivery to the Midline server recovered${lost ? `; ${lost} event(s) were dropped meanwhile` : ""}.`);
+            this.dropped = 0;
+            // Only a recovered outage resets de-duplication; a stream of individually
+            // rejected events between successes should still log once.
+            this.lastNotice = "";
+        }
+        this.failures = 0;
+        this.retryAfter = 0;
+    }
+    onFailure(retryAfterMs) {
+        const config = this.config;
+        this.failures += 1;
+        // Exponential backoff, capped, with jitter so a fleet of instances doesn't
+        // retry in lockstep against a server that is coming back up.
+        const ceiling = Math.min(config.flushIntervalMs * 2 ** Math.min(this.failures, 12), config.maxRetryDelayMs);
+        const backoff = Math.round(ceiling * (0.5 + Math.random() * 0.5));
+        const wait = retryAfterMs !== undefined ? Math.min(Math.max(retryAfterMs, backoff), config.maxRetryDelayMs) : backoff;
+        this.retryAfter = Date.now() + wait;
+    }
+    /** Unrecoverable configuration problem: go quiet instead of looping forever. */
+    disable() {
+        this.close();
+    }
+    log(level, message) {
+        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 (level === "error")
+            console.error(message);
+        else if (level === "warn")
+            console.warn(message);
+        else
+            console.info(message);
     }
 }
 exports.MidlineAgent = MidlineAgent;
-MidlineAgent.queue = [];
+MidlineAgent.defaultAgent = null;
+function classify(event, statusCode) {
+    if (event.severity && event.category) {
+        return { severity: event.severity, category: event.category };
+    }
+    let severity = "low";
+    let category = "performance";
+    if (event.type === "error") {
+        severity = "critical";
+        category = "application";
+    }
+    else if (event.type === "security") {
+        severity = "high";
+        category = "security";
+    }
+    else if (event.type === "custom") {
+        category = "business";
+    }
+    else if (statusCode && statusCode >= 500) {
+        severity = "high";
+        category = "application";
+    }
+    else if (statusCode && statusCode >= 400) {
+        severity = "medium";
+        category = "application";
+    }
+    return { severity: event.severity ?? severity, category: event.category ?? category };
+}
+/** Drops the heaviest optional parts until the event fits. Returns the new size. */
+function shrink(wire, maxBytes) {
+    const payload = wire.payload;
+    const size = () => Buffer.byteLength(JSON.stringify(wire));
+    if (!payload)
+        return size();
+    const steps = [
+        () => markOmitted(payload.response, "body"),
+        () => markOmitted(payload.request, "body"),
+        () => {
+            if (typeof payload.stack === "string")
+                payload.stack = payload.stack.slice(0, 2048);
+        },
+        () => delete payload.breadcrumbs,
+        () => markOmitted(payload.response, "headers"),
+        () => markOmitted(payload.request, "headers"),
+        () => markOmitted(payload.request, "query"),
+    ];
+    let bytes = size();
+    for (const step of steps) {
+        if (bytes <= maxBytes)
+            break;
+        step();
+        bytes = size();
+    }
+    return bytes;
+}
+function markOmitted(message, field) {
+    if (message && message[field] !== undefined) {
+        delete message[field];
+        message.omitted = "event size limit";
+    }
+}
+function clamp(value, max) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    return String(value).slice(0, max);
+}
+function stripQuery(path) {
+    const index = path.search(/[?#]/);
+    return index === -1 ? path : path.slice(0, index);
+}
+function validTimestamp(value) {
+    if (value) {
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed))
+            return new Date(parsed).toISOString();
+    }
+    return new Date().toISOString();
+}
+function errorCode(err) {
+    const e = err;
+    return String(e?.code ?? e?.cause?.code ?? e?.errno ?? e?.name ?? "");
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function serverMessage(body) {
+    const message = parseJson(body)?.message;
+    const text = Array.isArray(message) ? message.join("; ") : typeof message === "string" ? message : "";
+    return text ? `: ${text.slice(0, 300)}` : "";
+}
+function parseRetryAfter(header) {
+    const value = Array.isArray(header) ? header[0] : header;
+    if (!value)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds))
+        return Math.max(0, seconds * 1000);
+    const date = Date.parse(value);
+    return Number.isFinite(date) ? Math.max(0, date - Date.now()) : undefined;
+}