@maroonedsoftware/telemetry 0.0.0-stage → 0.1.1

package/dist/otlp.export.d.ts

@@ -0,0 +1,8 @@
+import { ExportResult } from '@opentelemetry/core';
+/**
+ * Runs an OTel exporter's callback-style `export` as a promise that rejects on failure.
+ *
+ * @param run - Calls the exporter with the given callback.
+ */
+export declare const exportAsPromise: (run: (done: (result: ExportResult) => void) => void) => Promise<void>;
+//# sourceMappingURL=otlp.export.d.ts.map

package/dist/otlp.export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp.export.d.ts","sourceRoot":"","sources":["../src/otlp.export.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAoB,MAAM,qBAAqB,CAAC;AAErE;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,KAAK,IAAI,KAAG,OAAO,CAAC,IAAI,CAS9F,CAAC"}

package/dist/otlp.ids.d.ts

@@ -0,0 +1,16 @@
+/**
+ * An OTLP trace id (32 lowercase hex characters) for an app's own trace id.
+ *
+ * An id already in that form is kept as it is. Anything else is hashed, so the same app id always
+ * maps to the same trace id, and spans exported in different batches still land in one trace.
+ *
+ * @param id - The app's trace id.
+ */
+export declare const otlpTraceId: (id: string) => string;
+/**
+ * An OTLP span id (16 lowercase hex characters) for an app's own span id. Same rules as {@link otlpTraceId}.
+ *
+ * @param id - The app's span id.
+ */
+export declare const otlpSpanId: (id: string) => string;
+//# sourceMappingURL=otlp.ids.d.ts.map

package/dist/otlp.ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp.ids.d.ts","sourceRoot":"","sources":["../src/otlp.ids.ts"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,IAAI,MAAM,KAAG,MAAkD,CAAC;AAE5F;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,IAAI,MAAM,KAAG,MAAiD,CAAC"}

package/dist/otlp.js

@@ -0,0 +1,237 @@
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/otlp.ids.ts
+import { createHash } from "crypto";
+var TRACE_ID = /^[0-9a-f]{32}$/;
+var SPAN_ID = /^[0-9a-f]{16}$/;
+var hexOf = /* @__PURE__ */ __name((id, length) => createHash("sha256").update(id).digest("hex").slice(0, length), "hexOf");
+var otlpTraceId = /* @__PURE__ */ __name((id) => TRACE_ID.test(id) ? id : hexOf(id, 32), "otlpTraceId");
+var otlpSpanId = /* @__PURE__ */ __name((id) => SPAN_ID.test(id) ? id : hexOf(id, 16), "otlpSpanId");
+
+// src/otlp.metrics.bridge.ts
+import { ValueType } from "@opentelemetry/api";
+import { millisToHrTime } from "@opentelemetry/core";
+import { defaultResource } from "@opentelemetry/resources";
+import { AggregationTemporality, DataPointType } from "@opentelemetry/sdk-metrics";
+
+// src/otlp.export.ts
+import { ExportResultCode } from "@opentelemetry/core";
+var exportAsPromise = /* @__PURE__ */ __name((run) => new Promise((resolve, reject) => {
+  run((result) => {
+    if (result.code === ExportResultCode.SUCCESS) {
+      resolve();
+    } else {
+      reject(result.error ?? new Error("OTLP export failed"));
+    }
+  });
+}), "exportAsPromise");
+
+// src/otlp.metrics.bridge.ts
+var MINUTE_MS = 6e4;
+var OtlpMetricsBridge = class {
+  static {
+    __name(this, "OtlpMetricsBridge");
+  }
+  exporter;
+  resource;
+  scope;
+  kindOf;
+  /**
+  * @param options - The exporter, resource, scope and kind picker.
+  */
+  constructor(options) {
+    this.exporter = options.exporter;
+    this.resource = options.resource ?? defaultResource();
+    this.scope = options.scope ?? "@maroonedsoftware/telemetry";
+    this.kindOf = options.kindOf ?? (() => "gauge");
+  }
+  /**
+  * Exports the buckets, one OTel metric per name.
+  *
+  * @param buckets - What a recorder drained.
+  * @throws Whatever the exporter reports when it fails.
+  */
+  async export(buckets) {
+    if (buckets.length === 0) {
+      return;
+    }
+    const byName = /* @__PURE__ */ new Map();
+    for (const bucket of buckets) {
+      byName.set(bucket.name, [
+        ...byName.get(bucket.name) ?? [],
+        bucket
+      ]);
+    }
+    const metrics = [
+      ...byName.entries()
+    ].map(([name, group]) => this.metricOf(name, group));
+    await exportAsPromise((done) => this.exporter.export({
+      resource: this.resource,
+      scopeMetrics: [
+        {
+          scope: {
+            name: this.scope
+          },
+          metrics
+        }
+      ]
+    }, done));
+  }
+  /** Flushes and closes the exporter. */
+  async shutdown() {
+    await this.exporter.shutdown();
+  }
+  metricOf(name, buckets) {
+    const descriptor = {
+      name,
+      description: "",
+      unit: "",
+      valueType: ValueType.DOUBLE
+    };
+    const timing = /* @__PURE__ */ __name((bucket) => ({
+      startTime: millisToHrTime(bucket.start.toMillis()),
+      endTime: millisToHrTime(bucket.start.toMillis() + MINUTE_MS),
+      attributes: {
+        ...bucket.labels
+      }
+    }), "timing");
+    switch (this.kindOf(name)) {
+      case "counter":
+        return {
+          descriptor,
+          aggregationTemporality: AggregationTemporality.DELTA,
+          dataPointType: DataPointType.SUM,
+          isMonotonic: true,
+          dataPoints: buckets.map((bucket) => ({
+            ...timing(bucket),
+            value: bucket.aggregate.sum
+          }))
+        };
+      case "histogram":
+        return {
+          descriptor,
+          aggregationTemporality: AggregationTemporality.DELTA,
+          dataPointType: DataPointType.HISTOGRAM,
+          dataPoints: buckets.map((bucket) => ({
+            ...timing(bucket),
+            value: {
+              buckets: {
+                boundaries: [],
+                counts: [
+                  bucket.aggregate.count
+                ]
+              },
+              count: bucket.aggregate.count,
+              sum: bucket.aggregate.sum,
+              min: bucket.aggregate.min,
+              max: bucket.aggregate.max
+            }
+          }))
+        };
+      case "gauge":
+        return {
+          descriptor,
+          aggregationTemporality: AggregationTemporality.CUMULATIVE,
+          dataPointType: DataPointType.GAUGE,
+          dataPoints: buckets.map((bucket) => ({
+            ...timing(bucket),
+            value: bucket.aggregate.last
+          }))
+        };
+    }
+  }
+};
+
+// src/otlp.span.bridge.ts
+import { SpanKind, SpanStatusCode, TraceFlags } from "@opentelemetry/api";
+import { hrTimeDuration, millisToHrTime as millisToHrTime2 } from "@opentelemetry/core";
+import { defaultResource as defaultResource2 } from "@opentelemetry/resources";
+var OtlpSpanBridge = class {
+  static {
+    __name(this, "OtlpSpanBridge");
+  }
+  exporter;
+  resource;
+  scope;
+  /**
+  * @param options - The exporter, resource and scope.
+  */
+  constructor(options) {
+    this.exporter = options.exporter;
+    this.resource = options.resource ?? defaultResource2();
+    this.scope = options.scope ?? "@maroonedsoftware/telemetry";
+  }
+  /**
+  * Exports the spans.
+  *
+  * @param spans - Finished work, in any order.
+  * @throws Whatever the exporter reports when it fails.
+  */
+  async export(spans) {
+    if (spans.length === 0) {
+      return;
+    }
+    await exportAsPromise((done) => this.exporter.export(spans.map((span) => this.readableOf(span)), done));
+  }
+  /** Flushes and closes the exporter. */
+  async shutdown() {
+    await this.exporter.shutdown();
+  }
+  readableOf(span) {
+    const traceId = otlpTraceId(span.traceId);
+    const context = {
+      traceId,
+      spanId: otlpSpanId(span.spanId),
+      traceFlags: TraceFlags.SAMPLED
+    };
+    const startTime = millisToHrTime2(span.start.toMillis());
+    const endTime = millisToHrTime2(span.end.toMillis());
+    return {
+      name: span.name,
+      kind: SpanKind.INTERNAL,
+      spanContext: /* @__PURE__ */ __name(() => context, "spanContext"),
+      parentSpanContext: span.parentSpanId === void 0 ? void 0 : {
+        traceId,
+        spanId: otlpSpanId(span.parentSpanId),
+        traceFlags: TraceFlags.SAMPLED
+      },
+      startTime,
+      endTime,
+      duration: hrTimeDuration(startTime, endTime),
+      status: span.ok ? {
+        code: SpanStatusCode.OK
+      } : {
+        code: SpanStatusCode.ERROR,
+        message: span.error
+      },
+      attributes: {
+        ...span.attributes
+      },
+      links: (span.links ?? []).map((link) => ({
+        context: {
+          traceId: otlpTraceId(link.traceId),
+          spanId: otlpSpanId(link.spanId),
+          traceFlags: TraceFlags.SAMPLED
+        }
+      })),
+      events: [],
+      ended: true,
+      resource: this.resource,
+      instrumentationScope: {
+        name: this.scope
+      },
+      droppedAttributesCount: 0,
+      droppedEventsCount: 0,
+      droppedLinksCount: 0
+    };
+  }
+};
+export {
+  OtlpMetricsBridge,
+  OtlpSpanBridge,
+  otlpSpanId,
+  otlpTraceId
+};
+//# sourceMappingURL=otlp.js.map

package/dist/otlp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/otlp.ids.ts","../src/otlp.metrics.bridge.ts","../src/otlp.export.ts","../src/otlp.span.bridge.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\n\nconst TRACE_ID = /^[0-9a-f]{32}$/;\nconst SPAN_ID = /^[0-9a-f]{16}$/;\n\nconst hexOf = (id: string, length: number): string => createHash('sha256').update(id).digest('hex').slice(0, length);\n\n/**\n * An OTLP trace id (32 lowercase hex characters) for an app's own trace id.\n *\n * An id already in that form is kept as it is. Anything else is hashed, so the same app id always\n * maps to the same trace id, and spans exported in different batches still land in one trace.\n *\n * @param id - The app's trace id.\n */\nexport const otlpTraceId = (id: string): string => (TRACE_ID.test(id) ? id : hexOf(id, 32));\n\n/**\n * An OTLP span id (16 lowercase hex characters) for an app's own span id. Same rules as {@link otlpTraceId}.\n *\n * @param id - The app's span id.\n */\nexport const otlpSpanId = (id: string): string => (SPAN_ID.test(id) ? id : hexOf(id, 16));\n","import { ValueType } from '@opentelemetry/api';\nimport { millisToHrTime } from '@opentelemetry/core';\nimport { defaultResource, Resource } from '@opentelemetry/resources';\nimport { AggregationTemporality, DataPointType, MetricData, PushMetricExporter } from '@opentelemetry/sdk-metrics';\nimport { MetricBucket } from './metric.bucket.js';\nimport { exportAsPromise } from './otlp.export.js';\n\n/**\n * How a metric is sent over OTLP. The stored aggregate is the same for all three; this only says\n * which part of it a collector should see.\n *\n * - `gauge` sends `last`.\n * - `counter` sends `sum` as a monotonic delta sum.\n * - `histogram` sends `count`, `sum`, `min` and `max` as a delta histogram with no bucket boundaries.\n */\nexport type MetricKind = 'gauge' | 'counter' | 'histogram';\n\n/**\n * How an {@link OtlpMetricsBridge} is built.\n */\nexport interface OtlpMetricsBridgeOptions {\n  /** Where the metrics go: an `OTLPMetricExporter`, or `InMemoryMetricExporter` in tests. */\n  exporter: PushMetricExporter;\n  /** Says who is sending. Defaults to the SDK's default resource. */\n  resource?: Resource;\n  /** The instrumentation scope name. Defaults to `@maroonedsoftware/telemetry`. */\n  scope?: string;\n  /** Picks each metric's kind by name. Defaults to `gauge` for everything. */\n  kindOf?: (name: string) => MetricKind;\n}\n\nconst MINUTE_MS = 60_000;\n\n/**\n * Sends drained minute buckets to an OTLP exporter as already-aggregated data.\n *\n * It does not go through a `MeterProvider`: the buckets are already aggregates, and recording them\n * into SDK instruments would aggregate them a second time. Each bucket becomes one data point\n * spanning its minute, with delta temporality, so a collector that wants cumulative series (a\n * Prometheus exporter, say) needs its `deltatocumulative` processor.\n *\n * @example\n * ```typescript\n * const bridge = new OtlpMetricsBridge({\n *   exporter: new OTLPMetricExporter({ url }),\n *   resource: resourceFromAttributes({ 'service.name': 'my.app' }),\n *   kindOf: name => (name.endsWith('.ms') ? 'histogram' : 'gauge'),\n * });\n * await bridge.export(buckets);\n * ```\n */\nexport class OtlpMetricsBridge {\n  private readonly exporter: PushMetricExporter;\n  private readonly resource: Resource;\n  private readonly scope: string;\n  private readonly kindOf: (name: string) => MetricKind;\n\n  /**\n   * @param options - The exporter, resource, scope and kind picker.\n   */\n  constructor(options: OtlpMetricsBridgeOptions) {\n    this.exporter = options.exporter;\n    this.resource = options.resource ?? defaultResource();\n    this.scope = options.scope ?? '@maroonedsoftware/telemetry';\n    this.kindOf = options.kindOf ?? (() => 'gauge');\n  }\n\n  /**\n   * Exports the buckets, one OTel metric per name.\n   *\n   * @param buckets - What a recorder drained.\n   * @throws Whatever the exporter reports when it fails.\n   */\n  async export(buckets: readonly MetricBucket[]): Promise<void> {\n    if (buckets.length === 0) {\n      return;\n    }\n    const byName = new Map<string, MetricBucket[]>();\n    for (const bucket of buckets) {\n      byName.set(bucket.name, [...(byName.get(bucket.name) ?? []), bucket]);\n    }\n    const metrics = [...byName.entries()].map(([name, group]) => this.metricOf(name, group));\n    await exportAsPromise(done => this.exporter.export({ resource: this.resource, scopeMetrics: [{ scope: { name: this.scope }, metrics }] }, done));\n  }\n\n  /** Flushes and closes the exporter. */\n  async shutdown(): Promise<void> {\n    await this.exporter.shutdown();\n  }\n\n  private metricOf(name: string, buckets: MetricBucket[]): MetricData {\n    const descriptor = { name, description: '', unit: '', valueType: ValueType.DOUBLE };\n    const timing = (bucket: MetricBucket) => ({\n      startTime: millisToHrTime(bucket.start.toMillis()),\n      endTime: millisToHrTime(bucket.start.toMillis() + MINUTE_MS),\n      attributes: { ...bucket.labels },\n    });\n    switch (this.kindOf(name)) {\n      case 'counter':\n        return {\n          descriptor,\n          aggregationTemporality: AggregationTemporality.DELTA,\n          dataPointType: DataPointType.SUM,\n          isMonotonic: true,\n          dataPoints: buckets.map(bucket => ({ ...timing(bucket), value: bucket.aggregate.sum })),\n        };\n      case 'histogram':\n        return {\n          descriptor,\n          aggregationTemporality: AggregationTemporality.DELTA,\n          dataPointType: DataPointType.HISTOGRAM,\n          dataPoints: buckets.map(bucket => ({\n            ...timing(bucket),\n            value: {\n              buckets: { boundaries: [], counts: [bucket.aggregate.count] },\n              count: bucket.aggregate.count,\n              sum: bucket.aggregate.sum,\n              min: bucket.aggregate.min,\n              max: bucket.aggregate.max,\n            },\n          })),\n        };\n      case 'gauge':\n        return {\n          descriptor,\n          aggregationTemporality: AggregationTemporality.CUMULATIVE,\n          dataPointType: DataPointType.GAUGE,\n          dataPoints: buckets.map(bucket => ({ ...timing(bucket), value: bucket.aggregate.last })),\n        };\n    }\n  }\n}\n","import { ExportResult, ExportResultCode } from '@opentelemetry/core';\n\n/**\n * Runs an OTel exporter's callback-style `export` as a promise that rejects on failure.\n *\n * @param run - Calls the exporter with the given callback.\n */\nexport const exportAsPromise = (run: (done: (result: ExportResult) => void) => void): Promise<void> =>\n  new Promise((resolve, reject) => {\n    run(result => {\n      if (result.code === ExportResultCode.SUCCESS) {\n        resolve();\n      } else {\n        reject(result.error ?? new Error('OTLP export failed'));\n      }\n    });\n  });\n","import { SpanKind, SpanStatusCode, TraceFlags } from '@opentelemetry/api';\nimport { hrTimeDuration, millisToHrTime } from '@opentelemetry/core';\nimport { defaultResource, Resource } from '@opentelemetry/resources';\nimport { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace';\nimport { FinishedSpan } from './finished.span.js';\nimport { otlpSpanId, otlpTraceId } from './otlp.ids.js';\nimport { exportAsPromise } from './otlp.export.js';\n\n/**\n * How an {@link OtlpSpanBridge} is built.\n */\nexport interface OtlpSpanBridgeOptions {\n  /** Where the spans go: an `OTLPTraceExporter`, or `InMemorySpanExporter` in tests. */\n  exporter: SpanExporter;\n  /** Says who is sending. Defaults to the SDK's default resource. */\n  resource?: Resource;\n  /** The instrumentation scope name. Defaults to `@maroonedsoftware/telemetry`. */\n  scope?: string;\n}\n\n/**\n * Sends {@link FinishedSpan}s to an OTel span exporter.\n *\n * The spans are built as finished `ReadableSpan`s with the times the app recorded, rather than\n * started and ended on a live tracer, so work timed before this bridge existed (or in a process\n * with no tracer at all) exports with its real start and end. Ids are derived with\n * {@link otlpTraceId} and {@link otlpSpanId}, so the same app id always lands in the same trace.\n *\n * The caller batches: hand it whatever accumulated since the last call.\n */\nexport class OtlpSpanBridge {\n  private readonly exporter: SpanExporter;\n  private readonly resource: Resource;\n  private readonly scope: string;\n\n  /**\n   * @param options - The exporter, resource and scope.\n   */\n  constructor(options: OtlpSpanBridgeOptions) {\n    this.exporter = options.exporter;\n    this.resource = options.resource ?? defaultResource();\n    this.scope = options.scope ?? '@maroonedsoftware/telemetry';\n  }\n\n  /**\n   * Exports the spans.\n   *\n   * @param spans - Finished work, in any order.\n   * @throws Whatever the exporter reports when it fails.\n   */\n  async export(spans: readonly FinishedSpan[]): Promise<void> {\n    if (spans.length === 0) {\n      return;\n    }\n    await exportAsPromise(done =>\n      this.exporter.export(\n        spans.map(span => this.readableOf(span)),\n        done,\n      ),\n    );\n  }\n\n  /** Flushes and closes the exporter. */\n  async shutdown(): Promise<void> {\n    await this.exporter.shutdown();\n  }\n\n  private readableOf(span: FinishedSpan): ReadableSpan {\n    const traceId = otlpTraceId(span.traceId);\n    const context = { traceId, spanId: otlpSpanId(span.spanId), traceFlags: TraceFlags.SAMPLED };\n    const startTime = millisToHrTime(span.start.toMillis());\n    const endTime = millisToHrTime(span.end.toMillis());\n    return {\n      name: span.name,\n      kind: SpanKind.INTERNAL,\n      spanContext: () => context,\n      parentSpanContext:\n        span.parentSpanId === undefined ? undefined : { traceId, spanId: otlpSpanId(span.parentSpanId), traceFlags: TraceFlags.SAMPLED },\n      startTime,\n      endTime,\n      duration: hrTimeDuration(startTime, endTime),\n      status: span.ok ? { code: SpanStatusCode.OK } : { code: SpanStatusCode.ERROR, message: span.error },\n      attributes: { ...span.attributes },\n      links: (span.links ?? []).map(link => ({\n        context: { traceId: otlpTraceId(link.traceId), spanId: otlpSpanId(link.spanId), traceFlags: TraceFlags.SAMPLED },\n      })),\n      events: [],\n      ended: true,\n      resource: this.resource,\n      instrumentationScope: { name: this.scope },\n      droppedAttributesCount: 0,\n      droppedEventsCount: 0,\n      droppedLinksCount: 0,\n    };\n  }\n}\n"],"mappings":";;;;;AAAA,SAASA,kBAAkB;AAE3B,IAAMC,WAAW;AACjB,IAAMC,UAAU;AAEhB,IAAMC,QAAQ,wBAACC,IAAYC,WAA2BC,WAAW,QAAA,EAAUC,OAAOH,EAAAA,EAAII,OAAO,KAAA,EAAOC,MAAM,GAAGJ,MAAAA,GAA/F;AAUP,IAAMK,cAAc,wBAACN,OAAwBH,SAASU,KAAKP,EAAAA,IAAMA,KAAKD,MAAMC,IAAI,EAAA,GAA5D;AAOpB,IAAMQ,aAAa,wBAACR,OAAwBF,QAAQS,KAAKP,EAAAA,IAAMA,KAAKD,MAAMC,IAAI,EAAA,GAA3D;;;ACtB1B,SAASS,iBAAiB;AAC1B,SAASC,sBAAsB;AAC/B,SAASC,uBAAiC;AAC1C,SAASC,wBAAwBC,qBAAqD;;;ACHtF,SAAuBC,wBAAwB;AAOxC,IAAMC,kBAAkB,wBAACC,QAC9B,IAAIC,QAAQ,CAACC,SAASC,WAAAA;AACpBH,MAAII,CAAAA,WAAAA;AACF,QAAIA,OAAOC,SAASC,iBAAiBC,SAAS;AAC5CL,cAAAA;IACF,OAAO;AACLC,aAAOC,OAAOI,SAAS,IAAIC,MAAM,oBAAA,CAAA;IACnC;EACF,CAAA;AACF,CAAA,GAT6B;;;ADwB/B,IAAMC,YAAY;AAoBX,IAAMC,oBAAN,MAAMA;EAnDb,OAmDaA;;;EACMC;EACAC;EACAC;EACAC;;;;EAKjB,YAAYC,SAAmC;AAC7C,SAAKJ,WAAWI,QAAQJ;AACxB,SAAKC,WAAWG,QAAQH,YAAYI,gBAAAA;AACpC,SAAKH,QAAQE,QAAQF,SAAS;AAC9B,SAAKC,SAASC,QAAQD,WAAW,MAAM;EACzC;;;;;;;EAQA,MAAMG,OAAOC,SAAiD;AAC5D,QAAIA,QAAQC,WAAW,GAAG;AACxB;IACF;AACA,UAAMC,SAAS,oBAAIC,IAAAA;AACnB,eAAWC,UAAUJ,SAAS;AAC5BE,aAAOG,IAAID,OAAOE,MAAM;WAAKJ,OAAOK,IAAIH,OAAOE,IAAI,KAAK,CAAA;QAAKF;OAAO;IACtE;AACA,UAAMI,UAAU;SAAIN,OAAOO,QAAO;MAAIC,IAAI,CAAC,CAACJ,MAAMK,KAAAA,MAAW,KAAKC,SAASN,MAAMK,KAAAA,CAAAA;AACjF,UAAME,gBAAgBC,CAAAA,SAAQ,KAAKrB,SAASM,OAAO;MAAEL,UAAU,KAAKA;MAAUqB,cAAc;QAAC;UAAEpB,OAAO;YAAEW,MAAM,KAAKX;UAAM;UAAGa;QAAQ;;IAAG,GAAGM,IAAAA,CAAAA;EAC5I;;EAGA,MAAME,WAA0B;AAC9B,UAAM,KAAKvB,SAASuB,SAAQ;EAC9B;EAEQJ,SAASN,MAAcN,SAAqC;AAClE,UAAMiB,aAAa;MAAEX;MAAMY,aAAa;MAAIC,MAAM;MAAIC,WAAWC,UAAUC;IAAO;AAClF,UAAMC,SAAS,wBAACnB,YAA0B;MACxCoB,WAAWC,eAAerB,OAAOsB,MAAMC,SAAQ,CAAA;MAC/CC,SAASH,eAAerB,OAAOsB,MAAMC,SAAQ,IAAKpC,SAAAA;MAClDsC,YAAY;QAAE,GAAGzB,OAAO0B;MAAO;IACjC,IAJe;AAKf,YAAQ,KAAKlC,OAAOU,IAAAA,GAAAA;MAClB,KAAK;AACH,eAAO;UACLW;UACAc,wBAAwBC,uBAAuBC;UAC/CC,eAAeC,cAAcC;UAC7BC,aAAa;UACbC,YAAYtC,QAAQU,IAAIN,CAAAA,YAAW;YAAE,GAAGmB,OAAOnB,MAAAA;YAASmC,OAAOnC,OAAOoC,UAAUC;UAAI,EAAA;QACtF;MACF,KAAK;AACH,eAAO;UACLxB;UACAc,wBAAwBC,uBAAuBC;UAC/CC,eAAeC,cAAcO;UAC7BJ,YAAYtC,QAAQU,IAAIN,CAAAA,YAAW;YACjC,GAAGmB,OAAOnB,MAAAA;YACVmC,OAAO;cACLvC,SAAS;gBAAE2C,YAAY,CAAA;gBAAIC,QAAQ;kBAACxC,OAAOoC,UAAUK;;cAAO;cAC5DA,OAAOzC,OAAOoC,UAAUK;cACxBJ,KAAKrC,OAAOoC,UAAUC;cACtBK,KAAK1C,OAAOoC,UAAUM;cACtBC,KAAK3C,OAAOoC,UAAUO;YACxB;UACF,EAAA;QACF;MACF,KAAK;AACH,eAAO;UACL9B;UACAc,wBAAwBC,uBAAuBgB;UAC/Cd,eAAeC,cAAcc;UAC7BX,YAAYtC,QAAQU,IAAIN,CAAAA,YAAW;YAAE,GAAGmB,OAAOnB,MAAAA;YAASmC,OAAOnC,OAAOoC,UAAUU;UAAK,EAAA;QACvF;IACJ;EACF;AACF;;;AEnIA,SAASC,UAAUC,gBAAgBC,kBAAkB;AACrD,SAASC,gBAAgBC,kBAAAA,uBAAsB;AAC/C,SAASC,mBAAAA,wBAAiC;AA4BnC,IAAMC,iBAAN,MAAMA;EA9Bb,OA8BaA;;;EACMC;EACAC;EACAC;;;;EAKjB,YAAYC,SAAgC;AAC1C,SAAKH,WAAWG,QAAQH;AACxB,SAAKC,WAAWE,QAAQF,YAAYG,iBAAAA;AACpC,SAAKF,QAAQC,QAAQD,SAAS;EAChC;;;;;;;EAQA,MAAMG,OAAOC,OAA+C;AAC1D,QAAIA,MAAMC,WAAW,GAAG;AACtB;IACF;AACA,UAAMC,gBAAgBC,CAAAA,SACpB,KAAKT,SAASK,OACZC,MAAMI,IAAIC,CAAAA,SAAQ,KAAKC,WAAWD,IAAAA,CAAAA,GAClCF,IAAAA,CAAAA;EAGN;;EAGA,MAAMI,WAA0B;AAC9B,UAAM,KAAKb,SAASa,SAAQ;EAC9B;EAEQD,WAAWD,MAAkC;AACnD,UAAMG,UAAUC,YAAYJ,KAAKG,OAAO;AACxC,UAAME,UAAU;MAAEF;MAASG,QAAQC,WAAWP,KAAKM,MAAM;MAAGE,YAAYC,WAAWC;IAAQ;AAC3F,UAAMC,YAAYC,gBAAeZ,KAAKa,MAAMC,SAAQ,CAAA;AACpD,UAAMC,UAAUH,gBAAeZ,KAAKgB,IAAIF,SAAQ,CAAA;AAChD,WAAO;MACLG,MAAMjB,KAAKiB;MACXC,MAAMC,SAASC;MACfC,aAAa,6BAAMhB,SAAN;MACbiB,mBACEtB,KAAKuB,iBAAiBC,SAAYA,SAAY;QAAErB;QAASG,QAAQC,WAAWP,KAAKuB,YAAY;QAAGf,YAAYC,WAAWC;MAAQ;MACjIC;MACAI;MACAU,UAAUC,eAAef,WAAWI,OAAAA;MACpCY,QAAQ3B,KAAK4B,KAAK;QAAEC,MAAMC,eAAeC;MAAG,IAAI;QAAEF,MAAMC,eAAeE;QAAOC,SAASjC,KAAKkC;MAAM;MAClGC,YAAY;QAAE,GAAGnC,KAAKmC;MAAW;MACjCC,QAAQpC,KAAKoC,SAAS,CAAA,GAAIrC,IAAIsC,CAAAA,UAAS;QACrChC,SAAS;UAAEF,SAASC,YAAYiC,KAAKlC,OAAO;UAAGG,QAAQC,WAAW8B,KAAK/B,MAAM;UAAGE,YAAYC,WAAWC;QAAQ;MACjH,EAAA;MACA4B,QAAQ,CAAA;MACRC,OAAO;MACPjD,UAAU,KAAKA;MACfkD,sBAAsB;QAAEvB,MAAM,KAAK1B;MAAM;MACzCkD,wBAAwB;MACxBC,oBAAoB;MACpBC,mBAAmB;IACrB;EACF;AACF;","names":["createHash","TRACE_ID","SPAN_ID","hexOf","id","length","createHash","update","digest","slice","otlpTraceId","test","otlpSpanId","ValueType","millisToHrTime","defaultResource","AggregationTemporality","DataPointType","ExportResultCode","exportAsPromise","run","Promise","resolve","reject","result","code","ExportResultCode","SUCCESS","error","Error","MINUTE_MS","OtlpMetricsBridge","exporter","resource","scope","kindOf","options","defaultResource","export","buckets","length","byName","Map","bucket","set","name","get","metrics","entries","map","group","metricOf","exportAsPromise","done","scopeMetrics","shutdown","descriptor","description","unit","valueType","ValueType","DOUBLE","timing","startTime","millisToHrTime","start","toMillis","endTime","attributes","labels","aggregationTemporality","AggregationTemporality","DELTA","dataPointType","DataPointType","SUM","isMonotonic","dataPoints","value","aggregate","sum","HISTOGRAM","boundaries","counts","count","min","max","CUMULATIVE","GAUGE","last","SpanKind","SpanStatusCode","TraceFlags","hrTimeDuration","millisToHrTime","defaultResource","OtlpSpanBridge","exporter","resource","scope","options","defaultResource","export","spans","length","exportAsPromise","done","map","span","readableOf","shutdown","traceId","otlpTraceId","context","spanId","otlpSpanId","traceFlags","TraceFlags","SAMPLED","startTime","millisToHrTime","start","toMillis","endTime","end","name","kind","SpanKind","INTERNAL","spanContext","parentSpanContext","parentSpanId","undefined","duration","hrTimeDuration","status","ok","code","SpanStatusCode","OK","ERROR","message","error","attributes","links","link","events","ended","instrumentationScope","droppedAttributesCount","droppedEventsCount","droppedLinksCount"]}

package/dist/otlp.metrics.bridge.d.ts

@@ -0,0 +1,64 @@
+import { Resource } from '@opentelemetry/resources';
+import { PushMetricExporter } from '@opentelemetry/sdk-metrics';
+import { MetricBucket } from './metric.bucket.js';
+/**
+ * How a metric is sent over OTLP. The stored aggregate is the same for all three; this only says
+ * which part of it a collector should see.
+ *
+ * - `gauge` sends `last`.
+ * - `counter` sends `sum` as a monotonic delta sum.
+ * - `histogram` sends `count`, `sum`, `min` and `max` as a delta histogram with no bucket boundaries.
+ */
+export type MetricKind = 'gauge' | 'counter' | 'histogram';
+/**
+ * How an {@link OtlpMetricsBridge} is built.
+ */
+export interface OtlpMetricsBridgeOptions {
+    /** Where the metrics go: an `OTLPMetricExporter`, or `InMemoryMetricExporter` in tests. */
+    exporter: PushMetricExporter;
+    /** Says who is sending. Defaults to the SDK's default resource. */
+    resource?: Resource;
+    /** The instrumentation scope name. Defaults to `@maroonedsoftware/telemetry`. */
+    scope?: string;
+    /** Picks each metric's kind by name. Defaults to `gauge` for everything. */
+    kindOf?: (name: string) => MetricKind;
+}
+/**
+ * Sends drained minute buckets to an OTLP exporter as already-aggregated data.
+ *
+ * It does not go through a `MeterProvider`: the buckets are already aggregates, and recording them
+ * into SDK instruments would aggregate them a second time. Each bucket becomes one data point
+ * spanning its minute, with delta temporality, so a collector that wants cumulative series (a
+ * Prometheus exporter, say) needs its `deltatocumulative` processor.
+ *
+ * @example
+ * ```typescript
+ * const bridge = new OtlpMetricsBridge({
+ *   exporter: new OTLPMetricExporter({ url }),
+ *   resource: resourceFromAttributes({ 'service.name': 'my.app' }),
+ *   kindOf: name => (name.endsWith('.ms') ? 'histogram' : 'gauge'),
+ * });
+ * await bridge.export(buckets);
+ * ```
+ */
+export declare class OtlpMetricsBridge {
+    private readonly exporter;
+    private readonly resource;
+    private readonly scope;
+    private readonly kindOf;
+    /**
+     * @param options - The exporter, resource, scope and kind picker.
+     */
+    constructor(options: OtlpMetricsBridgeOptions);
+    /**
+     * Exports the buckets, one OTel metric per name.
+     *
+     * @param buckets - What a recorder drained.
+     * @throws Whatever the exporter reports when it fails.
+     */
+    export(buckets: readonly MetricBucket[]): Promise<void>;
+    /** Flushes and closes the exporter. */
+    shutdown(): Promise<void>;
+    private metricOf;
+}
+//# sourceMappingURL=otlp.metrics.bridge.d.ts.map

package/dist/otlp.metrics.bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp.metrics.bridge.d.ts","sourceRoot":"","sources":["../src/otlp.metrics.bridge.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,EAAqD,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACnH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,SAAS,GAAG,WAAW,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,2FAA2F;IAC3F,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,iFAAiF;IACjF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4EAA4E;IAC5E,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,CAAC;CACvC;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;IACpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+B;IAEtD;;OAEG;gBACS,OAAO,EAAE,wBAAwB;IAO7C;;;;;OAKG;IACG,MAAM,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAY7D,uCAAuC;IACjC,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B,OAAO,CAAC,QAAQ;CAyCjB"}

package/dist/otlp.metrics.receiver.d.ts

@@ -0,0 +1,79 @@
+import { DateTime } from 'luxon';
+import { MetricBucket } from './metric.bucket.js';
+/**
+ * Thrown when a body is not an OTLP metrics export at all. A body that is one but carries parts this
+ * receiver cannot use is not an error; those parts are counted in {@link OtlpReceiveResult}.
+ */
+export declare class OtlpPayloadError extends Error {
+    constructor(message: string);
+}
+/**
+ * How an {@link OtlpMetricsReceiver} bounds what it keeps.
+ */
+export interface OtlpMetricsReceiverOptions {
+    /** Distinct label sets kept per metric name. Further series are dropped. Defaults to 50. */
+    maxSeriesPerName?: number;
+    /** Distinct metric names kept. Further names are dropped. Defaults to 500. */
+    maxNames?: number;
+}
+/**
+ * What one {@link OtlpMetricsReceiver.receive} call produced.
+ */
+export interface OtlpReceiveResult {
+    /** Minute buckets, ready for a store. */
+    buckets: MetricBucket[];
+    /** Data points dropped by the series or name cap. */
+    dropped: number;
+    /** Data points of kinds this receiver does not read (exponential histograms, summaries), or malformed. */
+    unsupported: number;
+}
+/**
+ * Turns OTLP/JSON metric exports (the body of `POST /v1/metrics` with `Content-Type: application/json`)
+ * into minute buckets.
+ *
+ * - A **gauge** point, or a **non-monotonic sum** (an up-down counter), is one observation of its value.
+ * - A **monotonic sum** contributes its increase. A delta point is the increase; a cumulative point is
+ *   the difference from the previous point of the same series, so the first point of a series (and the
+ *   first after the sender restarts, which shows as a new start time or a smaller total) only sets the
+ *   baseline.
+ * - A **histogram** contributes its count and sum the same way, with `min` and `max` when a delta point
+ *   carries them. A cumulative histogram's extremes cover the sender's whole life, so they are replaced
+ *   by the interval's mean.
+ * - Exponential histograms and summaries are counted as unsupported.
+ *
+ * Labels are the point's attributes over the resource's `service.name`. Each name keeps at most
+ * `maxSeriesPerName` label sets and the receiver at most `maxNames` names, for its whole life: a
+ * sender that puts a request id in an attribute cannot grow the table without bound.
+ *
+ * Keep one instance per process. It holds the cumulative baselines, so a fresh instance costs every
+ * cumulative series one point.
+ */
+export declare class OtlpMetricsReceiver {
+    private readonly maxSeriesPerName;
+    private readonly maxNames;
+    private readonly series;
+    private readonly cumulative;
+    /**
+     * @param options - The series and name caps.
+     */
+    constructor(options?: OtlpMetricsReceiverOptions);
+    /**
+     * Reads one export request.
+     *
+     * @param body - The parsed JSON body.
+     * @param now - Used for points with no timestamp. Defaults to now.
+     * @throws {@link OtlpPayloadError} when the body has no `resourceMetrics` array.
+     */
+    receive(body: unknown, now?: DateTime): OtlpReceiveResult;
+    /** Whether a series may be kept, registering it if it is new and there is room. */
+    private admit;
+    /**
+     * The increase of a cumulative series since its previous point, or `undefined` when this point only
+     * sets the baseline (first sight, a new start time, or a total that went backwards).
+     *
+     * @param sum - The point's running total.
+     * @param count - The point's running observation count, for a histogram; zero for a sum.
+     */
+    private increase;
+}
+//# sourceMappingURL=otlp.metrics.receiver.d.ts.map

package/dist/otlp.metrics.receiver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp.metrics.receiver.d.ts","sourceRoot":"","sources":["../src/otlp.metrics.receiver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEjC,OAAO,EAAE,YAAY,EAAY,MAAM,oBAAoB,CAAC;AAG5D;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,4FAA4F;IAC5F,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,yCAAyC;IACzC,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,0GAA0G;IAC1G,WAAW,EAAE,MAAM,CAAC;CACrB;AAoFD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IACzD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsC;IAEjE;;OAEG;gBACS,OAAO,GAAE,0BAA+B;IAKpD;;;;;;OAMG;IACH,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,GAAE,QAAyB,GAAG,iBAAiB;IAwGzE,mFAAmF;IACnF,OAAO,CAAC,KAAK;IAmBb;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;CAQjB"}

package/dist/otlp.span.bridge.d.ts

@@ -0,0 +1,44 @@
+import { Resource } from '@opentelemetry/resources';
+import { SpanExporter } from '@opentelemetry/sdk-trace';
+import { FinishedSpan } from './finished.span.js';
+/**
+ * How an {@link OtlpSpanBridge} is built.
+ */
+export interface OtlpSpanBridgeOptions {
+    /** Where the spans go: an `OTLPTraceExporter`, or `InMemorySpanExporter` in tests. */
+    exporter: SpanExporter;
+    /** Says who is sending. Defaults to the SDK's default resource. */
+    resource?: Resource;
+    /** The instrumentation scope name. Defaults to `@maroonedsoftware/telemetry`. */
+    scope?: string;
+}
+/**
+ * Sends {@link FinishedSpan}s to an OTel span exporter.
+ *
+ * The spans are built as finished `ReadableSpan`s with the times the app recorded, rather than
+ * started and ended on a live tracer, so work timed before this bridge existed (or in a process
+ * with no tracer at all) exports with its real start and end. Ids are derived with
+ * {@link otlpTraceId} and {@link otlpSpanId}, so the same app id always lands in the same trace.
+ *
+ * The caller batches: hand it whatever accumulated since the last call.
+ */
+export declare class OtlpSpanBridge {
+    private readonly exporter;
+    private readonly resource;
+    private readonly scope;
+    /**
+     * @param options - The exporter, resource and scope.
+     */
+    constructor(options: OtlpSpanBridgeOptions);
+    /**
+     * Exports the spans.
+     *
+     * @param spans - Finished work, in any order.
+     * @throws Whatever the exporter reports when it fails.
+     */
+    export(spans: readonly FinishedSpan[]): Promise<void>;
+    /** Flushes and closes the exporter. */
+    shutdown(): Promise<void>;
+    private readableOf;
+}
+//# sourceMappingURL=otlp.span.bridge.d.ts.map

package/dist/otlp.span.bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp.span.bridge.d.ts","sourceRoot":"","sources":["../src/otlp.span.bridge.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,EAAgB,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAIlD;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,sFAAsF;IACtF,QAAQ,EAAE,YAAY,CAAC;IACvB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,iFAAiF;IACjF,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;GASG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;IACpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAE/B;;OAEG;gBACS,OAAO,EAAE,qBAAqB;IAM1C;;;;;OAKG;IACG,MAAM,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAY3D,uCAAuC;IACjC,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B,OAAO,CAAC,UAAU;CA4BnB"}

package/package.json

@@ -1,6 +1,106 @@
 {
   "name": "@maroonedsoftware/telemetry",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Minute-bucket metrics for ServerKit: an in-process recorder and gauge registry, a Kysely store with hourly rollups, and OpenTelemetry bridges.",
+  "author": {
+    "name": "Marooned Software",
+    "url": "https://github.com/MaroonedSoftware/serverkit"
+  },
+  "bugs": {
+    "url": "https://github.com/MaroonedSoftware/serverkit/issues"
+  },
+  "homepage": "https://github.com/MaroonedSoftware/serverkit/packages/telemetry#readme",
+  "keywords": [
+    "backend",
+    "metrics",
+    "telemetry",
+    "opentelemetry",
+    "otlp",
+    "serverkit",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MaroonedSoftware/serverkit.git"
+  },
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./kysely": {
+      "types": "./dist/kysely.d.ts",
+      "import": "./dist/kysely.js"
+    },
+    "./otlp": {
+      "types": "./dist/otlp.d.ts",
+      "import": "./dist/otlp.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "MIT",
+  "files": [
+    "AGENTS.md",
+    "dist/**"
+  ],
+  "dependencies": {
+    "injectkit": "^1.7.1",
+    "luxon": "^3.7.2"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/core": "^2.12.0",
+    "@opentelemetry/resources": "^2.12.0",
+    "@opentelemetry/sdk-metrics": "^2.12.0",
+    "@opentelemetry/sdk-trace": "^2.12.0",
+    "kysely": "^0.29.5"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
+    },
+    "@opentelemetry/core": {
+      "optional": true
+    },
+    "@opentelemetry/resources": {
+      "optional": true
+    },
+    "@opentelemetry/sdk-metrics": {
+      "optional": true
+    },
+    "@opentelemetry/sdk-trace": {
+      "optional": true
+    },
+    "kysely": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/core": "^2.12.0",
+    "@opentelemetry/otlp-transformer": "^0.223.0",
+    "@opentelemetry/resources": "^2.12.0",
+    "@opentelemetry/sdk-metrics": "^2.12.0",
+    "@opentelemetry/sdk-trace": "^2.12.0",
+    "@types/luxon": "^3.7.5",
+    "kysely": "^0.29.5",
+    "@repo/config-eslint": "0.2.1",
+    "@repo/config-typescript": "0.1.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/kysely.ts src/otlp.ts --format esm --sourcemap && tsc --emitDeclarationOnly --declaration",
+    "build:ci": "eslint --max-warnings=0 && pnpm run build",
+    "lint": "eslint --fix",
+    "format": "prettier --write .",
+    "test": "vitest run",
+    "test:ci": "vitest run --coverage"
+  }
 }