@comprehend/telemetry-node 0.1.4 → 0.2.1

package/dist/ComprehendMetricsExporter.d.ts

@@ -0,0 +1,18 @@
+import { ExportResult } from '@opentelemetry/core';
+import { AggregationTemporality, InstrumentType, PushMetricExporter, ResourceMetrics } from '@opentelemetry/sdk-metrics';
+import { CustomMetricSpecification } from './wire-protocol';
+import { WebSocketConnection } from './WebSocketConnection';
+export declare class ComprehendMetricsExporter implements PushMetricExporter {
+    private readonly connection;
+    private customCumulativeSpecs;
+    private customTimeSeriesSpecs;
+    constructor(connection: WebSocketConnection);
+    updateCustomMetrics(specs: CustomMetricSpecification[]): void;
+    export(metrics: ResourceMetrics, resultCallback: (result: ExportResult) => void): void;
+    private sendTimeSeriesData;
+    private sendCumulativeData;
+    private getServiceSubject;
+    selectAggregationTemporality(instrumentType: InstrumentType): AggregationTemporality;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/ComprehendMetricsExporter.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComprehendMetricsExporter = void 0;
+const core_1 = require("@opentelemetry/core");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const sha2_1 = require("@noble/hashes/sha2");
+const utils_1 = require("@noble/hashes/utils");
+/**
+ * Well-known Node.js runtime metric names that we forward as timeseries (gauge) metrics.
+ * Sources:
+ *  - @opentelemetry/instrumentation-runtime-node (process.runtime.nodejs.*, nodejs.*)
+ *  - OTel semconv: process metrics (process.cpu.utilization, process.uptime)
+ *  - OTel semconv: V8 JS metrics (v8js.memory.heap.*)
+ */
+const KNOWN_GAUGE_METRICS = new Set([
+    // Node.js runtime instrumentation metrics (@opentelemetry/instrumentation-runtime-node)
+    'process.runtime.nodejs.memory.heap.total',
+    'process.runtime.nodejs.memory.heap.used',
+    'process.runtime.nodejs.memory.rss',
+    'process.runtime.nodejs.memory.array_buffers',
+    'process.runtime.nodejs.memory.external',
+    'nodejs.eventloop.delay.min',
+    'nodejs.eventloop.delay.max',
+    'nodejs.eventloop.delay.mean',
+    'nodejs.eventloop.delay.p50',
+    'nodejs.eventloop.delay.p99',
+    'nodejs.eventloop.utilization',
+    'nodejs.active_handles.total',
+    // OTel semconv process metrics
+    'process.cpu.utilization',
+    'process.uptime',
+    // OTel semconv V8 JS runtime metrics
+    'v8js.memory.heap.limit',
+    'v8js.memory.heap.used',
+    'v8js.memory.heap.space.available_size',
+    'v8js.memory.heap.space.physical_size',
+    // Host metrics (@opentelemetry/host-metrics)
+    'process.memory.usage',
+]);
+/** Well-known counter/cumulative metrics. */
+const KNOWN_CUMULATIVE_METRICS = new Set([
+    'process.cpu.time',
+    'process.memory.virtual',
+]);
+class ComprehendMetricsExporter {
+    constructor(connection) {
+        this.customCumulativeSpecs = [];
+        this.customTimeSeriesSpecs = [];
+        this.connection = connection;
+    }
+    updateCustomMetrics(specs) {
+        this.customCumulativeSpecs = specs.filter((s) => s.type === 'cumulative');
+        this.customTimeSeriesSpecs = specs.filter((s) => s.type === 'timeseries');
+    }
+    export(metrics, resultCallback) {
+        try {
+            const serviceSubject = this.getServiceSubject(metrics);
+            for (const scopeMetrics of metrics.scopeMetrics) {
+                for (const metric of scopeMetrics.metrics) {
+                    const name = metric.descriptor.name;
+                    const unit = metric.descriptor.unit;
+                    // Skip histogram types entirely
+                    if (metric.dataPointType === sdk_metrics_1.DataPointType.HISTOGRAM ||
+                        metric.dataPointType === sdk_metrics_1.DataPointType.EXPONENTIAL_HISTOGRAM) {
+                        continue;
+                    }
+                    // Check standard well-known metrics
+                    if (KNOWN_GAUGE_METRICS.has(name) && serviceSubject) {
+                        this.sendTimeSeriesData(serviceSubject, name, unit, metric);
+                        continue;
+                    }
+                    if (KNOWN_CUMULATIVE_METRICS.has(name) && serviceSubject) {
+                        this.sendCumulativeData(serviceSubject, name, unit, metric);
+                        continue;
+                    }
+                    // Check custom metric specs
+                    const cumulativeSpec = this.customCumulativeSpecs.find(s => s.id === name);
+                    if (cumulativeSpec) {
+                        this.sendCumulativeData(cumulativeSpec.subject, name, unit, metric, cumulativeSpec.attributes);
+                        continue;
+                    }
+                    const timeSeriesSpec = this.customTimeSeriesSpecs.find(s => s.id === name);
+                    if (timeSeriesSpec) {
+                        this.sendTimeSeriesData(timeSeriesSpec.subject, name, unit, metric, timeSeriesSpec.attributes);
+                    }
+                }
+            }
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+        }
+        catch {
+            resultCallback({ code: core_1.ExportResultCode.FAILED });
+        }
+    }
+    sendTimeSeriesData(subject, name, unit, metric, filterAttributes) {
+        const data = [];
+        for (const dp of metric.dataPoints) {
+            data.push({
+                subject,
+                type: name,
+                timestamp: hrTimeFromOtel(dp.endTime),
+                value: dp.value,
+                unit,
+                attributes: extractAttributes(dp.attributes, filterAttributes),
+            });
+        }
+        if (data.length > 0) {
+            this.connection.sendMessage({
+                event: 'timeseries',
+                seq: this.connection.nextSeq(),
+                data,
+            });
+        }
+    }
+    sendCumulativeData(subject, name, unit, metric, filterAttributes) {
+        const data = [];
+        for (const dp of metric.dataPoints) {
+            data.push({
+                subject,
+                type: name,
+                timestamp: hrTimeFromOtel(dp.endTime),
+                value: dp.value,
+                unit,
+                attributes: extractAttributes(dp.attributes, filterAttributes),
+            });
+        }
+        if (data.length > 0) {
+            this.connection.sendMessage({
+                event: 'cumulative',
+                seq: this.connection.nextSeq(),
+                data,
+            });
+        }
+    }
+    getServiceSubject(metrics) {
+        const attrs = metrics.resource.attributes;
+        const name = attrs['service.name'];
+        if (!name)
+            return null;
+        const namespace = attrs['service.namespace'];
+        const environment = attrs['deployment.environment'];
+        const idString = `service:${name}:${namespace ?? ''}:${environment ?? ''}`;
+        return hashIdString(idString);
+    }
+    selectAggregationTemporality(instrumentType) {
+        switch (instrumentType) {
+            case sdk_metrics_1.InstrumentType.COUNTER:
+            case sdk_metrics_1.InstrumentType.HISTOGRAM:
+                return sdk_metrics_1.AggregationTemporality.DELTA;
+            default:
+                return sdk_metrics_1.AggregationTemporality.CUMULATIVE;
+        }
+    }
+    async forceFlush() {
+    }
+    async shutdown() {
+    }
+}
+exports.ComprehendMetricsExporter = ComprehendMetricsExporter;
+function hashIdString(idString) {
+    return Array.from((0, sha2_1.sha256)((0, utils_1.utf8ToBytes)(idString)))
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+function extractAttributes(attrs, filterKeys) {
+    const result = {};
+    for (const [key, value] of Object.entries(attrs)) {
+        if (value === undefined)
+            continue;
+        if (filterKeys && !filterKeys.includes(key))
+            continue;
+        result[key] = value;
+    }
+    return result;
+}
+/** Convert OTel HrTime to our wire protocol HrTime (same format: [seconds, nanoseconds]). */
+function hrTimeFromOtel(time) {
+    return time;
+}

package/dist/ComprehendMetricsExporter.test.d.ts

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

package/dist/ComprehendMetricsExporter.test.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@opentelemetry/core");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const ComprehendMetricsExporter_1 = require("./ComprehendMetricsExporter");
+jest.mock('./WebSocketConnection');
+describe('ComprehendMetricsExporter', () => {
+    let exporter;
+    let mockConnection;
+    let sentMessages;
+    let seqCounter;
+    beforeEach(() => {
+        sentMessages = [];
+        seqCounter = 1;
+        mockConnection = {
+            sendMessage: jest.fn((message) => {
+                sentMessages.push(message);
+            }),
+            nextSeq: jest.fn(() => seqCounter++),
+            close: jest.fn(),
+            setProcessContext: jest.fn(),
+        };
+        exporter = new ComprehendMetricsExporter_1.ComprehendMetricsExporter(mockConnection);
+    });
+    function createResourceMetrics(metrics, resourceAttributes = { 'service.name': 'test-service' }) {
+        return ({
+            resource: { attributes: resourceAttributes },
+            scopeMetrics: [{
+                    scope: { name: 'test-scope' },
+                    metrics: metrics.map(m => ({
+                        descriptor: {
+                            name: m.name,
+                            description: '',
+                            unit: m.unit ?? '',
+                            valueType: 0,
+                        },
+                        dataPointType: m.dataPointType,
+                        dataPoints: m.dataPoints.map(dp => ({
+                            startTime: dp.startTime ?? [0, 0],
+                            endTime: dp.endTime,
+                            attributes: dp.attributes,
+                            value: dp.value,
+                        })),
+                        ...(m.isMonotonic !== undefined ? { isMonotonic: m.isMonotonic } : {}),
+                        aggregationTemporality: sdk_metrics_1.AggregationTemporality.CUMULATIVE,
+                    })),
+                }],
+        });
+    }
+    describe('Standard Gauge Metrics', () => {
+        it('should forward known gauge metrics as timeseries', () => {
+            const rm = createResourceMetrics([{
+                    name: 'process.runtime.nodejs.memory.heap.used',
+                    unit: 'By',
+                    dataPointType: sdk_metrics_1.DataPointType.GAUGE,
+                    dataPoints: [{
+                            endTime: [1700000000, 0],
+                            attributes: {},
+                            value: 52428800,
+                        }],
+                }]);
+            const callback = jest.fn();
+            exporter.export(rm, callback);
+            expect(callback).toHaveBeenCalledWith({ code: core_1.ExportResultCode.SUCCESS });
+            const tsMsg = sentMessages.find(m => m.event === 'timeseries');
+            expect(tsMsg).toBeDefined();
+            expect(tsMsg.data).toHaveLength(1);
+            expect(tsMsg.data[0]).toMatchObject({
+                type: 'process.runtime.nodejs.memory.heap.used',
+                value: 52428800,
+                unit: 'By',
+            });
+        });
+        it('should forward multiple known gauge metrics', () => {
+            const rm = createResourceMetrics([
+                {
+                    name: 'process.runtime.nodejs.memory.heap.total',
+                    unit: 'By',
+                    dataPointType: sdk_metrics_1.DataPointType.GAUGE,
+                    dataPoints: [{ endTime: [1700000000, 0], attributes: {}, value: 104857600 }],
+                },
+                {
+                    name: 'nodejs.eventloop.delay.mean',
+                    unit: 'ms',
+                    dataPointType: sdk_metrics_1.DataPointType.GAUGE,
+                    dataPoints: [{ endTime: [1700000000, 0], attributes: {}, value: 1.5 }],
+                },
+            ]);
+            const callback = jest.fn();
+            exporter.export(rm, callback);
+            const tsMessages = sentMessages.filter(m => m.event === 'timeseries');
+            expect(tsMessages).toHaveLength(2);
+        });
+    });
+    describe('Unknown Metrics', () => {
+        it('should ignore unknown metric names', () => {
+            const rm = createResourceMetrics([{
+                    name: 'some.unknown.metric',
+                    dataPointType: sdk_metrics_1.DataPointType.GAUGE,
+                    dataPoints: [{ endTime: [0, 0], attributes: {}, value: 42 }],
+                }]);
+            const callback = jest.fn();
+            exporter.export(rm, callback);
+            expect(sentMessages).toHaveLength(0);
+            expect(callback).toHaveBeenCalledWith({ code: core_1.ExportResultCode.SUCCESS });
+        });
+    });
+    describe('Histogram Metrics', () => {
+        it('should skip histogram data point types', () => {
+            const rm = createResourceMetrics([{
+                    name: 'process.runtime.nodejs.memory.heap.used',
+                    dataPointType: sdk_metrics_1.DataPointType.HISTOGRAM,
+                    dataPoints: [{ endTime: [0, 0], attributes: {}, value: { buckets: {} } }],
+                }]);
+            const callback = jest.fn();
+            exporter.export(rm, callback);
+            expect(sentMessages).toHaveLength(0);
+        });
+        it('should skip exponential histogram data point types', () => {
+            const rm = createResourceMetrics([{
+                    name: 'process.runtime.nodejs.memory.heap.used',
+                    dataPointType: sdk_metrics_1.DataPointType.EXPONENTIAL_HISTOGRAM,
+                    dataPoints: [{ endTime: [0, 0], attributes: {}, value: {} }],
+                }]);
+            const callback = jest.fn();
+            exporter.export(rm, callback);
+            expect(sentMessages).toHaveLength(0);
+        });
+    });
+    describe('Custom Metrics', () => {
+        it('should forward custom cumulative metrics', () => {
+            exporter.updateCustomMetrics([
+                { type: 'cumulative', id: 'app.requests.total', attributes: ['method', 'status'], subject: 'custom-sub' },
+            ]);
+            const rm = createResourceMetrics([{
+                    name: 'app.requests.total',
+                    unit: '1',
+                    dataPointType: sdk_metrics_1.DataPointType.SUM,
+                    dataPoints: [{
+                            endTime: [1700000000, 0],
+                            attributes: { method: 'GET', status: '200', ignored: 'yes' },
+                            value: 150,
+                        }],
+                }]);
+            const callback = jest.fn();
+            exporter.export(rm, callback);
+            const cumMsg = sentMessages.find(m => m.event === 'cumulative');
+            expect(cumMsg).toBeDefined();
+            expect(cumMsg.data[0]).toMatchObject({
+                subject: 'custom-sub',
+                type: 'app.requests.total',
+                value: 150,
+            });
+            // Should only include filtered attributes
+            expect(cumMsg.data[0].attributes).toEqual({ method: 'GET', status: '200' });
+        });
+        it('should forward custom timeseries metrics', () => {
+            exporter.updateCustomMetrics([
+                { type: 'timeseries', id: 'app.cpu.usage', attributes: ['core'], subject: 'cpu-sub' },
+            ]);
+            const rm = createResourceMetrics([{
+                    name: 'app.cpu.usage',
+                    unit: '%',
+                    dataPointType: sdk_metrics_1.DataPointType.GAUGE,
+                    dataPoints: [{
+                            endTime: [1700000000, 0],
+                            attributes: { core: '0' },
+                            value: 45.2,
+                        }],
+                }]);
+            const callback = jest.fn();
+            exporter.export(rm, callback);
+            const tsMsg = sentMessages.find(m => m.event === 'timeseries');
+            expect(tsMsg).toBeDefined();
+            expect(tsMsg.data[0]).toMatchObject({
+                subject: 'cpu-sub',
+                type: 'app.cpu.usage',
+                value: 45.2,
+            });
+        });
+        it('should update custom metric specs when updateCustomMetrics is called', () => {
+            exporter.updateCustomMetrics([
+                { type: 'cumulative', id: 'old.metric', attributes: [], subject: 's1' },
+            ]);
+            // Replace with new specs
+            exporter.updateCustomMetrics([
+                { type: 'timeseries', id: 'new.metric', attributes: [], subject: 's2' },
+            ]);
+            const rmOld = createResourceMetrics([{
+                    name: 'old.metric',
+                    dataPointType: sdk_metrics_1.DataPointType.SUM,
+                    dataPoints: [{ endTime: [0, 0], attributes: {}, value: 1 }],
+                }]);
+            const rmNew = createResourceMetrics([{
+                    name: 'new.metric',
+                    dataPointType: sdk_metrics_1.DataPointType.GAUGE,
+                    dataPoints: [{ endTime: [0, 0], attributes: {}, value: 2 }],
+                }]);
+            const callback = jest.fn();
+            exporter.export(rmOld, callback);
+            expect(sentMessages).toHaveLength(0); // old spec no longer active
+            exporter.export(rmNew, callback);
+            expect(sentMessages).toHaveLength(1);
+        });
+    });
+    describe('Service Subject Hashing', () => {
+        it('should derive service subject from resource attributes', () => {
+            const rm = createResourceMetrics([{
+                    name: 'process.runtime.nodejs.memory.heap.used',
+                    unit: 'By',
+                    dataPointType: sdk_metrics_1.DataPointType.GAUGE,
+                    dataPoints: [{ endTime: [0, 0], attributes: {}, value: 100 }],
+                }], {
+                'service.name': 'my-svc',
+                'service.namespace': 'ns',
+                'deployment.environment': 'prod',
+            });
+            const callback = jest.fn();
+            exporter.export(rm, callback);
+            const tsMsg = sentMessages.find(m => m.event === 'timeseries');
+            expect(tsMsg.data[0].subject).toBeDefined();
+            expect(typeof tsMsg.data[0].subject).toBe('string');
+            expect(tsMsg.data[0].subject.length).toBe(64); // SHA256 hex
+        });
+        it('should skip known metrics when no service.name in resource', () => {
+            const rm = createResourceMetrics([{
+                    name: 'process.runtime.nodejs.memory.heap.used',
+                    dataPointType: sdk_metrics_1.DataPointType.GAUGE,
+                    dataPoints: [{ endTime: [0, 0], attributes: {}, value: 100 }],
+                }], {}); // No service.name
+            const callback = jest.fn();
+            exporter.export(rm, callback);
+            expect(sentMessages).toHaveLength(0);
+        });
+    });
+    describe('Aggregation Temporality', () => {
+        it('should return DELTA for COUNTER', () => {
+            expect(exporter.selectAggregationTemporality(sdk_metrics_1.InstrumentType.COUNTER))
+                .toBe(sdk_metrics_1.AggregationTemporality.DELTA);
+        });
+        it('should return DELTA for HISTOGRAM', () => {
+            expect(exporter.selectAggregationTemporality(sdk_metrics_1.InstrumentType.HISTOGRAM))
+                .toBe(sdk_metrics_1.AggregationTemporality.DELTA);
+        });
+        it('should return CUMULATIVE for OBSERVABLE_GAUGE', () => {
+            expect(exporter.selectAggregationTemporality(sdk_metrics_1.InstrumentType.OBSERVABLE_GAUGE))
+                .toBe(sdk_metrics_1.AggregationTemporality.CUMULATIVE);
+        });
+        it('should return CUMULATIVE for OBSERVABLE_COUNTER', () => {
+            expect(exporter.selectAggregationTemporality(sdk_metrics_1.InstrumentType.OBSERVABLE_COUNTER))
+                .toBe(sdk_metrics_1.AggregationTemporality.CUMULATIVE);
+        });
+        it('should return CUMULATIVE for GAUGE', () => {
+            expect(exporter.selectAggregationTemporality(sdk_metrics_1.InstrumentType.GAUGE))
+                .toBe(sdk_metrics_1.AggregationTemporality.CUMULATIVE);
+        });
+    });
+    describe('Lifecycle', () => {
+        it('should resolve forceFlush', async () => {
+            await expect(exporter.forceFlush()).resolves.toBeUndefined();
+        });
+        it('should resolve shutdown', async () => {
+            await expect(exporter.shutdown()).resolves.toBeUndefined();
+        });
+    });
+});

package/dist/ComprehendSDK.d.ts

@@ -0,0 +1,18 @@
+import { ComprehendDevSpanProcessor } from './ComprehendDevSpanProcessor';
+import { ComprehendMetricsExporter } from './ComprehendMetricsExporter';
+export type LogFn = (message: string) => void;
+export declare class ComprehendSDK {
+    private readonly connection;
+    private spanProcessor;
+    private metricsExporter;
+    private customMetricListeners;
+    constructor(options: {
+        organization: string;
+        token: string;
+        debug?: boolean | LogFn;
+    });
+    private distributeCustomMetrics;
+    getSpanProcessor(): ComprehendDevSpanProcessor;
+    getMetricsExporter(): ComprehendMetricsExporter;
+    shutdown(): Promise<void>;
+}

package/dist/ComprehendSDK.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComprehendSDK = void 0;
+const WebSocketConnection_1 = require("./WebSocketConnection");
+const ComprehendDevSpanProcessor_1 = require("./ComprehendDevSpanProcessor");
+const ComprehendMetricsExporter_1 = require("./ComprehendMetricsExporter");
+class ComprehendSDK {
+    constructor(options) {
+        this.spanProcessor = null;
+        this.metricsExporter = null;
+        this.customMetricListeners = [];
+        const logger = options.debug === true ? console.log
+            : options.debug === false ? undefined
+                : options.debug;
+        this.connection = new WebSocketConnection_1.WebSocketConnection({
+            organization: options.organization,
+            token: options.token,
+            logger,
+            onAuthorized: (ack) => {
+                this.distributeCustomMetrics(ack.customMetrics);
+            },
+            onCustomMetricChange: (specs) => {
+                this.distributeCustomMetrics(specs);
+            },
+        });
+    }
+    distributeCustomMetrics(specs) {
+        for (const listener of this.customMetricListeners) {
+            listener(specs);
+        }
+    }
+    getSpanProcessor() {
+        if (!this.spanProcessor) {
+            this.spanProcessor = new ComprehendDevSpanProcessor_1.ComprehendDevSpanProcessor(this.connection);
+            this.customMetricListeners.push((specs) => this.spanProcessor.updateCustomMetrics(specs));
+        }
+        return this.spanProcessor;
+    }
+    getMetricsExporter() {
+        if (!this.metricsExporter) {
+            this.metricsExporter = new ComprehendMetricsExporter_1.ComprehendMetricsExporter(this.connection);
+            this.customMetricListeners.push((specs) => this.metricsExporter.updateCustomMetrics(specs));
+        }
+        return this.metricsExporter;
+    }
+    async shutdown() {
+        if (this.spanProcessor) {
+            await this.spanProcessor.shutdown();
+        }
+        if (this.metricsExporter) {
+            await this.metricsExporter.shutdown();
+        }
+        this.connection.close();
+    }
+}
+exports.ComprehendSDK = ComprehendSDK;

package/dist/ComprehendSDK.test.d.ts

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

package/dist/ComprehendSDK.test.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ComprehendSDK_1 = require("./ComprehendSDK");
+const WebSocketConnection_1 = require("./WebSocketConnection");
+const ComprehendDevSpanProcessor_1 = require("./ComprehendDevSpanProcessor");
+const ComprehendMetricsExporter_1 = require("./ComprehendMetricsExporter");
+jest.mock('./WebSocketConnection');
+jest.mock('./ComprehendDevSpanProcessor');
+jest.mock('./ComprehendMetricsExporter');
+const MockedWebSocketConnection = WebSocketConnection_1.WebSocketConnection;
+const MockedSpanProcessor = ComprehendDevSpanProcessor_1.ComprehendDevSpanProcessor;
+const MockedMetricsExporter = ComprehendMetricsExporter_1.ComprehendMetricsExporter;
+describe('ComprehendSDK', () => {
+    let capturedOnAuthorized;
+    let capturedOnCustomMetricChange;
+    let mockConnectionInstance;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        capturedOnAuthorized = undefined;
+        capturedOnCustomMetricChange = undefined;
+        mockConnectionInstance = null;
+        MockedWebSocketConnection.mockImplementation((options) => {
+            capturedOnAuthorized = options.onAuthorized;
+            capturedOnCustomMetricChange = options.onCustomMetricChange;
+            mockConnectionInstance = {
+                sendMessage: jest.fn(),
+                setProcessContext: jest.fn(),
+                nextSeq: jest.fn(),
+                close: jest.fn(),
+            };
+            return mockConnectionInstance;
+        });
+        MockedSpanProcessor.mockImplementation(() => ({
+            onStart: jest.fn(),
+            onEnd: jest.fn(),
+            forceFlush: jest.fn().mockResolvedValue(undefined),
+            shutdown: jest.fn().mockResolvedValue(undefined),
+            updateCustomMetrics: jest.fn(),
+        }));
+        MockedMetricsExporter.mockImplementation(() => ({
+            export: jest.fn(),
+            forceFlush: jest.fn().mockResolvedValue(undefined),
+            shutdown: jest.fn().mockResolvedValue(undefined),
+            selectAggregationTemporality: jest.fn(),
+            updateCustomMetrics: jest.fn(),
+        }));
+    });
+    it('should create a WebSocketConnection with the correct options', () => {
+        new ComprehendSDK_1.ComprehendSDK({ organization: 'test-org', token: 'test-token' });
+        expect(MockedWebSocketConnection).toHaveBeenCalledTimes(1);
+        const opts = MockedWebSocketConnection.mock.calls[0][0];
+        expect(opts.organization).toBe('test-org');
+        expect(opts.token).toBe('test-token');
+    });
+    it('should pass console.log as logger when debug is true', () => {
+        new ComprehendSDK_1.ComprehendSDK({ organization: 'org', token: 'tok', debug: true });
+        const opts = MockedWebSocketConnection.mock.calls[0][0];
+        expect(opts.logger).toBe(console.log);
+    });
+    it('should pass custom logger function', () => {
+        const myLogger = jest.fn();
+        new ComprehendSDK_1.ComprehendSDK({ organization: 'org', token: 'tok', debug: myLogger });
+        const opts = MockedWebSocketConnection.mock.calls[0][0];
+        expect(opts.logger).toBe(myLogger);
+    });
+    it('should return the same span processor on multiple calls', () => {
+        const sdk = new ComprehendSDK_1.ComprehendSDK({ organization: 'org', token: 'tok' });
+        const proc1 = sdk.getSpanProcessor();
+        const proc2 = sdk.getSpanProcessor();
+        expect(proc1).toBe(proc2);
+        expect(MockedSpanProcessor).toHaveBeenCalledTimes(1);
+    });
+    it('should return the same metrics exporter on multiple calls', () => {
+        const sdk = new ComprehendSDK_1.ComprehendSDK({ organization: 'org', token: 'tok' });
+        const exp1 = sdk.getMetricsExporter();
+        const exp2 = sdk.getMetricsExporter();
+        expect(exp1).toBe(exp2);
+        expect(MockedMetricsExporter).toHaveBeenCalledTimes(1);
+    });
+    it('should share the same WebSocketConnection between processor and exporter', () => {
+        const sdk = new ComprehendSDK_1.ComprehendSDK({ organization: 'org', token: 'tok' });
+        sdk.getSpanProcessor();
+        sdk.getMetricsExporter();
+        // Both should receive the same connection instance
+        expect(MockedSpanProcessor).toHaveBeenCalledWith(mockConnectionInstance);
+        expect(MockedMetricsExporter).toHaveBeenCalledWith(mockConnectionInstance);
+    });
+    it('should distribute custom metrics from onAuthorized to processor and exporter', () => {
+        const sdk = new ComprehendSDK_1.ComprehendSDK({ organization: 'org', token: 'tok' });
+        const processor = sdk.getSpanProcessor();
+        const exporter = sdk.getMetricsExporter();
+        const specs = [
+            { type: 'span', rule: { kind: 'type', value: 'server' }, subject: 's1' },
+            { type: 'cumulative', id: 'm1', attributes: ['a'], subject: 's2' },
+        ];
+        // Simulate the auth callback
+        capturedOnAuthorized({ type: 'ack-authorized', customMetrics: specs });
+        expect(processor.updateCustomMetrics).toHaveBeenCalledWith(specs);
+        expect(exporter.updateCustomMetrics).toHaveBeenCalledWith(specs);
+    });
+    it('should distribute custom metrics from onCustomMetricChange', () => {
+        const sdk = new ComprehendSDK_1.ComprehendSDK({ organization: 'org', token: 'tok' });
+        const processor = sdk.getSpanProcessor();
+        const exporter = sdk.getMetricsExporter();
+        const specs = [
+            { type: 'timeseries', id: 'new-metric', attributes: [], subject: 's3' },
+        ];
+        capturedOnCustomMetricChange(specs);
+        expect(processor.updateCustomMetrics).toHaveBeenCalledWith(specs);
+        expect(exporter.updateCustomMetrics).toHaveBeenCalledWith(specs);
+    });
+    it('should shutdown processor, exporter, and connection', async () => {
+        const sdk = new ComprehendSDK_1.ComprehendSDK({ organization: 'org', token: 'tok' });
+        const processor = sdk.getSpanProcessor();
+        const exporter = sdk.getMetricsExporter();
+        await sdk.shutdown();
+        expect(processor.shutdown).toHaveBeenCalled();
+        expect(exporter.shutdown).toHaveBeenCalled();
+        expect(mockConnectionInstance.close).toHaveBeenCalled();
+    });
+    it('should shutdown cleanly even without processor or exporter created', async () => {
+        const sdk = new ComprehendSDK_1.ComprehendSDK({ organization: 'org', token: 'tok' });
+        await expect(sdk.shutdown()).resolves.toBeUndefined();
+        expect(mockConnectionInstance.close).toHaveBeenCalled();
+    });
+});