otelturbine 0.1.0

package/src/proto/writeRequest.ts

@@ -0,0 +1,133 @@
+/**
+ * Two-pass protobuf encoder for Prometheus WriteRequest.
+ *
+ * Pass 1 — size calculation: walks the structure using integer math and
+ *   Buffer.byteLength (native, non-allocating) to compute the exact total
+ *   byte count. No heap allocations.
+ *
+ * Pass 2 — single-allocation write: allocates exactly one Uint8Array, then
+ *   writes every field directly into it using TextEncoder.encodeInto() and
+ *   writeIntVarint(). Zero intermediate buffers, zero copies.
+ *
+ * Proto schema:
+ *   message Label       { string name = 1; string value = 2; }
+ *   message Sample      { double value = 1; int64 timestamp = 2; }
+ *   message TimeSeries  { repeated Label labels = 1; repeated Sample samples = 2; }
+ *   message WriteRequest { repeated TimeSeries timeseries = 1; }
+ */
+
+import type { WriteRequest, TimeSeries, Label, Sample } from '../types/prometheus.ts';
+import { writeIntVarint, intVarintSize, writeVarint, varintSize } from '../util/varint.ts';
+
+const ENC = new TextEncoder();
+
+// ─── Size calculation (pass 1) ──────────────────────────────────────────────
+
+function tsSize(ts: bigint): number {
+  // Fast path: timestamps in ms since epoch fit in JS safe integer range
+  return ts <= 9_007_199_254_740_991n ? intVarintSize(Number(ts)) : varintSize(ts);
+}
+
+function labelMsgSize(l: Label): number {
+  const nl = Buffer.byteLength(l.name);
+  const vl = Buffer.byteLength(l.value);
+  // tag(1) + varint(nl) + nl  +  tag(1) + varint(vl) + vl
+  return 1 + intVarintSize(nl) + nl + 1 + intVarintSize(vl) + vl;
+}
+
+function sampleMsgSize(s: Sample): number {
+  // field1 double: tag(1) + 8 bytes
+  // field2 timestamp: tag(1) + varint(ts)
+  return 9 + 1 + tsSize(s.timestamp);
+}
+
+function timeSeriesMsgSize(ts: TimeSeries): number {
+  let size = 0;
+  for (const l of ts.labels) {
+    const lms = labelMsgSize(l);
+    size += 1 + intVarintSize(lms) + lms;
+  }
+  for (const s of ts.samples) {
+    const sms = sampleMsgSize(s);
+    size += 1 + intVarintSize(sms) + sms;
+  }
+  return size;
+}
+
+function computeTotalSize(req: WriteRequest): number {
+  let size = 0;
+  for (const ts of req.timeseries) {
+    const tsms = timeSeriesMsgSize(ts);
+    size += 1 + intVarintSize(tsms) + tsms;
+  }
+  return size;
+}
+
+// ─── Write pass (pass 2) ────────────────────────────────────────────────────
+
+function writeLabel(buf: Uint8Array, off: number, l: Label): number {
+  buf[off++] = 0x0a; // field 1 (name), LEN
+  const nl = Buffer.byteLength(l.name);
+  off += writeIntVarint(buf, off, nl);
+  ENC.encodeInto(l.name, buf.subarray(off));
+  off += nl;
+
+  buf[off++] = 0x12; // field 2 (value), LEN
+  const vl = Buffer.byteLength(l.value);
+  off += writeIntVarint(buf, off, vl);
+  ENC.encodeInto(l.value, buf.subarray(off));
+  off += vl;
+
+  return off;
+}
+
+function writeSample(buf: Uint8Array, view: DataView, off: number, s: Sample): number {
+  buf[off++] = 0x09; // field 1 (value), 64-bit fixed
+  view.setFloat64(off, s.value, true /* LE */);
+  off += 8;
+
+  buf[off++] = 0x10; // field 2 (timestamp), varint
+  const ts = s.timestamp;
+  if (ts <= 9_007_199_254_740_991n) {
+    off += writeIntVarint(buf, off, Number(ts));
+  } else {
+    off += writeVarint(buf, off, ts);
+  }
+  return off;
+}
+
+function writeTimeSeries(buf: Uint8Array, view: DataView, off: number, ts: TimeSeries): number {
+  for (const l of ts.labels) {
+    buf[off++] = 0x0a; // field 1 (labels), LEN
+    const lms = labelMsgSize(l);
+    off += writeIntVarint(buf, off, lms);
+    off = writeLabel(buf, off, l);
+  }
+  for (const s of ts.samples) {
+    buf[off++] = 0x12; // field 2 (samples), LEN
+    const sms = sampleMsgSize(s);
+    off += writeIntVarint(buf, off, sms);
+    off = writeSample(buf, view, off, s);
+  }
+  return off;
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+export function encodeWriteRequest(req: WriteRequest): Uint8Array {
+  if (req.timeseries.length === 0) return new Uint8Array(0);
+
+  const totalSize = computeTotalSize(req);
+  const buf = new Uint8Array(totalSize);
+  const view = new DataView(buf.buffer); // one DataView for the entire buffer
+
+  let off = 0;
+  for (const ts of req.timeseries) {
+    buf[off++] = 0x0a; // field 1 (timeseries), LEN
+    const tsms = timeSeriesMsgSize(ts);
+    off += writeIntVarint(buf, off, tsms);
+    off = writeTimeSeries(buf, view, off, ts);
+  }
+
+  return buf;
+}

package/src/tests/bunHandler.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { bunHandler, bunRouteHandler } from '../adapters/bun.ts';
+import { Pipeline } from '../core/Pipeline.ts';
+
+const validOtlpPayload = JSON.stringify({
+  resourceMetrics: [
+    {
+      resource: {},
+      scopeMetrics: [
+        {
+          metrics: [
+            {
+              name: 'test_metric',
+              gauge: {
+                dataPoints: [
+                  { timeUnixNano: '1700000000000000000', asDouble: 1.0 },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+    },
+  ],
+});
+
+describe('bunHandler', () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(async () => new Response(null, { status: 204 })) as unknown as typeof fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  function makePipeline() {
+    return new Pipeline(
+      { url: 'http://localhost:9090/api/v1/write', timeout: 5000 },
+      [],
+      'pass'
+    );
+  }
+
+  it('returns 404 for wrong path', async () => {
+    const handler = bunHandler(makePipeline(), '/v1/metrics');
+    const req = new Request('http://localhost/wrong/path', {
+      method: 'POST',
+      body: validOtlpPayload,
+      headers: { 'Content-Type': 'application/json' },
+    });
+    const res = await handler(req);
+    expect(res.status).toBe(404);
+  });
+
+  it('returns 405 for GET request', async () => {
+    const handler = bunHandler(makePipeline(), '/v1/metrics');
+    const req = new Request('http://localhost/v1/metrics', { method: 'GET' });
+    const res = await handler(req);
+    expect(res.status).toBe(405);
+  });
+
+  it('returns 405 for PUT request', async () => {
+    const handler = bunHandler(makePipeline(), '/v1/metrics');
+    const req = new Request('http://localhost/v1/metrics', { method: 'PUT', body: '' });
+    const res = await handler(req);
+    expect(res.status).toBe(405);
+  });
+
+  it('processes valid POST request', async () => {
+    const handler = bunHandler(makePipeline(), '/v1/metrics');
+    const req = new Request('http://localhost/v1/metrics', {
+      method: 'POST',
+      body: validOtlpPayload,
+      headers: { 'Content-Type': 'application/json' },
+    });
+    const res = await handler(req);
+    expect(res.status).toBe(204);
+  });
+
+  it('returns 405 with Allow header', async () => {
+    const handler = bunHandler(makePipeline(), '/v1/metrics');
+    const req = new Request('http://localhost/v1/metrics', { method: 'GET' });
+    const res = await handler(req);
+    expect(res.headers.get('Allow')).toBe('POST');
+  });
+});
+
+describe('bunRouteHandler', () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(async () => new Response(null, { status: 204 })) as unknown as typeof fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it('processes valid POST request', async () => {
+    const pipeline = new Pipeline(
+      { url: 'http://localhost:9090/api/v1/write', timeout: 5000 },
+      [],
+      'pass'
+    );
+    const handler = bunRouteHandler(pipeline);
+    const req = new Request('http://localhost/v1/metrics', {
+      method: 'POST',
+      body: validOtlpPayload,
+      headers: { 'Content-Type': 'application/json' },
+    });
+    const res = await handler(req);
+    expect(res.status).toBe(204);
+  });
+
+  it('returns 400 for bad JSON', async () => {
+    const pipeline = new Pipeline(
+      { url: 'http://localhost:9090/api/v1/write', timeout: 5000 },
+      [],
+      'pass'
+    );
+    const handler = bunRouteHandler(pipeline);
+    const req = new Request('http://localhost/v1/metrics', {
+      method: 'POST',
+      body: 'bad json',
+      headers: { 'Content-Type': 'application/json' },
+    });
+    const res = await handler(req);
+    expect(res.status).toBe(400);
+  });
+});

package/src/tests/compat.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect } from 'bun:test';
+import {
+  createCompatHandler,
+  type CompatRequestLike,
+} from '../core/Compat.ts';
+import {
+  applyRequestLabelInjections,
+  type LabelInjectionRule,
+} from '../core/Pipeline.ts';
+import type { TimeSeries } from '../types/prometheus.ts';
+
+function makeSeries(name: string, labels: Record<string, string> = {}): TimeSeries {
+  return {
+    labels: [
+      { name: '__name__', value: name },
+      ...Object.entries(labels).map(([k, v]) => ({ name: k, value: v })),
+    ].sort((a, b) => a.name.localeCompare(b.name)),
+    samples: [{ value: 1, timestamp: 1n }],
+  };
+}
+
+describe('compat handler', () => {
+  it('passes per-request injection rules to pipeline.process', async () => {
+    const calls: Array<{ body: string | Uint8Array; contentType: string; injectCount: number }> = [];
+    const fakePipeline = {
+      process: async (
+        body: string | Uint8Array,
+        contentType: string,
+        options?: { injectLabels?: LabelInjectionRule[] }
+      ) => {
+        calls.push({
+          body,
+          contentType,
+          injectCount: options?.injectLabels?.length ?? 0,
+        });
+        return { status: 200, message: 'OK' };
+      },
+    };
+
+    const otelTurbine = createCompatHandler(fakePipeline as never);
+    const req: CompatRequestLike = {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: '{"resourceMetrics":[]}',
+    };
+
+    const result = await otelTurbine(req)
+      .injectLabel('*', { instance_name: 'worker-a' })
+      .push();
+
+    expect(result.status).toBe(200);
+    expect(calls).toHaveLength(1);
+    expect(calls[0]!.injectCount).toBe(1);
+    expect(calls[0]!.contentType).toBe('application/json');
+  });
+
+  it('keeps request ownership isolated between calls', async () => {
+    const injectCounts: number[] = [];
+    const fakePipeline = {
+      process: async (
+        _body: string | Uint8Array,
+        _contentType: string,
+        options?: { injectLabels?: LabelInjectionRule[] }
+      ) => {
+        injectCounts.push(options?.injectLabels?.length ?? 0);
+        return { status: 200, message: 'OK' };
+      },
+    };
+
+    const otelTurbine = createCompatHandler(fakePipeline as never);
+    const req: CompatRequestLike = {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: '{"resourceMetrics":[]}',
+    };
+
+    await otelTurbine(req).injectLabel('*', { instance_name: 'one' }).push();
+    await otelTurbine(req).push();
+
+    expect(injectCounts).toEqual([1, 0]);
+  });
+
+  it('returns 405 for non-POST methods', async () => {
+    const fakePipeline = {
+      process: async () => ({ status: 200, message: 'OK' }),
+    };
+    const otelTurbine = createCompatHandler(fakePipeline as never);
+    const result = await otelTurbine({
+      method: 'GET',
+      headers: { 'content-type': 'application/json' },
+      body: '{}',
+    }).push();
+    expect(result.status).toBe(405);
+  });
+});
+
+describe('applyRequestLabelInjections', () => {
+  it('injects labels for wildcard selector', () => {
+    const out = applyRequestLabelInjections(
+      [makeSeries('cpu_usage', { host: 'a' })],
+      [{ selector: '*', labels: { instance_name: 'node-1' } }]
+    );
+    expect(out[0]!.labels.find((l) => l.name === 'instance_name')?.value).toBe('node-1');
+  });
+
+  it('supports exact and regex selectors', () => {
+    const out = applyRequestLabelInjections(
+      [
+        makeSeries('http_requests_total'),
+        makeSeries('db_connections'),
+      ],
+      [
+        { selector: 'db_connections', labels: { domain: 'db' } },
+        { selector: /^http_/, labels: { domain: 'http' } },
+      ]
+    );
+    expect(out[0]!.labels.find((l) => l.name === 'domain')?.value).toBe('http');
+    expect(out[1]!.labels.find((l) => l.name === 'domain')?.value).toBe('db');
+  });
+});

package/src/tests/otlpToTimeSeries.test.ts

@@ -0,0 +1,184 @@
+import { describe, it, expect } from 'bun:test';
+import { otlpToTimeSeries } from '../transform/otlpToTimeSeries.ts';
+import type { OtlpMetricsPayload } from '../types/otlp.ts';
+
+const basePayload = (metrics: OtlpMetricsPayload['resourceMetrics'][0]['scopeMetrics'][0]['metrics']): OtlpMetricsPayload => ({
+  resourceMetrics: [
+    {
+      resource: { attributes: [{ key: 'service.name', value: { stringValue: 'test-svc' } }] },
+      scopeMetrics: [{ metrics }],
+    },
+  ],
+});
+
+describe('otlpToTimeSeries', () => {
+  describe('gauge', () => {
+    it('converts a gauge to a single TimeSeries', () => {
+      const payload = basePayload([
+        {
+          name: 'cpu_usage',
+          gauge: {
+            dataPoints: [
+              {
+                attributes: [{ key: 'host', value: { stringValue: 'server1' } }],
+                timeUnixNano: '1700000000000000000',
+                asDouble: 0.75,
+              },
+            ],
+          },
+        },
+      ]);
+
+      const series = otlpToTimeSeries(payload);
+      expect(series).toHaveLength(1);
+      const ts = series[0]!;
+      expect(ts.labels.find(l => l.name === '__name__')?.value).toBe('cpu_usage');
+      expect(ts.labels.find(l => l.name === 'host')?.value).toBe('server1');
+      expect(ts.labels.find(l => l.name === 'service.name')?.value).toBe('test-svc');
+      expect(ts.samples[0]?.value).toBe(0.75);
+      expect(ts.samples[0]?.timestamp).toBe(1700000000000n);
+    });
+
+    it('labels are sorted alphabetically', () => {
+      const payload = basePayload([
+        {
+          name: 'mem_usage',
+          gauge: {
+            dataPoints: [
+              {
+                attributes: [
+                  { key: 'zone', value: { stringValue: 'us-east' } },
+                  { key: 'app', value: { stringValue: 'api' } },
+                ],
+                timeUnixNano: '1000000000000000000',
+                asDouble: 512.0,
+              },
+            ],
+          },
+        },
+      ]);
+
+      const series = otlpToTimeSeries(payload);
+      const names = series[0]!.labels.map(l => l.name);
+      expect(names).toEqual([...names].sort());
+    });
+
+    it('dp attributes win over resource attributes on conflict', () => {
+      const payload: OtlpMetricsPayload = {
+        resourceMetrics: [
+          {
+            resource: {
+              attributes: [{ key: 'env', value: { stringValue: 'resource-env' } }],
+            },
+            scopeMetrics: [
+              {
+                metrics: [
+                  {
+                    name: 'test',
+                    gauge: {
+                      dataPoints: [
+                        {
+                          attributes: [{ key: 'env', value: { stringValue: 'dp-env' } }],
+                          timeUnixNano: '1000000000000000000',
+                          asDouble: 1.0,
+                        },
+                      ],
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      };
+
+      const series = otlpToTimeSeries(payload);
+      expect(series[0]!.labels.find(l => l.name === 'env')?.value).toBe('dp-env');
+    });
+  });
+
+  describe('sum', () => {
+    it('converts a sum to a single TimeSeries', () => {
+      const payload = basePayload([
+        {
+          name: 'requests_total',
+          sum: {
+            dataPoints: [
+              {
+                timeUnixNano: '1700000000000000000',
+                asInt: '100',
+              },
+            ],
+            isMonotonic: true,
+          },
+        },
+      ]);
+
+      const series = otlpToTimeSeries(payload);
+      expect(series).toHaveLength(1);
+      expect(series[0]!.labels.find(l => l.name === '__name__')?.value).toBe('requests_total');
+      expect(series[0]!.samples[0]?.value).toBe(100);
+    });
+  });
+
+  describe('histogram', () => {
+    it('converts a histogram to bucket + count + sum series', () => {
+      const payload = basePayload([
+        {
+          name: 'latency',
+          histogram: {
+            dataPoints: [
+              {
+                timeUnixNano: '1700000000000000000',
+                count: '10',
+                sum: 500.0,
+                explicitBounds: [10, 50, 100],
+                bucketCounts: ['2', '3', '4', '1'],
+              },
+            ],
+          },
+        },
+      ]);
+
+      const series = otlpToTimeSeries(payload);
+      // 4 buckets (3 bounds + +Inf) + _count + _sum = 6
+      expect(series).toHaveLength(6);
+
+      const buckets = series.filter(ts =>
+        ts.labels.find(l => l.name === '__name__')?.value === 'latency_bucket'
+      );
+      expect(buckets).toHaveLength(4);
+
+      // Check le labels
+      const leValues = buckets.map(ts => ts.labels.find(l => l.name === 'le')?.value);
+      expect(leValues).toContain('10');
+      expect(leValues).toContain('50');
+      expect(leValues).toContain('100');
+      expect(leValues).toContain('+Inf');
+
+      // Check cumulative counts
+      const sortedBuckets = [...buckets].sort((a, b) => {
+        const aLe = a.labels.find(l => l.name === 'le')?.value ?? '';
+        const bLe = b.labels.find(l => l.name === 'le')?.value ?? '';
+        if (aLe === '+Inf') return 1;
+        if (bLe === '+Inf') return -1;
+        return Number(aLe) - Number(bLe);
+      });
+      expect(sortedBuckets[0]!.samples[0]?.value).toBe(2);  // le=10: 2
+      expect(sortedBuckets[1]!.samples[0]?.value).toBe(5);  // le=50: 2+3=5
+      expect(sortedBuckets[2]!.samples[0]?.value).toBe(9);  // le=100: 2+3+4=9
+      expect(sortedBuckets[3]!.samples[0]?.value).toBe(10); // le=+Inf: 2+3+4+1=10
+
+      // Check _count and _sum
+      const countSeries = series.find(ts =>
+        ts.labels.find(l => l.name === '__name__')?.value === 'latency_count'
+      );
+      expect(countSeries?.samples[0]?.value).toBe(10);
+
+      const sumSeries = series.find(ts =>
+        ts.labels.find(l => l.name === '__name__')?.value === 'latency_sum'
+      );
+      expect(sumSeries?.samples[0]?.value).toBe(500.0);
+    });
+  });
+});