@safaricom-mxl/effect-sdk 0.0.15 → 0.0.17

package/dist/cloudflare/index.js

@@ -0,0 +1,587 @@
+import { Cause, Config, Context, Duration, Effect, Layer, ManagedRuntime, Match, Option, Schedule, Schema, Semaphore } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { SchemaJITCompiler } from "effect/unstable/schema";
+import { Otlp } from "effect/unstable/observability";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import * as Otel from "@opentelemetry/api";
+import * as Tracer from "effect/Tracer";
+import { v7 } from "uuid";
+import { platform, provider, runtime } from "std-env";
+const RESERVED_EVENT_NAMES = ["session_start", "session_end"];
+const isReservedEventName = (name) => RESERVED_EVENT_NAMES.some((reserved) => reserved === name);
+const coerceTrackProps = (props) => {
+	if (props === void 0) return {};
+	const attributes = {};
+	for (const [key, value] of Object.entries(props)) {
+		if (value === void 0) continue;
+		attributes[key] = typeof value === "string" ? value : String(value);
+	}
+	return attributes;
+};
+const toEventTimestamp = (value) => (value instanceof Date ? value : new Date(value ?? Date.now())).toISOString();
+const encodeProductEventLine = (input) => {
+	const trimmed = typeof input.name === "string" ? input.name.trim() : "";
+	if (trimmed.length === 0 || isReservedEventName(trimmed)) return;
+	const options = input.options ?? {};
+	return {
+		attributes: coerceTrackProps(options.attributes),
+		group_id: options.groupId ?? "",
+		name: trimmed.slice(0, 80),
+		page_path: options.pagePath ?? "",
+		service_name: input.serviceName,
+		session_id: options.sessionId ?? "",
+		source: input.source,
+		timestamp: toEventTimestamp(options.timestamp),
+		traceparent: options.traceparent,
+		url: options.url ?? "",
+		user_id: options.userId ?? "",
+		visitor_id: options.visitorId ?? ""
+	};
+};
+const encodeNdjson = (lines) => `${lines.map((line) => JSON.stringify(line)).join("\n")}\n`;
+//#endregion
+//#region src/version.ts
+const SDK_NAME = "mxl-effect-sdk";
+const SDK_VERSION = "0.0.15";
+//#endregion
+//#region src/server/events.ts
+const DEFAULT_FLUSH_INTERVAL = Duration.seconds(5);
+const DEFAULT_MAX_BATCH_SIZE = 100;
+const MAX_BUFFERED_EVENTS = 1e3;
+const WARN_INTERVAL_MS = 3e4;
+const DEFAULT_BASKET_URL = "http://127.0.0.1:8000";
+var MxlEvents = class extends Context.Service()("@safaricom-mxl/effect-sdk/MxlEvents") {};
+var ProductEventsPostError = class extends Schema.TaggedError()("@safaricom-mxl/effect-sdk/ProductEventsPostError", {
+	cause: Schema.optionalKey(Schema.Defect()),
+	message: Schema.String,
+	status: Schema.optionalKey(Schema.Number)
+}) {};
+SchemaJITCompiler.enable(ProductEventsPostError.ast);
+const stringOrUndefined$1 = (value) => value && value.length > 0 ? value : void 0;
+const resolveEventsConfig$1 = (config) => {
+	const endpoint = (config.endpoint ?? process.env.MXL_BASKET_URL ?? DEFAULT_BASKET_URL).replace(/\/$/, "");
+	return {
+		apiKey: stringOrUndefined$1(config.apiKey ?? process.env.MXL_API_KEY),
+		clientId: stringOrUndefined$1(config.clientId ?? process.env.MXL_CLIENT_ID),
+		serviceName: config.serviceName ?? process.env.OTEL_SERVICE_NAME ?? "unknown",
+		url: `${endpoint}${config.eventsPath ?? "/events"}`
+	};
+};
+const make$1 = Effect.fn("MxlEvents.make")(function* (config = {}) {
+	const resolved = resolveEventsConfig$1(config);
+	const maxBatchSize = Math.max(1, config.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE);
+	const client = (yield* HttpClient.HttpClient).pipe(HttpClient.filterStatusOk);
+	const flushing = yield* Semaphore.make(1);
+	let buffer = [];
+	let warnedAboutName = false;
+	let warnedAboutClient = false;
+	let lastPostWarnAt = 0;
+	const warnPost = (error) => {
+		const now = Date.now();
+		if (now - lastPostWarnAt < WARN_INTERVAL_MS) return;
+		lastPostWarnAt = now;
+		console.warn(`[MxlEvents] ${error.message} (dropping batch)`, error.cause ?? "");
+	};
+	const warnMissingClient = () => {
+		if (warnedAboutClient) return;
+		warnedAboutClient = true;
+		console.warn("[MxlEvents] no client id — set MXL_CLIENT_ID or pass `clientId`; dropping events");
+	};
+	const warnEmptyName = () => {
+		if (warnedAboutName) return;
+		warnedAboutName = true;
+		console.warn("[MxlEvents] track() needs a non-empty event name; the call was ignored.");
+	};
+	const post = (lines) => {
+		const headers = {
+			"mxl-client-id": resolved.clientId ?? "",
+			"mxl-sdk-name": SDK_NAME,
+			"mxl-sdk-version": SDK_VERSION,
+			"user-agent": `${SDK_NAME}-server/${SDK_VERSION}`
+		};
+		if (resolved.apiKey) headers["mxl-api-key"] = resolved.apiKey;
+		return HttpClientRequest.post(resolved.url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(encodeNdjson(lines), "application/x-ndjson"), client.execute, Effect.asVoid, Effect.mapError((error) => error.response !== void 0 ? new ProductEventsPostError({
+			message: `POST ${resolved.url} → ${error.response.status}`,
+			status: error.response.status
+		}) : new ProductEventsPostError({
+			cause: error,
+			message: `POST ${resolved.url} failed: ${error.message}`
+		})));
+	};
+	const flush = flushing.withPermits(1)(Effect.suspend(() => {
+		if (buffer.length === 0) return Effect.void;
+		const batch = buffer;
+		buffer = [];
+		if (resolved.clientId === void 0) {
+			warnMissingClient();
+			return Effect.void;
+		}
+		return post(batch).pipe(Effect.catchCause((cause) => Effect.sync(() => {
+			warnPost(Option.getOrElse(Cause.findErrorOption(cause), () => new ProductEventsPostError({
+				cause: Cause.squash(cause),
+				message: `POST ${resolved.url} failed`
+			})));
+		})));
+	}));
+	const track = (name, options = {}) => Effect.sync(() => {
+		const line = encodeProductEventLine({
+			name,
+			options,
+			serviceName: resolved.serviceName,
+			source: "server"
+		});
+		if (line === void 0) {
+			warnEmptyName();
+			return false;
+		}
+		buffer.push(line);
+		if (buffer.length > MAX_BUFFERED_EVENTS) buffer.splice(0, buffer.length - MAX_BUFFERED_EVENTS);
+		return buffer.length >= maxBatchSize;
+	}).pipe(Effect.flatMap((full) => full ? Effect.forkDetach(flush) : Effect.void), Effect.asVoid);
+	const interval = config.flushInterval ?? DEFAULT_FLUSH_INTERVAL;
+	if (Duration.toMillis(interval) > 0) yield* Effect.forkScoped(flush.pipe(Effect.schedule(Schedule.spaced(interval))));
+	yield* Effect.addFinalizer(() => flush);
+	return {
+		flush,
+		track
+	};
+});
+const layer$1 = (config = {}) => Layer.effect(MxlEvents, make$1(config)).pipe(Layer.provide(FetchHttpClient.layer));
+const makeHandle = (config = {}) => {
+	const runtime = ManagedRuntime.make(layer$1(config));
+	const swallow = (promise) => promise.then(() => void 0, () => void 0);
+	return {
+		dispose: () => swallow(runtime.dispose()),
+		flush: () => swallow(runtime.runPromise(Effect.gen(function* () {
+			yield* (yield* MxlEvents).flush;
+		}))),
+		track: (name, options) => {
+			swallow(runtime.runPromise(Effect.gen(function* () {
+				yield* (yield* MxlEvents).track(name, options);
+			})));
+		}
+	};
+};
+//#endregion
+//#region src/server/otel-context-bridge.ts
+const evaluate = "~effect/Effect/evaluate";
+let contextManagerInstalled = false;
+/**
+* Install AsyncLocalStorage so `Otel.context.with` actually propagates.
+* Does not replace a context manager the host app already registered.
+*/
+function ensureOtelContextManager() {
+	if (contextManagerInstalled) return;
+	const manager = new AsyncLocalStorageContextManager();
+	manager.enable();
+	if (!Otel.context.setGlobalContextManager(manager)) {
+		manager.disable();
+		contextManagerInstalled = true;
+		return;
+	}
+	contextManagerInstalled = true;
+}
+/**
+* Put Effect span ids on the global OpenTelemetry context.
+*
+* Id-only `setSpanContext`. Live `Otel.Span` objects come from
+* `OtelTracer.currentOtelSpan` in Effect space, not from a private TypeId.
+*/
+function effectSpanToOtelContext(activeContext, span) {
+	return Otel.trace.setSpanContext(activeContext, {
+		isRemote: span._tag === "ExternalSpan",
+		spanId: span.spanId,
+		traceFlags: span.sampled ? Otel.TraceFlags.SAMPLED : Otel.TraceFlags.NONE,
+		traceId: span.traceId
+	});
+}
+/**
+* Wrap a tracer so Effect spans activate global `@opentelemetry/api` context.
+*
+* Prefer this over `Otlp.layerJson({ tracerContext })`. That callback receives
+* `(primitive, span)` and must return the evaluation, but `EffectPrimitive`
+* only evaluates with a `fiber`. Keep this wrap until Effect passes fiber.
+*/
+function wrapTracerWithOtelContextBridge(base) {
+	ensureOtelContextManager();
+	const existingContext = base.context;
+	return Tracer.make({
+		span(options) {
+			return base.span(options);
+		},
+		context(primitive, fiber) {
+			if (fiber.cache.span === void 0) {
+				if (existingContext) return existingContext(primitive, fiber);
+				return primitive[evaluate](fiber);
+			}
+			return Otel.context.with(effectSpanToOtelContext(Otel.context.active(), fiber.cache.span), () => {
+				if (existingContext) return existingContext(primitive, fiber);
+				return primitive[evaluate](fiber);
+			});
+		}
+	});
+}
+/**
+* Layer that wraps the configured Effect tracer with a global OTel context bridge.
+*
+* Must be provided over `Otlp.layerJson` so queue propagation, log correlation,
+* and outbound W3C headers see the active server span.
+*/
+const otelGlobalContextBridgeLayer = Layer.effect(Tracer.Tracer, Effect.gen(function* () {
+	return wrapTracerWithOtelContextBridge(yield* Tracer.Tracer);
+}));
+//#endregion
+//#region src/server/otlp.ts
+function normalizeOtlpBaseUrl(url) {
+	const trimmed = url.replace(/\/$/, "");
+	if (trimmed.endsWith("/v1/traces") || trimmed.endsWith("/v1/logs")) return trimmed.replace(/\/v1\/(traces|logs|metrics)$/, "");
+	return trimmed;
+}
+/** Resolve the OTLP exporter endpoint from standard env vars. */
+const endpoint = Effect.gen(function* () {
+	const otlp = yield* Config.option(Config.String("OTEL_EXPORTER_OTLP_ENDPOINT"));
+	if (Option.isSome(otlp)) return otlp;
+	return yield* Config.option(Config.String("OTLP_ENDPOINT"));
+});
+const sdkDisabled = Config.Boolean("OTEL_SDK_DISABLED").pipe(Config.withDefault(false));
+/**
+* Resolve service version / commit SHA from platform-specific env vars.
+*
+* Priority: npm_package_version > COMMIT_SHA > RAILWAY_GIT_COMMIT_SHA >
+* VERCEL_GIT_COMMIT_SHA > CF_PAGES_COMMIT_SHA > RENDER_GIT_COMMIT
+*/
+const serviceVersion = Config.option(Config.String("npm_package_version").pipe(Config.orElse(() => Config.String("COMMIT_SHA")), Config.orElse(() => Config.String("RAILWAY_GIT_COMMIT_SHA")), Config.orElse(() => Config.String("VERCEL_GIT_COMMIT_SHA")), Config.orElse(() => Config.String("CF_PAGES_COMMIT_SHA")), Config.orElse(() => Config.String("RENDER_GIT_COMMIT"))));
+/**
+* Resolve deployment environment from env vars.
+*
+* Priority: NODE_ENV > DEPLOYMENT_ENV > "development"
+*/
+const environment = Config.String("NODE_ENV").pipe(Config.orElse(() => Config.String("DEPLOYMENT_ENV")), Config.withDefault("development"));
+/** OTel-standard service name override. */
+const otelServiceName = Config.option(Config.String("OTEL_SERVICE_NAME"));
+/**
+* Parse the OTel-standard `OTEL_RESOURCE_ATTRIBUTES` env var.
+*
+* Format per the OTel spec: comma-separated `key=value` pairs, values may be
+* URL-encoded.
+*/
+const parseOtelResourceAttributes = (input) => {
+	const result = {};
+	for (const pair of input.split(",")) {
+		const eq = pair.indexOf("=");
+		if (eq === -1) continue;
+		const key = pair.slice(0, eq).trim();
+		if (!key) continue;
+		const raw = pair.slice(eq + 1).trim();
+		let value = raw;
+		try {
+			value = decodeURIComponent(raw);
+		} catch {}
+		result[key] = value;
+	}
+	return result;
+};
+/** Resolve and parse `OTEL_RESOURCE_ATTRIBUTES`. */
+const otelResourceAttributes = Effect.gen(function* () {
+	const raw = yield* Config.option(Config.String("OTEL_RESOURCE_ATTRIBUTES"));
+	return Option.match(raw, {
+		onNone: () => ({}),
+		onSome: (value) => parseOtelResourceAttributes(value)
+	});
+});
+/**
+* Parse `OTEL_EXPORTER_OTLP_HEADERS` (`key=value,key2=value2`) into a header map.
+*/
+const parseOtlpHeaders = (input) => {
+	const result = {};
+	for (const pair of input.split(",")) {
+		const eq = pair.indexOf("=");
+		if (eq === -1) continue;
+		const key = pair.slice(0, eq).trim();
+		if (!key) continue;
+		const raw = pair.slice(eq + 1).trim();
+		try {
+			result[key] = decodeURIComponent(raw);
+		} catch {
+			result[key] = raw;
+		}
+	}
+	return result;
+};
+/** Resolve OTLP export headers from env. */
+const otlpHeaders = Effect.gen(function* () {
+	const raw = yield* Config.option(Config.String("OTEL_EXPORTER_OTLP_HEADERS"));
+	return Option.match(raw, {
+		onNone: () => ({}),
+		onSome: (value) => parseOtlpHeaders(value)
+	});
+});
+//#endregion
+//#region src/server/platform.ts
+const empty = {};
+const runtimeAttrs = (rt) => Match.value(rt).pipe(Match.when("node", () => ({ "process.runtime.name": "nodejs" })), Match.whenOr("bun", "deno", "workerd", "edge-light", "fastly", (name) => ({ "process.runtime.name": name })), Match.orElse(() => empty));
+const osAttrs = (plat) => Match.value(plat).pipe(Match.when("win32", () => ({ "os.type": "windows" })), Match.whenOr("darwin", "linux", "freebsd", "openbsd", "netbsd", (p) => ({ "os.type": p })), Match.orElse(() => empty));
+const archAttrs = (a) => a === "" ? empty : { "host.arch": Match.value(a).pipe(Match.when("x64", () => "amd64"), Match.when("ia32", () => "x86"), Match.orElse((other) => other)) };
+const lambdaAttrs = (env) => ({
+	"cloud.provider": "aws",
+	"cloud.platform": "aws_lambda",
+	"faas.name": env.AWS_LAMBDA_FUNCTION_NAME,
+	...env.AWS_LAMBDA_FUNCTION_VERSION && { "faas.version": env.AWS_LAMBDA_FUNCTION_VERSION },
+	...env.AWS_LAMBDA_LOG_STREAM_NAME && { "faas.instance": env.AWS_LAMBDA_LOG_STREAM_NAME },
+	...env.AWS_REGION ? { "cloud.region": env.AWS_REGION } : env.AWS_DEFAULT_REGION ? { "cloud.region": env.AWS_DEFAULT_REGION } : {}
+});
+const providerAttrs = (prov, env) => Match.value(prov).pipe(Match.when("cloudflare_workers", () => ({
+	"cloud.provider": "cloudflare",
+	"cloud.platform": "cloudflare.workers"
+})), Match.when("cloudflare_pages", () => ({
+	"cloud.provider": "cloudflare",
+	"cloud.platform": "cloudflare.pages"
+})), Match.when("vercel", () => ({
+	"cloud.provider": "vercel",
+	"cloud.platform": "vercel",
+	...env.VERCEL_REGION && { "cloud.region": env.VERCEL_REGION },
+	...env.VERCEL_DEPLOYMENT_ID && { "faas.instance": env.VERCEL_DEPLOYMENT_ID }
+})), Match.when("netlify", () => ({
+	"cloud.provider": "netlify",
+	"cloud.platform": "netlify"
+})), Match.whenOr("google_cloudrun", "google_cloudrun_job", () => ({
+	"cloud.provider": "gcp",
+	"cloud.platform": "gcp_cloud_run",
+	...env.K_SERVICE && { "faas.name": env.K_SERVICE },
+	...env.K_REVISION && { "faas.version": env.K_REVISION },
+	...env.CLOUD_RUN_REGION && { "cloud.region": env.CLOUD_RUN_REGION }
+})), Match.when("firebase_app_hosting", () => ({
+	"cloud.provider": "gcp",
+	"cloud.platform": "gcp_firebase_app_hosting"
+})), Match.when("aws_amplify", () => ({
+	"cloud.provider": "aws",
+	"cloud.platform": "aws_amplify"
+})), Match.when("deno-deploy", () => ({
+	"cloud.provider": "deno",
+	"cloud.platform": "deno_deploy",
+	...env.DENO_REGION && { "cloud.region": env.DENO_REGION },
+	...env.DENO_DEPLOYMENT_ID && { "faas.instance": env.DENO_DEPLOYMENT_ID }
+})), Match.when("render", () => ({
+	"cloud.provider": "render",
+	"cloud.platform": "render",
+	...env.RENDER_INSTANCE_ID && { "faas.instance": env.RENDER_INSTANCE_ID }
+})), Match.when("railway", () => ({
+	"cloud.provider": "railway",
+	"cloud.platform": "railway",
+	...env.RAILWAY_REPLICA_ID && { "faas.instance": env.RAILWAY_REPLICA_ID }
+})), Match.when("edgeone_pages", () => ({
+	"cloud.provider": "tencent_cloud",
+	"cloud.platform": "tencent_edgeone_pages"
+})), Match.orElse(() => empty));
+const workerdFallback = (rt, alreadyResolved) => rt === "workerd" && !alreadyResolved ? {
+	"cloud.provider": "cloudflare",
+	"cloud.platform": "cloudflare.workers"
+} : empty;
+const vercelEdgeFallback = (rt, alreadyResolved, env) => rt === "edge-light" && !alreadyResolved && env.VERCEL ? {
+	"cloud.provider": "vercel",
+	"cloud.platform": "vercel"
+} : empty;
+const derivePlatformAttributes = (inputs) => {
+	const { runtime: rt, provider: prov, platform: plat, arch, env } = inputs;
+	const cloudAttrs = env.AWS_LAMBDA_FUNCTION_NAME ? lambdaAttrs(env) : providerAttrs(prov, env);
+	const cloudResolved = "cloud.provider" in cloudAttrs;
+	return {
+		...rt && { "mxl.runtime": rt },
+		...prov && { "mxl.provider": prov },
+		...runtimeAttrs(rt),
+		...osAttrs(plat),
+		...archAttrs(arch),
+		...cloudAttrs,
+		...workerdFallback(rt, cloudResolved),
+		...vercelEdgeFallback(rt, cloudResolved, env)
+	};
+};
+const PLATFORM_ENV_KEYS = [
+	"AWS_LAMBDA_FUNCTION_NAME",
+	"AWS_LAMBDA_FUNCTION_VERSION",
+	"AWS_LAMBDA_LOG_STREAM_NAME",
+	"AWS_REGION",
+	"AWS_DEFAULT_REGION",
+	"VERCEL",
+	"VERCEL_REGION",
+	"VERCEL_DEPLOYMENT_ID",
+	"K_SERVICE",
+	"K_REVISION",
+	"CLOUD_RUN_REGION",
+	"DENO_REGION",
+	"DENO_DEPLOYMENT_ID",
+	"RENDER_INSTANCE_ID",
+	"RAILWAY_REPLICA_ID"
+];
+const getAutoPlatformAttributes = () => {
+	const proc = globalThis.process;
+	const procEnv = proc?.env ?? {};
+	const env = {};
+	for (const key of PLATFORM_ENV_KEYS) env[key] = procEnv[key];
+	return derivePlatformAttributes({
+		runtime: runtime ?? "",
+		provider: provider ?? "",
+		platform: platform ?? "",
+		arch: proc?.arch ?? "",
+		env
+	});
+};
+//#endregion
+//#region src/server/resource.ts
+const stringOrUndefined = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+const DEFAULT_VCS_REPOSITORY_URL = "https://gitlab.safaricom.co.ke/mxl/apm/mxl-effect-sdk";
+function resolveCommitRevision() {
+	return stringOrUndefined(process.env.COMMIT_SHA) ?? stringOrUndefined(process.env.VERCEL_GIT_COMMIT_SHA) ?? stringOrUndefined(process.env.GITHUB_SHA) ?? stringOrUndefined(process.env.RAILWAY_GIT_COMMIT_SHA) ?? stringOrUndefined(process.env.CF_PAGES_COMMIT_SHA) ?? stringOrUndefined(process.env.RENDER_GIT_COMMIT);
+}
+let serviceInstanceId;
+const getServiceInstanceId = () => serviceInstanceId ??= v7();
+const resolveResource = (config) => Effect.gen(function* () {
+	if (yield* sdkDisabled) return {
+		endpoint: void 0,
+		environment: void 0,
+		headers: void 0,
+		resource: {
+			attributes: {},
+			serviceName: config.serviceName ?? "unknown",
+			serviceVersion: void 0
+		}
+	};
+	const envEndpoint = yield* endpoint;
+	const endpoint$1 = config.endpoint ?? Option.getOrUndefined(envEndpoint) ?? "http://127.0.0.1:4318";
+	const envHeaders = yield* otlpHeaders;
+	const headers = config.headers && Object.keys(config.headers).length > 0 ? config.headers : Object.keys(envHeaders).length > 0 ? envHeaders : void 0;
+	const envServiceVersion = yield* serviceVersion;
+	const serviceVersion$1 = config.serviceVersion ?? Option.getOrUndefined(envServiceVersion);
+	const envEnvironment = yield* environment;
+	const environment$1 = config.environment ?? envEnvironment;
+	const envOtelServiceName = yield* otelServiceName;
+	const serviceName = config.serviceName ?? Option.getOrUndefined(envOtelServiceName) ?? "unknown";
+	const envResourceAttributes = yield* otelResourceAttributes;
+	const attributes = {};
+	Object.assign(attributes, getAutoPlatformAttributes());
+	attributes["mxl.sdk.type"] = config.sdkType ?? "server";
+	attributes["service.instance.id"] = getServiceInstanceId();
+	if (environment$1) {
+		attributes["deployment.environment"] = environment$1;
+		attributes["deployment.environment.name"] = environment$1;
+	}
+	if (serviceVersion$1) attributes["service.version"] = serviceVersion$1;
+	const commitRevision = resolveCommitRevision();
+	if (commitRevision) {
+		attributes["deployment.commit_sha"] = commitRevision;
+		attributes["vcs.ref.head.revision"] = commitRevision;
+	}
+	attributes["vcs.repository.url.full"] = stringOrUndefined(process.env.MXL_VCS_REPOSITORY_URL) ?? DEFAULT_VCS_REPOSITORY_URL;
+	Object.assign(attributes, envResourceAttributes);
+	if (config.attributes) Object.assign(attributes, config.attributes);
+	return {
+		endpoint: endpoint$1,
+		environment: environment$1,
+		headers,
+		resource: {
+			serviceName,
+			serviceVersion: serviceVersion$1,
+			attributes
+		}
+	};
+}).pipe(Effect.orDie);
+//#endregion
+//#region src/server/layer.ts
+/**
+* Create an Effect Layer that provides OpenTelemetry traces, logs, and metrics
+* configured for MXL's OTLP collector.
+*
+* Returns a no-op layer when `OTEL_SDK_DISABLED=true`.
+*
+* Wraps the OTLP tracer with `otelGlobalContextBridgeLayer` via `provideMerge`.
+* `Otlp.layerJson({ tracerContext })` cannot evaluate without a `fiber`, and
+* `Layer.updateService` cannot wrap a Tracer the OTLP layer already provides.
+*/
+const layer = (config = {}) => Layer.unwrap(Effect.gen(function* () {
+	const resolved = yield* resolveResource({
+		...config,
+		sdkType: "server"
+	});
+	if (!resolved.endpoint) return Layer.empty;
+	const otlp = Otlp.layerJson({
+		baseUrl: normalizeOtlpBaseUrl(resolved.endpoint),
+		headers: resolved.headers,
+		resource: resolved.resource,
+		maxBatchSize: config.maxBatchSize,
+		loggerExportInterval: config.loggerExportInterval,
+		metricsExportInterval: config.metricsExportInterval,
+		tracerExportInterval: config.tracerExportInterval,
+		shutdownTimeout: config.shutdownTimeout
+	}).pipe(Layer.provide(FetchHttpClient.layer));
+	return otelGlobalContextBridgeLayer.pipe(Layer.provideMerge(otlp));
+}));
+//#endregion
+//#region src/shared/flush-core.ts
+const COOLDOWN_MS = 6e4;
+const makeSerializedFlush = (flush) => {
+	let pending = Promise.resolve();
+	return (...args) => {
+		pending = pending.then(() => flush(...args), () => flush(...args));
+		return pending;
+	};
+};
+const guardFlush = (prefix, flush, state) => {
+	return async (...args) => {
+		if (state && Date.now() < state.disabledUntil) return;
+		try {
+			await flush(...args);
+		} catch (error) {
+			if (state) state.disabledUntil = Date.now() + COOLDOWN_MS;
+			console.error(`${prefix} flush failed; cooling down 60s`, error);
+		}
+	};
+};
+//#endregion
+//#region src/cloudflare/index.ts
+var WorkerEnvironment = class extends Context.Service()("Cloudflare.Workers.WorkerEnvironment") {};
+const stringFromEnv = (env, key) => {
+	const value = env[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+};
+const resolveEventsConfig = (env, config) => ({
+	apiKey: config.apiKey ?? stringFromEnv(env, "MXL_API_KEY"),
+	clientId: config.clientId ?? stringFromEnv(env, "MXL_CLIENT_ID"),
+	endpoint: config.ingestUrl ?? stringFromEnv(env, "MXL_BASKET_URL") ?? void 0,
+	flushInterval: 0,
+	serviceName: config.serviceName ?? stringFromEnv(env, "OTEL_SERVICE_NAME") ?? "unknown"
+});
+const make = (config = {}) => {
+	let handle;
+	const flush = makeSerializedFlush(guardFlush("[MxlCloudflareSDK]", async (env) => {
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		const eventsConfig = resolveEventsConfig(env, config);
+		if (!eventsConfig.clientId) return;
+		handle ??= makeHandle(eventsConfig);
+		await handle.flush();
+	}, { disabledUntil: 0 }));
+	const layer$2 = layer({
+		attributes: Object.fromEntries(Object.entries(config.attributes ?? {}).map(([key, value]) => [key, String(value)])),
+		endpoint: config.endpoint,
+		environment: config.environment,
+		serviceName: config.serviceName,
+		serviceVersion: config.serviceVersion
+	});
+	return {
+		flush,
+		layer: layer$2,
+		requestLayer: Layer.mergeAll(layer$2, Layer.unwrap(Effect.gen(function* () {
+			const env = yield* WorkerEnvironment;
+			const eventsConfig = resolveEventsConfig(env, config);
+			if (!eventsConfig.clientId) return Layer.empty;
+			return layer$1(eventsConfig);
+		})), Layer.effectDiscard(Effect.gen(function* () {
+			const env = yield* WorkerEnvironment;
+			yield* Effect.addFinalizer(() => Effect.promise(() => flush(env)));
+		})))
+	};
+};
+const MxlCloudflareSDK = { make };
+//#endregion
+export { MxlCloudflareSDK, WorkerEnvironment, make };
+
+//# sourceMappingURL=index.js.map