@telora/daemon 0.12.33

package/dist/otlp-receiver.js

@@ -0,0 +1,663 @@
+/**
+ * OTLP HTTP Receiver for agent telemetry.
+ *
+ * Lightweight HTTP server accepting OpenTelemetry JSON payloads:
+ * - POST /v1/metrics  -- OTLP metrics (token counts, cost, tool calls)
+ * - POST /v1/logs     -- OTLP logs (tool call events, errors)
+ *
+ * Extracts Telora resource attributes (telora.org_id, telora.strategy_id,
+ * telora.delivery_id) for entity correlation and forwards parsed data
+ * to the telemetry writer for batched Postgres inserts.
+ *
+ * Runs on a configurable port (default 4318) alongside the daemon process.
+ */
+import { createServer } from 'node:http';
+import { connect as netConnect } from 'node:net';
+import { execFileSync } from 'node:child_process';
+import { readFileSync, existsSync } from 'node:fs';
+import { bufferMetric, bufferEvent, } from './telemetry-writer.js';
+function extractResourceAttributes(resource) {
+    const attrs = {
+        orgId: null,
+        strategyId: null,
+        deliveryId: null,
+        sessionId: null,
+        instanceId: null,
+        workUnitId: null,
+        specId: null,
+    };
+    if (!resource?.attributes)
+        return attrs;
+    for (const kv of resource.attributes) {
+        const val = kv.value.stringValue;
+        if (!val)
+            continue;
+        switch (kv.key) {
+            case 'telora.org_id':
+                attrs.orgId = val;
+                break;
+            case 'telora.strategy_id':
+                attrs.strategyId = val;
+                break;
+            case 'telora.delivery_id':
+                attrs.deliveryId = val;
+                break;
+            case 'telora.session_id':
+                attrs.sessionId = val;
+                break;
+            case 'telora.instance_id':
+                attrs.instanceId = val;
+                break;
+            case 'telora.work_unit_id':
+                attrs.workUnitId = val;
+                break;
+            case 'telora.spec_id':
+                attrs.specId = val;
+                break;
+        }
+    }
+    return attrs;
+}
+/**
+ * Build factory-specific metadata from resource attributes.
+ * Returns null when no factory attributes are present.
+ */
+function buildFactoryMetadata(attrs) {
+    const meta = {};
+    if (attrs.instanceId)
+        meta.factory_instance_id = attrs.instanceId;
+    if (attrs.workUnitId)
+        meta.factory_work_unit_id = attrs.workUnitId;
+    if (attrs.specId)
+        meta.factory_spec_id = attrs.specId;
+    return Object.keys(meta).length > 0 ? meta : null;
+}
+// ── Metric parsing ───────────────────────────────────────────────────
+function getDataPointValue(dp) {
+    if (dp.asDouble !== undefined)
+        return dp.asDouble;
+    if (dp.asInt !== undefined)
+        return typeof dp.asInt === 'string' ? parseInt(dp.asInt, 10) : dp.asInt;
+    return 0;
+}
+function nanoToIso(nanos) {
+    if (!nanos)
+        return new Date().toISOString();
+    const ms = Math.floor(parseInt(nanos, 10) / 1_000_000);
+    return new Date(ms).toISOString();
+}
+/**
+ * Get a string attribute from an OTLP data point's attributes array.
+ */
+function getDataPointAttribute(dp, key) {
+    if (!dp.attributes)
+        return null;
+    const kv = dp.attributes.find(a => a.key === key);
+    if (!kv)
+        return null;
+    return kv.value.stringValue ?? null;
+}
+/**
+ * Parse OTLP metrics payload and buffer metric rows.
+ *
+ * Claude Code emits these metrics (per official OTel schema):
+ * - claude_code.token.usage (Counter, attrs: type=input|output|cacheRead|cacheCreation, model)
+ * - claude_code.cost.usage (Counter, attr: model, unit: USD)
+ * - claude_code.active_time.total (Counter, unit: seconds)
+ * - claude_code.session.count, claude_code.lines_of_code.count, etc.
+ *
+ * We aggregate per-resource into a single TelemetryMetricRow.
+ */
+function processMetrics(payload, fallbackOrgId) {
+    if (!payload.resourceMetrics)
+        return;
+    for (const rm of payload.resourceMetrics) {
+        const attrs = extractResourceAttributes(rm.resource);
+        const orgId = attrs.orgId ?? fallbackOrgId;
+        // Collect all metric values into a single row per resource
+        const factoryMeta = buildFactoryMetadata(attrs);
+        const row = {
+            organization_id: orgId,
+            strategy_id: attrs.strategyId,
+            delivery_id: attrs.deliveryId,
+            session_id: attrs.sessionId,
+            input_tokens: 0,
+            output_tokens: 0,
+            cache_read_tokens: 0,
+            cache_creation_tokens: 0,
+            cost_usd: 0,
+            active_time_ms: 0,
+            tool_call_count: 0,
+            tool_error_count: 0,
+            model: null,
+            metadata: factoryMeta,
+            period_start: new Date().toISOString(),
+            period_end: new Date().toISOString(),
+        };
+        let hasData = false;
+        let earliestNano;
+        let latestNano;
+        for (const sm of rm.scopeMetrics ?? []) {
+            for (const metric of sm.metrics ?? []) {
+                const dataPoints = metric.sum?.dataPoints ?? metric.gauge?.dataPoints ?? [];
+                for (const dp of dataPoints) {
+                    const value = getDataPointValue(dp);
+                    // Track time range
+                    if (dp.startTimeUnixNano && (!earliestNano || dp.startTimeUnixNano < earliestNano)) {
+                        earliestNano = dp.startTimeUnixNano;
+                    }
+                    if (dp.timeUnixNano && (!latestNano || dp.timeUnixNano > latestNano)) {
+                        latestNano = dp.timeUnixNano;
+                    }
+                    switch (metric.name) {
+                        case 'claude_code.token.usage': {
+                            // Token usage has a `type` attribute: input, output, cacheRead, cacheCreation
+                            const tokenType = getDataPointAttribute(dp, 'type');
+                            // Extract model from first data point that has it
+                            if (!row.model) {
+                                row.model = getDataPointAttribute(dp, 'model');
+                            }
+                            switch (tokenType) {
+                                case 'input':
+                                    row.input_tokens = value;
+                                    hasData = true;
+                                    break;
+                                case 'output':
+                                    row.output_tokens = value;
+                                    hasData = true;
+                                    break;
+                                case 'cacheRead':
+                                    row.cache_read_tokens = value;
+                                    hasData = true;
+                                    break;
+                                case 'cacheCreation':
+                                    row.cache_creation_tokens = value;
+                                    hasData = true;
+                                    break;
+                            }
+                            break;
+                        }
+                        case 'claude_code.cost.usage':
+                            row.cost_usd = value;
+                            hasData = true;
+                            break;
+                        case 'claude_code.active_time.total':
+                            // Claude emits seconds, DB stores milliseconds
+                            row.active_time_ms = Math.round(value * 1000);
+                            hasData = true;
+                            break;
+                        // code_edit_tool.decision tracks Edit/Write/NotebookEdit permission
+                        // decisions (accept/reject), not general tool calls. Tool call counts
+                        // are derived from tool_result log events in processLogs() instead.
+                        // Unknown metrics (session.count, lines_of_code.count, etc.) are silently ignored
+                    }
+                }
+            }
+        }
+        if (hasData) {
+            row.period_start = nanoToIso(earliestNano);
+            row.period_end = nanoToIso(latestNano);
+            bufferMetric(row);
+        }
+    }
+}
+// ── Log/event parsing ────────────────────────────────────────────────
+function getLogAttribute(attrs, key) {
+    if (!attrs)
+        return null;
+    const kv = attrs.find(a => a.key === key);
+    if (!kv)
+        return null;
+    return kv.value.stringValue ?? (kv.value.intValue !== undefined ? String(kv.value.intValue) : null);
+}
+function getLogAttributeBool(attrs, key) {
+    if (!attrs)
+        return null;
+    const kv = attrs.find(a => a.key === key);
+    if (!kv)
+        return null;
+    if (kv.value.boolValue !== undefined)
+        return kv.value.boolValue;
+    if (kv.value.stringValue !== undefined)
+        return kv.value.stringValue === 'true';
+    return null;
+}
+function getLogAttributeInt(attrs, key) {
+    if (!attrs)
+        return null;
+    const kv = attrs.find(a => a.key === key);
+    if (!kv)
+        return null;
+    if (kv.value.intValue !== undefined)
+        return typeof kv.value.intValue === 'string' ? parseInt(kv.value.intValue, 10) : kv.value.intValue;
+    if (kv.value.doubleValue !== undefined)
+        return Math.round(kv.value.doubleValue);
+    return null;
+}
+function getLogAttributeDouble(attrs, key) {
+    if (!attrs)
+        return null;
+    const kv = attrs.find(a => a.key === key);
+    if (!kv)
+        return null;
+    if (kv.value.doubleValue !== undefined)
+        return kv.value.doubleValue;
+    if (kv.value.intValue !== undefined)
+        return typeof kv.value.intValue === 'string' ? parseFloat(kv.value.intValue) : kv.value.intValue;
+    return null;
+}
+/**
+ * Parse OTLP logs payload and buffer event rows.
+ *
+ * Claude Code emits events via the OTLP logs protocol with an `event.name`
+ * attribute identifying the event type. Names may be prefixed with `claude_code.`
+ * or bare -- we normalize to bare names before matching:
+ * - tool_result: tool_name, success, duration_ms, error
+ * - api_request: model, cost_usd, duration_ms, token counts
+ * - api_error: model, error, status_code, duration_ms
+ * - user_prompt: prompt_length
+ * - tool_decision: tool_name, decision, source
+ */
+function processLogs(payload, fallbackOrgId) {
+    if (!payload.resourceLogs)
+        return;
+    for (const rl of payload.resourceLogs) {
+        const attrs = extractResourceAttributes(rl.resource);
+        const orgId = attrs.orgId ?? fallbackOrgId;
+        const factoryMeta = buildFactoryMetadata(attrs);
+        // Track tool call/error counts per resource for metric aggregation
+        let toolCallCount = 0;
+        let toolErrorCount = 0;
+        let earliestNano;
+        let latestNano;
+        for (const sl of rl.scopeLogs ?? []) {
+            for (const lr of sl.logRecords ?? []) {
+                // Claude Code uses `event.name` attribute for event identification.
+                // Fall back to body.stringValue (some OTel exporters put event name there).
+                const rawEventName = getLogAttribute(lr.attributes, 'event.name')
+                    ?? lr.body?.stringValue
+                    ?? lr.severityText
+                    ?? 'unknown';
+                // Normalize: strip `claude_code.` prefix if present so the switch
+                // matches regardless of whether Claude Code emits prefixed or bare names.
+                const eventName = rawEventName.startsWith('claude_code.')
+                    ? rawEventName.slice('claude_code.'.length)
+                    : rawEventName;
+                // Track time range across all events
+                if (lr.timeUnixNano) {
+                    if (!earliestNano || lr.timeUnixNano < earliestNano)
+                        earliestNano = lr.timeUnixNano;
+                    if (!latestNano || lr.timeUnixNano > latestNano)
+                        latestNano = lr.timeUnixNano;
+                }
+                const row = {
+                    organization_id: orgId,
+                    strategy_id: attrs.strategyId,
+                    delivery_id: attrs.deliveryId,
+                    session_id: attrs.sessionId,
+                    event_type: eventName,
+                    tool_name: null,
+                    success: null,
+                    duration_ms: null,
+                    error_message: null,
+                    metadata: factoryMeta ? { ...factoryMeta } : null,
+                    event_timestamp: nanoToIso(lr.timeUnixNano),
+                };
+                // Extract event-specific fields based on normalized event name
+                switch (eventName) {
+                    case 'tool_result': {
+                        row.tool_name = getLogAttribute(lr.attributes, 'tool_name');
+                        row.success = getLogAttributeBool(lr.attributes, 'success');
+                        row.duration_ms = getLogAttributeInt(lr.attributes, 'duration_ms');
+                        row.error_message = getLogAttribute(lr.attributes, 'error');
+                        // Aggregate tool counts for metric row
+                        toolCallCount++;
+                        if (row.success === false)
+                            toolErrorCount++;
+                        break;
+                    }
+                    case 'api_request':
+                        row.duration_ms = getLogAttributeInt(lr.attributes, 'duration_ms');
+                        row.metadata = {
+                            ...row.metadata,
+                            model: getLogAttribute(lr.attributes, 'model'),
+                            cost_usd: getLogAttributeDouble(lr.attributes, 'cost_usd'),
+                            input_tokens: getLogAttributeInt(lr.attributes, 'input_tokens'),
+                            output_tokens: getLogAttributeInt(lr.attributes, 'output_tokens'),
+                            cache_read_tokens: getLogAttributeInt(lr.attributes, 'cache_read_tokens'),
+                            cache_creation_tokens: getLogAttributeInt(lr.attributes, 'cache_creation_tokens'),
+                        };
+                        break;
+                    case 'api_error':
+                        row.error_message = getLogAttribute(lr.attributes, 'error');
+                        row.duration_ms = getLogAttributeInt(lr.attributes, 'duration_ms');
+                        row.metadata = {
+                            ...row.metadata,
+                            model: getLogAttribute(lr.attributes, 'model'),
+                            status_code: getLogAttributeInt(lr.attributes, 'status_code'),
+                            attempt: getLogAttributeInt(lr.attributes, 'attempt'),
+                        };
+                        break;
+                    case 'user_prompt':
+                        row.metadata = {
+                            ...row.metadata,
+                            prompt_length: getLogAttributeInt(lr.attributes, 'prompt_length'),
+                        };
+                        break;
+                    case 'tool_decision':
+                        row.tool_name = getLogAttribute(lr.attributes, 'tool_name');
+                        row.metadata = {
+                            ...row.metadata,
+                            decision: getLogAttribute(lr.attributes, 'decision'),
+                            source: getLogAttribute(lr.attributes, 'source'),
+                        };
+                        break;
+                }
+                bufferEvent(row);
+            }
+        }
+        // Emit a metric row with aggregated tool counts from tool_result events
+        if (toolCallCount > 0) {
+            const now = new Date().toISOString();
+            bufferMetric({
+                organization_id: orgId,
+                strategy_id: attrs.strategyId,
+                delivery_id: attrs.deliveryId,
+                session_id: attrs.sessionId,
+                input_tokens: 0,
+                output_tokens: 0,
+                cache_read_tokens: 0,
+                cache_creation_tokens: 0,
+                cost_usd: 0,
+                active_time_ms: 0,
+                tool_call_count: toolCallCount,
+                tool_error_count: toolErrorCount,
+                model: null,
+                metadata: factoryMeta,
+                period_start: earliestNano ? nanoToIso(earliestNano) : now,
+                period_end: latestNano ? nanoToIso(latestNano) : now,
+            });
+        }
+    }
+}
+// ── HTTP server ──────────────────────────────────────────────────────
+let server = null;
+/**
+ * Read the full request body as a string.
+ */
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let totalBytes = 0;
+        const MAX_BODY_BYTES = 10 * 1024 * 1024; // 10 MB
+        req.on('data', (chunk) => {
+            totalBytes += chunk.length;
+            if (totalBytes > MAX_BODY_BYTES) {
+                req.destroy();
+                reject(new Error('Request body too large'));
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+        req.on('error', reject);
+    });
+}
+function sendJson(res, status, body) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(body));
+}
+// ── Stale port detection and reclaim ─────────────────────────────────
+/**
+ * Check if a port is currently in use by attempting a TCP connection.
+ * Returns true if something is listening on the port.
+ */
+export function isPortInUse(port, host = '127.0.0.1') {
+    return new Promise((resolve) => {
+        const socket = netConnect({ port, host });
+        socket.once('connect', () => {
+            socket.destroy();
+            resolve(true);
+        });
+        socket.once('error', () => {
+            socket.destroy();
+            resolve(false);
+        });
+        // Short timeout -- we only need to know if something answers
+        socket.setTimeout(1000, () => {
+            socket.destroy();
+            resolve(false);
+        });
+    });
+}
+/**
+ * Find the PID(s) holding a given TCP port using `lsof`.
+ * Returns an array of PIDs (may be empty if lsof is unavailable or no match).
+ */
+export function findPidsOnPort(port) {
+    try {
+        // -i :port -t returns just PIDs, one per line
+        const output = execFileSync('lsof', ['-i', `:${port}`, '-t', '-sTCP:LISTEN'], {
+            encoding: 'utf-8',
+            timeout: 5000,
+        });
+        return output
+            .trim()
+            .split('\n')
+            .map(line => parseInt(line.trim(), 10))
+            .filter(pid => !isNaN(pid) && pid > 0);
+    }
+    catch {
+        // lsof not available or no matches -- not fatal
+        return [];
+    }
+}
+/**
+ * Check if a process with the given PID is alive.
+ */
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Read the daemon PID file and return the PID, or null if unreadable/missing.
+ */
+function readDaemonPid(pidFilePath) {
+    if (!pidFilePath || !existsSync(pidFilePath))
+        return null;
+    try {
+        const contents = readFileSync(pidFilePath, 'utf-8').trim();
+        const pid = parseInt(contents, 10);
+        return isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Attempt to reclaim a stale OTLP port.
+ *
+ * Checks if the port is in use, cross-references with the PID file,
+ * and kills orphaned processes if the recorded daemon PID is stale.
+ *
+ * @returns true if reclaim was attempted (port was in use), false if port was free
+ */
+export async function reclaimStalePort(port, pidFilePath) {
+    const inUse = await isPortInUse(port);
+    if (!inUse)
+        return false;
+    console.warn(`[otlp-receiver] Port ${port} is already in use, attempting reclaim`);
+    // Read the daemon PID file to check if the previous daemon is still alive
+    const daemonPid = readDaemonPid(pidFilePath);
+    if (daemonPid !== null && isProcessAlive(daemonPid)) {
+        // The previous daemon is still running -- do not kill it.
+        // The caller (acquirePidFile in index.ts) should have caught this.
+        console.warn(`[otlp-receiver] Previous daemon (PID ${daemonPid}) is still alive -- cannot reclaim`);
+        return true;
+    }
+    // Previous daemon is dead (or no PID file). Find what holds the port.
+    const pids = findPidsOnPort(port);
+    if (pids.length === 0) {
+        // Port appears in use but lsof found nothing -- possibly TIME_WAIT.
+        // SO_REUSEADDR + retry should handle this.
+        console.log('[otlp-receiver] No process found holding port (likely TIME_WAIT)');
+        return true;
+    }
+    // Kill orphaned processes that are holding the port.
+    // Only kill processes that are NOT the current daemon.
+    for (const pid of pids) {
+        if (pid === process.pid)
+            continue;
+        // If we have a PID file, only kill processes that match the stale daemon PID
+        // or are children of it. Without ppid checks, be conservative: kill if
+        // the daemon PID is stale (already verified above).
+        console.log(`[otlp-receiver] Killing orphaned process ${pid} holding port ${port}`);
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch (err) {
+            console.warn(`[otlp-receiver] Failed to kill PID ${pid}: ${err.message}`);
+        }
+    }
+    // Give killed processes a moment to release the port
+    await new Promise(resolve => setTimeout(resolve, 500));
+    return true;
+}
+// ── Retry configuration ──────────────────────────────────────────────
+/** Maximum number of listen attempts before failing fatally. */
+const MAX_LISTEN_ATTEMPTS = 5;
+/** Base delay between retries in ms (exponential backoff: 500, 1000, 2000, 4000). */
+const BASE_RETRY_DELAY_MS = 500;
+/**
+ * Attempt to bind the HTTP server to the configured port.
+ * Returns a promise that resolves when listening or rejects on error.
+ */
+function attemptListen(srv, port, host) {
+    return new Promise((resolve, reject) => {
+        const onError = (err) => {
+            srv.removeListener('listening', onListening);
+            reject(err);
+        };
+        const onListening = () => {
+            srv.removeListener('error', onError);
+            resolve();
+        };
+        srv.once('error', onError);
+        srv.once('listening', onListening);
+        // exclusive: false allows SO_REUSEADDR, preventing TIME_WAIT sockets
+        // from a previous daemon instance from blocking rebind.
+        srv.listen({ port, host, exclusive: false });
+    });
+}
+/**
+ * Start the OTLP HTTP receiver server.
+ *
+ * Performs stale port detection and reclaim before binding, then retries
+ * with exponential backoff if EADDRINUSE persists (e.g. TIME_WAIT).
+ *
+ * @param pidFilePath - Path to the daemon PID file for stale process detection
+ */
+export async function startOtlpReceiver(config, organizationId, pidFilePath) {
+    // Pre-bind: attempt to reclaim stale port from a previous daemon
+    await reclaimStalePort(config.port, pidFilePath);
+    const srv = createServer(async (req, res) => {
+        // CORS preflight
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204, {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type',
+            });
+            res.end();
+            return;
+        }
+        if (req.method !== 'POST') {
+            sendJson(res, 405, { error: 'Method not allowed' });
+            return;
+        }
+        try {
+            const body = await readBody(req);
+            const parsed = JSON.parse(body);
+            if (req.url === '/v1/metrics') {
+                processMetrics(parsed, organizationId);
+                sendJson(res, 200, { partialSuccess: {} });
+            }
+            else if (req.url === '/v1/logs') {
+                processLogs(parsed, organizationId);
+                sendJson(res, 200, { partialSuccess: {} });
+            }
+            else {
+                sendJson(res, 404, { error: `Unknown endpoint: ${req.url}` });
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.warn(`[otlp-receiver] Parse error on ${req.url}:`, message);
+            sendJson(res, 400, { error: `Parse error: ${message}` });
+        }
+    });
+    // Retry listen with exponential backoff on EADDRINUSE
+    for (let attempt = 1; attempt <= MAX_LISTEN_ATTEMPTS; attempt++) {
+        try {
+            await attemptListen(srv, config.port, '127.0.0.1');
+            server = srv;
+            // Attach a persistent error handler for post-startup errors
+            srv.on('error', (err) => {
+                console.error('[otlp-receiver] Server error:', err.message);
+            });
+            console.log(`[otlp-receiver] Listening on http://127.0.0.1:${config.port}`);
+            return;
+        }
+        catch (err) {
+            const isAddrInUse = err.code === 'EADDRINUSE';
+            if (!isAddrInUse || attempt === MAX_LISTEN_ATTEMPTS) {
+                // Non-retryable error or exhausted retries -- fail fatally
+                srv.close();
+                const suffix = isAddrInUse
+                    ? ` (EADDRINUSE after ${MAX_LISTEN_ATTEMPTS} attempts -- port ${config.port} may be held by another process)`
+                    : '';
+                throw new Error(`[otlp-receiver] Failed to bind port ${config.port}: ${err.message}${suffix}`);
+            }
+            const delayMs = BASE_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+            console.warn(`[otlp-receiver] EADDRINUSE on port ${config.port}, ` +
+                `retrying in ${delayMs}ms (attempt ${attempt}/${MAX_LISTEN_ATTEMPTS})`);
+            await new Promise(resolve => setTimeout(resolve, delayMs));
+        }
+    }
+}
+/**
+ * Stop the OTLP HTTP receiver server.
+ *
+ * Closes all open connections and waits for the server to shut down.
+ * If the server doesn't close within SHUTDOWN_TIMEOUT_MS, it is
+ * force-destroyed to prevent hanging on stale keep-alive connections.
+ */
+export function stopOtlpReceiver() {
+    const SHUTDOWN_TIMEOUT_MS = 5000;
+    return new Promise((resolve) => {
+        if (!server) {
+            resolve();
+            return;
+        }
+        const srv = server;
+        server = null;
+        // Force-close after timeout to avoid hanging on stale connections
+        const forceTimer = setTimeout(() => {
+            console.warn('[otlp-receiver] Shutdown timeout reached, force-closing server');
+            srv.closeAllConnections();
+        }, SHUTDOWN_TIMEOUT_MS);
+        srv.close(() => {
+            clearTimeout(forceTimer);
+            console.log('[otlp-receiver] Server stopped');
+            resolve();
+        });
+        // Immediately close idle connections so close() completes faster
+        srv.closeAllConnections();
+    });
+}
+//# sourceMappingURL=otlp-receiver.js.map