otelturbine 0.1.0

package/src/tests/pipeline.test.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { Pipeline } from '../core/Pipeline.ts';
+import { compileSchemas } from '../transform/SchemaEngine.ts';
+
+const validOtlpPayload = JSON.stringify({
+  resourceMetrics: [
+    {
+      resource: {},
+      scopeMetrics: [
+        {
+          metrics: [
+            {
+              name: 'test_metric',
+              gauge: {
+                dataPoints: [
+                  {
+                    timeUnixNano: '1700000000000000000',
+                    asDouble: 42.0,
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+    },
+  ],
+});
+
+const emptyOtlpPayload = JSON.stringify({
+  resourceMetrics: [],
+});
+
+describe('Pipeline', () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  function makePipeline(defaultAction: 'pass' | 'drop' = 'pass') {
+    return new Pipeline(
+      { url: 'http://localhost:9090/api/v1/write', timeout: 5000 },
+      [],
+      defaultAction
+    );
+  }
+
+  it('returns 415 for application/x-protobuf content type', async () => {
+    const pipeline = makePipeline();
+    const result = await pipeline.process('', 'application/x-protobuf');
+    expect(result.status).toBe(415);
+  });
+
+  it('returns 415 for unsupported content types', async () => {
+    const pipeline = makePipeline();
+    const result = await pipeline.process('', 'text/plain');
+    expect(result.status).toBe(415);
+  });
+
+  it('returns 400 for invalid JSON', async () => {
+    const pipeline = makePipeline();
+    const result = await pipeline.process('not json at all {{{', 'application/json');
+    expect(result.status).toBe(400);
+  });
+
+  it('returns 400 for valid JSON without resourceMetrics', async () => {
+    const pipeline = makePipeline();
+    const result = await pipeline.process('{"foo": "bar"}', 'application/json');
+    expect(result.status).toBe(400);
+  });
+
+  it('returns 204 for empty resourceMetrics', async () => {
+    const pipeline = makePipeline();
+    const result = await pipeline.process(emptyOtlpPayload, 'application/json');
+    expect(result.status).toBe(204);
+  });
+
+  it('returns 204 when all metrics are dropped', async () => {
+    const pipeline = new Pipeline(
+      { url: 'http://localhost:9090/api/v1/write', timeout: 5000 },
+      [],
+      'drop'
+    );
+    const result = await pipeline.process(validOtlpPayload, 'application/json');
+    expect(result.status).toBe(204);
+  });
+
+  it('returns 200 on successful remote write', async () => {
+    globalThis.fetch = mock(async () => new Response(null, { status: 204 })) as unknown as typeof fetch;
+    const pipeline = makePipeline();
+    const result = await pipeline.process(validOtlpPayload, 'application/json');
+    expect(result.status).toBe(200);
+  });
+
+  it('returns 502 when remote write fails with non-2xx', async () => {
+    globalThis.fetch = mock(async () => new Response('Internal Server Error', { status: 500 })) as unknown as typeof fetch;
+    const pipeline = makePipeline();
+    const result = await pipeline.process(validOtlpPayload, 'application/json');
+    expect(result.status).toBe(502);
+    expect(result.message).toContain('500');
+  });
+
+  it('returns 502 when remote write throws (network error)', async () => {
+    globalThis.fetch = mock(async () => { throw new Error('Connection refused'); }) as unknown as typeof fetch;
+    const pipeline = makePipeline();
+    const result = await pipeline.process(validOtlpPayload, 'application/json');
+    expect(result.status).toBe(502);
+    expect(result.message).toContain('Connection refused');
+  });
+
+  it('accepts content-type with charset parameter', async () => {
+    globalThis.fetch = mock(async () => new Response(null, { status: 204 })) as unknown as typeof fetch;
+    const pipeline = makePipeline();
+    const result = await pipeline.process(validOtlpPayload, 'application/json; charset=utf-8');
+    expect(result.status).toBe(200);
+  });
+
+  it('applies schemas before sending', async () => {
+    let capturedBody: Uint8Array | undefined;
+    globalThis.fetch = mock(async (_: Request, init: RequestInit) => {
+      capturedBody = init.body as Uint8Array;
+      return new Response(null, { status: 204 });
+    }) as unknown as typeof fetch;
+
+    const schemas = compileSchemas([{ name: 'test_metric' }]);
+    const pipeline = new Pipeline(
+      { url: 'http://localhost:9090/api/v1/write', timeout: 5000 },
+      schemas,
+      'drop'
+    );
+    const result = await pipeline.process(validOtlpPayload, 'application/json');
+    expect(result.status).toBe(200);
+    expect(capturedBody).toBeDefined();
+  });
+});

package/src/tests/proto.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect } from 'bun:test';
+import { encodeWriteRequest } from '../proto/writeRequest.ts';
+import type { WriteRequest, TimeSeries } from '../types/prometheus.ts';
+
+describe('protobuf encoding', () => {
+  it('encodes an empty WriteRequest', () => {
+    const req: WriteRequest = { timeseries: [] };
+    const encoded = encodeWriteRequest(req);
+    expect(encoded).toBeInstanceOf(Uint8Array);
+    expect(encoded.length).toBe(0);
+  });
+
+  it('encodes a single TimeSeries with one label and one sample', () => {
+    const req: WriteRequest = {
+      timeseries: [
+        {
+          labels: [
+            { name: '__name__', value: 'test_metric' },
+          ],
+          samples: [
+            { value: 42.0, timestamp: 1000n },
+          ],
+        },
+      ],
+    };
+    const encoded = encodeWriteRequest(req);
+    expect(encoded).toBeInstanceOf(Uint8Array);
+    expect(encoded.length).toBeGreaterThan(0);
+    // Field tag 0x0A = timeseries field 1
+    expect(encoded[0]).toBe(0x0a);
+  });
+
+  it('produces non-zero output for valid series', () => {
+    const ts: TimeSeries = {
+      labels: [
+        { name: '__name__', value: 'http_requests_total' },
+        { name: 'method', value: 'GET' },
+        { name: 'status', value: '200' },
+      ],
+      samples: [
+        { value: 1234.5, timestamp: 1700000000000n },
+      ],
+    };
+    const encoded = encodeWriteRequest({ timeseries: [ts] });
+    expect(encoded.length).toBeGreaterThan(20);
+  });
+
+  it('double value is encoded as 8 bytes LE', () => {
+    // Encode a known double: 1.0
+    const req: WriteRequest = {
+      timeseries: [
+        {
+          labels: [{ name: 'n', value: 'v' }],
+          samples: [{ value: 1.0, timestamp: 0n }],
+        },
+      ],
+    };
+    const encoded = encodeWriteRequest(req);
+    // Find the double bytes for 1.0: 3F F0 00 00 00 00 00 00 in BE, reversed for LE
+    const buf = Buffer.from(encoded);
+    // Search for 0x3F 0xF0 sequence (last 6 bytes would be 00s)
+    let found = false;
+    for (let i = 0; i < buf.length - 7; i++) {
+      if (buf[i + 7] === 0x3f && buf[i + 6] === 0xf0) {
+        found = true;
+        break;
+      }
+    }
+    expect(found).toBe(true);
+  });
+
+  it('encodes multiple time series', () => {
+    const series: TimeSeries[] = Array.from({ length: 5 }, (_, i) => ({
+      labels: [{ name: '__name__', value: `metric_${i}` }],
+      samples: [{ value: i * 10.0, timestamp: BigInt(i * 1000) }],
+    }));
+    const encoded = encodeWriteRequest({ timeseries: series });
+    expect(encoded.length).toBeGreaterThan(0);
+    // Should have 5 repeated field 1 entries (each starting with 0x0A)
+    let count = 0;
+    // Count top-level 0x0A bytes (approximation)
+    let i = 0;
+    while (i < encoded.length) {
+      const tag = encoded[i]!;
+      i++;
+      if (tag === 0x0a) {
+        count++;
+        // Read length varint
+        let len = 0;
+        let shift = 0;
+        while (i < encoded.length) {
+          const b = encoded[i++]!;
+          len |= (b & 0x7f) << shift;
+          shift += 7;
+          if ((b & 0x80) === 0) break;
+        }
+        i += len;
+      }
+    }
+    expect(count).toBe(5);
+  });
+});

package/src/tests/schemaEngine.test.ts

@@ -0,0 +1,222 @@
+import { describe, it, expect } from 'bun:test';
+import { compileSchemas, applySchemas } from '../transform/SchemaEngine.ts';
+import type { TimeSeries } from '../types/prometheus.ts';
+import type { MetricSchema } from '../types/schema.ts';
+
+function makeSeries(name: string, labels: Record<string, string> = {}): TimeSeries {
+  const allLabels = [
+    { name: '__name__', value: name },
+    ...Object.entries(labels).map(([k, v]) => ({ name: k, value: v })),
+  ].sort((a, b) => a.name.localeCompare(b.name));
+  return {
+    labels: allLabels,
+    samples: [{ value: 1.0, timestamp: 1000n }],
+  };
+}
+
+describe('SchemaEngine', () => {
+  describe('name matching', () => {
+    it('matches exact string name', () => {
+      const schemas = compileSchemas([{ name: 'cpu_usage' }]);
+      const series = [makeSeries('cpu_usage'), makeSeries('mem_usage')];
+      const result = applySchemas(series, schemas, 'drop');
+      expect(result).toHaveLength(1);
+      expect(result[0]!.labels.find(l => l.name === '__name__')?.value).toBe('cpu_usage');
+    });
+
+    it('matches regexp name', () => {
+      const schemas = compileSchemas([{ name: /^http_/ }]);
+      const series = [
+        makeSeries('http_requests_total'),
+        makeSeries('http_errors_total'),
+        makeSeries('grpc_requests_total'),
+      ];
+      const result = applySchemas(series, schemas, 'drop');
+      expect(result).toHaveLength(2);
+    });
+
+    it('first matching schema wins', () => {
+      const schemas: MetricSchema[] = [
+        { name: /^http_/, inject: { matched: 'first' } },
+        { name: /^http_requests/, inject: { matched: 'second' } },
+      ];
+      const compiled = compileSchemas(schemas);
+      const series = [makeSeries('http_requests_total', { method: 'GET' })];
+      const result = applySchemas(series, compiled, 'drop');
+      expect(result[0]!.labels.find(l => l.name === 'matched')?.value).toBe('first');
+    });
+  });
+
+  describe('defaultAction', () => {
+    it('passes through unmatched metrics when defaultAction=pass', () => {
+      const schemas = compileSchemas([{ name: 'cpu_usage' }]);
+      const series = [makeSeries('mem_usage')];
+      const result = applySchemas(series, schemas, 'pass');
+      expect(result).toHaveLength(1);
+    });
+
+    it('drops unmatched metrics when defaultAction=drop', () => {
+      const schemas = compileSchemas([{ name: 'cpu_usage' }]);
+      const series = [makeSeries('mem_usage')];
+      const result = applySchemas(series, schemas, 'drop');
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  describe('explicit label matching', () => {
+    it('keeps series when explicit label matches', () => {
+      const schemas = compileSchemas([
+        { name: 'http_req', labels: { method: /^GET$/ } },
+      ]);
+      const series = [makeSeries('http_req', { method: 'GET', status: '200' })];
+      const result = applySchemas(series, schemas, 'drop');
+      expect(result).toHaveLength(1);
+    });
+
+    it('drops series when explicit label value does not match', () => {
+      const schemas = compileSchemas([
+        { name: 'http_req', labels: { method: /^GET$/ } },
+      ]);
+      const series = [makeSeries('http_req', { method: 'POST' })];
+      const result = applySchemas(series, schemas, 'drop');
+      expect(result).toHaveLength(0);
+    });
+
+    it('drops series when required explicit label is missing', () => {
+      const schemas = compileSchemas([
+        { name: 'http_req', labels: { method: /^GET$/ } },
+      ]);
+      const series = [makeSeries('http_req', { status: '200' })];
+      const result = applySchemas(series, schemas, 'drop');
+      expect(result).toHaveLength(0);
+    });
+
+    it('drops unlisted labels when no wildcard', () => {
+      const schemas = compileSchemas([
+        { name: 'http_req', labels: { method: /^GET$/ } },
+      ]);
+      const series = [makeSeries('http_req', { method: 'GET', status: '200', extra: 'val' })];
+      const result = applySchemas(series, schemas, 'drop');
+      expect(result).toHaveLength(1);
+      const labelNames = result[0]!.labels.map(l => l.name);
+      expect(labelNames).toContain('__name__');
+      expect(labelNames).toContain('method');
+      expect(labelNames).not.toContain('status');
+      expect(labelNames).not.toContain('extra');
+    });
+  });
+
+  describe('wildcard label matching', () => {
+    it('keeps unlisted labels when wildcard matches', () => {
+      const schemas = compileSchemas([
+        {
+          name: 'http_req',
+          labels: {
+            method: /^GET$/,
+            '*': /.*/,
+          },
+        },
+      ]);
+      const series = [makeSeries('http_req', { method: 'GET', status: '200', host: 'api.example.com' })];
+      const result = applySchemas(series, schemas, 'drop');
+      expect(result).toHaveLength(1);
+      const labelNames = result[0]!.labels.map(l => l.name);
+      expect(labelNames).toContain('status');
+      expect(labelNames).toContain('host');
+    });
+
+    it('drops unlisted labels when wildcard value does not match', () => {
+      // Wildcard matches label VALUES, not names
+      // labels: { a: 'allowed_val', b: 'blocked_val' }
+      // wildcard /^allowed_/ → keep 'a' (value matches), drop 'b' (value doesn't)
+      const schemas = compileSchemas([
+        {
+          name: 'http_req',
+          labels: {
+            '*': /^allowed_/,
+          },
+        },
+      ]);
+      const series = [makeSeries('http_req', { a: 'allowed_val', b: 'blocked_val' })];
+      const result = applySchemas(series, schemas, 'drop');
+      const labelNames = result[0]!.labels.map(l => l.name);
+      expect(labelNames).toContain('a');
+      expect(labelNames).not.toContain('b');
+    });
+  });
+
+  describe('inject', () => {
+    it('adds new labels via inject', () => {
+      const schemas = compileSchemas([
+        { name: 'test_metric', inject: { env: 'prod', region: 'us-east' } },
+      ]);
+      const series = [makeSeries('test_metric')];
+      const result = applySchemas(series, schemas, 'drop');
+      expect(result[0]!.labels.find(l => l.name === 'env')?.value).toBe('prod');
+      expect(result[0]!.labels.find(l => l.name === 'region')?.value).toBe('us-east');
+    });
+
+    it('overrides existing labels via inject', () => {
+      const schemas = compileSchemas([
+        {
+          name: 'test_metric',
+          labels: { env: /.*/ },
+          inject: { env: 'overridden' },
+        },
+      ]);
+      const series = [makeSeries('test_metric', { env: 'original' })];
+      const result = applySchemas(series, schemas, 'drop');
+      expect(result[0]!.labels.find(l => l.name === 'env')?.value).toBe('overridden');
+    });
+
+    it('inject does not cause series drop', () => {
+      const schemas = compileSchemas([
+        { name: 'test_metric', inject: { always: 'here' } },
+      ]);
+      const series = [makeSeries('test_metric')];
+      const result = applySchemas(series, schemas, 'drop');
+      expect(result).toHaveLength(1);
+    });
+  });
+
+  describe('maxLabels', () => {
+    it('caps total labels excluding __name__', () => {
+      const schemas = compileSchemas([
+        {
+          name: 'test_metric',
+          labels: { '*': /.*/ },
+          maxLabels: 2,
+        },
+      ]);
+      const series = [makeSeries('test_metric', { a: '1', b: '2', c: '3', d: '4' })];
+      const result = applySchemas(series, schemas, 'drop');
+      const labelNames = result[0]!.labels.map(l => l.name).filter(n => n !== '__name__');
+      expect(labelNames).toHaveLength(2);
+    });
+
+    it('always preserves __name__', () => {
+      const schemas = compileSchemas([
+        {
+          name: 'test_metric',
+          labels: { '*': /.*/ },
+          maxLabels: 1,
+        },
+      ]);
+      const series = [makeSeries('test_metric', { a: '1', b: '2', c: '3' })];
+      const result = applySchemas(series, schemas, 'drop');
+      expect(result[0]!.labels.find(l => l.name === '__name__')).toBeDefined();
+    });
+  });
+
+  describe('output sorted', () => {
+    it('output labels are sorted alphabetically', () => {
+      const schemas = compileSchemas([
+        { name: 'test_metric', labels: { '*': /.*/ } },
+      ]);
+      const series = [makeSeries('test_metric', { z: '1', a: '2', m: '3' })];
+      const result = applySchemas(series, schemas, 'drop');
+      const names = result[0]!.labels.map(l => l.name);
+      expect(names).toEqual([...names].sort());
+    });
+  });
+});

package/src/tests/varint.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from 'bun:test';
+import { encodeVarint, writeVarint, varintSize } from '../util/varint.ts';
+
+describe('varint encoding', () => {
+  it('encodes 0', () => {
+    expect(encodeVarint(0n)).toEqual(new Uint8Array([0x00]));
+  });
+
+  it('encodes 1', () => {
+    expect(encodeVarint(1n)).toEqual(new Uint8Array([0x01]));
+  });
+
+  it('encodes 127 as single byte', () => {
+    expect(encodeVarint(127n)).toEqual(new Uint8Array([0x7f]));
+  });
+
+  it('encodes 128 as two bytes', () => {
+    expect(encodeVarint(128n)).toEqual(new Uint8Array([0x80, 0x01]));
+  });
+
+  it('encodes 300', () => {
+    // 300 = 0x12C → varint: 0xAC 0x02
+    expect(encodeVarint(300n)).toEqual(new Uint8Array([0xac, 0x02]));
+  });
+
+  it('encodes large value (2^32)', () => {
+    const val = 4294967296n; // 2^32
+    const encoded = encodeVarint(val);
+    // Decode manually to verify
+    let result = 0n;
+    let shift = 0n;
+    for (const byte of encoded) {
+      result |= BigInt(byte & 0x7f) << shift;
+      shift += 7n;
+    }
+    expect(result).toBe(val);
+  });
+
+  it('varintSize matches encodeVarint length', () => {
+    const testValues = [0n, 1n, 127n, 128n, 300n, 16383n, 16384n, 2097151n, 2097152n];
+    for (const v of testValues) {
+      expect(varintSize(v)).toBe(encodeVarint(v).length);
+    }
+  });
+
+  it('writeVarint writes correctly', () => {
+    const buf = new Uint8Array(10);
+    const written = writeVarint(buf, 0, 300n);
+    expect(written).toBe(2);
+    expect(buf[0]).toBe(0xac);
+    expect(buf[1]).toBe(0x02);
+  });
+});

package/src/transform/SchemaEngine.ts

@@ -0,0 +1,174 @@
+/**
+ * Schema compilation and application engine.
+ *
+ * Compilation (once at build()):
+ *  - string name → exact-match RegExp (anchored)
+ *  - LabelPattern → FastMatcher (any / exact / regex)
+ *  - "*" key extracted as wildcardMatcher
+ *  - inject entries pre-computed as Array<[string, string]>
+ *
+ * Application (per-series):
+ *  1. Match series name against compiled schemas (first match wins)
+ *  2. Single pass over ts.labels:
+ *     - explicit key: value must match FastMatcher; else DROP series
+ *     - count how many explicit labels were seen; drop if any missing
+ *     - wildcard: keep unlisted labels whose value matches; drop otherwise
+ *  3. Apply inject (binary search on sorted outLabels)
+ *  4. Apply maxLabels cap
+ *  5. Re-sort labels
+ */
+
+import type { MetricSchema, CompiledSchema, FastMatcher, LabelPattern, DefaultAction } from '../types/schema.ts';
+import type { TimeSeries, Label } from '../types/prometheus.ts';
+
+// ─── Compilation ────────────────────────────────────────────────────────────
+
+function compileFastMatcher(p: LabelPattern): FastMatcher {
+  if (typeof p === 'string') {
+    return { type: 'exact', value: p };
+  }
+  const src = p.source;
+  // /.*/ with any flags → always matches
+  if (src === '.*' || src === '^.*$') return { type: 'any' };
+  // /^exact$/ where inner part has no regex special chars → equality
+  const exactInner = src.match(/^\^([^.*+?[\](){}\\|^$]+)\$$/)?.[1];
+  if (exactInner !== undefined) return { type: 'exact', value: exactInner };
+  return { type: 'regex', re: p };
+}
+
+function nameToRegExp(n: string | RegExp): RegExp {
+  if (n instanceof RegExp) return n;
+  return new RegExp(`^${n.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`);
+}
+
+export function compileSchemas(schemas: MetricSchema[]): CompiledSchema[] {
+  return schemas.map((s) => {
+    const labelMatchers = new Map<string, FastMatcher>();
+    let wildcardMatcher: FastMatcher | undefined;
+
+    if (s.labels) {
+      for (const [key, pattern] of Object.entries(s.labels)) {
+        if (key === '*') {
+          wildcardMatcher = compileFastMatcher(pattern);
+        } else {
+          labelMatchers.set(key, compileFastMatcher(pattern));
+        }
+      }
+    }
+
+    const inject = s.inject ?? {};
+    return {
+      namePattern: nameToRegExp(s.name),
+      labelMatchers,
+      wildcardMatcher,
+      inject,
+      injectEntries: Object.entries(inject) as Array<[string, string]>,
+      maxLabels: s.maxLabels,
+    };
+  });
+}
+
+// ─── Fast matcher ────────────────────────────────────────────────────────────
+
+function testFastMatcher(m: FastMatcher, value: string): boolean {
+  switch (m.type) {
+    case 'any':   return true;
+    case 'exact': return value === m.value;
+    case 'regex': return m.re.test(value);
+  }
+}
+
+// ─── Binary search over sorted Label[] ──────────────────────────────────────
+
+function bsearchLabel(labels: Label[], name: string): number {
+  let lo = 0, hi = labels.length - 1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >>> 1;
+    const n = labels[mid]!.name;
+    if (n === name) return mid;
+    if (n < name) lo = mid + 1;
+    else hi = mid - 1;
+  }
+  return -1;
+}
+
+// ─── Application ─────────────────────────────────────────────────────────────
+
+export function applySchemas(
+  series: TimeSeries[],
+  schemas: CompiledSchema[],
+  defaultAction: DefaultAction
+): TimeSeries[] {
+  const result: TimeSeries[] = [];
+  for (const ts of series) {
+    const nameLabel = ts.labels[bsearchLabel(ts.labels, '__name__')];
+    const metricName = nameLabel?.value ?? '';
+
+    const schema = schemas.find((s) => s.namePattern.test(metricName));
+    if (!schema) {
+      if (defaultAction === 'pass') result.push(ts);
+      continue;
+    }
+
+    const transformed = applySchema(ts, schema);
+    if (transformed !== null) result.push(transformed);
+  }
+  return result;
+}
+
+function applySchema(ts: TimeSeries, schema: CompiledSchema): TimeSeries | null {
+  const outLabels: Label[] = [];
+  // Track how many of the required explicit labels we've seen
+  let seenExplicit = 0;
+  const explicitCount = schema.labelMatchers.size;
+
+  for (const label of ts.labels) {
+    const name = label.name;
+
+    if (name === '__name__') {
+      outLabels.push(label);
+      continue;
+    }
+
+    const matcher = schema.labelMatchers.get(name);
+    if (matcher !== undefined) {
+      if (!testFastMatcher(matcher, label.value)) return null; // value mismatch → drop series
+      outLabels.push(label);
+      seenExplicit++;
+    } else if (schema.wildcardMatcher !== undefined) {
+      if (testFastMatcher(schema.wildcardMatcher, label.value)) {
+        outLabels.push(label);
+      }
+      // else: label value doesn't match wildcard → drop this label (not the series)
+    }
+    // No wildcard → drop unlisted label
+  }
+
+  // All explicitly required labels must have been present in the series
+  if (seenExplicit < explicitCount) return null;
+
+  // Apply inject labels (outLabels is still sorted here)
+  for (const [k, v] of schema.injectEntries) {
+    const idx = bsearchLabel(outLabels, k);
+    if (idx >= 0) {
+      outLabels[idx] = { name: k, value: v };
+    } else {
+      outLabels.push({ name: k, value: v });
+    }
+  }
+
+  // Apply maxLabels cap
+  if (schema.maxLabels !== undefined) {
+    const nameIdx = outLabels.findIndex((l) => l.name === '__name__');
+    const nameLabel = nameIdx >= 0 ? outLabels.splice(nameIdx, 1)[0]! : undefined;
+    outLabels.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    const trimmed = outLabels.slice(0, schema.maxLabels);
+    if (nameLabel) trimmed.push(nameLabel);
+    trimmed.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    return { labels: trimmed, samples: ts.samples };
+  }
+
+  // Re-sort (inject may have added new labels at the end)
+  outLabels.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+  return { labels: outLabels, samples: ts.samples };
+}