otelturbine 0.1.0

package/src/transform/otlpToTimeSeries.ts

@@ -0,0 +1,156 @@
+/**
+ * Converts OTLP JSON metrics payload to Prometheus TimeSeries[].
+ *
+ * Supports:
+ *  - gauge → 1 TimeSeries per data point
+ *  - sum   → 1 TimeSeries per data point
+ *  - histogram → _bucket (cumulative) × (bounds+1) + _count + _sum per data point
+ *
+ * Resource attributes are merged into every series (dp attributes win on conflict).
+ * Labels are sorted alphabetically (Prometheus requirement).
+ */
+
+import type { OtlpMetricsPayload, OtlpKeyValue, OtlpNumberDataPoint, OtlpHistogramDataPoint } from '../types/otlp.ts';
+import type { TimeSeries, Label } from '../types/prometheus.ts';
+
+/** Convert OTLP key-value attributes to a plain string map. */
+function attrsToMap(attrs: OtlpKeyValue[] | undefined): Record<string, string> {
+  const map: Record<string, string> = {};
+  if (!attrs) return map;
+  for (const kv of attrs) {
+    const v = kv.value;
+    if (v.stringValue !== undefined) {
+      map[kv.key] = v.stringValue;
+    } else if (v.intValue !== undefined) {
+      map[kv.key] = String(v.intValue);
+    } else if (v.doubleValue !== undefined) {
+      map[kv.key] = String(v.doubleValue);
+    } else if (v.boolValue !== undefined) {
+      map[kv.key] = String(v.boolValue);
+    } else {
+      map[kv.key] = '';
+    }
+  }
+  return map;
+}
+
+/** Convert timeUnixNano string to milliseconds as BigInt. */
+function nanoToMs(timeUnixNano: string | undefined): bigint {
+  if (!timeUnixNano) return BigInt(Date.now());
+  return BigInt(timeUnixNano) / 1_000_000n;
+}
+
+/** Build sorted Label[] from a merged attribute map + metric name. */
+function buildLabels(name: string, merged: Record<string, string>): Label[] {
+  const labels: Label[] = [{ name: '__name__', value: name }];
+  for (const [k, v] of Object.entries(merged)) {
+    labels.push({ name: k, value: v });
+  }
+  // Sort alphabetically by name (__name__ sorts before most names — fine)
+  labels.sort((a, b) => a.name.localeCompare(b.name));
+  return labels;
+}
+
+/** Merge resource attrs and data point attrs; dp wins on conflict. */
+function mergeAttrs(
+  resourceAttrs: Record<string, string>,
+  dpAttrs: OtlpKeyValue[] | undefined
+): Record<string, string> {
+  const dp = attrsToMap(dpAttrs);
+  return { ...resourceAttrs, ...dp };
+}
+
+function processNumberDataPoint(
+  name: string,
+  dp: OtlpNumberDataPoint,
+  resourceAttrs: Record<string, string>
+): TimeSeries {
+  const merged = mergeAttrs(resourceAttrs, dp.attributes);
+  const labels = buildLabels(name, merged);
+  const timestamp = nanoToMs(dp.timeUnixNano);
+  let value: number;
+  if (dp.asDouble !== undefined) {
+    value = dp.asDouble;
+  } else if (dp.asInt !== undefined) {
+    value = Number(dp.asInt);
+  } else {
+    value = 0;
+  }
+  return { labels, samples: [{ value, timestamp }] };
+}
+
+function processHistogramDataPoint(
+  name: string,
+  dp: OtlpHistogramDataPoint,
+  resourceAttrs: Record<string, string>
+): TimeSeries[] {
+  const merged = mergeAttrs(resourceAttrs, dp.attributes);
+  const timestamp = nanoToMs(dp.timeUnixNano);
+  const series: TimeSeries[] = [];
+
+  // Bucket series: cumulative counts
+  const bounds = dp.explicitBounds ?? [];
+  const bucketCounts = dp.bucketCounts ?? [];
+
+  let cumulative = 0n;
+  for (let i = 0; i <= bounds.length; i++) {
+    const le = i < bounds.length ? String(bounds[i]) : '+Inf';
+    const count = bucketCounts[i] !== undefined ? BigInt(bucketCounts[i]!) : 0n;
+    cumulative += count;
+    const bucketLabels = buildLabels(`${name}_bucket`, { ...merged, le });
+    series.push({
+      labels: bucketLabels,
+      samples: [{ value: Number(cumulative), timestamp }],
+    });
+  }
+
+  // _count series
+  const countVal = dp.count !== undefined ? Number(dp.count) : 0;
+  series.push({
+    labels: buildLabels(`${name}_count`, merged),
+    samples: [{ value: countVal, timestamp }],
+  });
+
+  // _sum series
+  const sumVal = dp.sum !== undefined ? dp.sum : 0;
+  series.push({
+    labels: buildLabels(`${name}_sum`, merged),
+    samples: [{ value: sumVal, timestamp }],
+  });
+
+  return series;
+}
+
+/**
+ * Convert an OTLP metrics payload to an array of Prometheus TimeSeries.
+ */
+export function otlpToTimeSeries(payload: OtlpMetricsPayload): TimeSeries[] {
+  const result: TimeSeries[] = [];
+
+  for (const rm of payload.resourceMetrics) {
+    const resourceAttrs = attrsToMap(rm.resource?.attributes);
+
+    for (const sm of rm.scopeMetrics) {
+      for (const metric of sm.metrics) {
+        const name = metric.name;
+
+        if (metric.gauge) {
+          for (const dp of metric.gauge.dataPoints) {
+            result.push(processNumberDataPoint(name, dp, resourceAttrs));
+          }
+        } else if (metric.sum) {
+          for (const dp of metric.sum.dataPoints) {
+            result.push(processNumberDataPoint(name, dp, resourceAttrs));
+          }
+        } else if (metric.histogram) {
+          for (const dp of metric.histogram.dataPoints) {
+            result.push(...processHistogramDataPoint(name, dp, resourceAttrs));
+          }
+        }
+        // Other metric types (ExponentialHistogram, Summary) not yet supported
+      }
+    }
+  }
+
+  return result;
+}

package/src/types/otlp.ts

@@ -0,0 +1,83 @@
+/**
+ * OTLP JSON payload types (minimal subset used for metrics ingestion).
+ * Based on the OTLP specification for metrics export.
+ */
+
+export interface OtlpKeyValue {
+  key: string;
+  value: OtlpAnyValue;
+}
+
+export interface OtlpAnyValue {
+  stringValue?: string;
+  intValue?: string | number;
+  doubleValue?: number;
+  boolValue?: boolean;
+  arrayValue?: { values: OtlpAnyValue[] };
+  kvlistValue?: { values: OtlpKeyValue[] };
+}
+
+export interface OtlpResource {
+  attributes?: OtlpKeyValue[];
+  droppedAttributesCount?: number;
+}
+
+export interface OtlpNumberDataPoint {
+  attributes?: OtlpKeyValue[];
+  startTimeUnixNano?: string;
+  timeUnixNano?: string;
+  asDouble?: number;
+  asInt?: string | number;
+  exemplars?: unknown[];
+  flags?: number;
+}
+
+export interface OtlpHistogramDataPoint {
+  attributes?: OtlpKeyValue[];
+  startTimeUnixNano?: string;
+  timeUnixNano?: string;
+  count?: string | number;
+  sum?: number;
+  bucketCounts?: (string | number)[];
+  explicitBounds?: number[];
+  exemplars?: unknown[];
+  flags?: number;
+}
+
+export interface OtlpGauge {
+  dataPoints: OtlpNumberDataPoint[];
+}
+
+export interface OtlpSum {
+  dataPoints: OtlpNumberDataPoint[];
+  aggregationTemporality?: number;
+  isMonotonic?: boolean;
+}
+
+export interface OtlpHistogram {
+  dataPoints: OtlpHistogramDataPoint[];
+  aggregationTemporality?: number;
+}
+
+export interface OtlpMetric {
+  name: string;
+  description?: string;
+  unit?: string;
+  gauge?: OtlpGauge;
+  sum?: OtlpSum;
+  histogram?: OtlpHistogram;
+}
+
+export interface OtlpScopeMetrics {
+  scope?: { name?: string; version?: string };
+  metrics: OtlpMetric[];
+}
+
+export interface OtlpResourceMetrics {
+  resource?: OtlpResource;
+  scopeMetrics: OtlpScopeMetrics[];
+}
+
+export interface OtlpMetricsPayload {
+  resourceMetrics: OtlpResourceMetrics[];
+}

package/src/types/prometheus.ts

@@ -0,0 +1,23 @@
+/**
+ * Internal Prometheus remote-write data structures.
+ * These map directly to the protobuf WriteRequest schema.
+ */
+
+export interface Label {
+  name: string;
+  value: string;
+}
+
+export interface Sample {
+  value: number;
+  timestamp: bigint; // milliseconds since epoch
+}
+
+export interface TimeSeries {
+  labels: Label[]; // must be sorted alphabetically by name
+  samples: Sample[];
+}
+
+export interface WriteRequest {
+  timeseries: TimeSeries[];
+}

package/src/types/schema.ts

@@ -0,0 +1,36 @@
+/**
+ * User-facing MetricSchema and internal CompiledSchema types.
+ */
+
+/** A label value pattern: RegExp for pattern match, string for exact match. */
+export type LabelPattern = RegExp | string;
+
+export interface MetricSchema {
+  name: string | RegExp;
+  labels?: { [labelName: string]: LabelPattern };
+  inject?: Record<string, string>;
+  maxLabels?: number;
+}
+
+/**
+ * Fast matcher that avoids regex overhead for common patterns.
+ * Compiled once at build() time.
+ */
+export type FastMatcher =
+  | { type: 'any' }                  // /.*/ — always true, zero cost
+  | { type: 'exact'; value: string } // /^foo$/ or string — equality check
+  | { type: 'regex'; re: RegExp }    // general fallback
+
+export interface CompiledSchema {
+  namePattern: RegExp;
+  /** Explicit label matchers (excludes "*"). */
+  labelMatchers: Map<string, FastMatcher>;
+  /** Wildcard matcher for unlisted labels. undefined = drop all unlisted. */
+  wildcardMatcher: FastMatcher | undefined;
+  inject: Record<string, string>;
+  /** Pre-computed entries array — avoids Object.entries() per series. */
+  injectEntries: Array<[string, string]>;
+  maxLabels: number | undefined;
+}
+
+export type DefaultAction = 'pass' | 'drop';

package/src/util/varint.ts

@@ -0,0 +1,80 @@
+/**
+ * LEB128 varint encoding for protobuf wire format.
+ */
+
+/** Write a varint for a non-negative JS number (no BigInt overhead). */
+export function writeIntVarint(buf: Uint8Array, offset: number, value: number): number {
+  let i = offset;
+  while (value > 0x7f) {
+    buf[i++] = (value & 0x7f) | 0x80;
+    value >>>= 7;
+  }
+  buf[i++] = value;
+  return i - offset;
+}
+
+/** Byte length of a non-negative JS number varint. */
+export function intVarintSize(n: number): number {
+  if (n < 0x80) return 1;
+  if (n < 0x4000) return 2;
+  if (n < 0x200000) return 3;
+  if (n < 0x10000000) return 4;
+  return 5; // up to ~4 GB, sufficient for proto field sizes
+}
+
+/**
+ * LEB128 varint encoding for protobuf wire format.
+ * Encodes a BigInt as a variable-length integer into a Uint8Array.
+ */
+export function encodeVarint(value: bigint): Uint8Array {
+  if (value < 0n) {
+    // For negative numbers, encode as 64-bit two's complement (10 bytes)
+    value = BigInt.asUintN(64, value);
+  }
+
+  const bytes: number[] = [];
+  do {
+    let byte = Number(value & 0x7fn);
+    value >>= 7n;
+    if (value !== 0n) {
+      byte |= 0x80;
+    }
+    bytes.push(byte);
+  } while (value !== 0n);
+
+  return new Uint8Array(bytes);
+}
+
+/**
+ * Write a varint into a pre-allocated buffer at the given offset.
+ * Returns the number of bytes written.
+ */
+export function writeVarint(buf: Uint8Array, offset: number, value: bigint): number {
+  if (value < 0n) {
+    value = BigInt.asUintN(64, value);
+  }
+  let i = offset;
+  do {
+    let byte = Number(value & 0x7fn);
+    value >>= 7n;
+    if (value !== 0n) {
+      byte |= 0x80;
+    }
+    buf[i++] = byte;
+  } while (value !== 0n);
+  return i - offset;
+}
+
+/**
+ * Calculate the byte length of a varint encoding without allocating.
+ */
+export function varintSize(value: bigint): number {
+  if (value < 0n) value = BigInt.asUintN(64, value);
+  if (value === 0n) return 1;
+  let size = 0;
+  while (value > 0n) {
+    size++;
+    value >>= 7n;
+  }
+  return size;
+}