@safaricom-mxl/effect-sdk 0.0.11

package/README.md

@@ -0,0 +1,39 @@
+# @safaricom-mxl/effect-sdk
+
+OpenTelemetry traces, logs, and metrics for [Effect](https://effect.website) applications, exported to the MXL OpenTelemetry collector via OTLP.
+
+## Install
+
+```bash
+pnpm add @safaricom-mxl/effect-sdk effect
+```
+
+## Server
+
+```typescript
+import { Mxl } from "@safaricom-mxl/effect-sdk/server";
+import { Effect } from "effect";
+
+const ObservabilityLive = Mxl.layer({ serviceName: "mxl-basket" });
+
+const program = Effect.log("Hello!").pipe(Effect.withSpan("hello"));
+
+Effect.runPromise(program.pipe(Effect.provide(ObservabilityLive)));
+```
+
+### Environment variables
+
+| Variable                      | Description                                |
+| ----------------------------- | ------------------------------------------ |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP HTTP endpoint (preferred)             |
+| `OTLP_ENDPOINT`               | Fallback OTLP endpoint                     |
+| `OTEL_EXPORTER_OTLP_HEADERS`  | Comma-separated `key=value` export headers |
+| `OTEL_SERVICE_NAME`           | Service name                               |
+| `OTEL_RESOURCE_ATTRIBUTES`    | Extra resource attributes                  |
+| `OTEL_SDK_DISABLED`           | When `true`, installs a no-op layer        |
+
+Default endpoint: `http://127.0.0.1:4318` (local `mxl-otel-collector`).
+
+## License
+
+MIT

package/dist/index.server.mjs

@@ -0,0 +1,2 @@
+import { A as minimumLogLevelLayer, B as layer_exports, C as withParentFromTraceparent, D as logError, E as logDebug, F as getEffectTraceCorrelation, G as normalizeOtlpBaseUrl, H as getAutoPlatformAttributes, I as parseTraceparent, J as otelGlobalContextBridgeLayer, K as buildTraceCarrierFromSpan, L as traceCorrelationLogAnnotations, M as resolveLogLevelFromEnv, N as serializeLogError, O as logInfo, P as annotateLogsWithActiveSpanCorrelation, R as shouldDisableHttpTrace, S as withParentFromTraceCarrier, T as logAtLevel, U as parseOtelResourceAttributes, V as derivePlatformAttributes, W as parseOtlpHeaders, Y as wrapTracerWithOtelContextBridge, _ as logHttpResponse, a as kafkaProducerSpanAttributes, b as spanContextFromTraceparent, c as withDependencySpan, d as jobWithSpanEffect, f as runJobWithSpan, g as logHttpRequestFailure, h as finalizeHttpSpan, i as geoSpanAttributes, j as resolveEffectLogLevelFromHttpStatus, k as logWarning, l as withPromiseDependencySpan, m as buildQueueTraceCarrierEffect, n as bufferSpanAttributes, o as queueConsumerSpanAttributes, p as buildQueueTraceCarrier, q as formatTraceparent, r as dbClientSpanAttributes, s as queueProducerSpanAttributes, t as addSpanLinksFromTraceCarriers, u as createEffectTraceEnricher, v as resolveTraceparentFromHeaders, w as buildHttpStatusLogFields, x as withHttpServerSpan, y as spanContextFromCarrier, z as tracerDisabledWhenLayer } from "./server-BsdarUpY.mjs";
+export { layer_exports as Mxl, addSpanLinksFromTraceCarriers, annotateLogsWithActiveSpanCorrelation, bufferSpanAttributes, buildHttpStatusLogFields, buildQueueTraceCarrier, buildQueueTraceCarrierEffect, buildTraceCarrierFromSpan, createEffectTraceEnricher, dbClientSpanAttributes, derivePlatformAttributes, finalizeHttpSpan, formatTraceparent, geoSpanAttributes, getAutoPlatformAttributes, getEffectTraceCorrelation, jobWithSpanEffect, kafkaProducerSpanAttributes, logAtLevel, logDebug, logError, logHttpRequestFailure, logHttpResponse, logInfo, logWarning, minimumLogLevelLayer, normalizeOtlpBaseUrl, otelGlobalContextBridgeLayer, parseOtelResourceAttributes, parseOtlpHeaders, parseTraceparent, queueConsumerSpanAttributes, queueProducerSpanAttributes, resolveEffectLogLevelFromHttpStatus, resolveLogLevelFromEnv, resolveTraceparentFromHeaders, runJobWithSpan, serializeLogError, shouldDisableHttpTrace, spanContextFromCarrier, spanContextFromTraceparent, traceCorrelationLogAnnotations, tracerDisabledWhenLayer, withDependencySpan, withHttpServerSpan, withParentFromTraceCarrier, withParentFromTraceparent, withPromiseDependencySpan, wrapTracerWithOtelContextBridge };

package/dist/server/index.mjs

@@ -0,0 +1,2 @@
+import { A as minimumLogLevelLayer, B as layer_exports, C as withParentFromTraceparent, D as logError, E as logDebug, F as getEffectTraceCorrelation, G as normalizeOtlpBaseUrl, H as getAutoPlatformAttributes, I as parseTraceparent, J as otelGlobalContextBridgeLayer, K as buildTraceCarrierFromSpan, L as traceCorrelationLogAnnotations, M as resolveLogLevelFromEnv, N as serializeLogError, O as logInfo, P as annotateLogsWithActiveSpanCorrelation, R as shouldDisableHttpTrace, S as withParentFromTraceCarrier, T as logAtLevel, U as parseOtelResourceAttributes, V as derivePlatformAttributes, W as parseOtlpHeaders, Y as wrapTracerWithOtelContextBridge, _ as logHttpResponse, a as kafkaProducerSpanAttributes, b as spanContextFromTraceparent, c as withDependencySpan, d as jobWithSpanEffect, f as runJobWithSpan, g as logHttpRequestFailure, h as finalizeHttpSpan, i as geoSpanAttributes, j as resolveEffectLogLevelFromHttpStatus, k as logWarning, l as withPromiseDependencySpan, m as buildQueueTraceCarrierEffect, n as bufferSpanAttributes, o as queueConsumerSpanAttributes, p as buildQueueTraceCarrier, q as formatTraceparent, r as dbClientSpanAttributes, s as queueProducerSpanAttributes, t as addSpanLinksFromTraceCarriers, u as createEffectTraceEnricher, v as resolveTraceparentFromHeaders, w as buildHttpStatusLogFields, x as withHttpServerSpan, y as spanContextFromCarrier, z as tracerDisabledWhenLayer } from "../server-BsdarUpY.mjs";
+export { layer_exports as Mxl, addSpanLinksFromTraceCarriers, annotateLogsWithActiveSpanCorrelation, bufferSpanAttributes, buildHttpStatusLogFields, buildQueueTraceCarrier, buildQueueTraceCarrierEffect, buildTraceCarrierFromSpan, createEffectTraceEnricher, dbClientSpanAttributes, derivePlatformAttributes, finalizeHttpSpan, formatTraceparent, geoSpanAttributes, getAutoPlatformAttributes, getEffectTraceCorrelation, jobWithSpanEffect, kafkaProducerSpanAttributes, logAtLevel, logDebug, logError, logHttpRequestFailure, logHttpResponse, logInfo, logWarning, minimumLogLevelLayer, normalizeOtlpBaseUrl, otelGlobalContextBridgeLayer, parseOtelResourceAttributes, parseOtlpHeaders, parseTraceparent, queueConsumerSpanAttributes, queueProducerSpanAttributes, resolveEffectLogLevelFromHttpStatus, resolveLogLevelFromEnv, resolveTraceparentFromHeaders, runJobWithSpan, serializeLogError, shouldDisableHttpTrace, spanContextFromCarrier, spanContextFromTraceparent, traceCorrelationLogAnnotations, tracerDisabledWhenLayer, withDependencySpan, withHttpServerSpan, withParentFromTraceCarrier, withParentFromTraceparent, withPromiseDependencySpan, wrapTracerWithOtelContextBridge };

package/dist/server-BsdarUpY.mjs

@@ -0,0 +1,839 @@
+import { Config, Effect, Layer, Match, Option, References } from "effect";
+import * as Tracer from "effect/Tracer";
+import { FetchHttpClient, HttpMiddleware } from "effect/unstable/http";
+import { Otlp } from "effect/unstable/observability";
+import * as Otel from "@opentelemetry/api";
+import { SpanKind, SpanStatusCode, TraceFlags, context, propagation, trace } from "@opentelemetry/api";
+import { v7 } from "uuid";
+import { platform, provider, runtime } from "std-env";
+import * as Option$1 from "effect/Option";
+import { OtelTracer } from "@effect/opentelemetry";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/server/otel-context-bridge.ts
+const OTEL_SPAN_TYPE_ID = "~@effect/opentelemetry/OtelTracer/OtelSpan";
+const evaluate = "~effect/Effect/evaluate";
+function formatTraceparent(span) {
+	const flags = span.sampled ? "01" : "00";
+	return `00-${span.traceId}-${span.spanId}-${flags}`;
+}
+function buildTraceCarrierFromSpan(span, headers) {
+	const carrier = { traceparent: formatTraceparent(span) };
+	if (headers?.tracestate) carrier.tracestate = headers.tracestate;
+	if (headers?.baggage) carrier.baggage = headers.baggage;
+	return carrier;
+}
+/** Map an Effect span to an OpenTelemetry context with the span active. */
+function effectSpanToOtelContext(activeContext, span) {
+	if (typeof span === "object" && span !== null && OTEL_SPAN_TYPE_ID in span && "span" in span) return Otel.trace.setSpan(activeContext, span.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. */
+function wrapTracerWithOtelContextBridge(base) {
+	const existingContext = base.context;
+	return Tracer.make({
+		span(options) {
+			return base.span(options);
+		},
+		context(primitive, fiber) {
+			if (fiber.currentSpan === void 0) {
+				if (existingContext) return existingContext(primitive, fiber);
+				return primitive[evaluate](fiber);
+			}
+			return Otel.context.with(effectSpanToOtelContext(Otel.context.active(), fiber.currentSpan), () => {
+				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 merged after `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-node-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
+var layer_exports = /* @__PURE__ */ __exportAll({ layer: () => layer });
+/**
+* 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`.
+*/
+const layer = (config = {}) => Layer.unwrap(Effect.gen(function* () {
+	const resolved = yield* resolveResource({
+		...config,
+		sdkType: "server"
+	});
+	if (!resolved.endpoint) return Layer.empty;
+	return 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));
+})).pipe(Layer.updateService(Tracer.Tracer, wrapTracerWithOtelContextBridge));
+//#endregion
+//#region src/server/http-middleware.ts
+function shouldDisableHttpTrace(request) {
+	return request.method === "OPTIONS" || request.url === "/health" || request.url === "/healthcheck" || request.url.startsWith("/healthz") || request.url === "/metrics" || /\.(png|ico|jpg|jpeg|gif|css|js|svg|webp|woff2?)(\?.*)?$/i.test(request.url);
+}
+function tracerDisabledWhenLayer(filter = shouldDisableHttpTrace) {
+	return Layer.succeed(HttpMiddleware.TracerDisabledWhen, filter);
+}
+//#endregion
+//#region src/server/trace-correlation.ts
+const ZERO_TRACE_ID = "00000000000000000000000000000000";
+const ZERO_SPAN_ID = "0000000000000000";
+/** Parse W3C `traceparent` (`00-{traceId}-{spanId}-{flags}`). */
+function parseTraceparent(traceparent) {
+	if (!traceparent) return {};
+	const parts = traceparent.trim().split("-");
+	if (parts.length < 4) return {};
+	const traceId = parts[1];
+	const spanId = parts[2];
+	if (!traceId || !spanId) return {};
+	if (traceId.length !== 32 || spanId.length !== 16) return {};
+	if (traceId === ZERO_TRACE_ID || spanId === ZERO_SPAN_ID) return {};
+	return {
+		spanId,
+		traceId
+	};
+}
+/**
+* Resolve trace/span IDs for log correlation.
+*
+* Prefers the active OpenTelemetry span (when a host bridge or queue propagation
+* is active), then falls back to a W3C `traceparent` carrier.
+*/
+function getEffectTraceCorrelation(options) {
+	const activeSpan = trace.getSpan(context.active());
+	if (activeSpan) {
+		const spanContext = activeSpan.spanContext();
+		if (spanContext.traceId && spanContext.traceId !== ZERO_TRACE_ID && spanContext.spanId && spanContext.spanId !== ZERO_SPAN_ID) return {
+			spanId: spanContext.spanId,
+			traceId: spanContext.traceId
+		};
+	}
+	return parseTraceparent(options?.traceparent);
+}
+/** Build log annotation fields from active span correlation. */
+function traceCorrelationLogAnnotations(options) {
+	const { traceparent, ...extra } = options ?? {};
+	const correlation = getEffectTraceCorrelation({ traceparent });
+	const annotations = { ...extra };
+	if (correlation.traceId) {
+		annotations["trace.trace_id"] = correlation.traceId;
+		annotations.trace_id = correlation.traceId;
+	}
+	if (correlation.spanId) {
+		annotations["trace.span_id"] = correlation.spanId;
+		annotations.span_id = correlation.spanId;
+	}
+	return annotations;
+}
+/** Annotate Effect logs with the active span's trace/span IDs. */
+function annotateLogsWithActiveSpanCorrelation(program, fields) {
+	return Effect.gen(function* () {
+		const { traceparent, ...extra } = fields ?? {};
+		const annotations = { ...extra };
+		const currentSpan = yield* Effect.currentSpan.pipe(Effect.option);
+		if (Option$1.isSome(currentSpan)) {
+			annotations["trace.trace_id"] = currentSpan.value.traceId;
+			annotations.trace_id = currentSpan.value.traceId;
+			annotations["trace.span_id"] = currentSpan.value.spanId;
+			annotations.span_id = currentSpan.value.spanId;
+		} else Object.assign(annotations, traceCorrelationLogAnnotations({
+			...traceparent !== void 0 ? { traceparent } : {},
+			...extra
+		}));
+		if (Object.keys(annotations).length === 0) return yield* program;
+		return yield* program.pipe(Effect.annotateLogs(annotations));
+	});
+}
+//#endregion
+//#region src/server/logging.ts
+const LOG_LEVEL_BY_ENV = {
+	trace: "Debug",
+	debug: "Debug",
+	info: "Info",
+	warn: "Warn",
+	warning: "Warn",
+	error: "Error",
+	fatal: "Fatal"
+};
+function resolveLogLevelFromEnv(env = process.env) {
+	const raw = env.OTEL_LOG_LEVEL ?? env.LOG_LEVEL ?? "info";
+	return LOG_LEVEL_BY_ENV[raw.trim().toLowerCase()] ?? "Info";
+}
+function isFiniteHttpStatus(status) {
+	return typeof status === "number" && Number.isFinite(status) && status >= 0;
+}
+/** Map HTTP status to Effect log level for response/failure logs. */
+function resolveEffectLogLevelFromHttpStatus(status) {
+	if (!isFiniteHttpStatus(status) || status < 400) return "Info";
+	if (status >= 500) return "Error";
+	return "Warn";
+}
+/** Standard log fields for HTTP response correlation in OTEL drains. */
+function buildHttpStatusLogFields(status) {
+	const level = resolveEffectLogLevelFromHttpStatus(status);
+	const outcome = isFiniteHttpStatus(status) && status >= 400 ? "error" : "success";
+	const logLevel = level === "Error" ? "error" : level === "Warn" ? "warn" : "info";
+	if (!isFiniteHttpStatus(status)) return {
+		"log.level": logLevel,
+		outcome
+	};
+	const statusText = String(status);
+	return {
+		"http.response.status_code": statusText,
+		"http.status": statusText,
+		"log.level": logLevel,
+		outcome
+	};
+}
+/** Filter Effect logs below the configured minimum level. */
+function minimumLogLevelLayer(level = resolveLogLevelFromEnv()) {
+	return Layer.succeed(References.MinimumLogLevel, level);
+}
+function resolveErrorMessage(error) {
+	if (error.message.trim().length > 0) return error.message;
+	if (error.cause !== void 0) {
+		if (error.cause instanceof Error && error.cause.message.trim().length > 0) return error.cause.message;
+		if (typeof error.cause === "string" && error.cause.trim().length > 0) return error.cause;
+	}
+	if ("reason" in error && typeof error.reason === "string" && error.reason.trim().length > 0) return error.reason;
+	return error.name;
+}
+function serializeLogError(error) {
+	if (error instanceof Error) return {
+		message: resolveErrorMessage(error),
+		name: error.name,
+		...error.stack ? { stack: error.stack } : {},
+		...error.message.trim().length === 0 && error.cause !== void 0 ? { cause: serializeLogError(error.cause) } : {}
+	};
+	return {
+		message: String(error),
+		name: "UnknownError"
+	};
+}
+function annotateFields(fields) {
+	if (!fields || Object.keys(fields).length === 0) return (effect) => effect;
+	const serialized = Object.fromEntries(Object.entries(fields).map(([key, value]) => [key, value instanceof Error ? serializeLogError(value) : value]));
+	return (effect) => effect.pipe(Effect.annotateLogs(serialized));
+}
+function logDebug(message, fields) {
+	return annotateFields(fields)(Effect.logDebug(message));
+}
+function logInfo(message, fields) {
+	return annotateFields(fields)(Effect.logInfo(message));
+}
+function logWarning(message, fields) {
+	return annotateFields(fields)(Effect.logWarning(message));
+}
+function logError(message, fields) {
+	return annotateFields(fields)(Effect.logError(message));
+}
+function logAtLevel(level, message, fields) {
+	switch (level) {
+		case "Debug": return logDebug(message, fields);
+		case "Info": return logInfo(message, fields);
+		case "Warn": return logWarning(message, fields);
+		case "Error":
+		case "Fatal": return logError(message, fields);
+	}
+}
+//#endregion
+//#region src/server/http-tracing.ts
+function headerValue$1(value) {
+	if (value === void 0) return void 0;
+	return typeof value === "string" ? value : value[0];
+}
+function spanContextFromTraceparent(traceparent) {
+	const { traceId, spanId } = parseTraceparent(traceparent);
+	if (!traceId || !spanId) return void 0;
+	return {
+		isRemote: true,
+		spanId,
+		traceFlags: TraceFlags.SAMPLED,
+		traceId
+	};
+}
+function resolveTraceparentFromHeaders(headers) {
+	return headerValue$1(headers.traceparent ?? headers["traceparent"]);
+}
+function withParentFromTraceparent(headers, program) {
+	const parentSpanContext = spanContextFromTraceparent(resolveTraceparentFromHeaders(headers));
+	if (parentSpanContext === void 0) return program;
+	return OtelTracer.withSpanContext(program, parentSpanContext);
+}
+function toSpanAttributes(attributes) {
+	const result = {
+		"http.request.method": attributes.method,
+		"http.route": attributes.route,
+		"url.path": attributes.route
+	};
+	if (attributes.requestId !== void 0) {
+		result["http.request_id"] = attributes.requestId;
+		result["request.id"] = attributes.requestId;
+	}
+	if (attributes.url !== void 0) result["url.full"] = attributes.url;
+	return result;
+}
+function withHttpServerSpan(name, attributes, program) {
+	return program.pipe(Effect.withSpan(name, {
+		attributes: toSpanAttributes(attributes),
+		kind: "server"
+	}), Effect.withLogSpan(name));
+}
+function finalizeHttpSpan(status, route) {
+	const annotations = { "http.response.status_code": status };
+	if (route !== void 0) {
+		annotations["http.route"] = route;
+		annotations["url.path"] = route;
+	}
+	return Effect.sync(() => {
+		if (status >= 500) trace.getActiveSpan()?.setStatus({
+			code: SpanStatusCode.ERROR,
+			message: String(status)
+		});
+	}).pipe(Effect.andThen(() => Effect.annotateCurrentSpan(annotations)));
+}
+function stringifyLogFieldValue(value) {
+	if (value === void 0) return "";
+	return String(value);
+}
+function buildHttpResponseLogFields(options) {
+	const fields = {
+		...buildHttpStatusLogFields(options.status),
+		...options.durationMs === void 0 ? {} : { durationMs: options.durationMs },
+		...options.method === void 0 ? {} : { "http.request.method": options.method },
+		...options.url === void 0 ? {} : { "url.full": options.url },
+		...options.route === void 0 ? {} : { "http.route": options.route },
+		...options.route === void 0 ? {} : { "url.path": options.route },
+		...options.traceparent === void 0 ? {} : { traceparent: options.traceparent }
+	};
+	if (options.error !== void 0) fields.error = serializeLogError(options.error);
+	return fields;
+}
+/** Log an HTTP response at info/warn/error severity based on status code. */
+function logHttpResponse(message, options) {
+	const level = resolveEffectLogLevelFromHttpStatus(options.status);
+	const fields = buildHttpResponseLogFields(options);
+	const correlationFields = Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== void 0).map(([key, value]) => [key, stringifyLogFieldValue(value)]));
+	return annotateLogsWithActiveSpanCorrelation(logAtLevel(level, message, fields), correlationFields);
+}
+function logHttpRequestFailure(message, error, fields) {
+	const logFields = {};
+	if (fields) {
+		for (const [key, value] of Object.entries(fields)) if (value !== void 0) logFields[key] = String(value);
+	}
+	return annotateLogsWithActiveSpanCorrelation(logError(message, {
+		error: serializeLogError(error),
+		...fields
+	}), logFields);
+}
+function normalizeHeaderRecord(headers) {
+	const normalized = {};
+	for (const [key, value] of Object.entries(headers)) {
+		if (value === void 0) continue;
+		normalized[key.toLowerCase()] = typeof value === "string" ? value : value[0] ?? "";
+	}
+	return normalized;
+}
+function normalizeCarrierRecord(carrier) {
+	if (!carrier) return void 0;
+	const normalized = {};
+	for (const [key, value] of Object.entries(carrier)) {
+		if (value === void 0 || value === "") continue;
+		normalized[key.toLowerCase()] = value;
+	}
+	return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+/** Resolve parent span context from a W3C trace carrier. */
+function spanContextFromCarrier(carrier) {
+	const normalized = normalizeCarrierRecord(carrier);
+	if (!normalized) return void 0;
+	const extracted = propagation.extract(context.active(), normalized);
+	const spanContext = trace.getSpan(extracted)?.spanContext();
+	if (spanContext?.traceId && spanContext.traceId !== "00000000000000000000000000000000" && spanContext.spanId && spanContext.spanId !== "0000000000000000") return spanContext;
+	return spanContextFromTraceparent(normalized.traceparent);
+}
+function withParentFromTraceCarrier(carrier, program) {
+	const parentSpanContext = spanContextFromCarrier(carrier);
+	if (parentSpanContext === void 0) return program;
+	return OtelTracer.withSpanContext(program, parentSpanContext);
+}
+/** Build W3C trace carrier for queue/job propagation from request headers + active OTel context. */
+function buildQueueTraceCarrier(headers) {
+	const normalized = headers ? normalizeHeaderRecord(headers) : {};
+	const parentContext = propagation.extract(context.active(), normalized);
+	const carrier = {};
+	propagation.inject(parentContext, carrier);
+	return Object.keys(carrier).length > 0 ? carrier : void 0;
+}
+/** Build W3C trace carrier using the active Effect span when available. */
+function buildQueueTraceCarrierEffect(headers) {
+	return Effect.gen(function* () {
+		const normalized = headers ? normalizeHeaderRecord(headers) : {};
+		const currentSpan = yield* Effect.currentSpan.pipe(Effect.option);
+		if (Option$1.isSome(currentSpan)) return buildTraceCarrierFromSpan(currentSpan.value, normalized);
+		return buildQueueTraceCarrier(headers);
+	});
+}
+//#endregion
+//#region src/server/jobs.ts
+function resolveParentSpanContext(options) {
+	if (options.parentSpanContext !== void 0) return options.parentSpanContext;
+	return spanContextFromCarrier(options.parentTraceCarrier);
+}
+function jobWithSpanEffect(options, program) {
+	const parentSpanContext = resolveParentSpanContext(options);
+	const startedAt = Date.now();
+	let wrapped = program.pipe(Effect.tap(() => logInfo("Job completed", {
+		durationMs: Date.now() - startedAt,
+		"job.name": options.name,
+		outcome: "success",
+		...options.logAttributes
+	})), Effect.tapError((error) => logError("Job failed", {
+		durationMs: Date.now() - startedAt,
+		error: serializeLogError(error),
+		"job.name": options.name,
+		outcome: "error",
+		...options.logAttributes
+	})), (effect) => annotateLogsWithActiveSpanCorrelation(effect, {
+		"job.name": options.name,
+		...options.logAttributes
+	}), Effect.withLogSpan(options.name), Effect.withSpan(options.name, {
+		attributes: options.attributes,
+		kind: "consumer"
+	}));
+	if (parentSpanContext !== void 0) wrapped = OtelTracer.withSpanContext(wrapped, parentSpanContext);
+	return wrapped;
+}
+function runJobWithSpan(runtime, options, program) {
+	return runtime.runPromise(jobWithSpanEffect(options, program));
+}
+//#endregion
+//#region src/server/evlog-bridge.ts
+function headerValue(headers, name) {
+	if (!headers) return void 0;
+	const direct = headers[name];
+	if (direct !== void 0) return direct;
+	const lower = headers[name.toLowerCase()];
+	if (lower !== void 0) return lower;
+}
+function assignTraceFields(event, traceId, spanId, overwrite) {
+	if (overwrite || event.trace_id === void 0) event.trace_id = traceId;
+	if (overwrite || event.span_id === void 0) event.span_id = spanId;
+	if (overwrite || event.traceId === void 0) event.traceId = traceId;
+	if (overwrite || event.spanId === void 0) event.spanId = spanId;
+	const trace = typeof event.trace === "object" && event.trace !== null ? event.trace : {};
+	if (overwrite || trace.trace_id === void 0) trace.trace_id = traceId;
+	if (overwrite || trace.span_id === void 0) trace.span_id = spanId;
+	if (Object.keys(trace).length > 0) event.trace = trace;
+}
+/**
+* Enrich evlog wide events with trace/span IDs from OTel global context or W3C headers.
+*
+* Use in the MXL evlog enricher chain alongside `createOtelTraceEnricher`.
+*/
+function createEffectTraceEnricher(options = {}) {
+	const overwrite = options.overwrite ?? false;
+	return (ctx) => {
+		const traceparent = headerValue(ctx.headers, "traceparent");
+		const correlation = getEffectTraceCorrelation({ traceparent });
+		if (correlation.traceId && correlation.spanId) {
+			assignTraceFields(ctx.event, correlation.traceId, correlation.spanId, overwrite);
+			return;
+		}
+		const parsed = parseTraceparent(traceparent);
+		if (parsed.traceId && parsed.spanId) assignTraceFields(ctx.event, parsed.traceId, parsed.spanId, overwrite);
+	};
+}
+//#endregion
+//#region src/server/dependency-spans.ts
+const MAX_FLUSH_SPAN_LINKS = 32;
+function dbClientSpanAttributes(dbSystem, operation) {
+	return {
+		"db.system": dbSystem,
+		"db.system.name": dbSystem,
+		"peer.service": dbSystem,
+		...operation ? { "db.operation.name": operation } : {}
+	};
+}
+function queueProducerSpanAttributes(destinationName, peerService = "mxl-worker") {
+	return {
+		"messaging.destination.name": destinationName,
+		"messaging.system": "bullmq",
+		"peer.service": peerService
+	};
+}
+function queueConsumerSpanAttributes(destinationName) {
+	return {
+		"messaging.destination.name": destinationName,
+		"messaging.system": "bullmq"
+	};
+}
+function kafkaProducerSpanAttributes(topic, peerService = "kafka") {
+	return {
+		"messaging.destination.name": topic,
+		"messaging.system": "kafka",
+		"peer.service": peerService
+	};
+}
+function bufferSpanAttributes(bufferName, operation) {
+	return {
+		"buffer.name": bufferName,
+		"db.operation.name": operation,
+		"db.system": "redis",
+		"db.system.name": "redis",
+		"peer.service": "redis"
+	};
+}
+function geoSpanAttributes() {
+	return {
+		"db.operation.name": "resolve",
+		"db.system": "maxmind",
+		"db.system.name": "maxmind",
+		"peer.service": "maxmind"
+	};
+}
+function addSpanLinksFromTraceCarriers(carriers) {
+	const span = trace.getActiveSpan();
+	if (!span) return 0;
+	const seen = /* @__PURE__ */ new Set();
+	let linked = 0;
+	for (const carrier of carriers) {
+		if (!carrier.traceparent || seen.has(carrier.traceparent)) continue;
+		seen.add(carrier.traceparent);
+		const extracted = propagation.extract(context.active(), carrier);
+		const linkedContext = trace.getSpanContext(extracted);
+		if (!linkedContext) continue;
+		span.addLink({ context: linkedContext });
+		linked += 1;
+		if (linked >= MAX_FLUSH_SPAN_LINKS) break;
+	}
+	return linked;
+}
+function withDependencySpan(name, attributesOrOptions, program) {
+	const options = isWithDependencySpanOptions(attributesOrOptions) ? attributesOrOptions : { attributes: attributesOrOptions };
+	const attributes = options.attributes ?? {};
+	const kind = options.kind ?? "client";
+	return program.pipe(Effect.withSpan(name, {
+		attributes,
+		kind
+	}));
+}
+function isWithDependencySpanOptions(value) {
+	return typeof value === "object" && ("kind" in value || "attributes" in value && typeof value.attributes === "object");
+}
+/** Promise-based dependency span for non-Effect code paths (CH buffers, Kafka produce). */
+async function withPromiseDependencySpan(name, attributes, operation, kind = "client") {
+	const tracer = trace.getTracer("mxl-effect-sdk");
+	const spanKind = kind === "producer" ? SpanKind.PRODUCER : kind === "consumer" ? SpanKind.CONSUMER : SpanKind.CLIENT;
+	return tracer.startActiveSpan(name, {
+		attributes,
+		kind: spanKind
+	}, async (span) => {
+		try {
+			const result = await operation();
+			span.end();
+			return result;
+		} catch (error) {
+			if (error instanceof Error) {
+				span.recordException(error);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: error.message
+				});
+			} else span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(error)
+			});
+			span.end();
+			throw error;
+		}
+	});
+}
+//#endregion
+export { minimumLogLevelLayer as A, layer_exports as B, withParentFromTraceparent as C, logError as D, logDebug as E, getEffectTraceCorrelation as F, normalizeOtlpBaseUrl as G, getAutoPlatformAttributes as H, parseTraceparent as I, otelGlobalContextBridgeLayer as J, buildTraceCarrierFromSpan as K, traceCorrelationLogAnnotations as L, resolveLogLevelFromEnv as M, serializeLogError as N, logInfo as O, annotateLogsWithActiveSpanCorrelation as P, shouldDisableHttpTrace as R, withParentFromTraceCarrier as S, logAtLevel as T, parseOtelResourceAttributes as U, derivePlatformAttributes as V, parseOtlpHeaders as W, wrapTracerWithOtelContextBridge as Y, logHttpResponse as _, kafkaProducerSpanAttributes as a, spanContextFromTraceparent as b, withDependencySpan as c, jobWithSpanEffect as d, runJobWithSpan as f, logHttpRequestFailure as g, finalizeHttpSpan as h, geoSpanAttributes as i, resolveEffectLogLevelFromHttpStatus as j, logWarning as k, withPromiseDependencySpan as l, buildQueueTraceCarrierEffect as m, bufferSpanAttributes as n, queueConsumerSpanAttributes as o, buildQueueTraceCarrier as p, formatTraceparent as q, dbClientSpanAttributes as r, queueProducerSpanAttributes as s, addSpanLinksFromTraceCarriers as t, createEffectTraceEnricher as u, resolveTraceparentFromHeaders as v, buildHttpStatusLogFields as w, withHttpServerSpan as x, spanContextFromCarrier as y, tracerDisabledWhenLayer as z };

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@safaricom-mxl/effect-sdk",
+  "version": "0.0.11",
+  "description": "MXL OpenTelemetry SDK for Effect applications",
+  "license": "MIT",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "node": {
+        "types": "./src/index.server.ts",
+        "import": "./dist/index.server.mjs"
+      },
+      "default": {
+        "types": "./src/index.server.ts",
+        "import": "./dist/index.server.mjs"
+      }
+    },
+    "./server": {
+      "types": "./src/server/index.ts",
+      "import": "./dist/server/index.mjs",
+      "require": "./dist/server/index.mjs",
+      "default": "./dist/server/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check": "tsc --noEmit",
+    "clean": "rimraf dist",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@effect/opentelemetry": "^4.0.0-beta.105",
+    "@opentelemetry/api": "^1.9.1",
+    "effect": "^4.0.0-beta.105",
+    "std-env": "^4.2.0",
+    "uuid": "^11.1.1"
+  },
+  "devDependencies": {
+    "@opentelemetry/sdk-trace-base": "^2.10.0",
+    "@opentelemetry/sdk-trace-web": "^2.10.0",
+    "@types/node": "^26.1.2",
+    "tsdown": "^0.22.14",
+    "typescript": "^7.0.2",
+    "vitest": "^3.2.7"
+  },
+  "peerDependencies": {
+    "@effect/opentelemetry": "^4.0.0-beta.104",
+    "effect": ">=4.0.0-beta.104"
+  },
+  "author": "MXL <ServiceAvailability@Safaricom.co.ke>",
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.safaricom.co.ke/mxl/apm/mxl-node-sdk.git",
+    "directory": "packages/effect-sdk"
+  },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "keywords": [
+    "mxl",
+    "effect",
+    "opentelemetry",
+    "observability",
+    "telemetry"
+  ]
+}