@safaricom-mxl/effect-sdk 0.0.15 → 0.0.17

package/dist/browser/index.js

@@ -3,44 +3,325 @@ import * as WebSdk from "@effect/opentelemetry/WebSdk";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { Effect, Layer } from "effect";
-import * as Tracer from "effect/Tracer";
-import * as Otel from "@opentelemetry/api";
 import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
-//#region src/server/otel-context-bridge.ts
-const OTEL_SPAN_TYPE_ID = "~@effect/opentelemetry/OtelTracer/OtelSpan";
-const evaluate = "~effect/Effect/evaluate";
-/** 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
+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/shared/identity.ts
+const normalizeIdentity = (input) => {
+	if (input === null || input === void 0) return;
+	if (typeof input === "string") {
+		const id = input.trim();
+		return id.length > 0 ? { id } : void 0;
+	}
+	const id = input.id.trim();
+	if (id.length === 0) return;
+	return {
+		email: input.email,
+		groupId: input.groupId,
+		groupName: input.groupName,
+		id,
+		traits: input.traits
+	};
+};
+//#endregion
+//#region src/version.ts
+const SDK_NAME = "mxl-effect-sdk";
+const SDK_VERSION = "0.0.15";
+//#endregion
+//#region src/browser/analytics.ts
+const DEFAULT_INGEST_URL = "http://127.0.0.1:8000";
+const MAX_QUEUE = 100;
+let config;
+let identity;
+let consentGranted = true;
+let sessionId = "";
+let queue = [];
+let started = false;
+const randomId = () => {
+	if (globalThis.crypto?.randomUUID) return globalThis.crypto.randomUUID();
+	return `mxl_${Math.random().toString(36).slice(2)}_${Date.now()}`;
+};
+const storageGet = (key) => {
+	try {
+		const value = globalThis.sessionStorage?.getItem(key);
+		return value && value.length > 0 ? value : void 0;
+	} catch {
+		return;
+	}
+};
+const storageSet = (key, value) => {
+	try {
+		globalThis.sessionStorage?.setItem(key, value);
+	} catch {}
+};
+const resolveSessionId = () => {
+	if (sessionId.length > 0) return sessionId;
+	sessionId = storageGet("mxl.session.id") ?? randomId();
+	storageSet("mxl.session.id", sessionId);
+	return sessionId;
+};
+const ingestOrigin = () => (config?.ingestUrl ?? DEFAULT_INGEST_URL).replace(/\/$/, "");
+const headers = () => {
+	const next = {
+		"content-type": "application/json",
+		"mxl-client-id": config?.clientId ?? "",
+		"mxl-sdk-name": SDK_NAME,
+		"mxl-sdk-version": SDK_VERSION
+	};
+	if (config?.apiKey) next["mxl-api-key"] = config.apiKey;
+	return next;
+};
+const post = (path, body, contentType, keepalive = false) => {
+	if (!config?.clientId) return;
+	try {
+		fetch(`${ingestOrigin()}${path}`, {
+			body,
+			headers: {
+				...headers(),
+				"content-type": contentType
+			},
+			keepalive,
+			method: "POST"
+		});
+	} catch {}
+};
+const captureAllowed = () => Boolean(config?.clientId) && consentGranted && started;
+const getCurrentIdentity = () => identity;
+const getCurrentUserId = () => identity?.id;
+const getCurrentSessionId = () => resolveSessionId();
+const configureBrowserAnalytics = (next) => {
+	config = next;
+	consentGranted = next.privacy?.requireConsent !== true;
+	started = true;
+	resolveSessionId();
+	drainQueue();
+};
+const setConsent = (granted) => {
+	consentGranted = granted;
+	if (granted) drainQueue();
+};
+const identify = (input) => {
+	identity = normalizeIdentity(input);
+	if (!captureAllowed() || identity === void 0) return;
+	post("/track", JSON.stringify({
+		payload: {
+			email: identity.email,
+			firstName: typeof identity.traits?.firstName === "string" ? identity.traits.firstName : void 0,
+			lastName: typeof identity.traits?.lastName === "string" ? identity.traits.lastName : void 0,
+			profileId: identity.id,
+			properties: {
+				...identity.traits ?? {},
+				groupId: identity.groupId,
+				groupName: identity.groupName
+			}
+		},
+		type: "identify"
+	}), "application/json");
+};
+const clearIdentity = () => {
+	identity = void 0;
+};
+const postProductAndSession = (name, props, keepalive = false) => {
+	const line = encodeProductEventLine({
+		name,
+		options: {
+			attributes: props,
+			groupId: identity?.groupId,
+			sessionId: resolveSessionId(),
+			userId: identity?.id
+		},
+		serviceName: config?.serviceName ?? "unknown",
+		source: "browser"
 	});
-}
-/** 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);
+	if (line === void 0) return;
+	post("/events", encodeNdjson([line]), "application/x-ndjson", keepalive);
+	post("/sessionEvents", `${JSON.stringify({
+		attributes: line.attributes,
+		message: line.name,
+		session_id: line.session_id,
+		timestamp: line.timestamp,
+		type: "custom"
+	})}\n`, "application/x-ndjson", keepalive);
+};
+const drainQueue = (keepalive = false) => {
+	if (!captureAllowed()) return;
+	const pending = queue;
+	queue = [];
+	for (const event of pending) postProductAndSession(event.name, event.props, keepalive);
+};
+const track = (name, props) => {
+	if (!started || !consentGranted || !config?.clientId) {
+		if (queue.length >= MAX_QUEUE) queue.shift();
+		queue.push({
+			name,
+			props
+		});
+		return;
+	}
+	postProductAndSession(name, props);
+};
+const postProfileDelta = (type, property, value) => {
+	if (!captureAllowed() || identity === void 0) return;
+	post("/track", JSON.stringify({
+		payload: {
+			profileId: identity.id,
+			property,
+			value: value ?? 1
 		},
-		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);
+		type
+	}), "application/json");
+};
+const increment = (property, value) => {
+	postProfileDelta("increment", property, value);
+};
+const decrement = (property, value) => {
+	postProfileDelta("decrement", property, value);
+};
+const flushAnalytics = (keepalive = false) => {
+	drainQueue(keepalive);
+};
+//#endregion
+//#region src/browser/replay.ts
+let stopRecorder;
+let chunkSeq = 0;
+const ingestHeaders = (clientId, apiKey, contentType) => {
+	const headers = {
+		"content-type": contentType,
+		"mxl-client-id": clientId,
+		"mxl-sdk-name": SDK_NAME,
+		"mxl-sdk-version": SDK_VERSION
+	};
+	if (apiKey) headers["mxl-api-key"] = apiKey;
+	return headers;
+};
+const isWebSdkPresent = () => {
+	const global = globalThis;
+	return Boolean(global.__MXL_WEB_SDK__ || global.MxlWebSdk || global.__MXL_REPLAY_SESSION__);
+};
+const shouldRecordReplay = (replay) => {
+	if (isWebSdkPresent()) return false;
+	if (replay?.enabled === false) return false;
+	const sampleRate = replay?.sampleRate ?? 1;
+	return sampleRate >= 1 || Math.random() < sampleRate;
+};
+const sessionMetaRow = (serviceName) => {
+	const identity = getCurrentIdentity();
+	const started = /* @__PURE__ */ new Date();
+	return {
+		service_name: serviceName,
+		session_id: getCurrentSessionId(),
+		start_time: started.toISOString().replace("T", " ").replace("Z", ""),
+		status: "active",
+		url_initial: typeof globalThis.location?.href === "string" ? globalThis.location.href : "",
+		user_agent: typeof globalThis.navigator?.userAgent === "string" ? globalThis.navigator.userAgent : "",
+		user_id: identity?.id ?? "",
+		version: 1
+	};
+};
+const postSessionReplayMeta = (ingestUrl, clientId, serviceName, apiKey) => {
+	try {
+		fetch(`${ingestUrl.replace(/\/$/, "")}/sessionReplays/meta`, {
+			body: `${JSON.stringify(sessionMetaRow(serviceName))}\n`,
+			headers: ingestHeaders(clientId, apiKey, "application/x-ndjson"),
+			keepalive: true,
+			method: "POST"
+		});
+	} catch {}
+};
+const postSessionReplayBlob = (ingestUrl, clientId, meta, body, apiKey) => {
+	try {
+		fetch(`${ingestUrl.replace(/\/$/, "")}/sessionReplays/blob`, {
+			body,
+			headers: {
+				...ingestHeaders(clientId, apiKey, "application/octet-stream"),
+				"x-mxl-chunk-seq": String(meta.chunkSeq),
+				"x-mxl-duration-ms": String(meta.durationMs),
+				"x-mxl-event-count": String(meta.eventCount),
+				"x-mxl-is-checkpoint": meta.isCheckpoint ? "1" : "0",
+				"x-mxl-session-id": meta.sessionId
+			},
+			keepalive: true,
+			method: "POST"
+		});
+	} catch {}
+};
+const gzipJson = async (value) => {
+	if (typeof CompressionStream === "undefined") return;
+	const encoded = new TextEncoder().encode(JSON.stringify(value));
+	const stream = new Blob([encoded]).stream().pipeThrough(new CompressionStream("gzip"));
+	return new Uint8Array(await new Response(stream).arrayBuffer());
+};
+const stopReplay = () => {
+	stopRecorder?.();
+	stopRecorder = void 0;
+};
+const startReplay = async (config) => {
+	if (!shouldRecordReplay(config.replay)) return;
+	stopReplay();
+	chunkSeq = 0;
+	postSessionReplayMeta(config.ingestUrl, config.clientId, config.serviceName, config.apiKey);
+	try {
+		const rrweb = await import(
+			/* @vite-ignore */
+			"rrweb"
+);
+		if (typeof rrweb.record !== "function") return;
+		const events = [];
+		const startedAt = Date.now();
+		const stop = rrweb.record({
+			emit: (event) => {
+				events.push(event);
+			},
+			maskAllInputs: config.replay?.maskAllInputs ?? true,
+			maskTextSelector: config.replay?.maskAllText === true ? "*" : void 0
+		});
+		stopRecorder = () => {
+			stop?.();
+			if (events.length === 0) return;
+			gzipJson(events).then((gzipped) => {
+				if (!gzipped) return;
+				postSessionReplayBlob(config.ingestUrl, config.clientId, {
+					chunkSeq: chunkSeq++,
+					durationMs: Date.now() - startedAt,
+					eventCount: events.length,
+					isCheckpoint: true,
+					sessionId: getCurrentSessionId()
+				}, gzipped, config.apiKey);
 			});
-		}
-	});
-}
-Layer.effect(Tracer.Tracer, Effect.gen(function* () {
-	return wrapTracerWithOtelContextBridge(yield* Tracer.Tracer);
-}));
+		};
+	} catch {}
+};
 //#endregion
 //#region src/server/otlp.ts
 function normalizeOtlpBaseUrl(url) {
@@ -50,7 +331,36 @@ function normalizeOtlpBaseUrl(url) {
 }
 //#endregion
 //#region src/browser/layer.ts
-var layer_exports = /* @__PURE__ */ __exportAll({ layer: () => layer });
+var layer_exports = /* @__PURE__ */ __exportAll({
+	clearIdentity: () => clearIdentity$1,
+	identify: () => identify$1,
+	layer: () => layer,
+	stampUserIdOnSpan: () => stampUserIdOnSpan,
+	track: () => track$1
+});
+const stampUserIdOnSpan = (span) => {
+	const userId = getCurrentUserId();
+	if (userId) span.setAttribute("user.id", userId);
+};
+var UserIdSpanProcessor = class {
+	inner;
+	constructor(inner) {
+		this.inner = inner;
+	}
+	forceFlush() {
+		return this.inner.forceFlush();
+	}
+	onEnd(span) {
+		this.inner.onEnd(span);
+	}
+	onStart(span, parentContext) {
+		stampUserIdOnSpan(span);
+		this.inner.onStart(span, parentContext);
+	}
+	shutdown() {
+		return this.inner.shutdown();
+	}
+};
 function resolveBrowserEndpoint(config) {
 	if (config.disabled) return;
 	if (config.endpoint && config.endpoint.length > 0) return normalizeOtlpBaseUrl(config.endpoint);
@@ -61,6 +371,22 @@ function resolveBrowserEndpoint(config) {
 * Returns a no-op layer when `disabled` is true or no OTLP endpoint is configured.
 */
 const layer = (config = {}) => {
+	if (config.clientId) {
+		configureBrowserAnalytics({
+			apiKey: config.apiKey,
+			clientId: config.clientId,
+			ingestUrl: config.ingestUrl,
+			privacy: config.privacy,
+			serviceName: config.serviceName
+		});
+		startReplay({
+			apiKey: config.apiKey,
+			clientId: config.clientId,
+			ingestUrl: config.ingestUrl ?? "http://127.0.0.1:8000",
+			replay: config.replay,
+			serviceName: config.serviceName ?? "unknown"
+		});
+	}
 	const endpoint = resolveBrowserEndpoint(config);
 	if (!endpoint) return Layer.empty;
 	const attributes = {
@@ -73,15 +399,113 @@ const layer = (config = {}) => {
 	};
 	return WebSdk.layer(() => ({
 		resource: {
+			attributes,
 			serviceName: config.serviceName ?? "unknown",
-			serviceVersion: config.serviceVersion,
-			attributes
+			serviceVersion: config.serviceVersion
+		},
+		spanProcessor: new UserIdSpanProcessor(new BatchSpanProcessor(new OTLPTraceExporter({
+			headers: config.headers,
+			url: `${endpoint}/v1/traces`
+		})))
+	}));
+};
+const identify$1 = (input) => Effect.sync(() => identify(input));
+const clearIdentity$1 = Effect.sync(() => clearIdentity());
+const track$1 = (name, props) => Effect.sync(() => track(name, props));
+//#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/browser/flushable.ts
+var flushable_exports = /* @__PURE__ */ __exportAll({
+	attachProcessor: () => attachProcessor,
+	make: () => make
+});
+const processors = /* @__PURE__ */ new WeakMap();
+const DEFAULT_AUTO_FLUSH_MS = 5e3;
+const attachProcessor = (telemetry, processor) => {
+	processors.set(telemetry, processor);
+};
+const make = (config = {}) => {
+	const layer$1 = layer(config);
+	const state = { disabledUntil: 0 };
+	const listeners = [];
+	const telemetry = {
+		captureException: (error, options) => {
+			track(options?.name ?? "uncaught_error", {
+				...options?.attributes,
+				message: error instanceof Error ? error.message : String(error)
+			});
 		},
-		spanProcessor: new BatchSpanProcessor(new OTLPTraceExporter({
-			url: `${endpoint}/v1/traces`,
-			headers: config.headers
-		}))
-	})).pipe(Layer.updateService(Tracer.Tracer, wrapTracerWithOtelContextBridge));
+		dispose: async () => {
+			for (const stop of listeners) stop();
+			listeners.length = 0;
+			stopReplay();
+			await telemetry.flush();
+		},
+		flush: makeSerializedFlush(guardFlush("[MxlFlush]", async () => {
+			flushAnalytics(true);
+			await processors.get(telemetry)?.forceFlush();
+		}, state)),
+		layer: layer$1
+	};
+	const intervalMs = config.autoFlushInterval === void 0 ? DEFAULT_AUTO_FLUSH_MS : config.autoFlushInterval === false ? 0 : config.autoFlushInterval;
+	if (intervalMs > 0) {
+		const timer = setInterval(() => {
+			telemetry.flush();
+		}, intervalMs);
+		timer.unref?.();
+		listeners.push(() => {
+			clearInterval(timer);
+		});
+	}
+	const documentRef = globalThis.document;
+	if (config.flushOnUnload !== false && documentRef) {
+		const onHidden = () => {
+			telemetry.flush();
+		};
+		const onVisibilityChange = () => {
+			if (documentRef.visibilityState === "hidden") onHidden();
+		};
+		documentRef.addEventListener("visibilitychange", onVisibilityChange);
+		globalThis.addEventListener?.("pagehide", onHidden);
+		listeners.push(() => {
+			documentRef.removeEventListener("visibilitychange", onVisibilityChange);
+			globalThis.removeEventListener?.("pagehide", onHidden);
+		});
+	}
+	if (config.captureGlobalErrors !== false && typeof globalThis.addEventListener === "function") {
+		const onError = (event) => {
+			const record = event;
+			telemetry.captureException(record.error ?? record.reason ?? event);
+			telemetry.flush();
+		};
+		globalThis.addEventListener("error", onError);
+		globalThis.addEventListener("unhandledrejection", onError);
+		listeners.push(() => {
+			globalThis.removeEventListener("error", onError);
+			globalThis.removeEventListener("unhandledrejection", onError);
+		});
+	}
+	return telemetry;
 };
 //#endregion
 //#region src/shared/dependency-spans.ts
@@ -189,6 +613,6 @@ async function withPromiseDependencySpan(name, attributes, operation, kind = "cl
 	});
 }
 //#endregion
-export { layer_exports as Mxl, addSpanLinksFromTraceCarriers, bufferSpanAttributes, dbClientSpanAttributes, geoSpanAttributes, kafkaProducerSpanAttributes, queueConsumerSpanAttributes, queueProducerSpanAttributes, withDependencySpan, withPromiseDependencySpan };
+export { layer_exports as Mxl, flushable_exports as MxlFlush, addSpanLinksFromTraceCarriers, bufferSpanAttributes, clearIdentity, dbClientSpanAttributes, decrement, geoSpanAttributes, identify, increment, kafkaProducerSpanAttributes, queueConsumerSpanAttributes, queueProducerSpanAttributes, setConsent, track, withDependencySpan, withPromiseDependencySpan };
 
 //# sourceMappingURL=index.js.map