@r_masseater/vitest-otlp 0.0.0 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@r_masseater/vitest-otlp",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "description": "A Vitest plugin that receives OTLP traces, metrics and logs during tests so tests can assert on the telemetry the code under test actually exported.",
   "keywords": [
     "opentelemetry",

package/dist/context-COyJBDQM.mjs

@@ -1,6 +0,0 @@
-// 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

@@ -1 +0,0 @@
-{"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

@@ -1,98 +0,0 @@
-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

@@ -1,186 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

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

package/dist/semconv.mjs

@@ -1,92 +0,0 @@
-import { n as SEMCONV_KEY, t as FORWARD_KEY } from "./context-COyJBDQM.mjs";
-import { Array, Duration, Effect, Exit, Layer, ManagedRuntime, MutableRef, Option, Predicate, Record, Schedule, Schema, Scope, Stream, String, pipe } from "effect";
-import { NodeServices } from "@effect/platform-node";
-import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/http";
-import { ChildProcess, ChildProcessSpawner } from "effect/process";
-// src/semconv.ts
-const taggedError = Schema.TaggedError;
-var SemconvCheckFailed = class extends taggedError()("SemconvCheckFailed", { message: Schema.String }) {};
-const LEVELS = [
-	"information",
-	"improvement",
-	"violation"
-];
-const ADVICE_KEY = "all_advice";
-const READY_POLL_MILLIS = 100;
-const READY_TIMEOUT_SECONDS = 120;
-const READY_POLL = Schedule.spaced(Duration.millis(READY_POLL_MILLIS));
-const READY_TIMEOUT = Duration.seconds(READY_TIMEOUT_SECONDS);
-const REPORT_INDENT = "\n  ";
-const GRPC_LISTENER = /OTLP gRPC listener started on (?<address>[\d.]+:\d+)/v;
-const ADMIN = /POST to (?<admin>http:\/\/[\d.]+:\d+)\/stop/v;
-const Advice = Schema.Struct({
-	id: Schema.String,
-	level: Schema.Literals(LEVELS),
-	message: Schema.String,
-	signal_name: Schema.NullOr(Schema.String)
-});
-const decodeAdvice = Schema.decodeUnknownOption(Advice);
-const checkFailed = (cause) => SemconvCheckFailed.make({ message: globalThis.String(cause) });
-const isList = (value) => Array.isArray(value);
-const childrenOf = (json) => pipe(Option.liftPredicate(json, isList), Option.map(Array.map((child) => ["", child])), Option.orElse(() => pipe(Option.liftPredicate(json, Predicate.isObject), Option.map(Record.toEntries))), Option.getOrElse(() => []));
-const isAdvice = (key) => (value) => key === ADVICE_KEY && isList(value);
-const adviceIn = (json) => pipe(childrenOf(json), Array.flatMap(([key, value]) => Option.getOrElse(Option.liftPredicate(value, isAdvice(key)), () => adviceIn(value))));
-const atLeast = (failOn) => (finding) => LEVELS.indexOf(finding.level) >= LEVELS.indexOf(failOn);
-const signalSuffix = (finding) => pipe(Option.fromNullishOr(finding.signal_name), Option.map((name) => ` (${name})`), Option.getOrElse(() => ""));
-const describeFinding = (finding) => `${finding.level} ${finding.id}: ${finding.message}${signalSuffix(finding)}`;
-const failingFindings = (failOn) => (report) => pipe(adviceIn(report), Array.map((advice) => decodeAdvice(advice)), Array.getSomes, Array.filter(atLeast(failOn)), Array.map(describeFinding), Array.dedupe);
-const grpcOf = (log) => pipe(log, String.match(GRPC_LISTENER), Option.flatMap((match) => Option.fromNullishOr(match.groups)), Option.flatMap((groups) => Option.fromNullishOr(groups["address"])), Option.map((address) => `http://${address}`));
-const adminOf = (log) => pipe(log, String.match(ADMIN), Option.flatMap((match) => Option.fromNullishOr(match.groups)), Option.flatMap((groups) => Option.fromNullishOr(groups["admin"])));
-const addressOf = (log) => Option.all({
-	grpc: grpcOf(log),
-	admin: adminOf(log)
-});
-const liveCheck = (semconv) => ChildProcess.make(semconv.weaver, [
-	"registry",
-	"live-check",
-	"--registry",
-	semconv.registry,
-	"--input-source",
-	"otlp",
-	"--otlp-grpc-port",
-	"0",
-	"--admin-port",
-	"0",
-	"--format",
-	"json",
-	"--output",
-	"http"
-]);
-const startWeaver = (semconv) => Effect.gen(function* weaverStart() {
-	const handle = yield* (yield* ChildProcessSpawner.ChildProcessSpawner).spawn(liveCheck(semconv)).pipe(Effect.mapError(checkFailed));
-	const log = MutableRef.make("");
-	yield* handle.stderr.pipe(Stream.decodeText, Stream.runForEach((text) => Effect.sync(() => MutableRef.update(log, String.concat(text)))), Effect.forkScoped);
-	return yield* Effect.sync(() => addressOf(MutableRef.get(log))).pipe(Effect.flatMap(Effect.fromOption), Effect.retry(READY_POLL), Effect.timeout(READY_TIMEOUT), Effect.mapError(() => checkFailed(`weaver did not start:\n${MutableRef.get(log)}`)));
-}).pipe(Effect.withSpan("vitest-otlp.semconv.start"));
-const reportOf = (weaver) => Effect.gen(function* weaverReport() {
-	yield* HttpClient.execute(HttpClientRequest.post(`${weaver.admin}/stop`));
-	const body = yield* (yield* HttpClient.execute(HttpClientRequest.get(`${weaver.admin}/report`))).json;
-	yield* HttpClient.execute(HttpClientRequest.post(`${weaver.admin}/shutdown`));
-	return body;
-}).pipe(Effect.mapError(checkFailed), Effect.withSpan("vitest-otlp.semconv.report"));
-const judge = (semconv) => (report) => Array.match(failingFindings(semconv.failOn)(report), {
-	onEmpty: () => Effect.void,
-	onNonEmpty: (findings) => Effect.fail(checkFailed(Array.join(["Telemetry does not follow the semantic conventions:", ...findings], REPORT_INDENT)))
-});
-const runtime = ManagedRuntime.make(Layer.mergeAll(NodeServices.layer, FetchHttpClient.layer));
-const noTeardown = () => runtime.runPromise(Effect.void);
-const checkedRun = (project, semconv) => {
-	const scope = Scope.makeUnsafe();
-	const finish = (weaver) => reportOf(weaver).pipe(Effect.flatMap(judge(semconv)), Effect.ensuring(Scope.close(scope, Exit.void)));
-	return startWeaver(semconv).pipe(Effect.tap((weaver) => Effect.sync(() => {
-		project.provide(FORWARD_KEY, [weaver.grpc]);
-	})), Effect.map((weaver) => () => runtime.runPromise(finish(weaver))), Scope.provide(scope));
-};
-const semconvOf = (project) => Option.fromNullishOr(project.getProvidedContext()[SEMCONV_KEY]);
-const setup = (project) => runtime.runPromise(Option.match(semconvOf(project), {
-	onNone: () => Effect.succeed(noTeardown),
-	onSome: (semconv) => checkedRun(project, semconv)
-}));
-export { setup };
-
-//# sourceMappingURL=semconv.mjs.map

package/dist/semconv.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"semconv.mjs","names":["Scopes"],"sources":["../src/semconv.ts"],"sourcesContent":["import { NodeServices } from \"@effect/platform-node\";\nimport type { Scope } from \"effect\";\nimport {\n  Array,\n  Duration,\n  Effect,\n  Exit,\n  Layer,\n  ManagedRuntime,\n  MutableRef,\n  Option,\n  Predicate,\n  Record,\n  Schedule,\n  Schema,\n  Scope as Scopes,\n  Stream,\n  String,\n  pipe,\n} from \"effect\";\nimport { FetchHttpClient, HttpClient, HttpClientRequest } from \"effect/http\";\nimport { ChildProcess, ChildProcessSpawner } from \"effect/process\";\nimport type { TestProject } from \"vite-plus/test/node\";\n\nimport { FORWARD_KEY, SEMCONV_KEY } from \"./context.ts\";\nimport type { ResolvedSemconv, SemconvLevel } from \"./context.ts\";\n\nconst taggedError = Schema.TaggedError;\n\nclass SemconvCheckFailed extends taggedError<\n  SemconvCheckFailed,\n  { readonly brand: unique symbol }\n>()(\"SemconvCheckFailed\", { message: Schema.String }) {}\n\nconst LEVELS: readonly SemconvLevel[] = [\"information\", \"improvement\", \"violation\"];\nconst ADVICE_KEY = \"all_advice\";\nconst READY_POLL_MILLIS = 100;\nconst READY_TIMEOUT_SECONDS = 120;\nconst READY_POLL = Schedule.spaced(Duration.millis(READY_POLL_MILLIS));\nconst READY_TIMEOUT = Duration.seconds(READY_TIMEOUT_SECONDS);\nconst REPORT_INDENT = \"\\n  \";\n\nconst GRPC_LISTENER = /OTLP gRPC listener started on (?<address>[\\d.]+:\\d+)/v;\nconst ADMIN = /POST to (?<admin>http:\\/\\/[\\d.]+:\\d+)\\/stop/v;\n\ninterface Weaver {\n  readonly grpc: string;\n  readonly admin: string;\n}\n\nconst Advice = Schema.Struct({\n  id: Schema.String,\n  level: Schema.Literals(LEVELS),\n  message: Schema.String,\n  signal_name: Schema.NullOr(Schema.String),\n});\n\ntype Finding = typeof Advice.Type;\n\nconst decodeAdvice = Schema.decodeUnknownOption(Advice);\n\nconst checkFailed = (cause: unknown): SemconvCheckFailed =>\n  SemconvCheckFailed.make({ message: globalThis.String(cause) });\n\nconst isList = (value: unknown): value is readonly unknown[] => Array.isArray(value);\n\nconst childrenOf = (json: unknown): readonly (readonly [string, unknown])[] =>\n  pipe(\n    Option.liftPredicate(json, isList),\n    Option.map(Array.map((child): readonly [string, unknown] => [\"\", child])),\n    Option.orElse(() =>\n      pipe(Option.liftPredicate(json, Predicate.isObject), Option.map(Record.toEntries)),\n    ),\n    Option.getOrElse(() => []),\n  );\n\nconst isAdvice =\n  (key: string) =>\n  (value: unknown): value is readonly unknown[] =>\n    key === ADVICE_KEY && isList(value);\n\nconst adviceIn = (json: unknown): readonly unknown[] =>\n  pipe(\n    childrenOf(json),\n    Array.flatMap(([key, value]) =>\n      Option.getOrElse(Option.liftPredicate(value, isAdvice(key)), () => adviceIn(value)),\n    ),\n  );\n\nconst atLeast =\n  (failOn: SemconvLevel) =>\n  (finding: Finding): boolean =>\n    LEVELS.indexOf(finding.level) >= LEVELS.indexOf(failOn);\n\nconst signalSuffix = (finding: Finding): string =>\n  pipe(\n    Option.fromNullishOr(finding.signal_name),\n    Option.map((name) => ` (${name})`),\n    Option.getOrElse(() => \"\"),\n  );\n\nconst describeFinding = (finding: Finding): string =>\n  `${finding.level} ${finding.id}: ${finding.message}${signalSuffix(finding)}`;\n\nconst failingFindings =\n  (failOn: SemconvLevel) =>\n  (report: unknown): readonly string[] =>\n    pipe(\n      adviceIn(report),\n      Array.map((advice) => decodeAdvice(advice)),\n      Array.getSomes,\n      Array.filter(atLeast(failOn)),\n      Array.map(describeFinding),\n      Array.dedupe,\n    );\n\nconst grpcOf = (log: string): Option.Option<string> =>\n  pipe(\n    log,\n    String.match(GRPC_LISTENER),\n    Option.flatMap((match) => Option.fromNullishOr(match.groups)),\n    Option.flatMap((groups) => Option.fromNullishOr(groups[\"address\"])),\n    Option.map((address) => `http://${address}`),\n  );\n\nconst adminOf = (log: string): Option.Option<string> =>\n  pipe(\n    log,\n    String.match(ADMIN),\n    Option.flatMap((match) => Option.fromNullishOr(match.groups)),\n    Option.flatMap((groups) => Option.fromNullishOr(groups[\"admin\"])),\n  );\n\nconst addressOf = (log: string): Option.Option<Weaver> =>\n  Option.all({ grpc: grpcOf(log), admin: adminOf(log) });\n\nconst liveCheck = (semconv: ResolvedSemconv): ChildProcess.Command =>\n  ChildProcess.make(semconv.weaver, [\n    \"registry\",\n    \"live-check\",\n    \"--registry\",\n    semconv.registry,\n    \"--input-source\",\n    \"otlp\",\n    \"--otlp-grpc-port\",\n    \"0\",\n    \"--admin-port\",\n    \"0\",\n    \"--format\",\n    \"json\",\n    \"--output\",\n    \"http\",\n  ]);\n\nconst startWeaver = (\n  semconv: ResolvedSemconv,\n): Effect.Effect<\n  Weaver,\n  SemconvCheckFailed,\n  Scope.Scope | ChildProcessSpawner.ChildProcessSpawner\n> =>\n  Effect.gen(function* weaverStart() {\n    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;\n    const handle = yield* spawner.spawn(liveCheck(semconv)).pipe(Effect.mapError(checkFailed));\n    const log = MutableRef.make(\"\");\n    yield* handle.stderr.pipe(\n      Stream.decodeText,\n      Stream.runForEach((text) => Effect.sync(() => MutableRef.update(log, String.concat(text)))),\n      Effect.forkScoped,\n    );\n    return yield* Effect.sync(() => addressOf(MutableRef.get(log))).pipe(\n      Effect.flatMap(Effect.fromOption),\n      Effect.retry(READY_POLL),\n      Effect.timeout(READY_TIMEOUT),\n      Effect.mapError(() => checkFailed(`weaver did not start:\\n${MutableRef.get(log)}`)),\n    );\n  }).pipe(Effect.withSpan(\"vitest-otlp.semconv.start\"));\n\nconst reportOf = (\n  weaver: Weaver,\n): Effect.Effect<unknown, SemconvCheckFailed, HttpClient.HttpClient> =>\n  Effect.gen(function* weaverReport() {\n    yield* HttpClient.execute(HttpClientRequest.post(`${weaver.admin}/stop`));\n    const response = yield* HttpClient.execute(HttpClientRequest.get(`${weaver.admin}/report`));\n    const body = yield* response.json;\n    yield* HttpClient.execute(HttpClientRequest.post(`${weaver.admin}/shutdown`));\n    return body;\n  }).pipe(Effect.mapError(checkFailed), Effect.withSpan(\"vitest-otlp.semconv.report\"));\n\nconst judge =\n  (semconv: ResolvedSemconv) =>\n  (report: unknown): Effect.Effect<void, SemconvCheckFailed> =>\n    Array.match(failingFindings(semconv.failOn)(report), {\n      onEmpty: () => Effect.void,\n      onNonEmpty: (findings) =>\n        Effect.fail(\n          checkFailed(\n            Array.join(\n              [\"Telemetry does not follow the semantic conventions:\", ...findings],\n              REPORT_INDENT,\n            ),\n          ),\n        ),\n    });\n\nconst runtime = ManagedRuntime.make(Layer.mergeAll(NodeServices.layer, FetchHttpClient.layer));\n\ntype Teardown = () => Promise<void>;\n\nconst noTeardown: Teardown = () => runtime.runPromise(Effect.void);\n\nconst checkedRun = (\n  project: TestProject,\n  semconv: ResolvedSemconv,\n): Effect.Effect<Teardown, SemconvCheckFailed, ChildProcessSpawner.ChildProcessSpawner> => {\n  const scope = Scopes.makeUnsafe();\n  const finish = (weaver: Weaver): Effect.Effect<void, SemconvCheckFailed, HttpClient.HttpClient> =>\n    reportOf(weaver).pipe(\n      Effect.flatMap(judge(semconv)),\n      Effect.ensuring(Scopes.close(scope, Exit.void)),\n    );\n  return startWeaver(semconv).pipe(\n    Effect.tap((weaver) =>\n      Effect.sync(() => {\n        project.provide(FORWARD_KEY, [weaver.grpc]);\n      }),\n    ),\n    Effect.map(\n      (weaver): Teardown =>\n        () =>\n          runtime.runPromise(finish(weaver)),\n    ),\n    Scopes.provide(scope),\n  );\n};\n\nconst semconvOf = (project: TestProject): Option.Option<ResolvedSemconv> =>\n  Option.fromNullishOr(project.getProvidedContext()[SEMCONV_KEY]);\n\nconst setup = (project: TestProject): Promise<() => Promise<void>> =>\n  runtime.runPromise(\n    Option.match(semconvOf(project), {\n      onNone: () => Effect.succeed(noTeardown),\n      onSome: (semconv) => checkedRun(project, semconv),\n    }),\n  );\n\nexport { setup };\n"],"mappings":"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"}

package/dist/setup.d.mts

@@ -1 +0,0 @@
-export {}