@r_masseater/vitest-otlp 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,87 @@
+MIT License
+
+Copyright (c) 2026 masseater
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+@tanstack/eslint-plugin-start
+
+MIT License
+
+Copyright (c) 2021-present Tanner Linsley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+@typescript-eslint/utils
+
+MIT License
+
+Copyright (c) 2019 typescript-eslint and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+globals
+
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,171 @@
-# Temporary Holding Version
+# @r_masseater/vitest-otlp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A Vitest plugin that receives OTLP during tests. A test can then assert the
+spans, metrics and logs that the code under test really exported. It shows that
+auto-instrumentation and `OTEL_*` settings work. It also shows that telemetry
+actually leaves the process.
+
+It requires [Vite+](https://viteplus.dev/) and Node.js 26 or later.
+
+```sh
+vp add -D @r_masseater/vitest-otlp
+```
+
+```ts
+import { otlp } from "@r_masseater/vitest-otlp";
+import { defineConfig } from "vite-plus";
+
+export default defineConfig({
+  plugins: [otlp()],
+});
+```
+
+```ts
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { waitForSpans } from "@r_masseater/vitest-otlp";
+import { Effect } from "effect";
+import { expect, test } from "vite-plus/test";
+
+test("checkout is traced", () =>
+  Effect.gen(function* () {
+    const sdk = new NodeSDK();
+    sdk.start();
+    yield* checkout;
+    yield* Effect.promise(() => sdk.shutdown());
+
+    const spans = yield* waitForSpans({
+      where: (span) => span.name === "checkout",
+    });
+    expect(spans).toMatchObject([{ attributes: { "order.id": "o-1" } }]);
+  }).pipe(Effect.runPromise));
+```
+
+## How it works
+
+Each test file gets its own OTLP receiver on free loopback ports. It serves
+OTLP/HTTP with protobuf or JSON, and OTLP/gRPC. Both accept gzip. Messages are
+decoded with code that [protobuf-es](https://github.com/bufbuild/protobuf-es)
+generated from
+[opentelemetry-proto](https://github.com/open-telemetry/opentelemetry-proto)
+v1.11.1.
+
+The test learns the receiver through the standard environment variables. An SDK
+that reads its configuration from the environment sends to it without code
+changes. Child processes of the test inherit the variables. They send to the
+same receiver.
+
+An in-memory exporter skips the real export path. This plugin instead sends
+over OTLP and reads the environment, just as production does. A Collector or
+grafana/otel-lgtm in a container needs Docker. This plugin needs none, and the
+test reads what arrived directly.
+
+## API
+
+The read API is written with Effect.
+
+`waitForSpans`, `waitForLogs` and `waitForMetrics` wait for items that match
+`where`. They reread every `interval` until `count` items arrive, and return all
+matches. The defaults are 20 ms and 1. After `timeout` they fail with
+`TelemetryNotReceived`, which carries how many arrived. The default timeout is
+5 seconds.
+
+`receivedSpans`, `receivedLogs` and `receivedMetrics` return everything that has
+arrived in the test file so far. `clearTelemetry` discards what has arrived.
+`receiverAddress` returns the `httpEndpoint` and `grpcEndpoint` of the receiver.
+
+Attributes become plain objects such as `{ "order.id": "o-1" }`. IDs become hex
+strings. Spans and logs carry `resource` and `scope`. They hold the resource
+attributes and the instrumentation scope.
+
+## Environment
+
+`OTEL_EXPORTER_OTLP_ENDPOINT` is the HTTP URL of the receiver. When
+`OTEL_EXPORTER_OTLP_PROTOCOL` is `grpc`, it is the gRPC URL instead.
+`OTEL_TRACES_EXPORTER`, `OTEL_METRICS_EXPORTER` and `OTEL_LOGS_EXPORTER` are
+`otlp`.
+
+Export delays are shortened, but only when they are unset.
+
+| Variable                      | Value |
+| ----------------------------- | ----- |
+| `OTEL_BSP_SCHEDULE_DELAY`     | 50    |
+| `OTEL_BLRP_SCHEDULE_DELAY`    | 50    |
+| `OTEL_METRIC_EXPORT_INTERVAL` | 100   |
+| `OTEL_METRIC_EXPORT_TIMEOUT`  | 100   |
+
+The per-signal variables `OTEL_EXPORTER_OTLP_<SIGNAL>_ENDPOINT` are emptied.
+Test telemetry therefore never leaks to an outside Collector.
+
+The receiver closes when the test file ends. With `isolate: false`, files may
+share one SDK. Then telemetry from the second file on is lost.
+
+## Semantic conventions
+
+`otlp({ semconv: true })` also checks every export against the OpenTelemetry
+semantic conventions. It starts the live-check of
+[OpenTelemetry Weaver](https://github.com/open-telemetry/weaver) once for the
+run. Each receiver forwards what it gets to Weaver before storing it. When the
+run ends, the plugin reads the report of Weaver. The run then fails and lists
+every finding at or above `failOn`.
+
+```ts
+otlp({
+  semconv: {
+    registry: "https://github.com/open-telemetry/semantic-conventions.git@v1.45.0[model]",
+    weaver: "weaver",
+    failOn: "violation",
+  },
+});
+```
+
+The values above are the defaults. `failOn` is `violation`, `improvement` or
+`information`. A custom attribute is a violation unless `registry` points to a
+registry that defines it. The `weaver` binary must be on `PATH`. In GitHub
+Actions, the
+[setup-weaver](https://github.com/open-telemetry/weaver/tree/main/.github/actions/setup-weaver)
+action installs it.
+
+## Cloudflare Workers
+
+Workers trace KV, D1, R2 and `fetch` calls without code changes, and hand the
+spans and logs to a
+[streaming tail worker](https://developers.cloudflare.com/workers/observability/logs/tail-workers/).
+`tailWorker()` from `@r_masseater/vitest-otlp/workers` builds a tail worker for
+[Miniflare](https://developers.cloudflare.com/workers/testing/miniflare/). It
+turns each invocation into OTLP and sends it to the receiver of the test file.
+
+```ts
+import { waitForSpans } from "@r_masseater/vitest-otlp";
+import { tailWorker } from "@r_masseater/vitest-otlp/workers";
+import { Effect } from "effect";
+import { Miniflare } from "miniflare";
+
+test("caching writes to KV", () =>
+  Effect.gen(function* () {
+    const tail = yield* tailWorker();
+    const miniflare = new Miniflare({
+      workers: [
+        {
+          name: "app",
+          scriptPath: "worker.js",
+          kvNamespaces: ["CACHE"],
+          streamingTails: [tail.name],
+        },
+        tail,
+      ],
+    });
+    yield* Effect.promise(() => miniflare.dispatchFetch("http://localhost/"));
+    yield* waitForSpans({ where: (span) => span.name === "kv_put" });
+    yield* Effect.promise(() => miniflare.dispose());
+  }).pipe(Effect.runPromise));
+```
+
+The invocation becomes a server span named after its trigger, such as `fetch`.
+Each traced call becomes a client span under it, and `console` calls become log
+records in the same trace. The resource `service.name` is the script name of
+the Worker. Miniflare reports no script name, so pass `serviceName` to
+`tailWorker()` instead.
+
+## License
+
+MIT

package/dist/context-COyJBDQM.mjs

@@ -0,0 +1,6 @@
+// src/context.ts
+const SEMCONV_KEY = "vitest-otlp:semconv";
+const FORWARD_KEY = "vitest-otlp:forward";
+export { SEMCONV_KEY as n, FORWARD_KEY as t };
+
+//# sourceMappingURL=context-COyJBDQM.mjs.map

package/dist/context-COyJBDQM.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-COyJBDQM.mjs","names":[],"sources":["../src/context.ts"],"sourcesContent":["type SemconvLevel = \"violation\" | \"improvement\" | \"information\";\n\ninterface SemconvOptions {\n  readonly registry?: string;\n  readonly weaver?: string;\n  readonly failOn?: SemconvLevel;\n}\n\ninterface ResolvedSemconv {\n  readonly registry: string;\n  readonly weaver: string;\n  readonly failOn: SemconvLevel;\n}\n\nconst SEMCONV_KEY = \"vitest-otlp:semconv\";\nconst FORWARD_KEY = \"vitest-otlp:forward\";\n\ndeclare module \"vite-plus/test\" {\n  interface ProvidedContext {\n    readonly [SEMCONV_KEY]?: ResolvedSemconv;\n    readonly [FORWARD_KEY]?: readonly string[];\n  }\n}\n\nexport { FORWARD_KEY, SEMCONV_KEY };\nexport type { ResolvedSemconv, SemconvLevel, SemconvOptions };\n"],"mappings":";AAcA,MAAM,cAAc;AACpB,MAAM,cAAc"}

package/dist/index.d.mts

@@ -0,0 +1,98 @@
+import { t as ReceiverNotRunning } from "./store-8DpTwYxj.mjs";
+import { Duration, Effect, Schema } from "effect";
+import { Plugin } from "vite-plus";
+type SemconvLevel = "violation" | "improvement" | "information";
+interface SemconvOptions {
+  readonly registry?: string;
+  readonly weaver?: string;
+  readonly failOn?: SemconvLevel;
+}
+interface ResolvedSemconv {
+  readonly registry: string;
+  readonly weaver: string;
+  readonly failOn: SemconvLevel;
+}
+declare const SEMCONV_KEY = "vitest-otlp:semconv";
+declare const FORWARD_KEY = "vitest-otlp:forward";
+declare module "vite-plus/test" {
+  interface ProvidedContext {
+    readonly [SEMCONV_KEY]?: ResolvedSemconv;
+    readonly [FORWARD_KEY]?: readonly string[];
+  }
+}
+interface ReceiverAddress {
+  readonly httpEndpoint: string;
+  readonly grpcEndpoint: string;
+}
+type Attributes = Readonly<Record<string, unknown>>;
+interface InstrumentationScope {
+  readonly name: string;
+  readonly version?: string;
+  readonly attributes?: Attributes;
+}
+interface ReceivedSpan {
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly parentSpanId?: string;
+  readonly name: string;
+  readonly kind: string;
+  readonly startTimeUnixNano: string;
+  readonly endTimeUnixNano: string;
+  readonly attributes: Attributes;
+  readonly events: readonly unknown[];
+  readonly links: readonly unknown[];
+  readonly status: {
+    readonly code?: string;
+    readonly message?: string;
+  };
+  readonly resource: Attributes;
+  readonly scope: InstrumentationScope;
+}
+interface ReceivedLogRecord {
+  readonly timeUnixNano?: string;
+  readonly observedTimeUnixNano?: string;
+  readonly severityNumber?: number | string;
+  readonly severityText?: string;
+  readonly body?: unknown;
+  readonly attributes: Attributes;
+  readonly traceId?: string;
+  readonly spanId?: string;
+  readonly resource: Attributes;
+  readonly scope: InstrumentationScope;
+}
+interface ReceivedMetric {
+  readonly name: string;
+  readonly description?: string;
+  readonly unit?: string;
+  readonly type: string;
+  readonly dataPoints: readonly unknown[];
+  readonly resource: Attributes;
+  readonly scope: InstrumentationScope;
+}
+declare const TelemetryNotReceived_base: Schema.Class<TelemetryNotReceived, Schema.TaggedStruct<"TelemetryNotReceived", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+declare class TelemetryNotReceived extends TelemetryNotReceived_base {}
+type ReadError = ReceiverNotRunning | Schema.SchemaError;
+interface WaitOptions<Item> {
+  readonly where?: (item: Item) => boolean;
+  readonly count?: number;
+  readonly timeout?: Duration.Duration;
+  readonly interval?: Duration.Duration;
+}
+interface OtlpOptions {
+  readonly semconv?: SemconvOptions | true;
+}
+declare const otlp: (options?: OtlpOptions) => Plugin;
+declare const receiverAddress: Effect.Effect<ReceiverAddress, ReceiverNotRunning>;
+declare const receivedSpans: Effect.Effect<readonly ReceivedSpan[], ReadError, never>;
+declare const receivedLogs: Effect.Effect<readonly ReceivedLogRecord[], ReadError, never>;
+declare const receivedMetrics: Effect.Effect<readonly ReceivedMetric[], ReadError, never>;
+declare const waitForSpans: ({ where, count, timeout, interval }?: WaitOptions<ReceivedSpan>) => Effect.Effect<readonly ReceivedSpan[], TelemetryNotReceived | ReadError, never>;
+declare const waitForLogs: ({ where, count, timeout, interval }?: WaitOptions<ReceivedLogRecord>) => Effect.Effect<readonly ReceivedLogRecord[], TelemetryNotReceived | ReadError, never>;
+declare const waitForMetrics: ({ where, count, timeout, interval }?: WaitOptions<ReceivedMetric>) => Effect.Effect<readonly ReceivedMetric[], TelemetryNotReceived | ReadError, never>;
+declare const clearTelemetry: Effect.Effect<void, ReceiverNotRunning>;
+export { type Attributes, type InstrumentationScope, type OtlpOptions, type ReadError, type ReceivedLogRecord, type ReceivedMetric, type ReceivedSpan, type ReceiverAddress, ReceiverNotRunning, type SemconvLevel, type SemconvOptions, TelemetryNotReceived, type WaitOptions, clearTelemetry, otlp, receivedLogs, receivedMetrics, receivedSpans, receiverAddress, waitForLogs, waitForMetrics, waitForSpans };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,186 @@
+import { n as SEMCONV_KEY } from "./context-COyJBDQM.mjs";
+import { n as currentReceiver, t as ReceiverNotRunning } from "./store-DSDf4Wia.mjs";
+import { Array, Duration, Effect, Option, Predicate, Schedule, Schema, pipe } from "effect";
+// src/otlp-schema.ts
+const orEmpty = (schema, empty) => schema.pipe(Schema.withDecodingDefault(Effect.succeed(empty)));
+const AttributesSchema = Schema.Record(Schema.String, Schema.Unknown);
+const OptionalString = Schema.optionalKey(Schema.String);
+const ResourceSchema = orEmpty(Schema.Struct({ attributes: orEmpty(AttributesSchema, {}) }), {});
+const ScopeSchema = orEmpty(Schema.Struct({
+	name: orEmpty(Schema.String, ""),
+	version: OptionalString,
+	attributes: Schema.optionalKey(AttributesSchema)
+}), {});
+const UnknownArray = orEmpty(Schema.Array(Schema.Unknown), []);
+const StatusSchema = Schema.Struct({
+	code: OptionalString,
+	message: OptionalString
+});
+const SpanSchema = Schema.Struct({
+	traceId: Schema.String,
+	spanId: Schema.String,
+	parentSpanId: OptionalString,
+	name: Schema.String,
+	kind: orEmpty(Schema.String, "SPAN_KIND_UNSPECIFIED"),
+	startTimeUnixNano: orEmpty(Schema.String, "0"),
+	endTimeUnixNano: orEmpty(Schema.String, "0"),
+	attributes: orEmpty(AttributesSchema, {}),
+	events: UnknownArray,
+	links: UnknownArray,
+	status: orEmpty(StatusSchema, {})
+});
+const LogRecordSchema = Schema.Struct({
+	timeUnixNano: OptionalString,
+	observedTimeUnixNano: OptionalString,
+	severityNumber: Schema.optionalKey(Schema.Union([Schema.Finite, Schema.String])),
+	severityText: OptionalString,
+	body: Schema.optionalKey(Schema.Unknown),
+	attributes: orEmpty(AttributesSchema, {}),
+	traceId: OptionalString,
+	spanId: OptionalString
+});
+const DataSchema = Schema.optionalKey(Schema.Struct({ dataPoints: UnknownArray }));
+const MetricSchema = Schema.Struct({
+	name: Schema.String,
+	description: OptionalString,
+	unit: OptionalString,
+	sum: DataSchema,
+	gauge: DataSchema,
+	histogram: DataSchema,
+	exponentialHistogram: DataSchema,
+	summary: DataSchema
+});
+const ScopeSpansSchema = Schema.Struct({
+	scope: ScopeSchema,
+	spans: orEmpty(Schema.Array(SpanSchema), [])
+});
+const ResourceSpansSchema = Schema.Struct({
+	resource: ResourceSchema,
+	scopeSpans: orEmpty(Schema.Array(ScopeSpansSchema), [])
+});
+const TraceRequestSchema = Schema.Struct({ resourceSpans: orEmpty(Schema.Array(ResourceSpansSchema), []) });
+const ScopeLogsSchema = Schema.Struct({
+	scope: ScopeSchema,
+	logRecords: orEmpty(Schema.Array(LogRecordSchema), [])
+});
+const ResourceLogsSchema = Schema.Struct({
+	resource: ResourceSchema,
+	scopeLogs: orEmpty(Schema.Array(ScopeLogsSchema), [])
+});
+const LogsRequestSchema = Schema.Struct({ resourceLogs: orEmpty(Schema.Array(ResourceLogsSchema), []) });
+const ScopeMetricsSchema = Schema.Struct({
+	scope: ScopeSchema,
+	metrics: orEmpty(Schema.Array(MetricSchema), [])
+});
+const ResourceMetricsSchema = Schema.Struct({
+	resource: ResourceSchema,
+	scopeMetrics: orEmpty(Schema.Array(ScopeMetricsSchema), [])
+});
+const MetricsRequestSchema = Schema.Struct({ resourceMetrics: orEmpty(Schema.Array(ResourceMetricsSchema), []) });
+const METRIC_TYPES = [
+	"sum",
+	"gauge",
+	"histogram",
+	"exponentialHistogram",
+	"summary"
+];
+const toMetric = (context) => ({ sum, gauge, histogram, exponentialHistogram, summary, ...metric }) => {
+	const data = {
+		sum,
+		gauge,
+		histogram,
+		exponentialHistogram,
+		summary
+	};
+	const found = pipe(METRIC_TYPES, Array.findFirst((type) => pipe(Option.fromNullishOr(data[type]), Option.map(({ dataPoints }) => ({
+		type,
+		dataPoints
+	})))));
+	return {
+		...metric,
+		...Option.getOrElse(found, () => ({
+			type: "unknown",
+			dataPoints: []
+		})),
+		...context
+	};
+};
+const spansOf = ({ resource, scopeSpans }) => pipe(scopeSpans, Array.flatMap(({ scope, spans }) => pipe(spans, Array.map((span) => ({
+	...span,
+	resource: resource.attributes,
+	scope
+})))));
+const logsOf = ({ resource, scopeLogs }) => pipe(scopeLogs, Array.flatMap(({ scope, logRecords }) => pipe(logRecords, Array.map((logRecord) => ({
+	...logRecord,
+	resource: resource.attributes,
+	scope
+})))));
+const metricsOf = ({ resource, scopeMetrics }) => pipe(scopeMetrics, Array.flatMap(({ scope, metrics }) => pipe(metrics, Array.map(toMetric({
+	resource: resource.attributes,
+	scope
+})))));
+const decodeSpans = (normalized) => Schema.decodeUnknownEffect(TraceRequestSchema)(normalized).pipe(Effect.map(({ resourceSpans }) => pipe(resourceSpans, Array.flatMap(spansOf))));
+const decodeLogs = (normalized) => Schema.decodeUnknownEffect(LogsRequestSchema)(normalized).pipe(Effect.map(({ resourceLogs }) => pipe(resourceLogs, Array.flatMap(logsOf))));
+const decodeMetrics = (normalized) => Schema.decodeUnknownEffect(MetricsRequestSchema)(normalized).pipe(Effect.map(({ resourceMetrics }) => pipe(resourceMetrics, Array.flatMap(metricsOf))));
+// src/index.ts
+const taggedError = Schema.TaggedError;
+var TelemetryNotReceived = class extends taggedError()("TelemetryNotReceived", { message: Schema.String }) {};
+const DEFAULT_TIMEOUT_SECONDS = 5;
+const DEFAULT_INTERVAL_MILLIS = 20;
+const DEFAULT_TIMEOUT = Duration.seconds(DEFAULT_TIMEOUT_SECONDS);
+const DEFAULT_INTERVAL = Duration.millis(DEFAULT_INTERVAL_MILLIS);
+const ONE = 1;
+const DEFAULT_SEMCONV = {
+	registry: "https://github.com/open-telemetry/semantic-conventions.git@v1.45.0[model]",
+	weaver: "weaver",
+	failOn: "violation"
+};
+const semconvConfig = (semconv) => ({
+	...DEFAULT_SEMCONV,
+	...Option.getOrElse(Option.liftPredicate(semconv, (options) => options !== true), () => ({}))
+});
+const otlp = (options = {}) => ({
+	name: "@r_masseater/vitest-otlp",
+	config: () => ({ test: {
+		setupFiles: ["@r_masseater/vitest-otlp/setup"],
+		...Option.match(Option.fromNullishOr(options.semconv), {
+			onNone: () => ({}),
+			onSome: (semconv) => ({
+				globalSetup: ["@r_masseater/vitest-otlp/semconv"],
+				provide: { [SEMCONV_KEY]: semconvConfig(semconv) }
+			})
+		})
+	} })
+});
+const signal = (label, key, decode) => ({
+	label,
+	received: currentReceiver.pipe(Effect.flatMap((receiver) => receiver.requests), Effect.flatMap((requests) => pipe(requests[key], Array.map(decode), Effect.all)), Effect.map(Array.flatten))
+});
+const spans = signal("spans", "traces", decodeSpans);
+const logs = signal("log records", "logs", decodeLogs);
+const metrics = signal("metrics", "metrics", decodeMetrics);
+const everything = () => true;
+const isNotReceived = Predicate.isTagged("TelemetryNotReceived");
+const waitFor = ({ label, received }) => ({ where = everything, count = ONE, timeout = DEFAULT_TIMEOUT, interval = DEFAULT_INTERVAL } = {}) => {
+	const check = (all) => {
+		const matched = pipe(all, Array.filter(where));
+		const notYet = TelemetryNotReceived.make({ message: `Expected ${count} ${label} within ${Duration.format(timeout)}, received ${matched.length} matching of ${all.length}.` });
+		return Effect.succeed(matched).pipe(Effect.filterOrFail(() => matched.length >= count, () => notYet));
+	};
+	const schedule = pipe(Schedule.spaced(interval), Schedule.upTo({ duration: timeout }));
+	return received.pipe(Effect.flatMap(check), Effect.retry({
+		while: isNotReceived,
+		schedule
+	}));
+};
+const receiverAddress = currentReceiver.pipe(Effect.map((receiver) => receiver.address));
+const receivedSpans = spans.received;
+const receivedLogs = logs.received;
+const receivedMetrics = metrics.received;
+const waitForSpans = waitFor(spans);
+const waitForLogs = waitFor(logs);
+const waitForMetrics = waitFor(metrics);
+const clearTelemetry = currentReceiver.pipe(Effect.flatMap((receiver) => receiver.clear));
+export { ReceiverNotRunning, TelemetryNotReceived, clearTelemetry, otlp, receivedLogs, receivedMetrics, receivedSpans, receiverAddress, waitForLogs, waitForMetrics, waitForSpans };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/otlp-schema.ts","../src/index.ts"],"sourcesContent":["import { Array, Effect, Option, Schema, pipe } from \"effect\";\n\nimport type {\n  Attributes,\n  InstrumentationScope,\n  ReceivedLogRecord,\n  ReceivedMetric,\n  ReceivedSpan,\n} from \"./telemetry.ts\";\n\nconst orEmpty = <Self extends Schema.Top>(\n  schema: Self,\n  empty: Self[\"Encoded\"],\n): Schema.withDecodingDefault<Self> =>\n  schema.pipe(Schema.withDecodingDefault(Effect.succeed(empty)));\n\nconst AttributesSchema = Schema.Record(Schema.String, Schema.Unknown);\n\nconst OptionalString = Schema.optionalKey(Schema.String);\n\nconst ResourceSchema = orEmpty(Schema.Struct({ attributes: orEmpty(AttributesSchema, {}) }), {});\n\nconst ScopeSchema = orEmpty(\n  Schema.Struct({\n    name: orEmpty(Schema.String, \"\"),\n    version: OptionalString,\n    attributes: Schema.optionalKey(AttributesSchema),\n  }),\n  {},\n);\n\nconst UnknownArray = orEmpty(Schema.Array(Schema.Unknown), []);\n\nconst StatusSchema = Schema.Struct({ code: OptionalString, message: OptionalString });\n\nconst SpanSchema = Schema.Struct({\n  traceId: Schema.String,\n  spanId: Schema.String,\n  parentSpanId: OptionalString,\n  name: Schema.String,\n  kind: orEmpty(Schema.String, \"SPAN_KIND_UNSPECIFIED\"),\n  startTimeUnixNano: orEmpty(Schema.String, \"0\"),\n  endTimeUnixNano: orEmpty(Schema.String, \"0\"),\n  attributes: orEmpty(AttributesSchema, {}),\n  events: UnknownArray,\n  links: UnknownArray,\n  status: orEmpty(StatusSchema, {}),\n});\n\nconst LogRecordSchema = Schema.Struct({\n  timeUnixNano: OptionalString,\n  observedTimeUnixNano: OptionalString,\n  severityNumber: Schema.optionalKey(Schema.Union([Schema.Finite, Schema.String])),\n  severityText: OptionalString,\n  body: Schema.optionalKey(Schema.Unknown),\n  attributes: orEmpty(AttributesSchema, {}),\n  traceId: OptionalString,\n  spanId: OptionalString,\n});\n\nconst DataSchema = Schema.optionalKey(Schema.Struct({ dataPoints: UnknownArray }));\n\nconst MetricSchema = Schema.Struct({\n  name: Schema.String,\n  description: OptionalString,\n  unit: OptionalString,\n  sum: DataSchema,\n  gauge: DataSchema,\n  histogram: DataSchema,\n  exponentialHistogram: DataSchema,\n  summary: DataSchema,\n});\n\nconst ScopeSpansSchema = Schema.Struct({\n  scope: ScopeSchema,\n  spans: orEmpty(Schema.Array(SpanSchema), []),\n});\nconst ResourceSpansSchema = Schema.Struct({\n  resource: ResourceSchema,\n  scopeSpans: orEmpty(Schema.Array(ScopeSpansSchema), []),\n});\nconst TraceRequestSchema = Schema.Struct({\n  resourceSpans: orEmpty(Schema.Array(ResourceSpansSchema), []),\n});\n\nconst ScopeLogsSchema = Schema.Struct({\n  scope: ScopeSchema,\n  logRecords: orEmpty(Schema.Array(LogRecordSchema), []),\n});\nconst ResourceLogsSchema = Schema.Struct({\n  resource: ResourceSchema,\n  scopeLogs: orEmpty(Schema.Array(ScopeLogsSchema), []),\n});\nconst LogsRequestSchema = Schema.Struct({\n  resourceLogs: orEmpty(Schema.Array(ResourceLogsSchema), []),\n});\n\nconst ScopeMetricsSchema = Schema.Struct({\n  scope: ScopeSchema,\n  metrics: orEmpty(Schema.Array(MetricSchema), []),\n});\nconst ResourceMetricsSchema = Schema.Struct({\n  resource: ResourceSchema,\n  scopeMetrics: orEmpty(Schema.Array(ScopeMetricsSchema), []),\n});\nconst MetricsRequestSchema = Schema.Struct({\n  resourceMetrics: orEmpty(Schema.Array(ResourceMetricsSchema), []),\n});\n\ninterface Context {\n  readonly resource: Attributes;\n  readonly scope: InstrumentationScope;\n}\n\nconst METRIC_TYPES = [\"sum\", \"gauge\", \"histogram\", \"exponentialHistogram\", \"summary\"] as const;\n\nconst toMetric =\n  (context: Context) =>\n  ({\n    sum,\n    gauge,\n    histogram,\n    exponentialHistogram,\n    summary,\n    ...metric\n  }: typeof MetricSchema.Type): ReceivedMetric => {\n    const data = { sum, gauge, histogram, exponentialHistogram, summary };\n    const found = pipe(\n      METRIC_TYPES,\n      Array.findFirst((type) =>\n        pipe(\n          Option.fromNullishOr(data[type]),\n          Option.map(({ dataPoints }) => ({ type, dataPoints })),\n        ),\n      ),\n    );\n    return {\n      ...metric,\n      ...Option.getOrElse(found, () => ({ type: \"unknown\", dataPoints: [] })),\n      ...context,\n    };\n  };\n\nconst spansOf = ({\n  resource,\n  scopeSpans,\n}: typeof ResourceSpansSchema.Type): readonly ReceivedSpan[] =>\n  pipe(\n    scopeSpans,\n    Array.flatMap(({ scope, spans }) =>\n      pipe(\n        spans,\n        Array.map((span) => ({ ...span, resource: resource.attributes, scope })),\n      ),\n    ),\n  );\n\nconst logsOf = ({\n  resource,\n  scopeLogs,\n}: typeof ResourceLogsSchema.Type): readonly ReceivedLogRecord[] =>\n  pipe(\n    scopeLogs,\n    Array.flatMap(({ scope, logRecords }) =>\n      pipe(\n        logRecords,\n        Array.map((logRecord) => ({ ...logRecord, resource: resource.attributes, scope })),\n      ),\n    ),\n  );\n\nconst metricsOf = ({\n  resource,\n  scopeMetrics,\n}: typeof ResourceMetricsSchema.Type): readonly ReceivedMetric[] =>\n  pipe(\n    scopeMetrics,\n    Array.flatMap(({ scope, metrics }) =>\n      pipe(metrics, Array.map(toMetric({ resource: resource.attributes, scope }))),\n    ),\n  );\n\nconst decodeSpans = (\n  normalized: unknown,\n): Effect.Effect<readonly ReceivedSpan[], Schema.SchemaError> =>\n  Schema.decodeUnknownEffect(TraceRequestSchema)(normalized).pipe(\n    Effect.map(({ resourceSpans }) => pipe(resourceSpans, Array.flatMap(spansOf))),\n  );\n\nconst decodeLogs = (\n  normalized: unknown,\n): Effect.Effect<readonly ReceivedLogRecord[], Schema.SchemaError> =>\n  Schema.decodeUnknownEffect(LogsRequestSchema)(normalized).pipe(\n    Effect.map(({ resourceLogs }) => pipe(resourceLogs, Array.flatMap(logsOf))),\n  );\n\nconst decodeMetrics = (\n  normalized: unknown,\n): Effect.Effect<readonly ReceivedMetric[], Schema.SchemaError> =>\n  Schema.decodeUnknownEffect(MetricsRequestSchema)(normalized).pipe(\n    Effect.map(({ resourceMetrics }) => pipe(resourceMetrics, Array.flatMap(metricsOf))),\n  );\n\nexport { decodeLogs, decodeMetrics, decodeSpans };\n","import { Array, Duration, Effect, Option, Predicate, Schedule, Schema, pipe } from \"effect\";\nimport type { Plugin } from \"vite-plus\";\n\nimport { SEMCONV_KEY } from \"./context.ts\";\nimport type { ResolvedSemconv, SemconvOptions } from \"./context.ts\";\nimport { decodeLogs, decodeMetrics, decodeSpans } from \"./otlp-schema.ts\";\nimport type { SignalKey } from \"./requests.ts\";\nimport type { ReceiverNotRunning } from \"./store.ts\";\nimport { currentReceiver } from \"./store.ts\";\nimport type {\n  ReceivedLogRecord,\n  ReceivedMetric,\n  ReceivedSpan,\n  ReceiverAddress,\n} from \"./telemetry.ts\";\n\nconst taggedError = Schema.TaggedError;\n\nclass TelemetryNotReceived extends taggedError<\n  TelemetryNotReceived,\n  { readonly brand: unique symbol }\n>()(\"TelemetryNotReceived\", { message: Schema.String }) {}\n\ntype ReadError = ReceiverNotRunning | Schema.SchemaError;\n\ninterface WaitOptions<Item> {\n  readonly where?: (item: Item) => boolean;\n  readonly count?: number;\n  readonly timeout?: Duration.Duration;\n  readonly interval?: Duration.Duration;\n}\n\ninterface Signal<Item> {\n  readonly label: string;\n  readonly received: Effect.Effect<readonly Item[], ReadError>;\n}\n\nconst DEFAULT_TIMEOUT_SECONDS = 5;\nconst DEFAULT_INTERVAL_MILLIS = 20;\nconst DEFAULT_TIMEOUT = Duration.seconds(DEFAULT_TIMEOUT_SECONDS);\nconst DEFAULT_INTERVAL = Duration.millis(DEFAULT_INTERVAL_MILLIS);\nconst ONE = 1;\n\nconst DEFAULT_SEMCONV: ResolvedSemconv = {\n  registry: \"https://github.com/open-telemetry/semantic-conventions.git@v1.45.0[model]\",\n  weaver: \"weaver\",\n  failOn: \"violation\",\n};\n\ninterface OtlpOptions {\n  readonly semconv?: SemconvOptions | true;\n}\n\nconst semconvConfig = (semconv: SemconvOptions | true): ResolvedSemconv => ({\n  ...DEFAULT_SEMCONV,\n  ...Option.getOrElse(\n    Option.liftPredicate(semconv, (options) => options !== true),\n    () => ({}),\n  ),\n});\n\nconst otlp = (options: OtlpOptions = {}): Plugin => ({\n  name: \"@r_masseater/vitest-otlp\",\n  config: () => ({\n    test: {\n      setupFiles: [\"@r_masseater/vitest-otlp/setup\"],\n      ...Option.match(Option.fromNullishOr(options.semconv), {\n        onNone: () => ({}),\n        onSome: (semconv) => ({\n          globalSetup: [\"@r_masseater/vitest-otlp/semconv\"],\n          provide: { [SEMCONV_KEY]: semconvConfig(semconv) },\n        }),\n      }),\n    },\n  }),\n});\n\nconst signal = <Item>(\n  label: string,\n  key: SignalKey,\n  decode: (normalized: unknown) => Effect.Effect<readonly Item[], Schema.SchemaError>,\n): Signal<Item> => ({\n  label,\n  received: currentReceiver.pipe(\n    Effect.flatMap((receiver) => receiver.requests),\n    Effect.flatMap((requests) => pipe(requests[key], Array.map(decode), Effect.all)),\n    Effect.map(Array.flatten),\n  ),\n});\n\nconst spans = signal<ReceivedSpan>(\"spans\", \"traces\", decodeSpans);\nconst logs = signal<ReceivedLogRecord>(\"log records\", \"logs\", decodeLogs);\nconst metrics = signal<ReceivedMetric>(\"metrics\", \"metrics\", decodeMetrics);\n\nconst everything = (): boolean => true;\n\nconst isNotReceived = Predicate.isTagged(\"TelemetryNotReceived\");\n\nconst waitFor =\n  <Item>({ label, received }: Signal<Item>) =>\n  ({\n    where = everything,\n    count = ONE,\n    timeout = DEFAULT_TIMEOUT,\n    interval = DEFAULT_INTERVAL,\n  }: WaitOptions<Item> = {}): Effect.Effect<readonly Item[], TelemetryNotReceived | ReadError> => {\n    const check = (all: readonly Item[]): Effect.Effect<readonly Item[], TelemetryNotReceived> => {\n      const matched = pipe(all, Array.filter(where));\n      const notYet = TelemetryNotReceived.make({\n        message: `Expected ${count} ${label} within ${Duration.format(timeout)}, received ${matched.length} matching of ${all.length}.`,\n      });\n      return Effect.succeed(matched).pipe(\n        Effect.filterOrFail(\n          () => matched.length >= count,\n          () => notYet,\n        ),\n      );\n    };\n    const schedule = pipe(Schedule.spaced(interval), Schedule.upTo({ duration: timeout }));\n    return received.pipe(Effect.flatMap(check), Effect.retry({ while: isNotReceived, schedule }));\n  };\n\nconst receiverAddress: Effect.Effect<ReceiverAddress, ReceiverNotRunning> = currentReceiver.pipe(\n  Effect.map((receiver) => receiver.address),\n);\n\nconst receivedSpans = spans.received;\nconst receivedLogs = logs.received;\nconst receivedMetrics = metrics.received;\n\nconst waitForSpans = waitFor(spans);\nconst waitForLogs = waitFor(logs);\nconst waitForMetrics = waitFor(metrics);\n\nconst clearTelemetry: Effect.Effect<void, ReceiverNotRunning> = currentReceiver.pipe(\n  Effect.flatMap((receiver) => receiver.clear),\n);\n\nexport {\n  TelemetryNotReceived,\n  clearTelemetry,\n  otlp,\n  receiverAddress,\n  receivedLogs,\n  receivedMetrics,\n  receivedSpans,\n  waitForLogs,\n  waitForMetrics,\n  waitForSpans,\n};\nexport { ReceiverNotRunning } from \"./store.ts\";\nexport type {\n  Attributes,\n  InstrumentationScope,\n  ReceivedLogRecord,\n  ReceivedMetric,\n  ReceivedSpan,\n  ReceiverAddress,\n} from \"./telemetry.ts\";\nexport type { OtlpOptions, ReadError, WaitOptions };\nexport type { SemconvLevel, SemconvOptions } from \"./context.ts\";\n"],"mappings":"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"}

package/dist/semconv.d.mts

@@ -0,0 +1,4 @@
+import { TestProject } from "vite-plus/test/node";
+declare const setup: (project: TestProject) => Promise<() => Promise<void>>;
+export { setup };
+//# sourceMappingURL=semconv.d.mts.map