@newrelic/preflight 0.0.1-pre.1 → 1.0.1

package/dist/transport/nr-ingest.js

@@ -0,0 +1,659 @@
+/**
+ * New Relic Event Ingestion — converts ToolCallRecords into NR events and
+ * metrics, then ships them via the shared HarvestScheduler.
+ */
+import { HarvestScheduler, MetricAggregator, sendEvents, sendMetrics, OtlpTransport, OtlpEventBridge, createLogger, } from '../shared/index.js';
+const logger = createLogger('nr-ingest');
+import { redactSensitive } from '../config.js';
+import { ProxyMetricsTracker } from '../metrics/proxy-metrics.js';
+import { AuditTrailManager, auditRecordToNrEvent, securityAlertToNrEvent, } from '../security/index.js';
+import { LogIngestManager } from './log-ingest.js';
+// ---------------------------------------------------------------------------
+// Serializer
+// ---------------------------------------------------------------------------
+/** Standard ToolCallRecord keys that are handled explicitly. */
+const STANDARD_KEYS = new Set([
+    'id',
+    'sessionId',
+    'toolName',
+    'toolUseId',
+    'timestamp',
+    'durationMs',
+    'success',
+    'errorType',
+    'error',
+    'inputSizeBytes',
+    'outputSizeBytes',
+    'inputHash',
+    'platform',
+]);
+/**
+ * Tool-specific string fields that may carry secrets (Bash commands, file paths,
+ * grep patterns, sub-agent prompts, audit detail strings). Anything in this set
+ * is run through redactSensitive() before leaving the process. New fields that
+ * could contain user input must be added here — silent passthrough is the
+ * default failure mode and it leaks secrets to NR.
+ */
+const REDACT_FIELD_KEYS = new Set([
+    'command',
+    'filePath',
+    'file_path',
+    'pattern',
+    'agentDescription',
+    'agent_description',
+    'detail',
+    'cwd',
+]);
+/**
+ * Convert a ToolCallRecord into a flat NR event object.
+ *
+ * Standard fields are mapped to snake_case NR attributes; any extra
+ * tool-specific fields (string | number | boolean) are included as-is.
+ */
+export function toolCallToNrEvent(record, attrs) {
+    const event = {
+        eventType: 'AiToolCall',
+        timestamp: record.timestamp,
+        tool: record.toolName,
+        tool_use_id: record.toolUseId,
+        success: record.success,
+        developer: attrs.developer,
+        app_name: attrs.appName,
+    };
+    if (attrs.teamId)
+        event.team_id = attrs.teamId;
+    if (attrs.projectId)
+        event.project_id = attrs.projectId;
+    if (attrs.orgId)
+        event.org_id = attrs.orgId;
+    if (attrs.sessionTraceId != null)
+        event.session_id = attrs.sessionTraceId;
+    if (record.durationMs != null)
+        event.duration_ms = record.durationMs;
+    if (record.errorType != null)
+        event.error_type = record.errorType;
+    // Tool error messages occasionally include URLs from failed curl commands
+    // and similar — possible to embed an Authorization header or token query
+    // string in the message. Same redaction policy as the tool-specific fields.
+    if (record.error != null)
+        event.error = redactSensitive(record.error);
+    if (record.inputSizeBytes != null)
+        event.input_size_bytes = record.inputSizeBytes;
+    if (record.outputSizeBytes != null)
+        event.output_size_bytes = record.outputSizeBytes;
+    if (record.inputHash != null)
+        event.input_hash = record.inputHash;
+    // Platform attribution — defaults to 'claude-code' for backward compatibility
+    event.platform = typeof record.platform === 'string' ? record.platform : 'claude-code';
+    // Include tool-specific fields from parsers. String fields known to potentially
+    // carry secrets (commands, file paths, grep patterns, sub-agent prompts) are
+    // redacted before egress — the auditRecordToNrEvent path already does this for
+    // its own egress channel; the AiToolCall path must do the same.
+    for (const [key, value] of Object.entries(record)) {
+        if (STANDARD_KEYS.has(key))
+            continue;
+        if (typeof value === 'string') {
+            event[key] = REDACT_FIELD_KEYS.has(key) ? redactSensitive(value) : value;
+        }
+        else if (typeof value === 'number' || typeof value === 'boolean') {
+            event[key] = value;
+        }
+    }
+    return event;
+}
+/** Type guard for ProxyToolCallRecord (has serverName and upstreamLatencyMs with correct types). */
+export function isProxyToolCall(record) {
+    return ('serverName' in record &&
+        typeof record.serverName === 'string' &&
+        'upstreamLatencyMs' in record &&
+        typeof record.upstreamLatencyMs === 'number');
+}
+/**
+ * Convert a ProxyToolCallRecord into an NR event with proxy-specific attributes.
+ */
+export function proxyToolCallToNrEvent(record, attrs) {
+    const event = {
+        eventType: 'AiMcpToolCall',
+        timestamp: record.timestamp,
+        server: record.serverName,
+        tool: record.toolName,
+        duration_ms: record.durationMs ?? 0,
+        upstream_latency_ms: record.upstreamLatencyMs,
+        success: record.success,
+        developer: attrs.developer,
+        app_name: attrs.appName,
+    };
+    if (attrs.teamId)
+        event.team_id = attrs.teamId;
+    if (attrs.projectId)
+        event.project_id = attrs.projectId;
+    if (attrs.orgId)
+        event.org_id = attrs.orgId;
+    if (attrs.sessionTraceId != null)
+        event.session_id = attrs.sessionTraceId;
+    if (record.proxyOverheadMs != null)
+        event.proxy_overhead_ms = record.proxyOverheadMs;
+    if (record.errorType != null)
+        event.error_type = record.errorType;
+    if (record.inputSizeBytes != null)
+        event.request_size_bytes = record.inputSizeBytes;
+    if (record.outputSizeBytes != null)
+        event.response_size_bytes = record.outputSizeBytes;
+    return event;
+}
+/**
+ * Convert a ProxyRequestRecord (discovery methods like tools/list) into an NR event.
+ */
+export function proxyRequestToNrEvent(record, attrs) {
+    const event = {
+        eventType: 'AiProxyRequest',
+        timestamp: record.timestamp,
+        server: record.serverName,
+        method: record.method,
+        duration_ms: record.durationMs,
+        upstream_latency_ms: record.upstreamLatencyMs,
+        success: record.success,
+        developer: attrs.developer,
+        app_name: attrs.appName,
+    };
+    if (attrs.teamId)
+        event.team_id = attrs.teamId;
+    if (attrs.projectId)
+        event.project_id = attrs.projectId;
+    if (attrs.orgId)
+        event.org_id = attrs.orgId;
+    if (record.proxyOverheadMs != null)
+        event.proxy_overhead_ms = record.proxyOverheadMs;
+    if (record.responseSizeBytes != null)
+        event.response_size_bytes = record.responseSizeBytes;
+    return event;
+}
+/**
+ * Convert an AiCodingTask into a flat NR event object.
+ *
+ * All fields use snake_case to match the convention of AiToolCall/AiAuditEvent.
+ * File path arrays are emitted as counts to keep event size small.
+ */
+export function codingTaskToNrEvent(task, attrs) {
+    const firstRecord = task.toolCalls[0];
+    const platform = typeof firstRecord?.platform === 'string' ? firstRecord.platform : 'claude-code';
+    const event = {
+        eventType: 'AiCodingTask',
+        timestamp: task.endTime,
+        task_id: task.taskId,
+        developer: attrs.developer,
+        app_name: attrs.appName,
+        platform,
+        start_time: task.startTime,
+        end_time: task.endTime,
+        duration_ms: task.durationMs,
+        tool_call_count: task.toolCallCount,
+        files_read: task.filesRead.length,
+        files_modified: task.filesModified.length,
+        lines_added: task.linesAdded,
+        lines_removed: task.linesRemoved,
+        bash_commands_run: task.bashCommandsRun,
+        tests_run: task.testsRun,
+        tests_passed: task.testsPassed,
+        build_run: task.buildRun,
+        build_passed: task.buildPassed,
+        estimated_cost_usd: task.estimatedCostUsd ?? 0,
+        // Distinguish genuine zero-cost from "cost was never computed" so NRQL
+        // sum(estimated_cost_usd) doesn't silently undercount.
+        cost_estimated: task.estimatedCostUsd !== null,
+        tokens_used: task.tokensUsed,
+        asked_user_questions: task.askedUserQuestions,
+        sub_agents_spawned: task.subAgentsSpawned,
+    };
+    if (attrs.teamId)
+        event.team_id = attrs.teamId;
+    if (attrs.projectId)
+        event.project_id = attrs.projectId;
+    if (attrs.orgId)
+        event.org_id = attrs.orgId;
+    // Fix 3: sessionTraceId is the resolved Claude Code session_id; the
+    // firstRecord?.sessionId fallback was only meaningful when the MCP fabricated
+    // its own UUID and lost cross-reference with the tool-call records.
+    if (attrs.sessionTraceId != null)
+        event.session_id = attrs.sessionTraceId;
+    return event;
+}
+/**
+ * Convert an AntiPattern into a flat NR event object.
+ *
+ * Optional fields are only included when defined on the source pattern.
+ */
+export function antiPatternToNrEvent(pattern, attrs) {
+    const event = {
+        eventType: 'AiAntiPattern',
+        timestamp: attrs.detectedAt ?? Date.now(),
+        // Field name is intentionally 'type' (not 'patternType') — used by all NRQL queries and dashboards. Do not rename.
+        type: pattern.type,
+        task_id: attrs.taskId,
+        developer: attrs.developer,
+        app_name: attrs.appName,
+        platform: attrs.platform ?? 'claude-code',
+        suggestion: pattern.suggestion,
+    };
+    if (attrs.teamId)
+        event.team_id = attrs.teamId;
+    if (attrs.projectId)
+        event.project_id = attrs.projectId;
+    if (attrs.orgId)
+        event.org_id = attrs.orgId;
+    if (attrs.sessionId != null)
+        event.session_id = attrs.sessionId;
+    // pattern.file is sourced from raw call.filePath in detectThrashing, and
+    // pattern.command from raw Bash commands in other detectors — both can
+    // carry query-string tokens or Authorization headers. Same egress channel
+    // as toolCallToNrEvent, so the same redaction policy applies.
+    if (pattern.file != null)
+        event.file = redactSensitive(pattern.file);
+    if (pattern.command != null)
+        event.command = redactSensitive(pattern.command);
+    if (pattern.iterations != null)
+        event.iterations = pattern.iterations;
+    if (pattern.readCount != null)
+        event.read_count = pattern.readCount;
+    if (pattern.repeatCount != null)
+        event.repeat_count = pattern.repeatCount;
+    if (pattern.editCount != null)
+        event.edit_count = pattern.editCount;
+    if (pattern.agentCount != null)
+        event.agent_count = pattern.agentCount;
+    return event;
+}
+// ---------------------------------------------------------------------------
+// Retry classification
+// ---------------------------------------------------------------------------
+// 4xx errors that the transport already dropped as permanent failures — re-queuing them
+// would cause an infinite retry loop since the same request will fail again. Exclude 408
+// (Request Timeout, network-level, worth retrying) and 429 (Too Many Requests, rate-limited,
+// worth retrying on the next harvest cycle).
+function isNonRetryable4xx(statusCode) {
+    return statusCode >= 400 && statusCode < 500 && statusCode !== 408 && statusCode !== 429;
+}
+// ---------------------------------------------------------------------------
+// NrIngestManager
+// ---------------------------------------------------------------------------
+export class NrIngestManager {
+    scheduler;
+    logIngest;
+    sessionTracker;
+    proxyMetrics;
+    costTracker;
+    efficiencyScorer;
+    auditTrail;
+    developer;
+    appName;
+    sessionTraceId;
+    teamId;
+    projectId;
+    orgId;
+    metricHarvestIntervalMs;
+    turnCostAttributor;
+    otlpTransport;
+    otlpEventBridge;
+    sessionGaugeIntervalId = null;
+    running = false;
+    constructor(options) {
+        this.developer = options.developer;
+        this.appName = options.appName;
+        this.sessionTraceId = options.sessionTraceId;
+        this.teamId = options.teamId;
+        this.projectId = options.projectId;
+        this.orgId = options.orgId;
+        this.sessionTracker = options.sessionTracker;
+        this.proxyMetrics = new ProxyMetricsTracker();
+        this.costTracker = options.costTracker;
+        this.efficiencyScorer = options.efficiencyScorer;
+        this.turnCostAttributor = options.turnCostAttributor;
+        this.auditTrail =
+            options.auditTrail ??
+                new AuditTrailManager({
+                    developer: options.developer,
+                    sessionId: options.sessionId ?? null,
+                    localStore: options.localStore,
+                });
+        this.metricHarvestIntervalMs = options.metricHarvestIntervalMs ?? 60_000;
+        let otlpTransport = null;
+        let otlpEventBridge = null;
+        if (options.otlpEndpoint) {
+            otlpTransport = new OtlpTransport({
+                endpoint: options.otlpEndpoint,
+                headers: options.otlpHeaders,
+                appName: options.appName,
+                clientName: 'newrelic-preflight',
+            });
+            otlpEventBridge = new OtlpEventBridge({
+                endpoint: options.otlpEndpoint,
+                headers: options.otlpHeaders,
+                appName: options.appName,
+                clientName: 'newrelic-preflight',
+            });
+            // OtlpTransport no longer has an explicit start() — providers initialise in the constructor.
+        }
+        this.otlpTransport = otlpTransport;
+        this.otlpEventBridge = otlpEventBridge;
+        // Wrap send functions so non-retryable 4xx failures (400, 403, etc.) are not
+        // re-queued by HarvestScheduler. Returning success=true suppresses the requeue
+        // without masking the original error — we log a warning before returning.
+        const rawSendEventsFn = options.sendEventsFn ?? sendEvents;
+        const classifyingEventsFn = async (events, licenseKey, opts) => {
+            const result = await rawSendEventsFn(events, licenseKey, opts);
+            if (!result.success && result.statusCode !== null && isNonRetryable4xx(result.statusCode)) {
+                logger.warn('Dropping non-retryable event batch', {
+                    statusCode: result.statusCode,
+                    batchSize: events.length,
+                });
+                return { ...result, success: true };
+            }
+            return result;
+        };
+        const rawSendMetricsFn = options.sendMetricsFn ?? sendMetrics;
+        const classifyingMetricsFn = async (metrics, licenseKey, opts) => {
+            const result = await rawSendMetricsFn(metrics, licenseKey, opts);
+            if (!result.success && result.statusCode !== null && isNonRetryable4xx(result.statusCode)) {
+                logger.warn('Dropping non-retryable metric batch', {
+                    statusCode: result.statusCode,
+                    batchSize: metrics.length,
+                });
+                return { ...result, success: true };
+            }
+            return result;
+        };
+        const transportOptions = {
+            ...options.transportOptions,
+            clientName: 'newrelic-preflight',
+        };
+        this.scheduler = new HarvestScheduler({
+            licenseKey: options.licenseKey,
+            transportOptions,
+            eventHarvestIntervalMs: options.eventHarvestIntervalMs,
+            metricHarvestIntervalMs: options.metricHarvestIntervalMs,
+            sendEventsFn: classifyingEventsFn,
+            sendMetricsFn: classifyingMetricsFn,
+            otlpEventBridge: otlpEventBridge ?? undefined,
+            otlpTransport: otlpTransport ?? undefined,
+            transport: options.transport,
+            allowProcessExit: true,
+        });
+        this.logIngest = new LogIngestManager({
+            licenseKey: options.licenseKey,
+            transportOptions,
+            developer: options.developer,
+            appName: options.appName,
+            logHarvestIntervalMs: options.logHarvestIntervalMs,
+            sendLogsFn: options.sendLogsFn,
+        });
+    }
+    ingestProxyRequest(record) {
+        const event = proxyRequestToNrEvent(record, {
+            developer: this.developer,
+            appName: this.appName,
+            teamId: this.teamId,
+            projectId: this.projectId,
+            orgId: this.orgId,
+        });
+        this.scheduler.addEvent(event);
+        const server = record.serverName;
+        this.scheduler.recordMetric('ai.mcp.proxy_request_count', 1, { server, method: record.method });
+        if (record.durationMs != null) {
+            this.scheduler.recordMetric('ai.mcp.proxy_request_duration_ms', record.durationMs, {
+                server,
+            });
+        }
+        // Aggregate into proxy metrics tracker
+        this.proxyMetrics.recordProxyRequest(record);
+    }
+    ingestToolCall(record, auditRecord) {
+        // Buffer event for NR Events API
+        const event = toolCallToNrEvent(record, {
+            developer: this.developer,
+            appName: this.appName,
+            sessionTraceId: this.sessionTraceId,
+            teamId: this.teamId,
+            projectId: this.projectId,
+            orgId: this.orgId,
+        });
+        // Cost attribution is available via the nr_observe_get_cost_per_tool MCP tool only.
+        // Enriching NR events here would always produce null because the token event
+        // (which finalizes turn cost) arrives asynchronously after ingestToolCall is called.
+        this.scheduler.addEvent(event);
+        // Record per-call metrics for NR Metric API
+        const tool = record.toolName;
+        const sessionId = this.sessionTraceId;
+        const teamDims = {};
+        if (this.teamId)
+            teamDims.team_id = this.teamId;
+        if (this.projectId)
+            teamDims.project_id = this.projectId;
+        if (this.orgId)
+            teamDims.org_id = this.orgId;
+        this.scheduler.recordMetric('ai.tool.call_count', 1, sessionId != null ? { tool, session_id: sessionId, ...teamDims } : { tool, ...teamDims });
+        if (record.durationMs != null) {
+            this.scheduler.recordMetric('ai.tool.duration_ms', record.durationMs, sessionId != null ? { tool, session_id: sessionId, ...teamDims } : { tool, ...teamDims });
+        }
+        this.scheduler.recordMetric('ai.tool.success', record.success ? 1 : 0, sessionId != null ? { tool, session_id: sessionId, ...teamDims } : { tool, ...teamDims });
+        // If this is a proxied tool call, also emit AiMcpToolCall event and aggregate
+        if (isProxyToolCall(record)) {
+            const proxyEvent = proxyToolCallToNrEvent(record, {
+                developer: this.developer,
+                appName: this.appName,
+                sessionTraceId: this.sessionTraceId,
+                teamId: this.teamId,
+                projectId: this.projectId,
+                orgId: this.orgId,
+            });
+            this.scheduler.addEvent(proxyEvent);
+            this.proxyMetrics.recordProxyCall(record);
+        }
+        // Security audit trail. The caller may pass a pre-computed auditRecord
+        // (e.g. from the onRecord pipeline so audit recording works in local mode);
+        // fall back to recording here for any callers that don't.
+        const finalAuditRecord = auditRecord ??
+            (isProxyToolCall(record)
+                ? this.auditTrail.recordProxyCall(record)
+                : this.auditTrail.recordToolCall(record));
+        this.scheduler.addEvent(auditRecordToNrEvent(finalAuditRecord, {
+            teamId: this.teamId,
+            projectId: this.projectId,
+            orgId: this.orgId,
+        }));
+        if (finalAuditRecord.securityAlert) {
+            this.scheduler.addEvent(securityAlertToNrEvent(finalAuditRecord, {
+                teamId: this.teamId,
+                projectId: this.projectId,
+                orgId: this.orgId,
+            }));
+        }
+        // Queue audit log entry for NR Logs API
+        this.logIngest.addAuditRecord(finalAuditRecord);
+    }
+    ingestCodingTask(task) {
+        const event = codingTaskToNrEvent(task, {
+            developer: this.developer,
+            appName: this.appName,
+            sessionTraceId: this.sessionTraceId,
+            teamId: this.teamId,
+            projectId: this.projectId,
+            orgId: this.orgId,
+        });
+        this.scheduler.addEvent(event);
+    }
+    ingestAntiPattern(pattern, context) {
+        const event = antiPatternToNrEvent(pattern, {
+            developer: this.developer,
+            appName: this.appName,
+            sessionId: this.sessionTraceId,
+            platform: context.platform,
+            taskId: context.taskId,
+            teamId: this.teamId,
+            projectId: this.projectId,
+            orgId: this.orgId,
+            detectedAt: context.detectedAt,
+        });
+        this.scheduler.addEvent(event);
+    }
+    ingestContextSnapshot(snapshot, topTools) {
+        const nrEvent = {
+            eventType: 'AiContextSnapshot',
+            timestamp: snapshot.timestamp,
+            developer: this.developer,
+            appName: this.appName,
+            turn_number: snapshot.turnNumber,
+            total_context_tokens: snapshot.inputTokens,
+            output_tokens: snapshot.outputTokens,
+            cache_read_tokens: snapshot.cacheReadTokens,
+            cache_creation_tokens: snapshot.cacheCreationTokens,
+            fill_percent: snapshot.fillPercent,
+            system_tokens: snapshot.breakdown.system,
+            tool_tokens: snapshot.breakdown.tools,
+            user_tokens: snapshot.breakdown.user,
+            assistant_tokens: snapshot.breakdown.assistant,
+        };
+        if (topTools.length > 0) {
+            nrEvent.top_tool = topTools[0].tool;
+            nrEvent.top_tool_bytes = topTools[0].totalBytes;
+            nrEvent.top_tool_tokens = topTools[0].estimatedTokens;
+        }
+        if (this.teamId)
+            nrEvent.team_id = this.teamId;
+        if (this.projectId)
+            nrEvent.project_id = this.projectId;
+        if (this.orgId)
+            nrEvent.org_id = this.orgId;
+        if (this.sessionTraceId != null)
+            nrEvent.session_id = this.sessionTraceId;
+        this.scheduler.addEvent(nrEvent);
+    }
+    ingestBudgetWarning(event) {
+        const nrEvent = {
+            eventType: 'AiBudgetWarning',
+            timestamp: event.timestamp,
+            developer: this.developer,
+            appName: this.appName,
+            budget_period: event.period,
+            threshold_pct: event.thresholdPct,
+            spent_usd: event.spentUsd,
+            budget_usd: event.budgetUsd,
+            remaining_usd: Math.max(0, event.budgetUsd - event.spentUsd),
+        };
+        if (this.teamId)
+            nrEvent.team_id = this.teamId;
+        if (this.projectId)
+            nrEvent.project_id = this.projectId;
+        if (this.orgId)
+            nrEvent.org_id = this.orgId;
+        if (this.sessionTraceId != null)
+            nrEvent.session_id = this.sessionTraceId;
+        this.scheduler.addEvent(nrEvent);
+    }
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.scheduler.start();
+        this.logIngest.start();
+        // Emit session-level gauges on the metric harvest cadence
+        this.sessionGaugeIntervalId = setInterval(() => {
+            this.emitSessionGauges();
+        }, this.metricHarvestIntervalMs);
+        this.sessionGaugeIntervalId.unref();
+    }
+    async stop() {
+        if (!this.running)
+            return;
+        // Emit final session gauges before clearing interval and stopping scheduler
+        this.emitSessionGauges();
+        // Clear session gauge interval
+        if (this.sessionGaugeIntervalId !== null) {
+            clearInterval(this.sessionGaugeIntervalId);
+            this.sessionGaugeIntervalId = null;
+        }
+        this.running = false;
+        const cleanupPromises = [this.scheduler.stop(), this.logIngest.stop()];
+        if (this.otlpTransport) {
+            cleanupPromises.push(this.otlpTransport.shutdown());
+        }
+        if (this.otlpEventBridge) {
+            cleanupPromises.push(this.otlpEventBridge.shutdown());
+        }
+        const results = await Promise.allSettled(cleanupPromises);
+        for (const r of results) {
+            if (r.status === 'rejected') {
+                logger.warn('Error stopping NrIngest service', { error: String(r.reason) });
+            }
+        }
+    }
+    emitSessionGauges() {
+        if (!this.running)
+            return;
+        const sessionId = this.sessionTraceId;
+        const teamAttrs = {};
+        if (this.teamId)
+            teamAttrs.team_id = this.teamId;
+        if (this.projectId)
+            teamAttrs.project_id = this.projectId;
+        if (this.orgId)
+            teamAttrs.org_id = this.orgId;
+        const record = (name, value, attrs = {}) => {
+            this.scheduler.recordMetric(name, value, sessionId != null ? { session_id: sessionId, ...attrs } : attrs);
+        };
+        const metrics = this.sessionTracker.getMetrics();
+        record('ai.session.duration_ms', metrics.sessionDurationMs, { ...teamAttrs });
+        record('ai.session.unique_files_read', metrics.uniqueFilesRead, { ...teamAttrs });
+        record('ai.session.unique_files_written', metrics.uniqueFilesWritten, { ...teamAttrs });
+        // Emit cost and efficiency metrics with developer dimension so Team View
+        // FACET developer queries return per-developer breakdowns.
+        if (this.costTracker || this.efficiencyScorer) {
+            const developer = this.developer;
+            const scheduler = this.scheduler;
+            const devAggregator = new MetricAggregator();
+            const _origRecord = devAggregator.record.bind(devAggregator);
+            // Override record() to inject developer + team attribution on every metric.
+            // The bound original is preserved so TypeScript sees the full MetricAggregator type.
+            devAggregator.record = (name, value, attrs = {}) => {
+                scheduler.recordMetric(name, value, sessionId != null
+                    ? { developer, session_id: sessionId, ...teamAttrs, ...attrs }
+                    : { developer, ...teamAttrs, ...attrs });
+                return true;
+            };
+            this.costTracker?.emitMetrics(devAggregator);
+            this.efficiencyScorer?.emitMetrics(devAggregator);
+        }
+        // Emit aggregated proxy metrics
+        const proxyMetrics = this.proxyMetrics.getMetrics();
+        for (const [server, stats] of Object.entries(proxyMetrics.perServer)) {
+            this.scheduler.recordMetric('ai.mcp.server_call_count', stats.callCount, {
+                server,
+                ...teamAttrs,
+            });
+            if (stats.latencyMs.count > 0) {
+                const avg = stats.latencyMs.sum / stats.latencyMs.count;
+                this.scheduler.recordMetric('ai.mcp.server_latency_ms', avg, { server, ...teamAttrs });
+            }
+            if (stats.errorRate > 0) {
+                this.scheduler.recordMetric('ai.mcp.server_error_rate', stats.errorRate, {
+                    server,
+                    ...teamAttrs,
+                });
+            }
+        }
+        if (proxyMetrics.avgProxyOverheadMs > 0) {
+            this.scheduler.recordMetric('ai.mcp.proxy_overhead_ms', proxyMetrics.avgProxyOverheadMs, {
+                ...teamAttrs,
+            });
+        }
+        // Cap at 100 (tool, server) combinations to stay within NR Metric API cardinality limits.
+        const MAX_TOOL_POPULARITY_ENTRIES = 100;
+        for (const entry of proxyMetrics.toolPopularity.slice(0, MAX_TOOL_POPULARITY_ENTRIES)) {
+            this.scheduler.recordMetric('ai.mcp.tool_popularity', entry.count, {
+                tool: entry.tool,
+                server: entry.server,
+                ...teamAttrs,
+            });
+        }
+    }
+}
+//# sourceMappingURL=nr-ingest.js.map