polartrace 2.0.0

package/dist/index.js

@@ -0,0 +1,1391 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolarTrace = void 0;
+const api_1 = require("@opentelemetry/api");
+const trace_1 = require("./trace");
+const crypto_1 = require("crypto");
+const diagnostics_1 = require("./diagnostics");
+const module_hook_1 = require("./module-hook");
+const SENSITIVE_FIELDS = [
+    "password",
+    "token",
+    "secret",
+    "apikey",
+    "api-key",
+    "authorization",
+    "creditcard",
+    "ssn",
+    "cookie",
+];
+const version_1 = require("./version");
+const instrumentation_manager_1 = require("./instrumentations/instrumentation-manager");
+const mongo_instrumentation_1 = require("./instrumentations/mongo.instrumentation");
+const redis_instrumentation_1 = require("./instrumentations/redis.instrumentation");
+const postgres_instrumentation_1 = require("./instrumentations/postgres.instrumentation");
+const host_metrics_monitor_1 = require("./metrics/host-metrics-monitor");
+class PolarTrace {
+    constructor(config) {
+        this.connectionStatus = "pending";
+        this.statusAnnounced = false;
+        this.logQueue = [];
+        this.isFlushing = false;
+        this.isTraceFlushing = false;
+        this.isHostMetricsFlushing = false;
+        this.traceQueue = [];
+        this.hostMetricsQueue = [];
+        this.HOST_METRICS_QUEUE_LIMIT = 1000;
+        this.LOG_QUEUE_LIMIT = 5000;
+        this.TRACE_QUEUE_LIMIT = 5000;
+        this.MAX_BATCH_SIZE = 500;
+        this.FLUSH_INTERVAL = 10000;
+        this.API_TIMEOUT = 10000;
+        this.MAX_BACKOFF_MS = 300000;
+        this.logConsecutiveFailures = 0;
+        this.logBackoffUntil = 0;
+        this.traceConsecutiveFailures = 0;
+        this.traceBackoffUntil = 0;
+        this.hostMetricsConsecutiveFailures = 0;
+        this.hostMetricsBackoffUntil = 0;
+        this.traceCache = new Map();
+        this.parentSpanTracker = new Map();
+        this.traceTimestamps = new Map();
+        this.TRACE_CACHE_TIMEOUT = 60000;
+        this.spanIdMap = new Map();
+        const defaultEndpoint = "https://collector.polartrace.io/api/log";
+        this.config = {
+            enableConsoleLog: false,
+            captureHeaders: true,
+            captureBody: true,
+            captureQuery: true,
+            captureConsoleLogs: true,
+            enableMongoSpanCollection: true,
+            enableRedisSpanCollection: true,
+            enablePostgresSpanCollection: true,
+            enableHostMetrics: true,
+            endpoint: defaultEndpoint,
+            ...config,
+        };
+        diagnostics_1.diagnostics.configure({
+            verbose: this.config.enableConsoleLog,
+            filePath: this.config.logFile,
+        });
+        if (!this.config.serviceName) {
+            throw new Error("serviceName is required (set POLARTRACE_APP_NAME)");
+        }
+        this.defaultHeaders = {
+            "Content-Type": "application/json",
+            "internal-access-token": this.config.apiKey,
+            "service-name": this.config.serviceName,
+        };
+        this.validateApiKey();
+        this.setupFlushTimer();
+        this.initializeTraceMonitoringSync();
+        this.initializeHostMetricsMonitoring();
+        this.validateConnection().catch((err) => {
+        });
+        setImmediate(() => {
+            this.showConnectionStatus();
+        });
+    }
+    async postJson(url, body) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.API_TIMEOUT);
+        try {
+            const res = await fetch(url, {
+                method: "POST",
+                headers: this.defaultHeaders,
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            const text = await res.text();
+            let data = undefined;
+            if (text) {
+                try {
+                    data = JSON.parse(text);
+                }
+                catch {
+                    data = text;
+                }
+            }
+            if (res.status >= 500) {
+                const err = new Error(`API returned status ${res.status}`);
+                err.response = { status: res.status, data };
+                throw err;
+            }
+            let retryAfterSeconds;
+            if (res.status === 429) {
+                const retryAfterHeader = res.headers.get("retry-after");
+                if (retryAfterHeader) {
+                    const seconds = Number(retryAfterHeader);
+                    if (Number.isFinite(seconds) && seconds > 0) {
+                        retryAfterSeconds = seconds;
+                    }
+                }
+            }
+            return { status: res.status, data, retryAfterSeconds };
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    shouldRetainBatch(status) {
+        if (status === undefined) {
+            return true;
+        }
+        return status === 429 || status >= 500;
+    }
+    nextBackoffMs(consecutiveFailures, retryAfterSeconds) {
+        const exponential = Math.min(this.FLUSH_INTERVAL * Math.pow(2, consecutiveFailures - 1), this.MAX_BACKOFF_MS);
+        return Math.max(exponential, (retryAfterSeconds ?? 0) * 1000);
+    }
+    getBaseUrl() {
+        if (!this.config.endpoint) {
+            return "";
+        }
+        const endpoint = this.config.endpoint.trim();
+        try {
+            const url = new URL(endpoint);
+            return `${url.protocol}//${url.host}`;
+        }
+        catch {
+            const match = endpoint.match(/^(https?:\/\/[^\/]+)/);
+            if (match) {
+                return match[1];
+            }
+            return "";
+        }
+    }
+    validateApiKey() {
+        if (!this.config.apiKey) {
+            throw new Error("apiKey is required (set POLARTRACE_LICENSE_KEY)");
+        }
+        if (this.config.apiKey.length < 10) {
+            throw new Error("apiKey does not look like a PolarTrace license key (set POLARTRACE_LICENSE_KEY)");
+        }
+    }
+    setupFlushTimer() {
+        if (this.config.endpoint) {
+            this.flushTimer = setInterval(() => {
+                this.flushLogs();
+            }, this.FLUSH_INTERVAL);
+            this.flushTimer.unref();
+            this.traceFlushTimer = setInterval(() => {
+                this.flushTraces();
+            }, this.FLUSH_INTERVAL);
+            this.traceFlushTimer.unref();
+            this.hostMetricsFlushTimer = setInterval(() => {
+                this.flushHostMetrics();
+            }, this.FLUSH_INTERVAL);
+            this.hostMetricsFlushTimer.unref();
+        }
+    }
+    initializeHostMetricsMonitoring() {
+        if (!this.config.enableHostMetrics) {
+            return;
+        }
+        try {
+            this.hostMetricsMonitor = new host_metrics_monitor_1.HostMetricsMonitor({
+                serviceName: this.config.serviceName,
+                sampleIntervalMs: this.FLUSH_INTERVAL,
+                onSample: (sample) => this.queueHostMetricSample(sample),
+                onError: (err) => {
+                    diagnostics_1.diagnostics.debug(`Host metrics sampling error: ${err.message}`);
+                },
+            });
+            this.hostMetricsMonitor.initialize();
+            diagnostics_1.diagnostics.debug("Host metrics monitoring started (CPU/memory/event-loop)");
+        }
+        catch (err) {
+            diagnostics_1.diagnostics.warn(`Failed to initialize host metrics monitoring: ${err.message}`);
+        }
+    }
+    queueHostMetricSample(sample) {
+        this.hostMetricsQueue.push({ sample });
+        if (this.hostMetricsQueue.length > this.HOST_METRICS_QUEUE_LIMIT) {
+            const overflow = this.hostMetricsQueue.length - this.HOST_METRICS_QUEUE_LIMIT;
+            this.hostMetricsQueue.splice(0, overflow);
+        }
+    }
+    describeNetworkError(error) {
+        const baseUrl = this.getBaseUrl() || this.config.endpoint || "(unknown)";
+        const cause = error?.cause;
+        const code = cause?.code || cause?.errno;
+        const detail = cause?.message || error?.message || "unknown error";
+        if (code === "ECONNREFUSED") {
+            return `Collector at ${baseUrl} refused connection - is it running?`;
+        }
+        if (code === "ENOTFOUND" || code === "EAI_AGAIN") {
+            return `Cannot resolve collector host ${baseUrl} (${code})`;
+        }
+        if (code === "ETIMEDOUT") {
+            return `Collector at ${baseUrl} timed out`;
+        }
+        if (code) {
+            return `Cannot reach collector at ${baseUrl} (${code})`;
+        }
+        return `Cannot reach collector at ${baseUrl} - ${detail}`;
+    }
+    async validateConnection() {
+        if (!this.config.endpoint) {
+            this.connectionStatus = "failed";
+            this.connectionError = "Endpoint not configured";
+            this.showConnectionStatus();
+            return;
+        }
+        const baseUrl = this.getBaseUrl();
+        const validationEndpoint = `${baseUrl}/api/service/validate`;
+        const backoffsMs = [0, 2000, 4000, 8000, 16000];
+        for (let attempt = 0; attempt < backoffsMs.length; attempt++) {
+            if (backoffsMs[attempt] > 0) {
+                await new Promise((r) => setTimeout(r, backoffsMs[attempt]));
+            }
+            try {
+                const response = await this.postJson(validationEndpoint, {});
+                if (response.status >= 200 && response.status < 300) {
+                    this.connectionStatus = "connected";
+                    this.connectionError = undefined;
+                    diagnostics_1.diagnostics.debug("Connection validated successfully");
+                    this.showConnectionStatus();
+                    return;
+                }
+                this.connectionStatus = "failed";
+                this.connectionError =
+                    response.data?.message || `API returned status ${response.status}`;
+                this.showConnectionStatus();
+                return;
+            }
+            catch (error) {
+                if (error?.response) {
+                    this.connectionStatus = "failed";
+                    this.connectionError =
+                        error.response.data?.message ||
+                            `API returned status ${error.response.status}`;
+                    this.showConnectionStatus();
+                    return;
+                }
+                const isLast = attempt === backoffsMs.length - 1;
+                const reason = error?.name === "AbortError"
+                    ? `Collector at ${baseUrl} did not respond within ${this.API_TIMEOUT / 1000}s`
+                    : this.describeNetworkError(error);
+                diagnostics_1.diagnostics.debug(`validate attempt ${attempt + 1}/${backoffsMs.length} failed - ${reason}`);
+                if (isLast) {
+                    this.connectionStatus = "failed";
+                    this.connectionError = reason;
+                    this.showConnectionStatus();
+                    return;
+                }
+            }
+        }
+    }
+    showConnectionStatus() {
+        if (this.connectionStatus === "pending" || this.statusAnnounced) {
+            return;
+        }
+        const globals = globalThis;
+        const components = [
+            {
+                name: "collector",
+                ok: this.connectionStatus === "connected",
+                reason: this.connectionError,
+            },
+            { name: "http/express tracing", ok: !!this.traceMonitor?.initialized },
+            {
+                name: "mongodb spans",
+                ok: !this.config.enableMongoSpanCollection ||
+                    !!globals.__POLARTRACE_MONGO_INSTRUMENTATION_ENABLED__,
+            },
+            {
+                name: "redis spans",
+                ok: !this.config.enableRedisSpanCollection ||
+                    !!globals.__POLARTRACE_REDIS_INSTRUMENTATION_ENABLED__,
+            },
+            {
+                name: "postgres spans",
+                ok: !this.config.enablePostgresSpanCollection ||
+                    !!globals.__POLARTRACE_POSTGRES_INSTRUMENTATION_ENABLED__,
+            },
+        ];
+        this.statusAnnounced = true;
+        const failed = components.filter((component) => !component.ok);
+        if (failed.length === 0) {
+            diagnostics_1.diagnostics.info(`agent ready (v${version_1.AGENT_VERSION}, service "${this.config.serviceName}")`);
+            return;
+        }
+        for (const component of failed) {
+            diagnostics_1.diagnostics.error(component.reason
+                ? `${component.name} unavailable: ${component.reason}`
+                : `${component.name} unavailable`);
+        }
+    }
+    initializeTraceMonitoringSync() {
+        try {
+            const agentEndpointPatterns = [];
+            if (this.config.endpoint) {
+                const baseUrl = this.getBaseUrl();
+                agentEndpointPatterns.push("/api/traces", "/api/log", "/api/logs", "/api/host-metrics", "/api/service/validate");
+                agentEndpointPatterns.push(`${baseUrl}/api/traces`, `${baseUrl}/api/log`, `${baseUrl}/api/logs`, `${baseUrl}/api/host-metrics`, `${baseUrl}/api/service/validate`);
+            }
+            this.traceMonitor = new trace_1.TraceMonitor({
+                serviceName: this.config.serviceName,
+                serviceVersion: version_1.AGENT_VERSION,
+                excludeAgentSpans: true,
+                agentEndpoints: agentEndpointPatterns.length > 0 ? agentEndpointPatterns : undefined,
+                sharedSpanIdMap: this.spanIdMap,
+                onSpan: (span) => {
+                    this.queueTraceSpan(span);
+                },
+            });
+            this.traceMonitor.initialize().catch((err) => {
+                diagnostics_1.diagnostics.error(`Failed to initialize trace monitoring: ${err}`);
+            });
+            diagnostics_1.diagnostics.debug("Trace monitoring initialization started (SDK will be ready before mongoose loads)");
+            const instrumentationManager = instrumentation_manager_1.InstrumentationManager.getInstance();
+            if (this.config.enableMongoSpanCollection) {
+                const mongoCallback = (mongoSpan) => {
+                    const traceSpan = this.convertMongoSpanToTraceSpan(mongoSpan);
+                    this.queueTraceSpan(traceSpan);
+                };
+                const updated = instrumentationManager.updateMongoCallback(mongoCallback);
+                if (!updated) {
+                    instrumentationManager.register(new mongo_instrumentation_1.MongoInstrumentation(mongoCallback, this.config.mongoose));
+                    instrumentationManager.enableAll();
+                }
+            }
+            if (this.config.enableRedisSpanCollection) {
+                const redisCallback = (redisSpan) => {
+                    const traceSpan = this.convertRedisSpanToTraceSpan(redisSpan);
+                    this.queueTraceSpan(traceSpan);
+                };
+                const updated = instrumentationManager.updateRedisCallback(redisCallback);
+                if (!updated) {
+                    instrumentationManager.register(new redis_instrumentation_1.RedisInstrumentation(redisCallback));
+                    instrumentationManager.enableAll();
+                }
+                globalThis.__POLARTRACE_REDIS_INSTRUMENTATION_ENABLED__ = true;
+            }
+            if (this.config.enablePostgresSpanCollection) {
+                const postgresCallback = (pgSpan) => {
+                    const traceSpan = this.convertPostgresSpanToTraceSpan(pgSpan);
+                    this.queueTraceSpan(traceSpan);
+                };
+                const updated = instrumentationManager.updatePostgresCallback(postgresCallback);
+                if (!updated) {
+                    instrumentationManager.register(new postgres_instrumentation_1.PostgresInstrumentation(postgresCallback));
+                    instrumentationManager.enableAll();
+                }
+                globalThis.__POLARTRACE_POSTGRES_INSTRUMENTATION_ENABLED__ = true;
+            }
+        }
+        catch (error) {
+            diagnostics_1.diagnostics.error(`Failed to initialize trace monitoring: ${error.message}`);
+        }
+    }
+    queueTraceSpan(span) {
+        const traceSpanData = {
+            ...span,
+        };
+        const traceId = span.traceId;
+        const isParentSpan = this.isParentSpan(span);
+        if (isParentSpan) {
+            const existingParentSpanId = this.parentSpanTracker.get(traceId);
+            if (!existingParentSpanId) {
+                this.parentSpanTracker.set(traceId, span.spanId);
+                if (!this.traceTimestamps.has(traceId)) {
+                    this.traceTimestamps.set(traceId, Date.now());
+                }
+                if (!this.traceCache.has(traceId)) {
+                    this.traceCache.set(traceId, []);
+                }
+                this.traceCache.get(traceId).push(traceSpanData);
+                this.flushTrace(traceId);
+                return;
+            }
+        }
+        if (!this.traceCache.has(traceId)) {
+            this.traceCache.set(traceId, []);
+            this.traceTimestamps.set(traceId, Date.now());
+        }
+        this.traceCache.get(traceId).push(traceSpanData);
+        if (this.traceCache.size % 100 === 0) {
+            this.cleanupOldTraces();
+        }
+    }
+    isParentSpan(span) {
+        return (span.kind === "SERVER" &&
+            !span.parentSpanId &&
+            (span.attributes?.["http.method"] !== undefined ||
+                span.attributes?.["http.request.method"] !== undefined));
+    }
+    flushTrace(traceId) {
+        const spans = this.traceCache.get(traceId);
+        if (!spans || spans.length === 0) {
+            this.parentSpanTracker.delete(traceId);
+            this.traceTimestamps.delete(traceId);
+            return;
+        }
+        for (const span of spans) {
+            this.traceQueue.push({ span });
+        }
+        if (this.traceQueue.length > this.TRACE_QUEUE_LIMIT) {
+            const overflow = this.traceQueue.length - this.TRACE_QUEUE_LIMIT;
+            this.traceQueue.splice(0, overflow);
+        }
+        diagnostics_1.diagnostics.debug(`Flushed trace ${traceId.substring(0, 8)}... with ${spans.length} spans (parent completed)`);
+        this.traceCache.delete(traceId);
+        this.parentSpanTracker.delete(traceId);
+        this.traceTimestamps.delete(traceId);
+    }
+    cleanupOldTraces() {
+        const now = Date.now();
+        const tracesToCleanup = [];
+        for (const [traceId, timestamp] of this.traceTimestamps.entries()) {
+            if (now - timestamp > this.TRACE_CACHE_TIMEOUT) {
+                tracesToCleanup.push(traceId);
+            }
+        }
+        for (const traceId of tracesToCleanup) {
+            diagnostics_1.diagnostics.debug(`Cleaning up orphaned trace ${traceId.substring(0, 8)}... (timeout)`);
+            this.flushTrace(traceId);
+        }
+    }
+    convertMongoSpanToTraceSpan(mongoSpan) {
+        const startMs = mongoSpan.startTime || Date.now();
+        const endMs = mongoSpan.endTime ?? Date.now();
+        const durationMs = mongoSpan.durationMs ?? endMs - startMs;
+        const startTimeNs = startMs * 1000000;
+        const endTimeNs = endMs * 1000000;
+        const traceId = mongoSpan.traceId || this.generateUUID();
+        const parentSpanIdUUID = mongoSpan.parentSpanId
+            ? this.convertSpanIdToUUID(mongoSpan.parentSpanId)
+            : undefined;
+        return {
+            traceId,
+            spanId: this.generateUUID(),
+            parentSpanId: parentSpanIdUUID,
+            name: mongoSpan.name,
+            kind: "CLIENT",
+            startTime: startTimeNs,
+            endTime: endTimeNs,
+            duration: durationMs,
+            status: {
+                code: mongoSpan.error ? "ERROR" : "OK",
+                message: mongoSpan.error?.message,
+            },
+            attributes: {
+                "db.system": "mongodb",
+                "db.name": mongoSpan.attributes.db,
+                "db.operation": mongoSpan.attributes.command,
+                "db.mongodb.collection": mongoSpan.attributes.collection,
+                ...mongoSpan.attributes,
+            },
+        };
+    }
+    convertRedisSpanToTraceSpan(redisSpan) {
+        const startMs = redisSpan.startTime || Date.now();
+        const endMs = redisSpan.endTime ?? Date.now();
+        const durationMs = redisSpan.durationMs ?? endMs - startMs;
+        const startTimeNs = startMs * 1000000;
+        const endTimeNs = endMs * 1000000;
+        const traceId = redisSpan.traceId || this.generateUUID();
+        const parentSpanIdUUID = redisSpan.parentSpanId
+            ? this.convertSpanIdToUUID(redisSpan.parentSpanId)
+            : undefined;
+        return {
+            traceId,
+            spanId: this.generateUUID(),
+            parentSpanId: parentSpanIdUUID,
+            name: redisSpan.name,
+            kind: "CLIENT",
+            startTime: startTimeNs,
+            endTime: endTimeNs,
+            duration: durationMs,
+            status: {
+                code: redisSpan.error ? "ERROR" : "OK",
+                message: redisSpan.error?.message,
+            },
+            attributes: {
+                "db.system": "redis",
+                "db.operation": redisSpan.attributes.command,
+                "db.redis.library": redisSpan.attributes.library,
+                "db.statement.key": redisSpan.attributes.key,
+                ...redisSpan.attributes,
+            },
+        };
+    }
+    convertPostgresSpanToTraceSpan(pgSpan) {
+        const startMs = pgSpan.startTime || Date.now();
+        const endMs = pgSpan.endTime ?? Date.now();
+        const durationMs = pgSpan.durationMs ?? endMs - startMs;
+        const traceId = pgSpan.traceId || this.generateUUID();
+        const parentSpanIdUUID = pgSpan.parentSpanId
+            ? this.convertSpanIdToUUID(pgSpan.parentSpanId)
+            : undefined;
+        return {
+            traceId,
+            spanId: this.generateUUID(),
+            parentSpanId: parentSpanIdUUID,
+            name: pgSpan.name,
+            kind: "CLIENT",
+            startTime: startMs * 1000000,
+            endTime: endMs * 1000000,
+            duration: durationMs,
+            status: {
+                code: pgSpan.error ? "ERROR" : "OK",
+                message: pgSpan.error?.message,
+            },
+            attributes: {
+                "db.system": "postgresql",
+                "db.operation": pgSpan.attributes.operation,
+                "db.sql.table": pgSpan.attributes.table,
+                "db.statement": pgSpan.attributes.statement,
+                ...pgSpan.attributes,
+            },
+        };
+    }
+    convertSpanIdToUUID(spanId) {
+        if (!spanId)
+            return spanId;
+        if (spanId.length === 32) {
+            return spanId;
+        }
+        if (this.spanIdMap.has(spanId)) {
+            return this.spanIdMap.get(spanId);
+        }
+        const uuidString = (0, crypto_1.randomUUID)().replace(/-/g, "");
+        this.spanIdMap.set(spanId, uuidString);
+        if (this.spanIdMap.size > 10000) {
+            const entries = Array.from(this.spanIdMap.entries());
+            this.spanIdMap.clear();
+            entries.slice(-5000).forEach(([key, value]) => {
+                this.spanIdMap.set(key, value);
+            });
+        }
+        return uuidString;
+    }
+    generateUUID() {
+        return (0, crypto_1.randomUUID)().replace(/-/g, "");
+    }
+    getActiveTraceId() {
+        try {
+            const span = api_1.trace.getActiveSpan();
+            const id = span?.spanContext().traceId;
+            if (!id || /^0+$/.test(id))
+                return undefined;
+            return id;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    middleware() {
+        return (req, res, next) => {
+            const startTimeMs = Date.now();
+            const startTime = new Date(startTimeMs).toISOString();
+            const capturedLogs = [];
+            this.generateRequestId();
+            const traceId = this.getActiveTraceId();
+            const requestLog = {
+                timestamp: startTime,
+                method: req.method,
+                path: req.path,
+                userAgent: req.get("user-agent"),
+                ip: this.getClientIp(req),
+                host: req.get("host"),
+                startTime: startTime,
+                ...(traceId ? { traceId } : {}),
+            };
+            req.__POLARTRACE_REQUEST_LOG__ = requestLog;
+            if (this.config.captureHeaders) {
+                requestLog.headers = this.redactSensitive(req.headers);
+            }
+            if (this.config.captureQuery && Object.keys(req.query).length > 0) {
+                requestLog.query = req.query;
+            }
+            let consoleIntercepted = false;
+            if (this.config.captureConsoleLogs) {
+                this.interceptConsole(capturedLogs);
+                consoleIntercepted = true;
+            }
+            const errorHandler = (err) => {
+                requestLog.error = {
+                    message: err.message,
+                    stack: err.stack,
+                    name: err.name,
+                };
+            };
+            const originalSend = res.send;
+            const originalJson = res.json;
+            let isLogged = false;
+            res.send = (data) => {
+                if (!isLogged) {
+                    isLogged = true;
+                    return this.handleResponse(req, res, originalSend, data, startTimeMs, requestLog, capturedLogs, consoleIntercepted);
+                }
+                return originalSend.call(res, data);
+            };
+            res.json = (data) => {
+                if (!isLogged) {
+                    isLogged = true;
+                    return this.handleResponse(req, res, originalJson, data, startTimeMs, requestLog, capturedLogs, consoleIntercepted);
+                }
+                return originalJson.call(res, data);
+            };
+            req.on("error", errorHandler);
+            res.on("error", errorHandler);
+            res.on("finish", () => {
+                if (!isLogged) {
+                    isLogged = true;
+                    this.handleResponse(req, res, () => res, undefined, startTimeMs, requestLog, capturedLogs, consoleIntercepted);
+                }
+            });
+            next();
+        };
+    }
+    koaMiddleware() {
+        return async (ctx, next) => {
+            const startTimeMs = Date.now();
+            const startTime = new Date(startTimeMs).toISOString();
+            const capturedLogs = [];
+            const traceId = this.getActiveTraceId();
+            const requestLog = {
+                timestamp: startTime,
+                method: ctx.method,
+                path: ctx.path,
+                userAgent: ctx.get("user-agent"),
+                ip: ctx.ip,
+                host: ctx.host,
+                startTime,
+                ...(traceId ? { traceId } : {}),
+            };
+            if (this.config.captureHeaders) {
+                requestLog.headers = this.redactSensitive(ctx.headers);
+            }
+            if (this.config.captureQuery &&
+                ctx.query &&
+                Object.keys(ctx.query).length > 0) {
+                requestLog.query = ctx.query;
+            }
+            let consoleIntercepted = false;
+            if (this.config.captureConsoleLogs) {
+                this.interceptConsole(capturedLogs);
+                consoleIntercepted = true;
+            }
+            let thrown;
+            try {
+                await next();
+            }
+            catch (err) {
+                thrown = err;
+                requestLog.error = {
+                    message: String(err?.message ?? err),
+                    stack: err?.stack,
+                    name: err?.name,
+                };
+            }
+            finally {
+                const endTimeMs = Date.now();
+                requestLog.statusCode = thrown
+                    ? thrown.status || thrown.statusCode || 500
+                    : ctx.status;
+                requestLog.duration = endTimeMs - startTimeMs;
+                requestLog.endTime = new Date(endTimeMs).toISOString();
+                if (this.config.captureBody && ctx.request?.body) {
+                    requestLog.body = this.redactSensitive(ctx.request.body);
+                }
+                if (consoleIntercepted) {
+                    this.restoreConsole();
+                    if (capturedLogs.length > 0) {
+                        requestLog.consoleLogs = capturedLogs;
+                    }
+                }
+                this.logRequest(requestLog);
+            }
+            if (thrown)
+                throw thrown;
+        };
+    }
+    instrumentFastify(app) {
+        if (!app || typeof app.addHook !== "function")
+            return;
+        if (app.__POLARTRACE_MIDDLEWARE_ATTACHED__)
+            return;
+        app.__POLARTRACE_MIDDLEWARE_ATTACHED__ = true;
+        const states = new WeakMap();
+        app.addHook("onRequest", async (request) => {
+            const state = {
+                startTimeMs: Date.now(),
+                traceId: this.getActiveTraceId(),
+                capturedLogs: [],
+                consoleIntercepted: false,
+            };
+            if (this.config.captureConsoleLogs) {
+                this.interceptConsole(state.capturedLogs);
+                state.consoleIntercepted = true;
+            }
+            states.set(request, state);
+            request.__POLARTRACE_FASTIFY_STATE__ = state;
+        });
+        app.addHook("onError", async (request, _reply, error) => {
+            const state = states.get(request);
+            if (state)
+                state.error = error;
+        });
+        app.addHook("onResponse", async (request, reply) => {
+            const state = states.get(request);
+            if (!state)
+                return;
+            states.delete(request);
+            const endTimeMs = Date.now();
+            const startTime = new Date(state.startTimeMs).toISOString();
+            const requestLog = {
+                timestamp: startTime,
+                method: request.method,
+                path: String(request.raw?.url || request.url || "").split("?")[0],
+                statusCode: reply.statusCode,
+                duration: endTimeMs - state.startTimeMs,
+                startTime,
+                endTime: new Date(endTimeMs).toISOString(),
+                userAgent: request.headers?.["user-agent"],
+                ip: request.ip,
+                host: request.headers?.host,
+                ...(state.traceId ? { traceId: state.traceId } : {}),
+            };
+            if (this.config.captureHeaders) {
+                requestLog.headers = this.redactSensitive(request.headers);
+            }
+            if (this.config.captureQuery &&
+                request.query &&
+                Object.keys(request.query).length > 0) {
+                requestLog.query = request.query;
+            }
+            if (this.config.captureBody && request.body) {
+                requestLog.body = this.redactSensitive(request.body);
+            }
+            if (state.consoleIntercepted) {
+                this.restoreConsole();
+                if (state.capturedLogs.length > 0) {
+                    requestLog.consoleLogs = state.capturedLogs;
+                }
+            }
+            if (state.error) {
+                requestLog.error = {
+                    message: String(state.error?.message ?? state.error),
+                    stack: state.error?.stack,
+                    name: state.error?.name,
+                };
+            }
+            this.logRequest(requestLog);
+        });
+    }
+    handleResponse(req, res, originalMethod, data, startTimeMs, requestLog, capturedLogs, consoleIntercepted) {
+        const endTimeMs = Date.now();
+        const duration = endTimeMs - startTimeMs;
+        const endTime = new Date(endTimeMs).toISOString();
+        requestLog.statusCode = res.statusCode;
+        requestLog.duration = duration;
+        requestLog.endTime = endTime;
+        if (this.config.captureBody && req?.body) {
+            requestLog.body = this.redactSensitive(req.body);
+        }
+        if (consoleIntercepted) {
+            this.restoreConsole();
+            if (capturedLogs.length > 0) {
+                requestLog.consoleLogs = capturedLogs;
+            }
+        }
+        this.logRequest(requestLog);
+        return originalMethod.call(res, data);
+    }
+    interceptConsole(capturedLogs) {
+        if (!this.originalConsoleLog) {
+            this.originalConsoleLog = console.log;
+            this.originalConsoleError = console.error;
+            this.originalConsoleWarn = console.warn;
+            this.originalConsoleInfo = console.info;
+        }
+        console.log = (...args) => {
+            capturedLogs.push({
+                timestamp: new Date().toISOString(),
+                level: "log",
+                args: args,
+            });
+            this.originalConsoleLog.apply(console, args);
+        };
+        console.error = (...args) => {
+            capturedLogs.push({
+                timestamp: new Date().toISOString(),
+                level: "error",
+                args: args,
+            });
+            this.originalConsoleError.apply(console, args);
+        };
+        console.warn = (...args) => {
+            capturedLogs.push({
+                timestamp: new Date().toISOString(),
+                level: "warn",
+                args: args,
+            });
+            this.originalConsoleWarn.apply(console, args);
+        };
+        console.info = (...args) => {
+            capturedLogs.push({
+                timestamp: new Date().toISOString(),
+                level: "info",
+                args: args,
+            });
+            this.originalConsoleInfo.apply(console, args);
+        };
+    }
+    restoreConsole() {
+        if (this.originalConsoleLog) {
+            console.log = this.originalConsoleLog;
+            console.error = this.originalConsoleError;
+            console.warn = this.originalConsoleWarn;
+            console.info = this.originalConsoleInfo;
+        }
+    }
+    redactSensitive(body) {
+        if (typeof body !== "object" || body === null) {
+            return body;
+        }
+        const sensitiveFields = SENSITIVE_FIELDS;
+        const sanitized = Array.isArray(body) ? [...body] : { ...body };
+        for (const key in sanitized) {
+            if (sensitiveFields.some((field) => key.toLowerCase().includes(field.toLowerCase()))) {
+                sanitized[key] = "[REDACTED]";
+            }
+            else if (typeof sanitized[key] === "object" &&
+                sanitized[key] !== null) {
+                sanitized[key] = this.redactSensitive(sanitized[key]);
+            }
+        }
+        return sanitized;
+    }
+    getClientIp(req) {
+        return (req.headers["x-forwarded-for"]?.split(",")[0] ||
+            req.headers["x-real-ip"] ||
+            req.socket.remoteAddress ||
+            req.ip ||
+            "unknown");
+    }
+    generateRequestId() {
+        return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+    }
+    logRequest(log) {
+        this.queueLog(log);
+    }
+    queueLog(log) {
+        this.logQueue.push({ log });
+        if (this.logQueue.length > this.LOG_QUEUE_LIMIT) {
+            const overflow = this.logQueue.length - this.LOG_QUEUE_LIMIT;
+            this.logQueue.splice(0, overflow);
+        }
+        diagnostics_1.diagnostics.debug(`Log queued. Queue size: ${this.logQueue.length}`);
+    }
+    async flushLogs() {
+        if (this.isFlushing || this.logQueue.length === 0) {
+            return;
+        }
+        if (Date.now() < this.logBackoffUntil) {
+            diagnostics_1.diagnostics.debug(`Log flush skipped - backing off until ${new Date(this.logBackoffUntil).toISOString()}`);
+            return;
+        }
+        this.isFlushing = true;
+        const batchLength = Math.min(this.logQueue.length, this.MAX_BATCH_SIZE);
+        const logsToSend = this.logQueue
+            .slice(0, batchLength)
+            .map((item) => item.log);
+        diagnostics_1.diagnostics.debug(`Attempting to send ${logsToSend.length} logs...`);
+        try {
+            await this.sendLogsToAPI(logsToSend);
+            this.logQueue.splice(0, batchLength);
+            this.logConsecutiveFailures = 0;
+            this.logBackoffUntil = 0;
+            diagnostics_1.diagnostics.debug(`Successfully sent ${logsToSend.length} logs and removed from queue`);
+        }
+        catch (error) {
+            const status = error?.response?.status;
+            if (this.shouldRetainBatch(status)) {
+                this.logConsecutiveFailures++;
+                this.logBackoffUntil =
+                    Date.now() +
+                        this.nextBackoffMs(this.logConsecutiveFailures, error?.response?.retryAfterSeconds);
+                diagnostics_1.diagnostics.debug(`Failed to send logs to API: ${error?.message}`);
+                diagnostics_1.diagnostics.debug(`Keeping ${batchLength} logs in queue for retry (failure #${this.logConsecutiveFailures})`);
+            }
+            else {
+                this.logQueue.splice(0, batchLength);
+                this.logConsecutiveFailures = 0;
+                this.logBackoffUntil = 0;
+                diagnostics_1.diagnostics.warnOnce(`drop:logs:${status}`, `dropped ${batchLength} logs rejected by collector (status ${status})`);
+            }
+        }
+        finally {
+            this.isFlushing = false;
+        }
+    }
+    async sendLogsToAPI(logs) {
+        if (!this.config.endpoint) {
+            return;
+        }
+        try {
+            const response = await this.postJson(this.config.endpoint, { logs });
+            if (response.status >= 400) {
+                const err = new Error(`API returned status ${response.status}`);
+                err.response = response;
+                throw err;
+            }
+        }
+        catch (error) {
+            if (error?.response) {
+                diagnostics_1.diagnostics.debug(`collector responded with error: ${error.response.status} ${JSON.stringify(error.response.data, null, 2)}`);
+            }
+            else if (error?.name === "AbortError") {
+                diagnostics_1.diagnostics.debug("no response received from collector");
+            }
+            else {
+                diagnostics_1.diagnostics.debug(`failed to send logs: ${error?.message}`);
+            }
+            throw error;
+        }
+    }
+    async flushTraces() {
+        this.cleanupOldTraces();
+        diagnostics_1.diagnostics.debug(`flushTraces called - queue size: ${this.traceQueue.length}, isFlushing: ${this.isTraceFlushing}`);
+        if (this.isTraceFlushing || this.traceQueue.length === 0) {
+            if (this.isTraceFlushing) {
+                diagnostics_1.diagnostics.debug("Trace flush skipped - already flushing");
+            }
+            else {
+                diagnostics_1.diagnostics.debug("Trace flush skipped - queue is empty");
+            }
+            return;
+        }
+        if (Date.now() < this.traceBackoffUntil) {
+            diagnostics_1.diagnostics.debug(`Trace flush skipped - backing off until ${new Date(this.traceBackoffUntil).toISOString()}`);
+            return;
+        }
+        this.isTraceFlushing = true;
+        const batchLength = Math.min(this.traceQueue.length, this.MAX_BATCH_SIZE);
+        const spansToSend = this.traceQueue
+            .slice(0, batchLength)
+            .map((item) => item.span);
+        diagnostics_1.diagnostics.debug(`Attempting to send ${spansToSend.length} trace spans...`);
+        diagnostics_1.diagnostics.debug(`Current queue size before send: ${this.traceQueue.length}`);
+        try {
+            const response = await this.sendTracesToAPI(spansToSend);
+            const status = response?.status;
+            if (response && status >= 200 && status < 300) {
+                const removed = this.traceQueue.splice(0, batchLength);
+                const removedCount = removed.length;
+                this.traceConsecutiveFailures = 0;
+                this.traceBackoffUntil = 0;
+                diagnostics_1.diagnostics.debug(`Successfully sent ${spansToSend.length} trace spans (status: ${status})`);
+                diagnostics_1.diagnostics.debug(`Removed ${removedCount} spans from queue`);
+                diagnostics_1.diagnostics.debug(`Remaining queue size: ${this.traceQueue.length}`);
+                if (removedCount !== batchLength) {
+                    diagnostics_1.diagnostics.debug(`Expected to remove ${batchLength} spans but removed ${removedCount}`);
+                }
+            }
+            else if (this.shouldRetainBatch(status)) {
+                this.traceConsecutiveFailures++;
+                this.traceBackoffUntil =
+                    Date.now() +
+                        this.nextBackoffMs(this.traceConsecutiveFailures, response?.retryAfterSeconds);
+                diagnostics_1.diagnostics.debug(`API returned status ${status}, keeping ${batchLength} spans in queue for retry (failure #${this.traceConsecutiveFailures})`);
+            }
+            else {
+                this.traceQueue.splice(0, batchLength);
+                this.traceConsecutiveFailures = 0;
+                this.traceBackoffUntil = 0;
+                diagnostics_1.diagnostics.warnOnce(`drop:traces:${status}`, `dropped ${batchLength} trace spans rejected by collector (status ${status})`);
+            }
+        }
+        catch (error) {
+            this.traceConsecutiveFailures++;
+            this.traceBackoffUntil =
+                Date.now() + this.nextBackoffMs(this.traceConsecutiveFailures);
+            diagnostics_1.diagnostics.debug(`Failed to send trace spans to API: ${error?.message}`);
+            diagnostics_1.diagnostics.debug(`Keeping ${batchLength} trace spans in queue for retry (failure #${this.traceConsecutiveFailures})`);
+            diagnostics_1.diagnostics.debug(`Current queue size: ${this.traceQueue.length}`);
+        }
+        finally {
+            this.isTraceFlushing = false;
+        }
+    }
+    async sendTracesToAPI(spans) {
+        if (!this.config.endpoint) {
+            throw new Error("Endpoint not configured");
+        }
+        let tracesEndpoint;
+        const endpoint = this.config.endpoint.trim();
+        if (endpoint.endsWith("/log")) {
+            tracesEndpoint = endpoint.replace("/log", "/traces");
+        }
+        else if (endpoint.includes("/api/log")) {
+            tracesEndpoint = endpoint.replace("/api/log", "/api/traces");
+        }
+        else {
+            const baseUrl = this.getBaseUrl();
+            tracesEndpoint = `${baseUrl}/traces`;
+        }
+        tracesEndpoint = tracesEndpoint.replace(/([^:]\/)\/+/g, "$1");
+        diagnostics_1.diagnostics.debug(`Sending traces to endpoint: ${tracesEndpoint}`);
+        try {
+            const response = await this.postJson(tracesEndpoint, { spans });
+            diagnostics_1.diagnostics.debug(`API response received - status: ${response.status}`);
+            return response;
+        }
+        catch (error) {
+            diagnostics_1.diagnostics.debug(`Failed to send trace spans: ${error?.message}`);
+            if (error?.response) {
+                diagnostics_1.diagnostics.debug(`Response status: ${error.response.status}`);
+                diagnostics_1.diagnostics.debug(`Response data: ${JSON.stringify(error.response.data)}`);
+            }
+            throw error;
+        }
+    }
+    async flushHostMetrics() {
+        if (this.isHostMetricsFlushing || this.hostMetricsQueue.length === 0) {
+            return;
+        }
+        if (Date.now() < this.hostMetricsBackoffUntil) {
+            diagnostics_1.diagnostics.debug(`Host metrics flush skipped - backing off until ${new Date(this.hostMetricsBackoffUntil).toISOString()}`);
+            return;
+        }
+        this.isHostMetricsFlushing = true;
+        const batchLength = Math.min(this.hostMetricsQueue.length, this.MAX_BATCH_SIZE);
+        const samplesToSend = this.hostMetricsQueue
+            .slice(0, batchLength)
+            .map((item) => item.sample);
+        try {
+            const response = await this.sendHostMetricsToAPI(samplesToSend);
+            const status = response?.status;
+            if (response && status >= 200 && status < 300) {
+                this.hostMetricsQueue.splice(0, batchLength);
+                this.hostMetricsConsecutiveFailures = 0;
+                this.hostMetricsBackoffUntil = 0;
+                diagnostics_1.diagnostics.debug(`Successfully sent ${samplesToSend.length} host metric samples`);
+            }
+            else if (this.shouldRetainBatch(status)) {
+                this.hostMetricsConsecutiveFailures++;
+                this.hostMetricsBackoffUntil =
+                    Date.now() +
+                        this.nextBackoffMs(this.hostMetricsConsecutiveFailures, response?.retryAfterSeconds);
+                diagnostics_1.diagnostics.debug(`API returned status ${status}, keeping ${batchLength} host metric samples in queue for retry (failure #${this.hostMetricsConsecutiveFailures})`);
+            }
+            else {
+                this.hostMetricsQueue.splice(0, batchLength);
+                this.hostMetricsConsecutiveFailures = 0;
+                this.hostMetricsBackoffUntil = 0;
+                diagnostics_1.diagnostics.warnOnce(`drop:host-metrics:${status}`, `dropped ${batchLength} host metric samples rejected by collector (status ${status})`);
+            }
+        }
+        catch (error) {
+            this.hostMetricsConsecutiveFailures++;
+            this.hostMetricsBackoffUntil =
+                Date.now() + this.nextBackoffMs(this.hostMetricsConsecutiveFailures);
+            diagnostics_1.diagnostics.debug(`Failed to send host metrics: ${error?.message}`);
+            diagnostics_1.diagnostics.debug(`Keeping ${batchLength} host metric samples in queue for retry (failure #${this.hostMetricsConsecutiveFailures})`);
+        }
+        finally {
+            this.isHostMetricsFlushing = false;
+        }
+    }
+    async sendHostMetricsToAPI(samples) {
+        if (!this.config.endpoint) {
+            throw new Error("Endpoint not configured");
+        }
+        const baseUrl = this.getBaseUrl();
+        const hostMetricsEndpoint = `${baseUrl}/api/host-metrics`.replace(/([^:]\/)\/+/g, "$1");
+        return this.postJson(hostMetricsEndpoint, { samples });
+    }
+    async shutdown(timeoutMs = 3000) {
+        if (this.flushTimer)
+            clearInterval(this.flushTimer);
+        if (this.traceFlushTimer)
+            clearInterval(this.traceFlushTimer);
+        if (this.hostMetricsFlushTimer)
+            clearInterval(this.hostMetricsFlushTimer);
+        for (const traceId of this.traceCache.keys()) {
+            this.flushTrace(traceId);
+        }
+        const pending = [];
+        if (this.logQueue.length > 0)
+            pending.push(this.flushLogs());
+        if (this.traceQueue.length > 0)
+            pending.push(this.flushTraces());
+        if (this.hostMetricsQueue.length > 0)
+            pending.push(this.flushHostMetrics());
+        if (pending.length > 0) {
+            const settled = Promise.allSettled(pending);
+            const deadline = new Promise((resolve) => {
+                const timer = setTimeout(resolve, timeoutMs);
+                if (typeof timer.unref === "function")
+                    timer.unref();
+            });
+            await Promise.race([settled, deadline]);
+        }
+        if (this.traceMonitor)
+            this.traceMonitor.destroy();
+        if (this.hostMetricsMonitor)
+            this.hostMetricsMonitor.destroy();
+        diagnostics_1.diagnostics.close();
+    }
+    destroy() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        if (this.traceFlushTimer) {
+            clearInterval(this.traceFlushTimer);
+        }
+        if (this.hostMetricsFlushTimer) {
+            clearInterval(this.hostMetricsFlushTimer);
+        }
+        for (const traceId of this.traceCache.keys()) {
+            this.flushTrace(traceId);
+        }
+        if (this.logQueue.length > 0) {
+            this.flushLogs().catch((err) => {
+                const errorMsg = `Error flushing logs on destroy: ${err}`;
+                diagnostics_1.diagnostics.debug(errorMsg);
+            });
+        }
+        if (this.traceQueue.length > 0) {
+            this.flushTraces().catch((err) => {
+                const errorMsg = `Error flushing traces on destroy: ${err}`;
+                diagnostics_1.diagnostics.debug(errorMsg);
+            });
+        }
+        if (this.hostMetricsQueue.length > 0) {
+            this.flushHostMetrics().catch((err) => {
+                const errorMsg = `Error flushing host metrics on destroy: ${err}`;
+                diagnostics_1.diagnostics.debug(errorMsg);
+            });
+        }
+        if (this.traceMonitor) {
+            this.traceMonitor.destroy();
+        }
+        if (this.hostMetricsMonitor) {
+            this.hostMetricsMonitor.destroy();
+        }
+        diagnostics_1.diagnostics.close();
+    }
+}
+exports.PolarTrace = PolarTrace;
+function envFlag(name, fallback) {
+    const raw = process.env[name]?.trim().toLowerCase();
+    if (raw === undefined || raw === "") {
+        return fallback;
+    }
+    return raw === "1" || raw === "true";
+}
+function autoInitFromEnv() {
+    const serviceName = process.env.POLARTRACE_APP_NAME;
+    const apiKey = process.env.POLARTRACE_LICENSE_KEY;
+    if (!serviceName || !apiKey) {
+        return;
+    }
+    const globalObj = globalThis;
+    if (globalObj.__POLARTRACE_AGENT__) {
+        return;
+    }
+    const endpoint = process.env.POLARTRACE_ENDPOINT?.trim() || undefined;
+    const logFile = process.env.POLARTRACE_LOG_FILE?.trim() || undefined;
+    let agent;
+    try {
+        agent = new PolarTrace({
+            apiKey,
+            serviceName,
+            enableConsoleLog: envFlag("POLARTRACE_ENABLE_CONSOLE_LOG", false),
+            enableHostMetrics: !envFlag("POLARTRACE_DISABLE_HOST_METRICS", false),
+            enableMongoSpanCollection: !envFlag("POLARTRACE_DISABLE_MONGO_SPANS", false),
+            enableRedisSpanCollection: !envFlag("POLARTRACE_DISABLE_REDIS_SPANS", false),
+            enablePostgresSpanCollection: !envFlag("POLARTRACE_DISABLE_POSTGRES_SPANS", false),
+            ...(endpoint ? { endpoint } : {}),
+            ...(logFile ? { logFile } : {}),
+        });
+    }
+    catch (error) {
+        diagnostics_1.diagnostics.configure({
+            verbose: envFlag("POLARTRACE_ENABLE_CONSOLE_LOG", false),
+            filePath: logFile,
+        });
+        diagnostics_1.diagnostics.error(`agent disabled: ${error?.message ?? error}`);
+        return;
+    }
+    globalObj.__POLARTRACE_AGENT__ = agent;
+    installShutdownHooks(agent);
+    autoAttachExpressMiddleware(agent);
+    autoAttachFastifyHook(agent);
+    autoAttachKoaHook(agent);
+    autoAttachNestErrorHook();
+}
+function installShutdownHooks(agent) {
+    const globalObj = globalThis;
+    if (globalObj.__POLARTRACE_SHUTDOWN_HOOKS__)
+        return;
+    globalObj.__POLARTRACE_SHUTDOWN_HOOKS__ = true;
+    let finished = null;
+    const flushOnce = () => {
+        if (!finished)
+            finished = agent.shutdown().catch(() => undefined);
+        return finished;
+    };
+    process.on("beforeExit", () => {
+        void flushOnce();
+    });
+    for (const signal of ["SIGTERM", "SIGINT"]) {
+        process.on(signal, () => {
+            const otherListeners = process.listenerCount(signal) - 1;
+            void flushOnce().then(() => {
+                if (otherListeners <= 0) {
+                    process.exit(signal === "SIGINT" ? 130 : 143);
+                }
+            });
+        });
+    }
+}
+function autoAttachExpressMiddleware(agent) {
+    (0, module_hook_1.onModuleLoad)("express", (module) => {
+        if (typeof module !== "function")
+            return;
+        const originalExpress = module;
+        const patchedExpress = function () {
+            const app = originalExpress.apply(this, arguments);
+            if (!app.__POLARTRACE_MIDDLEWARE_ATTACHED__) {
+                app.__POLARTRACE_MIDDLEWARE_ATTACHED__ = true;
+                try {
+                    app.use(agent.middleware());
+                }
+                catch {
+                }
+                try {
+                    const originalListen = app.listen;
+                    app.listen = function (...args) {
+                        if (!app.__POLARTRACE_ERROR_MW_ATTACHED__) {
+                            app.__POLARTRACE_ERROR_MW_ATTACHED__ = true;
+                            app.use((err, req, _res, next) => {
+                                const log = req?.__POLARTRACE_REQUEST_LOG__;
+                                if (err && log && !log.error) {
+                                    log.error = {
+                                        message: String(err?.message ?? err),
+                                        stack: err?.stack,
+                                        name: err?.name,
+                                    };
+                                }
+                                next(err);
+                            });
+                        }
+                        return originalListen.apply(this, args);
+                    };
+                }
+                catch {
+                }
+            }
+            return app;
+        };
+        Object.setPrototypeOf(patchedExpress, originalExpress);
+        Object.keys(originalExpress).forEach((key) => {
+            patchedExpress[key] = originalExpress[key];
+        });
+        return patchedExpress;
+    });
+}
+function autoAttachFastifyHook(agent) {
+    (0, module_hook_1.onModuleLoad)("fastify", (module) => {
+        if (typeof module !== "function")
+            return;
+        const originalFactory = module;
+        if (!originalFactory.__POLARTRACE_PATCHED_FACTORY__) {
+            const patchedFactory = function (...args) {
+                const app = originalFactory.apply(this, args);
+                try {
+                    agent.instrumentFastify(app);
+                }
+                catch {
+                }
+                return app;
+            };
+            Object.setPrototypeOf(patchedFactory, originalFactory);
+            Object.keys(originalFactory).forEach((key) => {
+                patchedFactory[key] = originalFactory[key];
+            });
+            patchedFactory.fastify = patchedFactory;
+            patchedFactory.default = patchedFactory;
+            originalFactory.__POLARTRACE_PATCHED_FACTORY__ = patchedFactory;
+        }
+        return originalFactory.__POLARTRACE_PATCHED_FACTORY__;
+    });
+}
+function autoAttachKoaHook(agent) {
+    (0, module_hook_1.onModuleLoad)("koa", (module) => {
+        if (typeof module !== "function" ||
+            !module.prototype ||
+            typeof module.prototype.callback !== "function" ||
+            module.__POLARTRACE_PATCHED__) {
+            return;
+        }
+        module.__POLARTRACE_PATCHED__ = true;
+        const originalCallback = module.prototype.callback;
+        module.prototype.callback = function (...args) {
+            if (!this.__POLARTRACE_MIDDLEWARE_ATTACHED__) {
+                this.__POLARTRACE_MIDDLEWARE_ATTACHED__ = true;
+                try {
+                    this.middleware.unshift(agent.koaMiddleware());
+                }
+                catch {
+                }
+            }
+            return originalCallback.apply(this, args);
+        };
+    });
+}
+function recordNestException(exception, host) {
+    if (!exception || !host || typeof host.switchToHttp !== "function")
+        return;
+    const req = host.switchToHttp()?.getRequest?.();
+    if (!req)
+        return;
+    const status = typeof exception.getStatus === "function" ? exception.getStatus() : undefined;
+    if (typeof status === "number" && status < 500)
+        return;
+    const error = {
+        message: String(exception?.message ?? exception),
+        stack: exception?.stack,
+        name: exception?.name,
+    };
+    const log = req.__POLARTRACE_REQUEST_LOG__ ??
+        req.raw?.__POLARTRACE_REQUEST_LOG__;
+    if (log) {
+        if (!log.error)
+            log.error = error;
+        return;
+    }
+    const state = req.__POLARTRACE_FASTIFY_STATE__ ??
+        req.raw?.__POLARTRACE_FASTIFY_STATE__;
+    if (state && !state.error)
+        state.error = error;
+}
+function autoAttachNestErrorHook() {
+    (0, module_hook_1.onModuleLoad)("@nestjs/core", (module) => {
+        const FilterClass = module?.BaseExceptionFilter;
+        if (!FilterClass?.prototype ||
+            typeof FilterClass.prototype.catch !== "function" ||
+            FilterClass.__POLARTRACE_PATCHED__) {
+            return;
+        }
+        FilterClass.__POLARTRACE_PATCHED__ = true;
+        const originalCatch = FilterClass.prototype.catch;
+        FilterClass.prototype.catch = function (exception, host) {
+            try {
+                recordNestException(exception, host);
+            }
+            catch {
+            }
+            return originalCatch.call(this, exception, host);
+        };
+    });
+}
+require("./register");
+autoInitFromEnv();