observability-toolkit 1.8.5 → 2.1.0

package/dist/lib/exports/otlp-proto-encode.test.js

@@ -0,0 +1,997 @@
+/**
+ * Tests for otlp-proto-encode.ts
+ *
+ * Covers hex-to-base64 conversion, ID remapping, and protobuf binary encoding.
+ */
+import { describe, it } from 'vitest';
+import assert from 'node:assert';
+import { fromBinary } from '@bufbuild/protobuf';
+import { ExportTraceServiceRequestSchema } from '../../generated/opentelemetry/proto/collector/trace/v1/trace_service_pb.js';
+import { ExportLogsServiceRequestSchema } from '../../generated/opentelemetry/proto/collector/logs/v1/logs_service_pb.js';
+import { hexToBase64, convertHexIdsToBase64, encodeTracesProtobuf, convertLogHexIdsToBase64, encodeLogsProtobuf, convertMetricHexIdsToBase64, encodeMetricsProtobuf, } from './otlp-proto-encode.js';
+import { MAX_HEX_BYTES, OTLP_SPAN_ID_LENGTH, OTLP_TRACE_ID_LENGTH } from '../core/constants.js';
+import { requireDefined } from '../../test-helpers/assertions.js';
+const HEX_DIGITS_PER_BYTE = 2;
+const HEX_RADIX = 16;
+const OTLP_TRACE_ID_BYTES = OTLP_TRACE_ID_LENGTH / HEX_DIGITS_PER_BYTE;
+const OTLP_SPAN_ID_BYTES = OTLP_SPAN_ID_LENGTH / HEX_DIGITS_PER_BYTE;
+const BYTE_ALL_BITS_SET = 0xff;
+const PROTOBUF_ROOT_FIELD_TAG = 0x0a;
+const HISTOGRAM_BOUND_MS_FAST = 100;
+const HISTOGRAM_BOUND_MS_MODERATE = 500;
+// Cross-platform base64 decoding helpers — no Buffer dependency (Workers-compatible)
+const b64ToHex = (b64) => Array.from(atob(b64), c => c.charCodeAt(0).toString(HEX_RADIX).padStart(HEX_DIGITS_PER_BYTE, '0')).join('');
+const b64ToBytes = (b64) => Uint8Array.from(atob(b64), c => c.charCodeAt(0));
+describe('otlp-proto-encode', () => {
+    describe('hexToBase64', () => {
+        it('converts known hex to base64', () => {
+            // "Hello" in hex = 48656c6c6f, base64 = SGVsbG8=
+            assert.strictEqual(hexToBase64('48656c6c6f'), 'SGVsbG8=');
+        });
+        it('converts 32-char trace ID hex to base64', () => {
+            const hex = 'abcdef0123456789abcdef0123456789';
+            const result = hexToBase64(hex);
+            // Verify roundtrip: base64 → bytes → hex matches original
+            assert.strictEqual(b64ToHex(result), hex);
+        });
+        it('converts 16-char span ID hex to base64', () => {
+            const hex = 'abcdef0123456789';
+            const result = hexToBase64(hex);
+            assert.strictEqual(b64ToHex(result), hex);
+            assert.strictEqual(b64ToBytes(result).length, OTLP_SPAN_ID_BYTES);
+        });
+        it('handles all-zeros hex', () => {
+            const hex = '00000000000000000000000000000000';
+            const result = hexToBase64(hex);
+            const bytes = b64ToBytes(result);
+            assert.strictEqual(bytes.length, OTLP_TRACE_ID_BYTES);
+            assert.ok(bytes.every(b => b === 0));
+        });
+        it('handles all-ff hex', () => {
+            const hex = 'ffffffffffffffffffffffffffffffff';
+            const result = hexToBase64(hex);
+            const bytes = b64ToBytes(result);
+            assert.strictEqual(bytes.length, OTLP_TRACE_ID_BYTES);
+            assert.ok(bytes.every(b => b === BYTE_ALL_BITS_SET));
+        });
+        it('handles empty string — returns empty base64 (valid; callers must guard absent IDs)', () => {
+            // Empty hex → empty base64 is mathematically correct.
+            // Callers must NOT pass empty strings for required trace/span IDs;
+            // convertHexIdsToBase64 omits parentSpanId when absent rather than passing empty hex.
+            const result = hexToBase64('');
+            assert.strictEqual(result, '');
+        });
+        it('throws on odd-length hex string', () => {
+            assert.throws(() => hexToBase64('abc'), /odd-length hex string/);
+        });
+        it('throws on non-hex characters', () => {
+            assert.throws(() => hexToBase64('abcdXX12'), /non-hex characters/);
+        });
+        it('throws on hex with dashes', () => {
+            assert.throws(() => hexToBase64('abcd-123-'), /odd-length hex string/);
+        });
+        it('throws on input exceeding MAX_HEX_BYTES boundary', () => {
+            const oversized = 'ab'.repeat(MAX_HEX_BYTES + 1);
+            assert.throws(() => hexToBase64(oversized), /input too large/);
+        });
+        it('accepts input at exactly MAX_HEX_BYTES boundary', () => {
+            // Guard is strict >, so exact boundary must succeed.
+            const atLimit = 'ab'.repeat(MAX_HEX_BYTES);
+            assert.doesNotThrow(() => hexToBase64(atLimit));
+        });
+    });
+    describe('convertHexIdsToBase64', () => {
+        it('converts trace and span IDs to base64', () => {
+            const input = {
+                resourceSpans: [{
+                        resource: { attributes: [] },
+                        scopeSpans: [{
+                                scope: { name: 'test' },
+                                spans: [{
+                                        traceId: 'abcdef0123456789abcdef0123456789',
+                                        spanId: 'abcdef0123456789',
+                                        name: 'test-span',
+                                        kind: 0,
+                                        startTimeUnixNano: '1000000000',
+                                        endTimeUnixNano: '2000000000',
+                                        status: { code: 1 },
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertHexIdsToBase64(input);
+            const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+            // IDs should now be base64, not hex
+            assert.notStrictEqual(span.traceId, 'abcdef0123456789abcdef0123456789');
+            assert.notStrictEqual(span.spanId, 'abcdef0123456789');
+            // Verify they're valid base64 that roundtrips to original hex
+            assert.strictEqual(b64ToHex(span.traceId), 'abcdef0123456789abcdef0123456789');
+            assert.strictEqual(b64ToHex(span.spanId), 'abcdef0123456789');
+        });
+        it('preserves other span fields', () => {
+            const input = {
+                resourceSpans: [{
+                        resource: { attributes: [{ key: 'service.name', value: { stringValue: 'test' } }] },
+                        scopeSpans: [{
+                                scope: { name: 'test', version: '1.0' },
+                                spans: [{
+                                        traceId: 'abcdef0123456789abcdef0123456789',
+                                        spanId: 'abcdef0123456789',
+                                        name: 'test-span',
+                                        kind: 1,
+                                        startTimeUnixNano: '1000000000',
+                                        endTimeUnixNano: '2000000000',
+                                        status: { code: 1 },
+                                        attributes: [{ key: 'test.key', value: { stringValue: 'test-value' } }],
+                                        events: [{
+                                                name: 'test-event',
+                                                timeUnixNano: '1500000000',
+                                                attributes: [{ key: 'event.key', value: { intValue: '42' } }],
+                                            }],
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertHexIdsToBase64(input);
+            const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+            assert.strictEqual(span.name, 'test-span');
+            assert.strictEqual(span.kind, 1);
+            assert.strictEqual(span.attributes?.[0].key, 'test.key');
+            assert.strictEqual(span.events?.[0].name, 'test-event');
+        });
+        it('converts parentSpanId when present', () => {
+            const input = {
+                resourceSpans: [{
+                        resource: { attributes: [] },
+                        scopeSpans: [{
+                                spans: [{
+                                        traceId: 'abcdef0123456789abcdef0123456789',
+                                        spanId: 'abcdef0123456789',
+                                        parentSpanId: '1234567890abcdef',
+                                        name: 'child-span',
+                                        kind: 0,
+                                        startTimeUnixNano: '1000000000',
+                                        endTimeUnixNano: '2000000000',
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertHexIdsToBase64(input);
+            const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+            // parentSpanId should be base64-converted
+            assert.ok(span.parentSpanId);
+            assert.strictEqual(b64ToHex(span.parentSpanId), '1234567890abcdef');
+        });
+        it('omits parentSpanId when not present', () => {
+            const input = {
+                resourceSpans: [{
+                        resource: { attributes: [] },
+                        scopeSpans: [{
+                                spans: [{
+                                        traceId: 'abcdef0123456789abcdef0123456789',
+                                        spanId: 'abcdef0123456789',
+                                        name: 'root-span',
+                                        kind: 0,
+                                        startTimeUnixNano: '1000000000',
+                                        endTimeUnixNano: '2000000000',
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertHexIdsToBase64(input);
+            const span = result.resourceSpans[0].scopeSpans[0].spans[0];
+            assert.strictEqual(span.parentSpanId, undefined);
+        });
+        it('does not mutate input', () => {
+            const input = {
+                resourceSpans: [{
+                        resource: { attributes: [] },
+                        scopeSpans: [{
+                                spans: [{
+                                        traceId: 'abcdef0123456789abcdef0123456789',
+                                        spanId: 'abcdef0123456789',
+                                        name: 'test',
+                                        kind: 0,
+                                        startTimeUnixNano: '1000000000',
+                                        endTimeUnixNano: '2000000000',
+                                    }],
+                            }],
+                    }],
+            };
+            convertHexIdsToBase64(input);
+            // Original should be unchanged
+            assert.strictEqual(input.resourceSpans[0].scopeSpans[0].spans[0].traceId, 'abcdef0123456789abcdef0123456789');
+        });
+    });
+    describe('encodeTracesProtobuf', () => {
+        it('encodes minimal trace to valid protobuf binary', () => {
+            const input = {
+                resourceSpans: [{
+                        resource: {
+                            attributes: [{ key: 'service.name', value: { stringValue: 'test-service' } }],
+                        },
+                        scopeSpans: [{
+                                scope: { name: 'test-scope', version: '1.0.0' },
+                                spans: [{
+                                        traceId: 'abcdef0123456789abcdef0123456789',
+                                        spanId: 'abcdef0123456789',
+                                        name: 'test-span',
+                                        kind: 0,
+                                        startTimeUnixNano: '1705312800000000000',
+                                        endTimeUnixNano: '1705312801000000000',
+                                        status: { code: 1 },
+                                    }],
+                            }],
+                    }],
+            };
+            const binary = encodeTracesProtobuf(input);
+            assert.ok(binary instanceof Uint8Array);
+            assert.ok(binary.length > 0);
+            // Protobuf field tag: field 1 (resourceSpans), wire type 2 (length-delimited) = 0x0a
+            assert.strictEqual(binary[0], PROTOBUF_ROOT_FIELD_TAG);
+        });
+        it('encodes empty resourceSpans', () => {
+            const input = {
+                resourceSpans: [],
+            };
+            const binary = encodeTracesProtobuf(input);
+            assert.ok(binary instanceof Uint8Array);
+            // Empty message should be 0 bytes
+            assert.strictEqual(binary.length, 0);
+        });
+        it('encodes spans with events and attributes', () => {
+            const input = {
+                resourceSpans: [{
+                        resource: {
+                            attributes: [{ key: 'service.name', value: { stringValue: 'test' } }],
+                        },
+                        scopeSpans: [{
+                                scope: { name: 'test' },
+                                spans: [{
+                                        traceId: 'abcdef0123456789abcdef0123456789',
+                                        spanId: 'abcdef0123456789',
+                                        name: 'eval_export',
+                                        kind: 0,
+                                        startTimeUnixNano: '1705312800000000000',
+                                        endTimeUnixNano: '1705312801000000000',
+                                        status: { code: 1 },
+                                        attributes: [
+                                            { key: 'export.type', value: { stringValue: 'phoenix' } },
+                                            { key: 'export.count', value: { intValue: '3' } },
+                                        ],
+                                        events: [{
+                                                name: 'gen_ai.evaluation.result',
+                                                timeUnixNano: '1705312800500000000',
+                                                attributes: [
+                                                    { key: 'gen_ai.evaluation.name', value: { stringValue: 'relevance' } },
+                                                    { key: 'gen_ai.evaluation.score.value', value: { doubleValue: 0.85 } },
+                                                ],
+                                            }],
+                                    }],
+                            }],
+                    }],
+            };
+            const binary = encodeTracesProtobuf(input);
+            assert.ok(binary instanceof Uint8Array);
+            assert.ok(binary.length > 0);
+            assert.strictEqual(binary[0], PROTOBUF_ROOT_FIELD_TAG);
+        });
+        it('produces different binary for different inputs', () => {
+            const input1 = {
+                resourceSpans: [{
+                        resource: { attributes: [{ key: 'service.name', value: { stringValue: 'svc-a' } }] },
+                        scopeSpans: [{
+                                spans: [{
+                                        traceId: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1',
+                                        spanId: 'aaaaaaaaaaaaaaaa',
+                                        name: 'span-1',
+                                        kind: 0,
+                                        startTimeUnixNano: '1000000000',
+                                        endTimeUnixNano: '2000000000',
+                                    }],
+                            }],
+                    }],
+            };
+            const input2 = {
+                resourceSpans: [{
+                        resource: { attributes: [{ key: 'service.name', value: { stringValue: 'svc-b' } }] },
+                        scopeSpans: [{
+                                spans: [{
+                                        traceId: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+                                        spanId: 'bbbbbbbbbbbbbbbb',
+                                        name: 'span-2',
+                                        kind: 0,
+                                        startTimeUnixNano: '3000000000',
+                                        endTimeUnixNano: '4000000000',
+                                    }],
+                            }],
+                    }],
+            };
+            const binary1 = encodeTracesProtobuf(input1);
+            const binary2 = encodeTracesProtobuf(input2);
+            assert.notDeepStrictEqual(binary1, binary2);
+        });
+        it('roundtrip: binary decodes back to original trace/span IDs', () => {
+            const traceId = 'abcdef0123456789abcdef0123456789';
+            const spanId = 'abcdef0123456789';
+            const parentSpanId = '1234567890abcdef';
+            const input = {
+                resourceSpans: [{
+                        resource: {
+                            attributes: [{ key: 'service.name', value: { stringValue: 'roundtrip-svc' } }],
+                        },
+                        scopeSpans: [{
+                                scope: { name: 'roundtrip-scope', version: '1.0.0' },
+                                spans: [{
+                                        traceId,
+                                        spanId,
+                                        parentSpanId,
+                                        name: 'roundtrip-span',
+                                        kind: 1,
+                                        startTimeUnixNano: '1705312800000000000',
+                                        endTimeUnixNano: '1705312801000000000',
+                                        status: { code: 1 },
+                                        attributes: [{ key: 'test.attr', value: { stringValue: 'value' } }],
+                                    }],
+                            }],
+                    }],
+            };
+            const binary = encodeTracesProtobuf(input);
+            const decoded = fromBinary(ExportTraceServiceRequestSchema, binary);
+            assert.strictEqual(decoded.resourceSpans.length, 1);
+            const decodedSpan = decoded.resourceSpans[0].scopeSpans[0].spans[0];
+            // Verify IDs roundtrip through encode → binary → decode as bytes
+            // Proto bytes fields come back as Uint8Array; convert to hex for comparison
+            const toHex = (bytes) => Array.from(bytes).map(b => b.toString(HEX_RADIX).padStart(HEX_DIGITS_PER_BYTE, '0')).join('');
+            assert.ok(decodedSpan.traceId instanceof Uint8Array, 'traceId should be Uint8Array');
+            assert.ok(decodedSpan.spanId instanceof Uint8Array, 'spanId should be Uint8Array');
+            assert.ok(decodedSpan.parentSpanId instanceof Uint8Array, 'parentSpanId should be Uint8Array');
+            assert.strictEqual(toHex(decodedSpan.traceId), traceId);
+            assert.strictEqual(toHex(decodedSpan.spanId), spanId);
+            assert.strictEqual(toHex(decodedSpan.parentSpanId), parentSpanId);
+            assert.strictEqual(decodedSpan.name, 'roundtrip-span');
+        });
+    });
+    describe('convertLogHexIdsToBase64', () => {
+        it('converts traceId and spanId on log records', () => {
+            const input = {
+                resourceLogs: [{
+                        resource: { attributes: [] },
+                        scopeLogs: [{
+                                logRecords: [{
+                                        timeUnixNano: '1705312800000000000',
+                                        observedTimeUnixNano: '1705312800000000000',
+                                        traceId: 'abcdef0123456789abcdef0123456789',
+                                        spanId: 'abcdef0123456789',
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertLogHexIdsToBase64(input);
+            const lr = result.resourceLogs[0].scopeLogs[0].logRecords[0];
+            assert.strictEqual(b64ToHex(requireDefined(lr.traceId, 'Expected converted log traceId')), 'abcdef0123456789abcdef0123456789');
+            assert.strictEqual(b64ToHex(requireDefined(lr.spanId, 'Expected converted log spanId')), 'abcdef0123456789');
+        });
+        it('preserves log records without traceId/spanId', () => {
+            const input = {
+                resourceLogs: [{
+                        resource: { attributes: [] },
+                        scopeLogs: [{
+                                logRecords: [{
+                                        timeUnixNano: '1705312800000000000',
+                                        observedTimeUnixNano: '1705312800000000000',
+                                        severityText: 'INFO',
+                                        body: { stringValue: 'hello world' },
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertLogHexIdsToBase64(input);
+            const lr = result.resourceLogs[0].scopeLogs[0].logRecords[0];
+            assert.strictEqual(lr.traceId, undefined);
+            assert.strictEqual(lr.spanId, undefined);
+            assert.strictEqual(lr.severityText, 'INFO');
+            assert.strictEqual(lr.body?.stringValue, 'hello world');
+        });
+        it('treats empty-string traceId/spanId as absent', () => {
+            const input = {
+                resourceLogs: [{
+                        resource: { attributes: [] },
+                        scopeLogs: [{
+                                logRecords: [{
+                                        timeUnixNano: '1000000000',
+                                        observedTimeUnixNano: '1000000000',
+                                        traceId: '',
+                                        spanId: '',
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertLogHexIdsToBase64(input);
+            const lr = result.resourceLogs[0].scopeLogs[0].logRecords[0];
+            // Empty-string IDs are excluded from output (undefined), consistent with
+            // the trace path omitting absent parentSpanId. Prevents empty-bytes proto fields.
+            assert.strictEqual(lr.traceId, undefined);
+            assert.strictEqual(lr.spanId, undefined);
+        });
+        it('does not mutate input', () => {
+            const input = {
+                resourceLogs: [{
+                        resource: { attributes: [] },
+                        scopeLogs: [{
+                                logRecords: [{
+                                        timeUnixNano: '1000000000',
+                                        observedTimeUnixNano: '1000000000',
+                                        traceId: 'abcdef0123456789abcdef0123456789',
+                                        spanId: 'abcdef0123456789',
+                                    }],
+                            }],
+                    }],
+            };
+            convertLogHexIdsToBase64(input);
+            assert.strictEqual(input.resourceLogs[0].scopeLogs[0].logRecords[0].traceId, 'abcdef0123456789abcdef0123456789');
+        });
+    });
+    describe('encodeLogsProtobuf', () => {
+        it('encodes minimal log to valid protobuf binary', () => {
+            const input = {
+                resourceLogs: [{
+                        resource: {
+                            attributes: [{ key: 'service.name', value: { stringValue: 'test-service' } }],
+                        },
+                        scopeLogs: [{
+                                scope: { name: 'test-scope', version: '1.0.0' },
+                                logRecords: [{
+                                        timeUnixNano: '1705312800000000000',
+                                        observedTimeUnixNano: '1705312800000000000',
+                                        severityNumber: 9,
+                                        severityText: 'INFO',
+                                        body: { stringValue: 'test log message' },
+                                        attributes: [{ key: 'log.key', value: { stringValue: 'log-value' } }],
+                                    }],
+                            }],
+                    }],
+            };
+            const binary = encodeLogsProtobuf(input);
+            assert.ok(binary instanceof Uint8Array);
+            assert.ok(binary.length > 0);
+            // Protobuf field tag: field 1 (resourceLogs), wire type 2 (length-delimited) = 0x0a
+            assert.strictEqual(binary[0], PROTOBUF_ROOT_FIELD_TAG);
+        });
+        it('encodes empty resourceLogs', () => {
+            const input = {
+                resourceLogs: [],
+            };
+            const binary = encodeLogsProtobuf(input);
+            assert.ok(binary instanceof Uint8Array);
+            assert.strictEqual(binary.length, 0);
+        });
+        it('encodes log with trace correlation IDs', () => {
+            const input = {
+                resourceLogs: [{
+                        resource: {
+                            attributes: [{ key: 'service.name', value: { stringValue: 'test' } }],
+                        },
+                        scopeLogs: [{
+                                logRecords: [{
+                                        timeUnixNano: '1705312800000000000',
+                                        observedTimeUnixNano: '1705312800000000000',
+                                        severityNumber: 17,
+                                        severityText: 'ERROR',
+                                        body: { stringValue: 'something went wrong' },
+                                        traceId: 'abcdef0123456789abcdef0123456789',
+                                        spanId: 'abcdef0123456789',
+                                    }],
+                            }],
+                    }],
+            };
+            const binary = encodeLogsProtobuf(input);
+            assert.ok(binary instanceof Uint8Array);
+            assert.ok(binary.length > 0);
+            assert.strictEqual(binary[0], PROTOBUF_ROOT_FIELD_TAG);
+        });
+        it('produces different binary for different inputs', () => {
+            const input1 = {
+                resourceLogs: [{
+                        resource: { attributes: [{ key: 'service.name', value: { stringValue: 'svc-a' } }] },
+                        scopeLogs: [{
+                                logRecords: [{
+                                        timeUnixNano: '1000000000',
+                                        observedTimeUnixNano: '1000000000',
+                                        body: { stringValue: 'message-a' },
+                                    }],
+                            }],
+                    }],
+            };
+            const input2 = {
+                resourceLogs: [{
+                        resource: { attributes: [{ key: 'service.name', value: { stringValue: 'svc-b' } }] },
+                        scopeLogs: [{
+                                logRecords: [{
+                                        timeUnixNano: '2000000000',
+                                        observedTimeUnixNano: '2000000000',
+                                        body: { stringValue: 'message-b' },
+                                    }],
+                            }],
+                    }],
+            };
+            const binary1 = encodeLogsProtobuf(input1);
+            const binary2 = encodeLogsProtobuf(input2);
+            assert.notDeepStrictEqual(binary1, binary2);
+        });
+        it('roundtrip: binary decodes back to original log trace/span IDs', () => {
+            const traceId = 'abcdef0123456789abcdef0123456789';
+            const spanId = 'abcdef0123456789';
+            const input = {
+                resourceLogs: [{
+                        resource: {
+                            attributes: [{ key: 'service.name', value: { stringValue: 'roundtrip-svc' } }],
+                        },
+                        scopeLogs: [{
+                                scope: { name: 'roundtrip-scope', version: '1.0.0' },
+                                logRecords: [{
+                                        timeUnixNano: '1705312800000000000',
+                                        observedTimeUnixNano: '1705312800000000000',
+                                        traceId,
+                                        spanId,
+                                        severityNumber: 9,
+                                        severityText: 'INFO',
+                                        body: { stringValue: 'roundtrip log message' },
+                                    }],
+                            }],
+                    }],
+            };
+            const binary = encodeLogsProtobuf(input);
+            assert.ok(binary instanceof Uint8Array, 'encodeLogsProtobuf should return Uint8Array');
+            assert.ok(binary.length > 0, 'encoded binary should be non-empty');
+            const decoded = fromBinary(ExportLogsServiceRequestSchema, binary);
+            assert.strictEqual(decoded.resourceLogs.length, 1);
+            const decodedRecord = decoded.resourceLogs[0].scopeLogs[0].logRecords[0];
+            // Verify IDs roundtrip through encode → binary → decode as bytes
+            const toHex = (bytes) => Array.from(bytes, b => b.toString(HEX_RADIX).padStart(HEX_DIGITS_PER_BYTE, '0')).join('');
+            assert.ok(decodedRecord.traceId instanceof Uint8Array, 'traceId should be Uint8Array');
+            assert.ok(decodedRecord.spanId instanceof Uint8Array, 'spanId should be Uint8Array');
+            assert.strictEqual(toHex(decodedRecord.traceId), traceId);
+            assert.strictEqual(toHex(decodedRecord.spanId), spanId);
+        });
+    });
+    describe('convertMetricHexIdsToBase64', () => {
+        it('converts exemplar traceId/spanId in gauge data points', () => {
+            const input = {
+                resourceMetrics: [{
+                        resource: { attributes: [{ key: 'service.name', value: { stringValue: 'test' } }] },
+                        scopeMetrics: [{
+                                metrics: [{
+                                        name: 'requests',
+                                        gauge: {
+                                            dataPoints: [{
+                                                    timeUnixNano: '1705312800000000000',
+                                                    asDouble: 42,
+                                                    exemplars: [{
+                                                            timeUnixNano: '1705312800000000000',
+                                                            asDouble: 1,
+                                                            traceId: 'abcdef0123456789abcdef0123456789',
+                                                            spanId: 'abcdef0123456789',
+                                                        }],
+                                                }],
+                                        },
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertMetricHexIdsToBase64(input);
+            const metric = result.resourceMetrics[0].scopeMetrics[0].metrics[0];
+            const gauge = requireDefined(metric.gauge, 'Expected gauge metric');
+            const exemplar = requireDefined(gauge.dataPoints[0]?.exemplars?.[0], 'Expected gauge exemplar');
+            assert.strictEqual(b64ToHex(requireDefined(exemplar.traceId, 'Expected exemplar traceId')), 'abcdef0123456789abcdef0123456789');
+            assert.strictEqual(b64ToHex(requireDefined(exemplar.spanId, 'Expected exemplar spanId')), 'abcdef0123456789');
+        });
+        it('omits empty-string exemplar IDs', () => {
+            const input = {
+                resourceMetrics: [{
+                        resource: { attributes: [] },
+                        scopeMetrics: [{
+                                metrics: [{
+                                        name: 'metric',
+                                        gauge: {
+                                            dataPoints: [{
+                                                    timeUnixNano: '1000000000',
+                                                    asDouble: 1,
+                                                    exemplars: [{
+                                                            timeUnixNano: '1000000000',
+                                                            asDouble: 1,
+                                                            traceId: '',
+                                                            spanId: '',
+                                                        }],
+                                                }],
+                                        },
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertMetricHexIdsToBase64(input);
+            const metric = result.resourceMetrics[0].scopeMetrics[0].metrics[0];
+            const gauge = requireDefined(metric.gauge, 'Expected gauge metric');
+            const exemplar = requireDefined(gauge.dataPoints[0]?.exemplars?.[0], 'Expected gauge exemplar');
+            assert.strictEqual(exemplar.traceId, undefined);
+            assert.strictEqual(exemplar.spanId, undefined);
+        });
+        it('converts exemplar traceId/spanId in sum data points', () => {
+            const input = {
+                resourceMetrics: [{
+                        resource: { attributes: [] },
+                        scopeMetrics: [{
+                                metrics: [{
+                                        name: 'errors',
+                                        sum: {
+                                            aggregationTemporality: 1,
+                                            isMonotonic: true,
+                                            dataPoints: [{
+                                                    timeUnixNano: '1705312800000000000',
+                                                    asDouble: 3,
+                                                    exemplars: [{
+                                                            timeUnixNano: '1705312800000000000',
+                                                            asDouble: 1,
+                                                            traceId: 'abcdef0123456789abcdef0123456789',
+                                                            spanId: 'abcdef0123456789',
+                                                        }],
+                                                }],
+                                        },
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertMetricHexIdsToBase64(input);
+            const metric = result.resourceMetrics[0].scopeMetrics[0].metrics[0];
+            const sum = requireDefined(metric.sum, 'Expected sum metric');
+            const exemplar = requireDefined(sum.dataPoints[0]?.exemplars?.[0], 'Expected sum exemplar');
+            assert.strictEqual(b64ToHex(requireDefined(exemplar.traceId, 'Expected exemplar traceId')), 'abcdef0123456789abcdef0123456789');
+        });
+        it('converts exemplar traceId/spanId in histogram data points', () => {
+            const input = {
+                resourceMetrics: [{
+                        resource: { attributes: [] },
+                        scopeMetrics: [{
+                                metrics: [{
+                                        name: 'latency',
+                                        histogram: {
+                                            aggregationTemporality: 2,
+                                            dataPoints: [{
+                                                    timeUnixNano: '1705312800000000000',
+                                                    count: '5',
+                                                    sum: 500,
+                                                    bucketCounts: ['2', '3'],
+                                                    explicitBounds: [HISTOGRAM_BOUND_MS_FAST],
+                                                    exemplars: [{
+                                                            timeUnixNano: '1705312800000000000',
+                                                            asDouble: 42,
+                                                            traceId: 'abcdef0123456789abcdef0123456789',
+                                                            spanId: 'abcdef0123456789',
+                                                        }],
+                                                }],
+                                        },
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertMetricHexIdsToBase64(input);
+            const metric = result.resourceMetrics[0].scopeMetrics[0].metrics[0];
+            const histogram = requireDefined(metric.histogram, 'Expected histogram metric');
+            const exemplar = requireDefined(histogram.dataPoints[0]?.exemplars?.[0], 'Expected histogram exemplar');
+            assert.strictEqual(b64ToHex(requireDefined(exemplar.traceId, 'Expected exemplar traceId')), 'abcdef0123456789abcdef0123456789');
+        });
+        it('does not mutate input', () => {
+            const traceId = 'abcdef0123456789abcdef0123456789';
+            const input = {
+                resourceMetrics: [{
+                        resource: { attributes: [] },
+                        scopeMetrics: [{
+                                metrics: [{
+                                        name: 'metric',
+                                        gauge: {
+                                            dataPoints: [{
+                                                    timeUnixNano: '1000000000',
+                                                    asDouble: 1,
+                                                    exemplars: [{ timeUnixNano: '1000000000', asDouble: 1, traceId }],
+                                                }],
+                                        },
+                                    }],
+                            }],
+                    }],
+            };
+            convertMetricHexIdsToBase64(input);
+            const metric = input.resourceMetrics[0].scopeMetrics[0].metrics[0];
+            const gauge = requireDefined(metric.gauge, 'Expected input gauge metric');
+            const exemplar = requireDefined(gauge.dataPoints[0]?.exemplars?.[0], 'Expected input exemplar');
+            assert.strictEqual(exemplar.traceId, traceId);
+        });
+    });
+    describe('encodeMetricsProtobuf', () => {
+        it('encodes minimal gauge metric to valid protobuf binary', () => {
+            const input = {
+                resourceMetrics: [{
+                        resource: {
+                            attributes: [{ key: 'service.name', value: { stringValue: 'test-service' } }],
+                        },
+                        scopeMetrics: [{
+                                scope: { name: 'test-scope', version: '1.0.0' },
+                                metrics: [{
+                                        name: 'http.requests',
+                                        gauge: {
+                                            dataPoints: [{
+                                                    timeUnixNano: '1705312800000000000',
+                                                    asDouble: 100,
+                                                    attributes: [{ key: 'method', value: { stringValue: 'GET' } }],
+                                                }],
+                                        },
+                                    }],
+                            }],
+                    }],
+            };
+            const binary = encodeMetricsProtobuf(input);
+            assert.ok(binary instanceof Uint8Array);
+            assert.ok(binary.length > 0);
+            // Protobuf field tag: field 1 (resourceMetrics), wire type 2 (length-delimited) = 0x0a
+            assert.strictEqual(binary[0], PROTOBUF_ROOT_FIELD_TAG);
+        });
+        it('encodes empty resourceMetrics', () => {
+            const input = { resourceMetrics: [] };
+            const binary = encodeMetricsProtobuf(input);
+            assert.ok(binary instanceof Uint8Array);
+            assert.strictEqual(binary.length, 0);
+        });
+        it('encodes histogram metric', () => {
+            const input = {
+                resourceMetrics: [{
+                        resource: { attributes: [{ key: 'service.name', value: { stringValue: 'svc' } }] },
+                        scopeMetrics: [{
+                                metrics: [{
+                                        name: 'request.duration',
+                                        histogram: {
+                                            aggregationTemporality: 2,
+                                            dataPoints: [{
+                                                    timeUnixNano: '1705312800000000000',
+                                                    count: '10',
+                                                    sum: 1500,
+                                                    bucketCounts: ['2', '5', '3'],
+                                                    explicitBounds: [HISTOGRAM_BOUND_MS_FAST, HISTOGRAM_BOUND_MS_MODERATE],
+                                                }],
+                                        },
+                                    }],
+                            }],
+                    }],
+            };
+            const binary = encodeMetricsProtobuf(input);
+            assert.ok(binary instanceof Uint8Array);
+            assert.ok(binary.length > 0);
+            assert.strictEqual(binary[0], PROTOBUF_ROOT_FIELD_TAG);
+        });
+        it('encodes metric with exemplar trace IDs', () => {
+            const input = {
+                resourceMetrics: [{
+                        resource: { attributes: [{ key: 'service.name', value: { stringValue: 'svc' } }] },
+                        scopeMetrics: [{
+                                metrics: [{
+                                        name: 'errors',
+                                        sum: {
+                                            aggregationTemporality: 1,
+                                            isMonotonic: true,
+                                            dataPoints: [{
+                                                    timeUnixNano: '1705312800000000000',
+                                                    asDouble: 3,
+                                                    exemplars: [{
+                                                            timeUnixNano: '1705312800000000000',
+                                                            asDouble: 1,
+                                                            traceId: 'abcdef0123456789abcdef0123456789',
+                                                            spanId: 'abcdef0123456789',
+                                                        }],
+                                                }],
+                                        },
+                                    }],
+                            }],
+                    }],
+            };
+            const binary = encodeMetricsProtobuf(input);
+            assert.ok(binary instanceof Uint8Array);
+            assert.ok(binary.length > 0);
+            assert.strictEqual(binary[0], PROTOBUF_ROOT_FIELD_TAG);
+        });
+        it('produces different binary for different inputs', () => {
+            const input1 = {
+                resourceMetrics: [{
+                        resource: { attributes: [{ key: 'service.name', value: { stringValue: 'svc-a' } }] },
+                        scopeMetrics: [{ metrics: [{ name: 'metric.a', gauge: { dataPoints: [{ timeUnixNano: '1000', asDouble: 1 }] } }] }],
+                    }],
+            };
+            const input2 = {
+                resourceMetrics: [{
+                        resource: { attributes: [{ key: 'service.name', value: { stringValue: 'svc-b' } }] },
+                        scopeMetrics: [{ metrics: [{ name: 'metric.b', gauge: { dataPoints: [{ timeUnixNano: '2000', asDouble: 2 }] } }] }],
+                    }],
+            };
+            assert.notDeepStrictEqual(encodeMetricsProtobuf(input1), encodeMetricsProtobuf(input2));
+        });
+        it('preserves metrics without exemplars', () => {
+            const input = {
+                resourceMetrics: [{
+                        resource: { attributes: [] },
+                        scopeMetrics: [{
+                                metrics: [{
+                                        name: 'requests',
+                                        gauge: {
+                                            dataPoints: [{
+                                                    timeUnixNano: '1705312800000000000',
+                                                    asDouble: 42,
+                                                }],
+                                        },
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertMetricHexIdsToBase64(input);
+            const metric = result.resourceMetrics[0].scopeMetrics[0].metrics[0];
+            const gauge = requireDefined(metric.gauge, 'Expected gauge metric');
+            assert.ok(gauge.dataPoints[0]);
+            assert.strictEqual(gauge.dataPoints[0]?.exemplars, undefined);
+        });
+        it('handles log records with only traceId (no spanId)', () => {
+            const input = {
+                resourceLogs: [{
+                        resource: { attributes: [] },
+                        scopeLogs: [{
+                                logRecords: [{
+                                        timeUnixNano: '1705312800000000000',
+                                        observedTimeUnixNano: '1705312800000000000',
+                                        traceId: 'abcdef0123456789abcdef0123456789',
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertLogHexIdsToBase64(input);
+            const lr = result.resourceLogs[0].scopeLogs[0].logRecords[0];
+            assert.ok(lr.traceId);
+            assert.strictEqual(lr.spanId, undefined);
+            assert.strictEqual(b64ToHex(requireDefined(lr.traceId, 'Expected traceId')), 'abcdef0123456789abcdef0123456789');
+        });
+        it('handles log records with only spanId (no traceId)', () => {
+            const input = {
+                resourceLogs: [{
+                        resource: { attributes: [] },
+                        scopeLogs: [{
+                                logRecords: [{
+                                        timeUnixNano: '1705312800000000000',
+                                        observedTimeUnixNano: '1705312800000000000',
+                                        spanId: 'abcdef0123456789',
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertLogHexIdsToBase64(input);
+            const lr = result.resourceLogs[0].scopeLogs[0].logRecords[0];
+            assert.strictEqual(lr.traceId, undefined);
+            assert.ok(lr.spanId);
+            assert.strictEqual(b64ToHex(requireDefined(lr.spanId, 'Expected spanId')), 'abcdef0123456789');
+        });
+        it('encodeLogsProtobuf roundtrip with multiple records', () => {
+            const toHex = (bytes) => Array.from(bytes).map(b => b.toString(HEX_RADIX).padStart(HEX_DIGITS_PER_BYTE, '0')).join('');
+            const traceId = 'abcdef0123456789abcdef0123456789';
+            const spanId = '0123456789abcdef';
+            const input = {
+                resourceLogs: [{
+                        resource: { attributes: [{ key: 'service.name', value: { stringValue: 'test-svc' } }] },
+                        scopeLogs: [{
+                                logRecords: [
+                                    {
+                                        timeUnixNano: '1705312800000000000',
+                                        observedTimeUnixNano: '1705312800000000000',
+                                        traceId,
+                                        spanId,
+                                        severityText: 'ERROR',
+                                        body: { stringValue: 'first error' },
+                                    },
+                                    {
+                                        timeUnixNano: '1705312801000000000',
+                                        observedTimeUnixNano: '1705312801000000000',
+                                        severityText: 'INFO',
+                                        body: { stringValue: 'info log' },
+                                    },
+                                ],
+                            }],
+                    }],
+            };
+            const binary = encodeLogsProtobuf(input);
+            const decoded = fromBinary(ExportLogsServiceRequestSchema, binary);
+            assert.strictEqual(decoded.resourceLogs?.length, 1);
+            const rl = requireDefined(decoded.resourceLogs?.[0], 'Expected resourceLogs[0]');
+            assert.strictEqual(rl.scopeLogs?.length, 1);
+            const sl = requireDefined(rl.scopeLogs?.[0], 'Expected scopeLogs[0]');
+            assert.strictEqual(sl.logRecords?.length, 2);
+            const record1 = requireDefined(sl.logRecords?.[0], 'Expected logRecords[0]');
+            assert.strictEqual(toHex(record1.traceId), traceId);
+            assert.strictEqual(toHex(record1.spanId), spanId);
+            const record2 = requireDefined(sl.logRecords?.[1], 'Expected logRecords[1]');
+            // Proto3 bytes fields default to empty Uint8Array when absent, never undefined
+            assert.deepStrictEqual(record2.traceId, new Uint8Array(0));
+            assert.deepStrictEqual(record2.spanId, new Uint8Array(0));
+        });
+        it('convertMetricHexIdsToBase64 with no exemplars in data points', () => {
+            const input = {
+                resourceMetrics: [{
+                        resource: { attributes: [] },
+                        scopeMetrics: [{
+                                metrics: [{
+                                        name: 'metric',
+                                        sum: {
+                                            aggregationTemporality: 1,
+                                            isMonotonic: true,
+                                            dataPoints: [{
+                                                    timeUnixNano: '1705312800000000000',
+                                                    asDouble: 10,
+                                                }],
+                                        },
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertMetricHexIdsToBase64(input);
+            const metric = result.resourceMetrics[0].scopeMetrics[0].metrics[0];
+            const sum = requireDefined(metric.sum, 'Expected sum metric');
+            assert.strictEqual(sum.dataPoints[0]?.exemplars, undefined);
+        });
+        it('convertMetricHexIdsToBase64 handles exemplar without IDs', () => {
+            const input = {
+                resourceMetrics: [{
+                        resource: { attributes: [] },
+                        scopeMetrics: [{
+                                metrics: [{
+                                        name: 'metric',
+                                        histogram: {
+                                            aggregationTemporality: 1,
+                                            dataPoints: [{
+                                                    timeUnixNano: '1705312800000000000',
+                                                    count: '5',
+                                                    sum: 100,
+                                                    bucketCounts: ['2', '3'],
+                                                    explicitBounds: [50],
+                                                    exemplars: [{
+                                                            timeUnixNano: '1705312800000000000',
+                                                            asDouble: 20,
+                                                        }],
+                                                }],
+                                        },
+                                    }],
+                            }],
+                    }],
+            };
+            const result = convertMetricHexIdsToBase64(input);
+            const metric = result.resourceMetrics[0].scopeMetrics[0].metrics[0];
+            const histogram = requireDefined(metric.histogram, 'Expected histogram metric');
+            const exemplar = requireDefined(histogram.dataPoints[0]?.exemplars?.[0], 'Expected exemplar');
+            assert.strictEqual(exemplar.traceId, undefined);
+            assert.strictEqual(exemplar.spanId, undefined);
+        });
+        it('encodeMetricsProtobuf handles empty resourceMetrics', () => {
+            const input = {
+                resourceMetrics: [],
+            };
+            const binary = encodeMetricsProtobuf(input);
+            assert.ok(binary instanceof Uint8Array);
+            // Empty metric export produces minimal binary
+            assert.ok(binary.length >= 0);
+        });
+        it('encodeLogsProtobuf handles empty logs array', () => {
+            const input = {
+                resourceLogs: [{
+                        resource: { attributes: [] },
+                        scopeLogs: [{
+                                logRecords: [],
+                            }],
+                    }],
+            };
+            const binary = encodeLogsProtobuf(input);
+            const decoded = fromBinary(ExportLogsServiceRequestSchema, binary);
+            assert.strictEqual(decoded.resourceLogs?.[0]?.scopeLogs?.[0]?.logRecords?.length, 0);
+        });
+    });
+});
+//# sourceMappingURL=otlp-proto-encode.test.js.map