better-effect 0.12.0 → 0.14.0

package/dist/opentelemetry.mjs

@@ -0,0 +1,871 @@
+import { ROOT_CONTEXT, SpanStatusCode, context, trace } from "@opentelemetry/api";
+//#region src/opentelemetry/lifecycle.ts
+const readMonotonicTime$1 = () => {
+	try {
+		return performance.now();
+	} catch {
+		return Date.now();
+	}
+};
+const eventName$1 = (phase) => `better-effect.lifecycle.${phase}`;
+const callSpan$2 = (operation) => {
+	try {
+		Promise.resolve(operation()).catch(() => {});
+	} catch {}
+};
+const finishSpan$1 = (span, status, details) => {
+	callSpan$2(() => span.setStatus({ code: status === "failure" ? SpanStatusCode.ERROR : SpanStatusCode.OK }));
+	if (details !== void 0) {
+		const message = details.message;
+		if (message !== void 0) callSpan$2(() => span.recordException(message));
+		if (Object.keys(details.attributes).length > 0) callSpan$2(() => span.addEvent("better-effect.failure", details.attributes));
+	}
+	callSpan$2(() => span.end());
+};
+const failureCause = (event) => {
+	if (event.error !== void 0) return event.error;
+	return event.outcome.status === "failure" ? event.outcome.cause : void 0;
+};
+const eventStatus = (event) => "error" in event && event.error !== void 0 ? "failure" : event.outcome.status;
+/** Internal lifecycle state machine for the OpenTelemetry Runtime observer. */
+var LifecycleTelemetry = class {
+	options;
+	states = /* @__PURE__ */ new Map();
+	disposed = false;
+	constructor(options) {
+		this.options = options;
+	}
+	onStart(event) {
+		if (this.disposed || this.options.mode === "off" || this.states.has(event.lifecycleId)) return;
+		const state = {
+			lifecycleId: event.lifecycleId,
+			startedAt: readMonotonicTime$1(),
+			parentContext: this.options.getParentContext(),
+			starting: true,
+			carrier: void 0,
+			activationSpan: void 0,
+			activationEnded: false,
+			activationReported: false,
+			pendingActivationEnd: void 0
+		};
+		this.states.set(event.lifecycleId, state);
+		const span = this.options.startSpan(this.options.mode === "events" ? "better-effect.lifecycle" : eventName$1("activate"), this.options.makeAttributes(event, "activate", void 0, void 0), state.parentContext);
+		if (!this.states.has(event.lifecycleId)) {
+			if (span !== void 0) callSpan$2(() => span.end());
+			return;
+		}
+		state.starting = false;
+		if (this.options.mode === "events") {
+			state.carrier = span;
+			if (span !== void 0) callSpan$2(() => span.addEvent(eventName$1("activate"), this.options.makeAttributes(event, "activate", void 0, void 0)));
+		} else state.activationSpan = span;
+		const pendingEnd = state.pendingActivationEnd;
+		if (pendingEnd !== void 0) {
+			state.pendingActivationEnd = void 0;
+			this.onEnd(pendingEnd);
+		}
+	}
+	onEnd(event) {
+		if (this.options.mode === "off") return;
+		const state = this.states.get(event.lifecycleId);
+		if (state === void 0 || state.activationReported) return;
+		const durationMs = Math.max(0, readMonotonicTime$1() - state.startedAt);
+		const status = eventStatus(event);
+		if (this.options.mode === "events") {
+			const span = state.carrier;
+			if (span === void 0) {
+				if (state.starting) {
+					state.pendingActivationEnd = event;
+					return;
+				}
+				state.activationReported = true;
+				if (status === "failure") this.states.delete(event.lifecycleId);
+				return;
+			}
+			state.activationReported = true;
+			state.activationEnded = true;
+			if (status === "failure") this.states.delete(event.lifecycleId);
+			callSpan$2(() => span.addEvent(eventName$1("activate"), this.options.makeAttributes(event, "activate", status, durationMs)));
+			if (status === "failure" && this.options.recordFailures) {
+				const details = this.options.getFailureDetails(failureCause(event));
+				if (details !== void 0) finishDetails(span, details);
+			}
+			if (status === "failure") {
+				callSpan$2(() => span.setStatus({ code: SpanStatusCode.ERROR }));
+				callSpan$2(() => span.end());
+			}
+			return;
+		}
+		const span = state.activationSpan;
+		if (span === void 0) {
+			if (state.starting) {
+				state.pendingActivationEnd = event;
+				return;
+			}
+			state.activationReported = true;
+			if (status === "failure") this.states.delete(event.lifecycleId);
+			return;
+		}
+		state.activationReported = true;
+		if (status === "failure") this.states.delete(event.lifecycleId);
+		state.activationEnded = true;
+		finishSpan$1(span, status, status === "failure" && this.options.recordFailures ? this.options.getFailureDetails(failureCause(event)) : void 0);
+	}
+	onRelease(event) {
+		if (this.options.mode === "off") return;
+		const state = this.states.get(event.lifecycleId);
+		if (state === void 0) return;
+		this.states.delete(event.lifecycleId);
+		const status = eventStatus(event);
+		const attributes = this.options.makeAttributes(event, "release", status, void 0);
+		const details = status === "failure" && this.options.recordFailures ? this.options.getFailureDetails(failureCause(event)) : void 0;
+		if (this.options.mode === "events") {
+			if (state.carrier === void 0) return;
+			callSpan$2(() => state.carrier.addEvent(eventName$1("release"), attributes));
+			if (details !== void 0) finishDetails(state.carrier, details);
+			finishSpan$1(state.carrier, status, void 0);
+			return;
+		}
+		const span = this.options.startSpan(eventName$1("release"), attributes, state.parentContext);
+		if (span !== void 0) finishSpan$1(span, status, details);
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		const pending = [...this.states.values()];
+		this.states.clear();
+		for (const state of pending) {
+			if (state.carrier !== void 0) callSpan$2(() => state.carrier.end());
+			if (state.activationSpan !== void 0 && !state.activationEnded) callSpan$2(() => state.activationSpan.end());
+		}
+	}
+};
+const finishDetails = (span, details) => {
+	const message = details.message;
+	if (message !== void 0) callSpan$2(() => span.recordException(message));
+	if (Object.keys(details.attributes).length > 0) callSpan$2(() => span.addEvent("better-effect.failure", details.attributes));
+};
+//#endregion
+//#region src/opentelemetry/shutdown.ts
+const callSpan$1 = (operation) => {
+	try {
+		Promise.resolve(operation()).catch(() => {});
+	} catch {}
+};
+const readMonotonicTime = () => {
+	try {
+		return performance.now();
+	} catch {
+		return Date.now();
+	}
+};
+const boundedDuration$1 = (value) => value !== void 0 && Number.isFinite(value) && value >= 0 ? Math.min(value, 2 ** 31 - 1) : void 0;
+const phaseOf = (phase) => {
+	switch (phase) {
+		case "shutdown-requested": return "requested";
+		case "quiesce-start":
+		case "quiesce-end": return "quiesce";
+		case "drain-start":
+		case "drain-end": return "drain";
+		case "abort-active": return "abort";
+		case "release-start":
+		case "release-end": return "release";
+		case "shutdown-complete":
+		case "shutdown-failure": return "complete";
+	}
+};
+const eventName = (phase) => `better-effect.shutdown.${phase}`;
+const isStart = (phase) => phase === "quiesce-start" || phase === "drain-start" || phase === "release-start";
+const isEnd = (phase) => phase === "quiesce-end" || phase === "drain-end" || phase === "release-end";
+const isTerminal = (phase) => phase === "shutdown-complete" || phase === "shutdown-failure";
+const finishSpan = (span, status, details) => {
+	callSpan$1(() => span.setStatus({ code: status === "failure" ? SpanStatusCode.ERROR : SpanStatusCode.OK }));
+	if (details !== void 0) {
+		const message = details.message;
+		if (message !== void 0) callSpan$1(() => span.recordException(message));
+		if (Object.keys(details.attributes).length > 0) callSpan$1(() => span.addEvent("better-effect.failure", details.attributes));
+	}
+	callSpan$1(() => span.end());
+};
+/** Internal shutdown state machine for the OpenTelemetry Runtime observer. */
+var ShutdownTelemetry = class {
+	options;
+	states = /* @__PURE__ */ new Map();
+	disposed = false;
+	constructor(options) {
+		this.options = options;
+	}
+	onEvent(event) {
+		if (this.disposed || this.options.mode === "off") return;
+		if (event.phase === "shutdown-requested") {
+			this.start(event);
+			return;
+		}
+		const state = this.states.get(event.reason);
+		if (state === void 0) return;
+		if (state.span === void 0 && state.starting) {
+			state.pendingEvents.push(event);
+			return;
+		}
+		if (state.span === void 0 && isTerminal(event.phase)) {
+			this.states.delete(event.reason);
+			state.pendingEvents.length = 0;
+			return;
+		}
+		if (state.span !== void 0) this.process(state, event);
+	}
+	start(event) {
+		if (this.states.has(event.reason)) return;
+		const state = {
+			reason: event.reason,
+			starting: true,
+			span: void 0,
+			phaseSpans: /* @__PURE__ */ new Map(),
+			phaseStartedAt: /* @__PURE__ */ new Map(),
+			pendingPhaseEnds: /* @__PURE__ */ new Map(),
+			pendingEvents: []
+		};
+		this.states.set(event.reason, state);
+		const span = this.options.startSpan("better-effect.shutdown", this.options.makeAttributes(event, "requested", void 0), this.options.rootContext);
+		if (!this.states.has(event.reason)) {
+			if (span !== void 0) callSpan$1(() => span.end());
+			return;
+		}
+		state.starting = false;
+		state.span = span;
+		if (span !== void 0) this.addEvent(state, event);
+		const pendingEvents = state.pendingEvents.splice(0);
+		for (const pendingEvent of pendingEvents) this.process(state, pendingEvent);
+	}
+	process(state, event) {
+		const phase = phaseOf(event.phase);
+		if (isStart(event.phase)) {
+			this.startPhase(state, event, phase);
+			return;
+		}
+		if (isEnd(event.phase)) {
+			if (!state.phaseStartedAt.has(phase)) return;
+			if (this.options.mode === "spans" && !state.phaseSpans.has(phase)) {
+				state.pendingPhaseEnds.set(phase, event);
+				return;
+			}
+			this.finishPhase(state, event, phase);
+			return;
+		}
+		if (event.phase === "abort-active") {
+			if (state.phaseStartedAt.has("abort")) return;
+			state.phaseStartedAt.set("abort", readMonotonicTime());
+			if (this.options.mode === "events") {
+				this.addEvent(state, event);
+				state.phaseStartedAt.delete("abort");
+			} else {
+				const span = this.startPhaseSpan(state, event, "abort");
+				if (span !== void 0) {
+					state.phaseStartedAt.delete("abort");
+					finishSpan(span, "success", void 0);
+				}
+			}
+			return;
+		}
+		if (isTerminal(event.phase)) this.finish(state, event);
+	}
+	startPhase(state, event, phase) {
+		if (state.phaseStartedAt.has(phase)) return;
+		state.phaseStartedAt.set(phase, readMonotonicTime());
+		if (this.options.mode === "events") {
+			this.addEvent(state, event);
+			return;
+		}
+		const span = this.startPhaseSpan(state, event, phase);
+		if (!this.states.has(state.reason)) {
+			if (span !== void 0) callSpan$1(() => span.end());
+			return;
+		}
+		if (span !== void 0) {
+			state.phaseSpans.set(phase, span);
+			const pendingEnd = state.pendingPhaseEnds.get(phase);
+			if (pendingEnd !== void 0) {
+				state.pendingPhaseEnds.delete(phase);
+				this.finishPhase(state, pendingEnd, phase);
+			}
+		}
+	}
+	startPhaseSpan(state, event, phase) {
+		let parent = this.options.rootContext;
+		if (state.span !== void 0) try {
+			parent = trace.setSpan(this.options.rootContext, state.span);
+		} catch {
+			parent = this.options.rootContext;
+		}
+		return this.options.startSpan(eventName(phase), this.options.makeAttributes(event, phase, void 0), parent);
+	}
+	addEvent(state, event, durationMsOverride) {
+		const span = state.span;
+		if (span === void 0) return;
+		const phase = phaseOf(event.phase);
+		const startedAt = state.phaseStartedAt.get(phase);
+		const durationMs = durationMsOverride ?? (startedAt === void 0 ? void 0 : Math.max(0, readMonotonicTime() - startedAt));
+		callSpan$1(() => span.addEvent(eventName(phase), this.options.makeAttributes(event, phase, durationMs)));
+	}
+	finishPhase(state, event, phase) {
+		const span = state.phaseSpans.get(phase);
+		const startedAt = state.phaseStartedAt.get(phase);
+		const durationMs = startedAt === void 0 ? event.durationMs : Math.max(0, readMonotonicTime() - startedAt);
+		state.phaseSpans.delete(phase);
+		state.phaseStartedAt.delete(phase);
+		state.pendingPhaseEnds.delete(phase);
+		if (this.options.mode === "events") {
+			this.addEvent(state, event, durationMs);
+			return;
+		}
+		if (span !== void 0) {
+			callSpan$1(() => span.setAttribute("better_effect.duration_ms", boundedDuration$1(durationMs) ?? 0));
+			finishSpan(span, "success", void 0);
+		}
+	}
+	finish(state, event) {
+		if (this.states.get(state.reason) !== state) return;
+		this.states.delete(state.reason);
+		const status = event.phase === "shutdown-failure" ? "failure" : "success";
+		const details = status === "failure" && this.options.recordFailures ? this.options.getFailureDetails(event.error) : void 0;
+		for (const span of state.phaseSpans.values()) callSpan$1(() => span.end());
+		state.phaseSpans.clear();
+		state.phaseStartedAt.clear();
+		state.pendingPhaseEnds.clear();
+		state.pendingEvents.length = 0;
+		if (state.span === void 0) return;
+		this.addEvent(state, event);
+		finishSpan(state.span, status, details);
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		const pending = [...this.states.values()];
+		this.states.clear();
+		for (const state of pending) {
+			for (const span of state.phaseSpans.values()) callSpan$1(() => span.end());
+			if (state.span !== void 0) callSpan$1(() => state.span.end());
+		}
+	}
+};
+//#endregion
+//#region src/opentelemetry/index.ts
+const DEFAULT_TRACER_NAME = "better-effect";
+const DEFAULT_EXECUTION_SPAN_NAME = "better-effect.execution";
+const DEFAULT_SERVICE_SPAN_NAME = "better-effect.service";
+const DEFAULT_MAX_ATTRIBUTE_LENGTH = 256;
+const DEFAULT_MAX_ATTRIBUTE_COUNT = 32;
+const DEFAULT_MAX_RESOLUTION_PATH_LENGTH = 16;
+const MAX_ATTRIBUTE_LENGTH = 4096;
+const MAX_ATTRIBUTE_COUNT = 128;
+const MAX_RESOLUTION_PATH_LENGTH = 128;
+const MAX_ARRAY_LENGTH = 16;
+const EXECUTION_ID_ATTRIBUTE = "better_effect.execution_id";
+const PROGRAM_NAME_ATTRIBUTE = "better_effect.program_name";
+const OUTCOME_ATTRIBUTE = "better_effect.outcome";
+const SERVICE_TAG_ATTRIBUTE = "better_effect.service_tag";
+const RESOLUTION_PATH_ATTRIBUTE = "better_effect.resolution_path";
+const RESOLUTION_PATH_TRUNCATED_ATTRIBUTE = "better_effect.resolution_path_truncated";
+const LIBRARY_ATTRIBUTE = "better_effect.library";
+const LIFECYCLE_NAME_ATTRIBUTE = "better_effect.lifecycle_name";
+const LIFECYCLE_PHASE_ATTRIBUTE = "better_effect.lifecycle_phase";
+const SHUTDOWN_PHASE_ATTRIBUTE = "better_effect.shutdown_phase";
+const SHUTDOWN_REASON_ATTRIBUTE = "better_effect.shutdown_reason";
+const SHUTDOWN_SIGNAL_ATTRIBUTE = "better_effect.shutdown_signal";
+const DURATION_ATTRIBUTE = "better_effect.duration_ms";
+const FAILURE_EVENT_NAME = "better-effect.failure";
+const serviceEventStatus = (event) => "error" in event && event.error !== void 0 ? "failure" : event.outcome.status;
+const executionEventStatus = (event) => event.cleanupFailure !== void 0 ? "failure" : event.outcome.status;
+const isStartedExecutionSpan = (execution) => execution.span !== void 0;
+const isActiveExecutionSpan = (execution) => isStartedExecutionSpan(execution) && execution.executionContext !== void 0;
+const isTelemetryMode = (value) => value === "off" || value === "events" || value === "spans";
+const boundedDuration = (value) => value !== void 0 && Number.isFinite(value) && value >= 0 ? Math.min(value, 2 ** 31 - 1) : void 0;
+const addOutcomeAttribute = (attributes, outcome, limit) => {
+	if (outcome !== void 0) addAttribute(attributes, OUTCOME_ATTRIBUTE, outcome, limit);
+};
+const addDurationAttribute = (attributes, durationMs, limit) => {
+	const duration = boundedDuration(durationMs);
+	if (duration !== void 0) addAttribute(attributes, DURATION_ATTRIBUTE, duration, limit);
+};
+const makeLifecycleAttributes = (event, phase, outcome, durationMs, limits) => {
+	const attributes = {};
+	const name = boundedNonEmptyString(event.name, limits.maxAttributeLength);
+	if (name !== void 0) addAttribute(attributes, LIFECYCLE_NAME_ATTRIBUTE, name, limits.maxAttributeCount);
+	addAttribute(attributes, LIFECYCLE_PHASE_ATTRIBUTE, phase, limits.maxAttributeCount);
+	addOutcomeAttribute(attributes, outcome, limits.maxAttributeCount);
+	addDurationAttribute(attributes, durationMs, limits.maxAttributeCount);
+	return attributes;
+};
+const makeShutdownAttributes = (event, phase, durationMs, limits) => {
+	const attributes = {};
+	const reason = event.reason;
+	addAttribute(attributes, SHUTDOWN_PHASE_ATTRIBUTE, phase, limits.maxAttributeCount);
+	addAttribute(attributes, SHUTDOWN_REASON_ATTRIBUTE, reason.kind, limits.maxAttributeCount);
+	if (reason.signal === "SIGINT" || reason.signal === "SIGTERM") addAttribute(attributes, SHUTDOWN_SIGNAL_ATTRIBUTE, reason.signal, limits.maxAttributeCount);
+	if (event.activeExecutions !== void 0 && Number.isSafeInteger(event.activeExecutions)) addAttribute(attributes, "better_effect.active_executions", Math.max(0, event.activeExecutions), limits.maxAttributeCount);
+	addDurationAttribute(attributes, durationMs ?? event.durationMs, limits.maxAttributeCount);
+	if (event.phase === "shutdown-complete") addOutcomeAttribute(attributes, "success", limits.maxAttributeCount);
+	else if (event.phase === "shutdown-failure") addOutcomeAttribute(attributes, "failure", limits.maxAttributeCount);
+	return attributes;
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isSpan = (value) => isRecord(value) && typeof value.end === "function";
+const isTracer = (value) => isRecord(value) && typeof value.startSpan === "function";
+const boundedString = (value, limit) => typeof value === "string" ? value.slice(0, limit) : void 0;
+const boundedNonEmptyString = (value, limit) => {
+	const text = boundedString(value, limit);
+	return text === void 0 || text.length === 0 ? void 0 : text;
+};
+const normalizeLimit = (value, fallback, maximum, name) => {
+	if (value === void 0) return fallback;
+	if (!Number.isSafeInteger(value) || value < 1 || value > maximum) throw new RangeError(`${name} must be an integer between 1 and ${maximum}`);
+	return value;
+};
+const normalizeLimits = (options) => ({
+	maxAttributeLength: normalizeLimit(options.maxAttributeLength, DEFAULT_MAX_ATTRIBUTE_LENGTH, MAX_ATTRIBUTE_LENGTH, "maxAttributeLength"),
+	maxAttributeCount: normalizeLimit(options.maxAttributeCount, DEFAULT_MAX_ATTRIBUTE_COUNT, MAX_ATTRIBUTE_COUNT, "maxAttributeCount"),
+	maxResolutionPathLength: normalizeLimit(options.maxResolutionPathLength, DEFAULT_MAX_RESOLUTION_PATH_LENGTH, MAX_RESOLUTION_PATH_LENGTH, "maxResolutionPathLength")
+});
+const normalizeStringArray = (values, limit) => {
+	const normalized = [];
+	const length = Math.min(values.length, MAX_ARRAY_LENGTH);
+	for (let index = 0; index < length; index += 1) {
+		const value = values[index];
+		if (value === void 0 || value === null) continue;
+		if (typeof value !== "string") return;
+		normalized.push(value.slice(0, limit));
+	}
+	return normalized;
+};
+const normalizeNumberArray = (values) => {
+	const normalized = [];
+	const length = Math.min(values.length, MAX_ARRAY_LENGTH);
+	normalized.length = length;
+	for (let index = 0; index < length; index += 1) {
+		if (!(index in values)) continue;
+		const value = values[index];
+		if (typeof value !== "number" || !Number.isFinite(value)) return;
+		normalized[index] = value;
+	}
+	return normalized;
+};
+const normalizeBooleanArray = (values) => {
+	const normalized = [];
+	const length = Math.min(values.length, MAX_ARRAY_LENGTH);
+	normalized.length = length;
+	for (let index = 0; index < length; index += 1) {
+		if (!(index in values)) continue;
+		const value = values[index];
+		if (typeof value !== "boolean") return;
+		normalized[index] = value;
+	}
+	return normalized;
+};
+const normalizeAttributeValue = (value, maxAttributeLength) => {
+	if (typeof value === "string") return value.slice(0, maxAttributeLength);
+	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+	if (typeof value === "boolean") return value;
+	if (!Array.isArray(value) || value.length === 0) return;
+	return normalizeStringArray(value, maxAttributeLength) ?? normalizeNumberArray(value) ?? normalizeBooleanArray(value);
+};
+const normalizeAttributes = (value, limits) => {
+	const result = {};
+	let inspected = 0;
+	let normalizedCount = 0;
+	if (!isRecord(value)) return result;
+	for (const key in value) {
+		if (inspected >= limits.maxAttributeCount) break;
+		inspected += 1;
+		if (!Object.prototype.propertyIsEnumerable.call(value, key)) continue;
+		if (key.length === 0 || key.length > limits.maxAttributeLength) continue;
+		let normalized;
+		try {
+			normalized = normalizeAttributeValue(value[key], limits.maxAttributeLength);
+		} catch {
+			continue;
+		}
+		if (normalized !== void 0) {
+			result[key] = normalized;
+			normalizedCount += 1;
+			if (normalizedCount >= limits.maxAttributeCount) break;
+		}
+	}
+	return result;
+};
+const selectAllowlistedAttributes = (source, allowlist, limits) => {
+	if (source === void 0 || allowlist === void 0) return {};
+	const selected = {};
+	const length = Math.min(allowlist.length, limits.maxAttributeCount);
+	let selectedCount = 0;
+	for (let index = 0; index < length; index += 1) {
+		const key = allowlist[index];
+		if (typeof key !== "string" || key.length === 0 || key.length > limits.maxAttributeLength) continue;
+		try {
+			if (!(key in selected)) selectedCount += 1;
+			selected[key] = source[key];
+		} catch {}
+		if (selectedCount >= limits.maxAttributeCount) break;
+	}
+	return normalizeAttributes(selected, limits);
+};
+const makeExecutionAttributes = (event, options, limits) => {
+	const result = selectAllowlistedAttributes(event.attributes, options.executionAttributeAllowlist, limits);
+	if (event.attributes !== void 0 && options.sanitizeExecutionAttributes !== void 0) try {
+		const sanitized = options.sanitizeExecutionAttributes(event.attributes);
+		ignoreRejection(sanitized);
+		Object.assign(result, normalizeAttributes(sanitized, limits));
+	} catch {}
+	return result;
+};
+const makeFailureDetails = (cause, sanitizer, limits) => {
+	if (sanitizer === void 0) return;
+	let sanitized;
+	try {
+		sanitized = sanitizer(cause);
+		ignoreRejection(sanitized);
+	} catch {
+		return;
+	}
+	if (typeof sanitized === "string") return {
+		message: sanitized.slice(0, limits.maxAttributeLength),
+		attributes: {}
+	};
+	if (!isRecord(sanitized)) return;
+	let message;
+	let attributes;
+	try {
+		message = boundedString(sanitized.message, limits.maxAttributeLength);
+		attributes = sanitized.attributes;
+	} catch {
+		return;
+	}
+	let normalizedAttributes;
+	try {
+		normalizedAttributes = normalizeAttributes(attributes, limits);
+	} catch {
+		return;
+	}
+	const details = { attributes: normalizedAttributes };
+	if (message !== void 0) details.message = message;
+	return details;
+};
+const mergeAdditionalAttributes = (target, additional, limit) => {
+	for (const [key, value] of Object.entries(additional)) {
+		if (Object.keys(target).length >= limit) break;
+		if (!(key in target)) target[key] = value;
+	}
+};
+const ignoreRejection = (value) => {
+	try {
+		Promise.resolve(value).catch(() => {});
+	} catch {}
+};
+const callSpan = (operation) => {
+	try {
+		ignoreRejection(operation());
+	} catch {}
+};
+const addFailureDetails = (span, details) => {
+	const message = details.message;
+	if (message !== void 0) callSpan(() => span.recordException(message));
+	if (Object.keys(details.attributes).length > 0) callSpan(() => span.addEvent(FAILURE_EVENT_NAME, details.attributes));
+};
+const addAttribute = (target, key, value, limit) => {
+	if (key in target || Object.keys(target).length < limit) target[key] = value;
+};
+const makeExecutionSpanAttributes = (event, options, limits) => {
+	const attributes = {};
+	const executionId = boundedNonEmptyString(event.executionId, limits.maxAttributeLength);
+	const name = boundedNonEmptyString(event.name, limits.maxAttributeLength);
+	if (executionId !== void 0) addAttribute(attributes, EXECUTION_ID_ATTRIBUTE, executionId, limits.maxAttributeCount);
+	if (name !== void 0) addAttribute(attributes, PROGRAM_NAME_ATTRIBUTE, name, limits.maxAttributeCount);
+	addAttribute(attributes, LIBRARY_ATTRIBUTE, "better-effect", limits.maxAttributeCount);
+	mergeAdditionalAttributes(attributes, makeExecutionAttributes(event, options, limits), limits.maxAttributeCount);
+	return attributes;
+};
+const makeResolutionPathAttributes = (path, limits) => {
+	const tags = [];
+	for (const service of path.slice(0, limits.maxResolutionPathLength)) {
+		const tag = boundedNonEmptyString(service.serviceTag, limits.maxAttributeLength);
+		if (tag !== void 0) tags.push(tag);
+	}
+	const result = {};
+	if (tags.length > 0) result[RESOLUTION_PATH_ATTRIBUTE] = tags;
+	if (path.length > limits.maxResolutionPathLength) result[RESOLUTION_PATH_TRUNCATED_ATTRIBUTE] = true;
+	return result;
+};
+const makeServiceEventAttributes = (event, limits, executionId) => {
+	const serviceTag = boundedNonEmptyString(event.service.serviceTag, limits.maxAttributeLength);
+	const attributes = {};
+	if (serviceTag !== void 0) addAttribute(attributes, SERVICE_TAG_ATTRIBUTE, serviceTag, limits.maxAttributeCount);
+	addAttribute(attributes, OUTCOME_ATTRIBUTE, serviceEventStatus(event), limits.maxAttributeCount);
+	if ("resolutionPath" in event) mergeAdditionalAttributes(attributes, makeResolutionPathAttributes(event.resolutionPath, limits), limits.maxAttributeCount);
+	if (executionId !== void 0) addAttribute(attributes, EXECUTION_ID_ATTRIBUTE, executionId, limits.maxAttributeCount);
+	return attributes;
+};
+const readActiveContext = () => {
+	try {
+		return context.active();
+	} catch {
+		return;
+	}
+};
+const setSpanInContext = (parent, span) => {
+	try {
+		return trace.setSpan(parent, span);
+	} catch {
+		return;
+	}
+};
+const resolveTracer = (options) => {
+	const hasTracer = options.tracer !== void 0;
+	const hasProvider = options.provider !== void 0;
+	if (hasTracer === hasProvider) throw new TypeError("OpenTelemetryRuntimeObserver requires exactly one tracer or provider");
+	if (hasTracer) {
+		if (!isTracer(options.tracer)) throw new TypeError("OpenTelemetryRuntimeObserver requires a tracer with startSpan");
+		return options.tracer;
+	}
+	if (hasProvider) {
+		const tracerName = options.tracerName ?? DEFAULT_TRACER_NAME;
+		const tracer = options.provider.getTracer(tracerName, options.tracerVersion);
+		if (!isTracer(tracer)) throw new TypeError("OpenTelemetry provider did not return a tracer with startSpan");
+		return tracer;
+	}
+	throw new TypeError("OpenTelemetryRuntimeObserver requires an existing tracer or provider");
+};
+/**
+* Best-effort RuntimeObserver adapter for an existing OpenTelemetry tracer.
+*
+* The adapter never installs a global provider, SDK, context manager, or
+* exporter. All observer hooks are synchronous and isolate tracer failures.
+*/
+var OpenTelemetryRuntimeObserver = class OpenTelemetryRuntimeObserver {
+	tracer;
+	options;
+	limits;
+	executionSpans = /* @__PURE__ */ new Map();
+	serviceResolution;
+	lifecycleTelemetry;
+	shutdownTelemetry;
+	recordFailures;
+	disposed = false;
+	constructor(options) {
+		this.tracer = resolveTracer(options);
+		this.options = options;
+		this.limits = normalizeLimits(options);
+		this.serviceResolution = options.serviceResolution ?? "off";
+		this.recordFailures = options.recordFailures === true;
+		if (!isTelemetryMode(this.serviceResolution)) throw new TypeError("serviceResolution must be off, events, or spans");
+		const lifecycle = options.lifecycle ?? "off";
+		if (!isTelemetryMode(lifecycle)) throw new TypeError("lifecycle must be off, events, or spans");
+		const shutdown = options.shutdown ?? "off";
+		if (!isTelemetryMode(shutdown)) throw new TypeError("shutdown must be off, events, or spans");
+		this.lifecycleTelemetry = new LifecycleTelemetry({
+			mode: lifecycle,
+			recordFailures: this.recordFailures,
+			getParentContext: () => readActiveContext() ?? ROOT_CONTEXT,
+			startSpan: this.startSpan.bind(this),
+			makeAttributes: (event, phase, outcome, durationMs) => makeLifecycleAttributes(event, phase, outcome, durationMs, this.limits),
+			getFailureDetails: (cause) => makeFailureDetails(cause, this.options.sanitizeFailure, this.limits)
+		});
+		this.shutdownTelemetry = new ShutdownTelemetry({
+			mode: shutdown,
+			recordFailures: this.recordFailures,
+			rootContext: ROOT_CONTEXT,
+			startSpan: this.startSpan.bind(this),
+			makeAttributes: (event, phase, durationMs) => makeShutdownAttributes(event, phase, durationMs, this.limits),
+			getFailureDetails: (cause) => makeFailureDetails(cause, this.options.sanitizeFailure, this.limits)
+		});
+	}
+	static make(options) {
+		return new OpenTelemetryRuntimeObserver(options);
+	}
+	onExecutionStart = (event) => {
+		this.safely(() => this.startExecution(event));
+	};
+	onExecutionEnd = (event) => {
+		this.safely(() => this.endExecution(event));
+	};
+	onServiceResolve = (event) => {
+		this.safely(() => this.observeService("better-effect.service.resolve", event));
+	};
+	onServiceAcquire = (event) => {
+		this.safely(() => this.observeService("better-effect.service.acquire", event));
+	};
+	onResourceRelease = (event) => {
+		this.safely(() => this.observeService("better-effect.service.release", event));
+	};
+	onLifecycleStart = (event) => {
+		this.safely(() => this.lifecycleTelemetry.onStart(event));
+	};
+	onLifecycleEnd = (event) => {
+		this.safely(() => this.lifecycleTelemetry.onEnd(event));
+	};
+	onLifecycleRelease = (event) => {
+		this.safely(() => this.lifecycleTelemetry.onRelease(event));
+	};
+	onShutdown = (event) => {
+		this.safely(() => this.shutdownTelemetry.onEvent(event));
+	};
+	/** End any spans whose malformed or missing end event left them pending. */
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		const pending = [...this.executionSpans.values()];
+		for (const execution of pending) {
+			const span = execution.span;
+			if (span === void 0) continue;
+			this.endExecutionSpan(execution, span);
+		}
+		this.lifecycleTelemetry.dispose();
+		this.shutdownTelemetry.dispose();
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	async [Symbol.asyncDispose]() {
+		this.dispose();
+	}
+	safely(operation) {
+		if (this.disposed) return;
+		try {
+			operation();
+		} catch {}
+	}
+	startSpan(name, attributes, parentContext) {
+		try {
+			const span = parentContext === void 0 ? this.tracer.startSpan(name, { attributes }) : this.tracer.startSpan(name, { attributes }, parentContext);
+			if (!isSpan(span)) {
+				ignoreRejection(span);
+				return;
+			}
+			return span;
+		} catch {
+			return;
+		}
+	}
+	ownsExecutionSpan(execution, span) {
+		return this.executionSpans.get(execution.executionId) === execution && execution.span === span;
+	}
+	claimExecutionSpan(execution, span) {
+		if (this.executionSpans.get(execution.executionId) !== execution || execution.span !== span) return false;
+		this.executionSpans.delete(execution.executionId);
+		return true;
+	}
+	endExecutionSpan(execution, span) {
+		if (this.claimExecutionSpan(execution, span)) callSpan(() => span.end());
+	}
+	finishPendingExecution(execution) {
+		if (execution.pendingEnd !== void 0 && isActiveExecutionSpan(execution)) this.finishExecution(execution, execution.pendingEnd);
+	}
+	startExecution(event) {
+		if (this.executionSpans.has(event.executionId)) return;
+		const execution = {
+			executionId: event.executionId,
+			ended: false
+		};
+		this.executionSpans.set(event.executionId, execution);
+		const parentContext = readActiveContext() ?? ROOT_CONTEXT;
+		let span;
+		try {
+			span = this.startSpan(boundedNonEmptyString(event.name, this.limits.maxAttributeLength) ?? DEFAULT_EXECUTION_SPAN_NAME, makeExecutionSpanAttributes(event, this.options, this.limits), parentContext);
+		} catch {
+			this.claimExecutionSpan(execution, void 0);
+			return;
+		}
+		if (span === void 0) {
+			this.claimExecutionSpan(execution, void 0);
+			return;
+		}
+		execution.span = span;
+		if (this.disposed) {
+			this.endExecutionSpan(execution, span);
+			return;
+		}
+		if (!this.ownsExecutionSpan(execution, span)) return;
+		const executionContext = setSpanInContext(parentContext, span);
+		if (executionContext === void 0) {
+			const pendingEnd = execution.pendingEnd;
+			if (pendingEnd !== void 0 && isStartedExecutionSpan(execution)) this.finishExecution(execution, pendingEnd);
+			else this.endExecutionSpan(execution, span);
+			return;
+		}
+		execution.executionContext = executionContext;
+		this.finishPendingExecution(execution);
+	}
+	endExecution(event) {
+		const execution = this.executionSpans.get(event.executionId);
+		if (execution === void 0 || execution.ended) return;
+		execution.ended = true;
+		if (!isActiveExecutionSpan(execution)) {
+			execution.pendingEnd = event;
+			return;
+		}
+		this.finishExecution(execution, event);
+	}
+	finishExecution(execution, event) {
+		const span = execution.span;
+		if (!this.claimExecutionSpan(execution, span)) return;
+		try {
+			const status = executionEventStatus(event);
+			callSpan(() => span.setAttribute(OUTCOME_ATTRIBUTE, status));
+			callSpan(() => span.setStatus({ code: status === "failure" ? SpanStatusCode.ERROR : SpanStatusCode.OK }));
+			if (status === "failure" && this.recordFailures) {
+				const cause = event.outcome.status === "failure" ? event.outcome.cause : event.cleanupFailure;
+				const details = makeFailureDetails(cause, this.options.sanitizeFailure, this.limits);
+				if (details !== void 0) addFailureDetails(span, details);
+			}
+		} finally {
+			callSpan(() => span.end());
+		}
+	}
+	findCorrelatedExecution(event) {
+		if (event.executionId === void 0) return;
+		const execution = this.executionSpans.get(event.executionId);
+		return execution !== void 0 && isActiveExecutionSpan(execution) ? execution : void 0;
+	}
+	observeService(name, event) {
+		if (this.serviceResolution === "off") return;
+		const execution = this.findCorrelatedExecution(event);
+		const executionId = execution === void 0 ? void 0 : this.findExecutionId(execution);
+		const attributes = makeServiceEventAttributes(event, this.limits, executionId);
+		let failureCause;
+		if ("error" in event && event.error !== void 0) failureCause = event.error;
+		else if (event.outcome.status === "failure") failureCause = event.outcome.cause;
+		const details = serviceEventStatus(event) === "failure" && this.recordFailures ? makeFailureDetails(failureCause, this.options.sanitizeFailure, this.limits) : void 0;
+		if (details?.attributes !== void 0) mergeAdditionalAttributes(attributes, details.attributes, this.limits.maxAttributeCount);
+		if (execution !== void 0) {
+			this.observeCorrelatedService(name, event, execution, attributes, details);
+			return;
+		}
+		this.observeStandaloneService(name, event, attributes, details);
+	}
+	findExecutionId(execution) {
+		return boundedNonEmptyString(execution.executionId, this.limits.maxAttributeLength);
+	}
+	observeCorrelatedService(name, event, execution, attributes, details) {
+		if (this.serviceResolution === "events") {
+			callSpan(() => execution.span.addEvent(name, attributes));
+			if (details !== void 0) addFailureDetails(execution.span, details);
+			return;
+		}
+		const span = this.startSpan(name, attributes, execution.executionContext);
+		if (span === void 0) return;
+		this.finishServiceSpan(span, event, details);
+	}
+	observeStandaloneService(name, event, attributes, details) {
+		const span = this.startSpan(this.serviceResolution === "events" ? DEFAULT_SERVICE_SPAN_NAME : name, attributes, ROOT_CONTEXT);
+		if (span === void 0) return;
+		if (this.serviceResolution === "events") callSpan(() => span.addEvent(name, attributes));
+		this.finishServiceSpan(span, event, details);
+	}
+	finishServiceSpan(span, event, details) {
+		callSpan(() => span.setStatus({ code: serviceEventStatus(event) === "failure" ? SpanStatusCode.ERROR : SpanStatusCode.OK }));
+		if (details !== void 0) addFailureDetails(span, details);
+		callSpan(() => span.end());
+	}
+};
+//#endregion
+export { OpenTelemetryRuntimeObserver };
+
+//# sourceMappingURL=opentelemetry.mjs.map