@benchkit/format 0.1.0

package/README.md

@@ -0,0 +1,521 @@
+# @benchkit/format
+
+Benchmark result types and format parsers for [benchkit](../../README.md). Parses Go bench output, [Hyperfine](https://github.com/sharkdp/hyperfine) JSON, [benchmark-action](https://github.com/benchmark-action/github-action-benchmark) JSON, [pytest-benchmark](https://pytest-benchmark.readthedocs.io/) JSON, and OTLP metrics JSON into a single normalized OTLP metrics document.
+
+## Installation
+
+> **Note:** `@benchkit/format` is not yet published to the npm registry.
+> Until the first release, install from source as described below.
+
+Clone the benchkit repository, install dependencies, and build the package:
+
+```bash
+git clone https://github.com/strawgate/benchkit.git
+cd benchkit
+npm ci
+npm run build --workspace=packages/format
+```
+
+Then, from your project directory, link the local package (adjust the path
+to where you cloned benchkit):
+
+```bash
+npm link <path-to-benchkit>/packages/format
+```
+
+Or use a `file:` reference in your project's `package.json`:
+
+```jsonc
+{
+  "dependencies": {
+    "@benchkit/format": "file:<path-to-benchkit>/packages/format"
+  }
+}
+```
+
+Once published, you will be able to install directly:
+
+```bash
+npm install @benchkit/format
+```
+
+## Quick start
+
+```ts
+import { parseBenchmarks } from "@benchkit/format";
+
+// Auto-detect the format and parse
+const result = parseBenchmarks(input);
+
+for (const bench of result.benchmarks) {
+  for (const [name, metric] of Object.entries(bench.metrics)) {
+    console.log(`${bench.name} ${name}: ${metric.value} ${metric.unit ?? ""}`);
+  }
+}
+```
+
+## Building native results
+
+If your benchmark does not come from a tool like `go test -bench`, you can
+build benchkit-native results programmatically and then write them to disk.
+
+```ts
+import {
+  buildNativeResult,
+  stringifyNativeResult,
+} from "@benchkit/format";
+
+const result = buildNativeResult({
+  context: {
+    commit: process.env.GITHUB_SHA,
+    ref: process.env.GITHUB_REF,
+    timestamp: new Date().toISOString(),
+  },
+  benchmarks: [
+    {
+      name: "mock-http-ingest",
+      tags: {
+        kind: "workflow",
+        scenario: "json-ingest",
+      },
+      metrics: {
+        events_per_sec: { value: 13240.5, unit: "events/sec" },
+        p95_batch_ms: { value: 143.2, unit: "ms", direction: "smaller_is_better" },
+        service_rss_mb: { value: 543.1, unit: "MB", direction: "smaller_is_better" },
+      },
+      samples: [
+        { t: 0, events_per_sec: 0, service_rss_mb: 112.3 },
+        { t: 1, events_per_sec: 11884.2, service_rss_mb: 241.7 },
+      ],
+    },
+  ],
+});
+
+const json = stringifyNativeResult(result);
+// write json to workflow-bench.json
+```
+
+Shorthands:
+
+- numeric metrics like `{ parse_errors: 0 }` are accepted
+- direction is inferred from `unit` when omitted, e.g. `events/sec` becomes
+  `bigger_is_better`
+
+## Parser entry points
+
+### `parseBenchmarks(input, format?)`
+
+Main entry point. Accepts a string and an optional format hint. When `format` is
+omitted or `"auto"`, the parser inspects the input and picks the right strategy:
+
+| Detected shape | Trigger | Format |
+|---|---|---|
+| JSON object with a `benchmarks` array whose entries have a `stats` object | `benchmarks[0].stats` is an object | `pytest-benchmark` |
+| JSON object with a `benchmarks` array | Top-level `benchmarks` key present | `native` |
+| JSON object with a `resourceMetrics` array | Top-level `resourceMetrics` key present | `otlp` |
+| JSON object with a `results` array | Top-level `results` key with objects containing a `command` string | `hyperfine` |
+| JSON array of objects | Array whose first element has both a string `name` and a numeric `value` | `benchmark-action` |
+| Plain text lines | Lines matching `/^Benchmark\w.*\s+\d+\s+[\d.]+\s+\w+\/\w+/` | `go` |
+| Plain text lines | Lines matching `/^test\s+\S+\s+\.\.\.\s+bench:/` | `rust` |
+
+If auto-detection fails, `parseBenchmarks` throws with a message listing the supported formats.
+
+```ts
+import { parseBenchmarks } from "@benchkit/format";
+
+// Explicit format
+const result = parseBenchmarks(goOutput, "go");
+
+// Auto-detect (default)
+const result = parseBenchmarks(unknownInput);
+```
+
+### `parseOtlp(input)`
+
+Parses OTLP metrics JSON and provides helpers for:
+
+- reading resource and datapoint attributes
+- discriminating metric kinds (`gauge`, `sum`, `histogram`)
+- reading aggregation temporality
+
+```ts
+import { parseOtlp } from "@benchkit/format";
+
+const document = parseOtlp(otlpJson);
+```
+
+### `parseGoBench(input)`
+
+Parses Go `testing.B` text output. Each benchmark line produces one `Benchmark`
+entry. The `-P` processor suffix is extracted into a `procs` tag. Multiple
+value/unit pairs on the same line produce separate named metrics.
+
+**Input** (typical `go test -bench=. -benchmem` output):
+
+```
+goos: linux
+goarch: amd64
+BenchmarkSort/small-8     500000     2345 ns/op     128 B/op     3 allocs/op
+BenchmarkSort/large-8       1000   987654 ns/op   65536 B/op   512 allocs/op
+BenchmarkHash-8          1000000      890 ns/op       0 B/op     0 allocs/op
+PASS
+ok  	example.com/mypackage	3.456s
+```
+
+**Call:**
+
+```ts
+import { parseGoBench } from "@benchkit/format";
+
+const input = `
+BenchmarkSort/small-8     500000     2345 ns/op     128 B/op     3 allocs/op
+BenchmarkSort/large-8       1000   987654 ns/op   65536 B/op   512 allocs/op
+BenchmarkHash-8          1000000      890 ns/op       0 B/op     0 allocs/op
+`.trim();
+
+const result = parseGoBench(input);
+```
+
+**Result** (abbreviated):
+
+```json
+{
+  "benchmarks": [
+    {
+      "name": "BenchmarkSort/small",
+      "tags": { "procs": "8" },
+      "metrics": {
+        "ns_per_op":     { "value": 2345,   "unit": "ns/op",     "direction": "smaller_is_better" },
+        "bytes_per_op":  { "value": 128,    "unit": "B/op",      "direction": "smaller_is_better" },
+        "allocs_per_op": { "value": 3,      "unit": "allocs/op", "direction": "smaller_is_better" }
+      }
+    },
+    {
+      "name": "BenchmarkSort/large",
+      "tags": { "procs": "8" },
+      "metrics": {
+        "ns_per_op":     { "value": 987654, "unit": "ns/op",     "direction": "smaller_is_better" },
+        "bytes_per_op":  { "value": 65536,  "unit": "B/op",      "direction": "smaller_is_better" },
+        "allocs_per_op": { "value": 512,    "unit": "allocs/op", "direction": "smaller_is_better" }
+      }
+    },
+    {
+      "name": "BenchmarkHash",
+      "tags": { "procs": "8" },
+      "metrics": {
+        "ns_per_op":     { "value": 890, "unit": "ns/op", "direction": "smaller_is_better" },
+        "bytes_per_op":  { "value": 0,   "unit": "B/op",  "direction": "smaller_is_better" },
+        "allocs_per_op": { "value": 0,   "unit": "allocs/op", "direction": "smaller_is_better" }
+      }
+    }
+  ]
+}
+```
+
+### `parseBenchmarkAction(input)`
+
+Parses the JSON array format used by
+[benchmark-action/github-action-benchmark](https://github.com/benchmark-action/github-action-benchmark).
+Each array entry becomes one `Benchmark` with a single metric called `value`.
+The `range` string (e.g. `"± 300"`) is parsed into a numeric `range` field.
+
+**Input** (JSON produced by the benchmark tool):
+
+```json
+[
+  { "name": "encode/small",  "value": 125430, "unit": "ops/sec", "range": "± 1200" },
+  { "name": "encode/medium", "value":  48200, "unit": "ops/sec", "range": "± 480" },
+  { "name": "decode/small",  "value":  98700, "unit": "ops/sec" },
+  { "name": "latency/p99",   "value":    4.2, "unit": "ms",      "range": "+/- 0.3" }
+]
+```
+
+**Call:**
+
+```ts
+import { parseBenchmarkAction } from "@benchkit/format";
+
+const result = parseBenchmarkAction(input);
+```
+
+**Result** (abbreviated):
+
+```json
+{
+  "benchmarks": [
+    {
+      "name": "encode/small",
+      "metrics": {
+        "value": { "value": 125430, "unit": "ops/sec", "direction": "bigger_is_better", "range": 1200 }
+      }
+    },
+    {
+      "name": "encode/medium",
+      "metrics": {
+        "value": { "value": 48200, "unit": "ops/sec", "direction": "bigger_is_better", "range": 480 }
+      }
+    },
+    {
+      "name": "decode/small",
+      "metrics": {
+        "value": { "value": 98700, "unit": "ops/sec", "direction": "bigger_is_better" }
+      }
+    },
+    {
+      "name": "latency/p99",
+      "metrics": {
+        "value": { "value": 4.2, "unit": "ms", "direction": "smaller_is_better", "range": 0.3 }
+      }
+    }
+  ]
+}
+```
+
+### `parseRustBench(input)`
+
+Parses Rust `cargo bench` (libtest) text output. Each benchmark line produces one
+`Benchmark` entry.
+
+```ts
+import { parseRustBench } from "@benchkit/format";
+
+const result = parseRustBench(
+  "test sort::bench_sort   ... bench:         320 ns/iter (+/- 42)"
+);
+// result.benchmarks[0].metrics => { ns_per_iter: { value: 320, unit: "ns/iter", range: 42 } }
+```
+
+### `parseHyperfine(input)`
+
+Parses the JSON export from [Hyperfine](https://github.com/sharkdp/hyperfine)
+(`hyperfine --export-json`). Each result becomes a benchmark named after the
+command, with `mean`, `stddev`, `median`, `min`, and `max` metrics.
+
+```ts
+import { parseHyperfine } from "@benchkit/format";
+
+const result = parseHyperfine(JSON.stringify({
+  results: [
+    {
+      command: "sleep 0.1",
+      mean: 0.105,
+      stddev: 0.002,
+      median: 0.105,
+      min: 0.103,
+      max: 0.108,
+      times: [0.103, 0.105, 0.108]
+    }
+  ]
+}));
+```
+
+### `parsePytestBenchmark(input)`
+
+Parses [pytest-benchmark](https://pytest-benchmark.readthedocs.io/) JSON output
+(`pytest --benchmark-json=results.json`). Each benchmark entry becomes a
+`Benchmark` with metrics for `mean` (primary, seconds), `ops`, `rounds`,
+`median`, `min`, `max`, and `stddev`.
+
+```ts
+import { parsePytestBenchmark } from "@benchkit/format";
+
+const result = parsePytestBenchmark(JSON.stringify({
+  benchmarks: [
+    {
+      name: "test_sort",
+      fullname: "tests/test_perf.py::test_sort",
+      stats: {
+        min: 0.000123,
+        max: 0.000156,
+        mean: 0.000134,
+        stddev: 0.0000089,
+        rounds: 1000,
+        median: 0.000132,
+        ops: 7462.68
+      }
+    }
+  ]
+}));
+// result.benchmarks[0].metrics.mean  => { value: 0.000134, unit: "s", direction: "smaller_is_better", range: 0.0000089 }
+// result.benchmarks[0].metrics.ops   => { value: 7462.68, unit: "ops/s", direction: "bigger_is_better" }
+// result.benchmarks[0].metrics.rounds => { value: 1000, direction: "bigger_is_better" }
+```
+
+**Python example** — generate and consume pytest-benchmark output:
+
+```python
+# conftest.py / test_perf.py
+def test_sort(benchmark):
+    benchmark(sorted, range(1000))
+```
+
+```bash
+pytest --benchmark-json=results.json
+```
+
+```ts
+import { readFileSync } from "fs";
+import { parsePytestBenchmark } from "@benchkit/format";
+
+const result = parsePytestBenchmark(readFileSync("results.json", "utf-8"));
+for (const bench of result.benchmarks) {
+  console.log(`${bench.name}: ${bench.metrics.mean.value}s (${bench.metrics.ops.value} ops/s)`);
+}
+```
+
+### `inferDirection(unit)`
+
+Infers whether a unit string represents a "bigger is better" or "smaller is
+better" metric. Used internally by all parsers when no explicit `direction` is
+provided.
+
+```ts
+import { inferDirection } from "@benchkit/format";
+
+inferDirection("ops/sec");   // "bigger_is_better"
+inferDirection("MB/s");      // "bigger_is_better"
+inferDirection("throughput"); // "bigger_is_better"
+inferDirection("ns/op");     // "smaller_is_better"
+inferDirection("ms");        // "smaller_is_better"
+inferDirection("B/op");      // "smaller_is_better"
+```
+
+The heuristic scans the lowercased unit string for substrings:
+
+| Matched substring | Direction | Example units |
+|---|---|---|
+| `ops/s` | `bigger_is_better` | `ops/sec`, `ops/s` |
+| `op/s` | `bigger_is_better` | `op/sec`, `op/s` |
+| `/sec` | `bigger_is_better` | `req/sec`, `events/sec` |
+| `mb/s` | `bigger_is_better` | `MB/s`, `mb/s` |
+| `throughput` | `bigger_is_better` | `throughput` |
+| `events` | `bigger_is_better` | `events`, `events/sec` |
+| _(no match)_ | `smaller_is_better` | `ns/op`, `ms`, `B/op`, `allocs/op`, `ns/iter`, `bytes` |
+
+## Types
+
+All types mirror the JSON schemas in [`schema/`](../../schema/README.md).
+
+### `compareRuns(current, baseline[], config?)`
+
+Compare a current benchmark run against one or more baseline runs.
+
+```ts
+import { compareRuns } from "@benchkit/format";
+
+const result = compareRuns(current, [baseline]);
+if (result.hasRegression) {
+  console.log("Regressions detected!");
+}
+```
+
+### `Sample`
+
+A time-series data point within a benchmark run. `t` is seconds since
+benchmark start; all other keys are metric values at that instant.
+
+```ts
+interface Sample {
+  t: number;
+  [metricName: string]: number;
+}
+```
+
+### `MonitorContext`
+
+Metadata about the resource monitoring context (when monitor output is merged via stash action).
+
+```ts
+interface MonitorContext {
+  monitor_version: string;
+  poll_interval_ms: number;
+  duration_ms: number;
+  runner_os?: string;
+  runner_arch?: string;
+  poll_count?: number;
+  kernel?: string;
+  cpu_model?: string;
+  cpu_count?: number;
+  total_memory_mb?: number;
+}
+```
+
+### Series and index types
+
+These types describe the aggregated files on the `bench-data` branch (see
+[Data files](#data-files) below):
+
+| Type | Schema | Purpose |
+|---|---|---|
+| `IndexFile` | [`index.schema.json`](../../schema/index.schema.json) | Run listing with per-run metadata |
+| `RunEntry` | (inline in index schema) | Single entry inside `IndexFile.runs` |
+| `SeriesFile` | [`series.schema.json`](../../schema/series.schema.json) | Pre-aggregated time-series for one metric |
+| `SeriesEntry` | (inline in series schema) | Points array for one benchmark within a series |
+| `DataPoint` | (inline in series schema) | Single `{timestamp, value}` point |
+
+## Metric naming conventions
+
+When the Go and benchmark-action parsers normalize metrics they apply these
+rules:
+
+| Go unit | Metric name | Rule |
+|---|---|---|
+| `ns/op` | `ns_per_op` | Replace `/` with `_per_`, lowercase |
+| `B/op` | `bytes_per_op` | Known alias |
+| `allocs/op` | `allocs_per_op` | Replace `/` with `_per_`, lowercase |
+| `MB/s` | `mb_per_s` | Known alias |
+
+General algorithm: replace every `/` with `_per_`, replace spaces with `_`,
+then lowercase. Specific aliases (`B/op` → `bytes_per_op`, `MB/s` → `mb_per_s`, `ns/iter` → `ns_per_iter`)
+take precedence.
+
+## Direction semantics
+
+Every metric may declare whether higher or lower values represent improvement.
+
+| Direction | Meaning | Examples |
+|---|---|---|
+| `bigger_is_better` | Higher values are improvements | throughput, ops/sec, MB/s |
+| `smaller_is_better` | Lower values are improvements | latency, ns/op, allocations |
+
+When direction is not specified in the input, all parsers call `inferDirection(unit)`
+to infer it from the unit string. See the [`inferDirection` section](#inferdirectionunit)
+for the full list of recognized unit patterns.
+
+If no unit is provided and no direction is set, consumers should treat the
+metric as `smaller_is_better`.
+
+## Data files
+
+The `bench-stash` and `bench-aggregate` actions maintain a set of JSON files
+on a dedicated Git branch (default `bench-data`). The branch layout is:
+
+```
+data/
+├── index.json              # All runs (IndexFile)
+├── runs/
+│   ├── {runId}.json        # OTLP metrics JSON for one run
+│   └── ...
+└── series/
+    ├── {metricName}.json   # Time-series for one metric (SeriesFile)
+    └── ...
+```
+
+| File | Schema | Written by |
+|---|---|---|
+| `data/index.json` | [`index.schema.json`](../../schema/index.schema.json) | `bench-aggregate` |
+| `data/runs/{id}.json` | OTLP metrics JSON | `bench-stash` |
+| `data/series/{metric}.json` | [`series.schema.json`](../../schema/series.schema.json) | `bench-aggregate` |
+
+## Validating your own output
+
+Validate aggregated output against the JSON schemas:
+
+```bash
+npx ajv validate -s schema/index.schema.json -d data/index.json
+npx ajv validate -s schema/series.schema.json -d data/series/ns_per_op.json
+```
+
+## License
+
+MIT

package/dist/build-otlp-result.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Build an OtlpMetricsDocument from a simple benchmark input shape.
+ *
+ * This is the canonical way to produce OTLP output from any parser or
+ * builder. Modeled after emit-metric's buildOtlpMetricPayload().
+ */
+import type { OtlpMetricsDocument } from "./types.js";
+import type { Direction, RunKind, SourceFormat } from "./otlp-conventions.js";
+export interface OtlpResultMetric {
+    value: number;
+    unit?: string;
+    direction?: Direction;
+}
+export interface OtlpResultBenchmark {
+    name: string;
+    tags?: Record<string, string>;
+    metrics: Record<string, OtlpResultMetric | number>;
+}
+export interface OtlpResultContext {
+    runId?: string;
+    kind?: RunKind;
+    sourceFormat: SourceFormat;
+    ref?: string;
+    commit?: string;
+    workflow?: string;
+    job?: string;
+    runAttempt?: string;
+    runner?: string;
+    serviceName?: string;
+}
+export interface BuildOtlpResultOptions {
+    benchmarks: OtlpResultBenchmark[];
+    context?: OtlpResultContext;
+}
+/**
+ * Build an OtlpMetricsDocument from a list of benchmarks and optional context.
+ *
+ * Each benchmark becomes a scenario. Each metric key within a benchmark
+ * becomes a separate OTLP metric with a single gauge datapoint carrying
+ * benchkit semantic attributes.
+ */
+export declare function buildOtlpResult(options: BuildOtlpResultOptions): OtlpMetricsDocument;
+//# sourceMappingURL=build-otlp-result.d.ts.map

package/dist/build-otlp-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-otlp-result.d.ts","sourceRoot":"","sources":["../src/build-otlp-result.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EACV,mBAAmB,EAIpB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAoB9E,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAAC,CAAC;CACpD;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,EAAE,YAAY,CAAC;IAC3B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC7B;AA+CD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,mBAAmB,CAkDpF"}

package/dist/build-otlp-result.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOtlpResult = buildOtlpResult;
+const otlp_conventions_js_1 = require("./otlp-conventions.js");
+// ---- Attribute helpers ----------------------------------------------------
+function toOtlpValue(value) {
+    if (typeof value === "boolean")
+        return { boolValue: value };
+    if (typeof value === "number") {
+        return Number.isSafeInteger(value)
+            ? { intValue: String(value) }
+            : { doubleValue: value };
+    }
+    return { stringValue: value };
+}
+function attr(key, value) {
+    return { key, value: toOtlpValue(value) };
+}
+function dataPointValue(value) {
+    return Number.isSafeInteger(value)
+        ? { asInt: String(value) }
+        : { asDouble: value };
+}
+// ---- Build ----------------------------------------------------------------
+function buildResourceAttributes(ctx) {
+    const attrs = [];
+    if (ctx.runId)
+        attrs.push(attr(otlp_conventions_js_1.ATTR_RUN_ID, ctx.runId));
+    if (ctx.kind)
+        attrs.push(attr(otlp_conventions_js_1.ATTR_KIND, ctx.kind));
+    attrs.push(attr(otlp_conventions_js_1.ATTR_SOURCE_FORMAT, ctx.sourceFormat));
+    if (ctx.ref)
+        attrs.push(attr(otlp_conventions_js_1.ATTR_REF, ctx.ref));
+    if (ctx.commit)
+        attrs.push(attr(otlp_conventions_js_1.ATTR_COMMIT, ctx.commit));
+    if (ctx.workflow)
+        attrs.push(attr(otlp_conventions_js_1.ATTR_WORKFLOW, ctx.workflow));
+    if (ctx.job)
+        attrs.push(attr(otlp_conventions_js_1.ATTR_JOB, ctx.job));
+    if (ctx.runAttempt)
+        attrs.push(attr(otlp_conventions_js_1.ATTR_RUN_ATTEMPT, ctx.runAttempt));
+    if (ctx.runner)
+        attrs.push(attr(otlp_conventions_js_1.ATTR_RUNNER, ctx.runner));
+    if (ctx.serviceName)
+        attrs.push(attr(otlp_conventions_js_1.ATTR_SERVICE_NAME, ctx.serviceName));
+    return attrs;
+}
+function normalizeMetric(input) {
+    return typeof input === "number" ? { value: input } : input;
+}
+/**
+ * Build an OtlpMetricsDocument from a list of benchmarks and optional context.
+ *
+ * Each benchmark becomes a scenario. Each metric key within a benchmark
+ * becomes a separate OTLP metric with a single gauge datapoint carrying
+ * benchkit semantic attributes.
+ */
+function buildOtlpResult(options) {
+    const ctx = options.context ?? { sourceFormat: "otlp" };
+    const now = String(BigInt(Date.now()) * 1000000n);
+    const metrics = [];
+    for (const bench of options.benchmarks) {
+        for (const [metricName, rawMetric] of Object.entries(bench.metrics)) {
+            const m = normalizeMetric(rawMetric);
+            const pointAttrs = [
+                attr(otlp_conventions_js_1.ATTR_SCENARIO, bench.name),
+                attr(otlp_conventions_js_1.ATTR_SERIES, bench.name),
+                attr(otlp_conventions_js_1.ATTR_METRIC_ROLE, "outcome"),
+            ];
+            if (m.direction) {
+                pointAttrs.push(attr(otlp_conventions_js_1.ATTR_METRIC_DIRECTION, m.direction));
+            }
+            if (bench.tags) {
+                for (const [k, v] of Object.entries(bench.tags)) {
+                    pointAttrs.push(attr(k, v));
+                }
+            }
+            metrics.push({
+                name: metricName,
+                unit: m.unit,
+                gauge: {
+                    dataPoints: [{
+                            timeUnixNano: now,
+                            attributes: pointAttrs,
+                            ...dataPointValue(m.value),
+                        }],
+                },
+            });
+        }
+    }
+    return {
+        resourceMetrics: [{
+                resource: {
+                    attributes: buildResourceAttributes(ctx),
+                },
+                scopeMetrics: [{
+                        metrics,
+                    }],
+            }],
+    };
+}
+//# sourceMappingURL=build-otlp-result.js.map

package/dist/build-otlp-result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-otlp-result.js","sourceRoot":"","sources":["../src/build-otlp-result.ts"],"names":[],"mappings":"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"}

package/dist/build-otlp-result.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build-otlp-result.test.d.ts.map

package/dist/build-otlp-result.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-otlp-result.test.d.ts","sourceRoot":"","sources":["../src/build-otlp-result.test.ts"],"names":[],"mappings":""}