@dxos/observability 0.10.0 → 0.11.0

package/dist/lib/index.mjs

@@ -0,0 +1,977 @@
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import { Event, SubscriptionList, scheduleTaskInterval } from "@dxos/async";
+import { invariant } from "@dxos/invariant";
+import { LogLevel, log } from "@dxos/log";
+import * as localForage from "localforage";
+import { compositeKey, isNode, isNonNullable } from "@dxos/util";
+import { defaultResource, resourceFromAttributes } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
+import { resolveTelemetryTag } from "@dxos/config";
+import { DeviceKind } from "@dxos/client/halo";
+import { Context } from "@dxos/context";
+import { ConnectionState, Platform } from "@dxos/protocols/proto/dxos/client/services";
+import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as Schema from "effect/Schema";
+import * as Duration from "effect/Duration";
+import * as Fiber from "effect/Fiber";
+import * as Schedule from "effect/Schedule";
+//#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/storage/browser.ts
+var __dxlog_file$5 = "/__w/dxos/dxos/packages/sdk/observability/src/storage/browser.ts";
+var OBSERVABILITY_DISABLED_KEY = "observability-disabled";
+var OBSERVABILITY_GROUP_KEY = "observability-group";
+var OTEL_LOG_LEVEL_KEY = "otel-log-level";
+/** No-op in browser contexts. */
+var showObservabilityBanner = () => {
+	log.warn("showObservabilityBanner is not supported in browser contexts.", void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$5,
+		L: 17,
+		S: void 0
+	});
+};
+/**
+* @param namespace - localForage key prefix used to scope the observability state in browser storage.
+*/
+var isObservabilityDisabled = async (namespace) => {
+	try {
+		return await localForage.getItem(compositeKey(namespace, OBSERVABILITY_DISABLED_KEY)) === "true";
+	} catch (err) {
+		log.catch("Failed to check if observability is disabled, assuming it is", err, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$5,
+			L: 27,
+			S: void 0
+		});
+		return true;
+	}
+};
+/**
+* @param namespace - localForage key prefix used to scope the observability state in browser storage.
+*/
+var storeObservabilityDisabled = async (namespace, value) => {
+	try {
+		await localForage.setItem(compositeKey(namespace, OBSERVABILITY_DISABLED_KEY), String(value));
+	} catch (err) {
+		log.catch("Failed to store observability disabled", err, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$5,
+			L: 39,
+			S: void 0
+		});
+	}
+	try {
+		if (typeof localStorage !== "undefined") localStorage.setItem(`${namespace}/${OBSERVABILITY_DISABLED_KEY}`, String(value));
+	} catch {}
+};
+/**
+* @param namespace - localForage key prefix used to scope the observability state in browser storage.
+*/
+var getObservabilityGroup = async (namespace) => {
+	try {
+		return await localForage.getItem(compositeKey(namespace, OBSERVABILITY_GROUP_KEY)) ?? void 0;
+	} catch (err) {
+		log.catch("Failed to get observability group", err, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$5,
+			L: 59,
+			S: void 0
+		});
+	}
+};
+/**
+* @param namespace - localForage key prefix used to scope the observability state in browser storage.
+*/
+var storeObservabilityGroup = async (namespace, value) => {
+	try {
+		await localForage.setItem(compositeKey(namespace, OBSERVABILITY_GROUP_KEY), value);
+	} catch (err) {
+		log.catch("Failed to store observability group", err, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$5,
+			L: 70,
+			S: void 0
+		});
+	}
+};
+/**
+* @param namespace - localForage key prefix used to scope the observability state in browser storage.
+*/
+var getOtelLogLevel = async (namespace) => {
+	try {
+		return await localForage.getItem(compositeKey(namespace, OTEL_LOG_LEVEL_KEY));
+	} catch (err) {
+		log.catch("Failed to get OTEL log level", err, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$5,
+			L: 81,
+			S: void 0
+		});
+		return null;
+	}
+};
+/**
+* @param namespace - localForage key prefix used to scope the observability state in browser storage.
+*/
+var storeOtelLogLevel = async (namespace, value) => {
+	try {
+		if (value === null) await localForage.removeItem(compositeKey(namespace, OTEL_LOG_LEVEL_KEY));
+		else await localForage.setItem(compositeKey(namespace, OTEL_LOG_LEVEL_KEY), value);
+	} catch (err) {
+		log.catch("Failed to store OTEL log level", err, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$5,
+			L: 97,
+			S: void 0
+		});
+	}
+};
+//#endregion
+//#region src/observability.ts
+var observability_exports = /* @__PURE__ */ __exportAll({
+	addDataProvider: () => addDataProvider,
+	addExtension: () => addExtension,
+	getObservabilityGroup: () => getObservabilityGroup,
+	getOtelLogLevel: () => getOtelLogLevel,
+	initialize: () => initialize,
+	isObservabilityDisabled: () => isObservabilityDisabled,
+	make: () => make,
+	showObservabilityBanner: () => showObservabilityBanner,
+	storeObservabilityDisabled: () => storeObservabilityDisabled,
+	storeObservabilityGroup: () => storeObservabilityGroup,
+	storeOtelLogLevel: () => storeOtelLogLevel
+});
+var __dxlog_file$4 = "/__w/dxos/dxos/packages/sdk/observability/src/observability.ts";
+var ObservabilityImpl = class {
+	_initialized = false;
+	_extensions = [];
+	_dataProviders = [];
+	_subscriptions = new SubscriptionList();
+	initialize() {
+		if (this._initialized) return Effect.succeed(void 0);
+		const initializedExtensions = [];
+		return Effect.gen(this, function* () {
+			for (const extension of this._extensions) {
+				if (extension.initialize) yield* extension.initialize();
+				initializedExtensions.push(extension);
+			}
+			const cleanups = yield* Effect.all(this._dataProviders.map((provider) => provider(this)));
+			this._subscriptions.add(...cleanups.filter((cleanup) => cleanup !== void 0));
+			this._initialized = true;
+		}).pipe(Effect.catchAll((error) => Effect.gen(this, function* () {
+			log.catch(error, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$4,
+				L: 85,
+				S: this
+			});
+			for (const extension of initializedExtensions) if (extension.close) yield* extension.close().pipe(Effect.catchAll(() => Effect.succeed(void 0)));
+			this._subscriptions.clear();
+		})));
+	}
+	close() {
+		return Effect.gen(this, function* () {
+			this._subscriptions.clear();
+			this._dataProviders.length = 0;
+			for (const extension of this._extensions) if (extension.close) yield* extension.close();
+			this._initialized = false;
+		});
+	}
+	enable() {
+		return Effect.gen(this, function* () {
+			for (const extension of this._extensions) if (extension.enable) yield* extension.enable();
+		});
+	}
+	disable() {
+		return Effect.gen(this, function* () {
+			for (const extension of this._extensions) if (extension.disable) yield* extension.disable();
+		});
+	}
+	flush() {
+		return Effect.gen(this, function* () {
+			for (const extension of this._extensions) if (extension.flush) yield* extension.flush();
+		});
+	}
+	_addExtension(extension) {
+		invariant(!this._initialized, "Observability is already initialized", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$4,
+			L: 142,
+			S: this,
+			A: ["!this._initialized", "'Observability is already initialized'"]
+		});
+		this._extensions.push(extension);
+	}
+	_addDataProvider(dataProvider) {
+		invariant(!this._initialized, "Observability is already initialized", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$4,
+			L: 147,
+			S: this,
+			A: ["!this._initialized", "'Observability is already initialized'"]
+		});
+		this._dataProviders.push(dataProvider);
+	}
+	/**
+	* Adds a data provider and initializes it.
+	*/
+	addDataProvider(dataProvider) {
+		return Effect.gen(this, function* () {
+			this._dataProviders.push(dataProvider);
+			const cleanup = yield* dataProvider(this);
+			if (cleanup) this._subscriptions.add(cleanup);
+		});
+	}
+	identify(distinctId, attributes, setOnceAttributes) {
+		for (const extension of this._extensions) extension.identify?.(distinctId, attributes, setOnceAttributes);
+	}
+	alias(distinctId, previousId) {
+		for (const extension of this._extensions) extension.alias?.(distinctId, previousId);
+	}
+	setTags(tags, kind) {
+		for (const extension of this._extensions) {
+			if (kind && !extension.apis.some((api) => api.kind === kind)) continue;
+			const processedTags = Object.fromEntries(Object.entries(tags).filter((entry) => entry[1] !== void 0).map(([key, value]) => [key, value.toString()]));
+			extension.setTags?.(processedTags);
+		}
+	}
+	get enabled() {
+		return this._extensions.every((extension) => extension.enabled);
+	}
+	get errors() {
+		return { captureException: (error, attributes) => {
+			for (const extension of this._getExtensions("errors")) extension.captureException(error, attributes);
+		} };
+	}
+	get events() {
+		return { captureEvent: (event, attributes) => {
+			for (const extension of this._getExtensions("events")) extension.captureEvent(event, attributes);
+		} };
+	}
+	get feedback() {
+		return { captureUserFeedback: async (form) => {
+			let eventUuid;
+			for (const extension of this._getExtensions("feedback")) eventUuid = await extension.captureUserFeedback(form) ?? eventUuid;
+			return eventUuid;
+		} };
+	}
+	isAvailable(kind) {
+		const apis = this._getExtensions(kind);
+		if (apis.length === 0) return Effect.succeed(false);
+		return Effect.gen(this, function* () {
+			for (const api of apis) if (yield* api.isAvailable()) return true;
+			return false;
+		});
+	}
+	get metrics() {
+		return {
+			gauge: (name, value, attributes) => {
+				for (const extension of this._getExtensions("metrics")) extension.gauge(name, value, attributes);
+			},
+			increment: (name, value, attributes) => {
+				for (const extension of this._getExtensions("metrics")) extension.increment(name, value, attributes);
+			},
+			distribution: (name, value, attributes) => {
+				for (const extension of this._getExtensions("metrics")) extension.distribution(name, value, attributes);
+			}
+		};
+	}
+	_getExtensions(kind) {
+		return Function.pipe(this._extensions, Array.flatMap((extension) => extension.apis), Array.filter((api) => api.kind === kind));
+	}
+};
+var make = () => Effect.succeed(new ObservabilityImpl());
+var addExtension = (_extension) => Effect.fn(function* (_observability) {
+	const observability = yield* _observability;
+	const extension = yield* _extension;
+	invariant("_addExtension" in observability && typeof observability._addExtension === "function", void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$4,
+		L: 278,
+		S: this,
+		A: ["'_addExtension' in observability && typeof observability._addExtension === 'function'", ""]
+	});
+	observability._addExtension(extension);
+	return observability;
+});
+var addDataProvider = (dataProvider) => Effect.fn(function* (_observability) {
+	const observability = yield* _observability;
+	invariant("_addDataProvider" in observability && typeof observability._addDataProvider === "function", void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$4,
+		L: 286,
+		S: this,
+		A: ["'_addDataProvider' in observability && typeof observability._addDataProvider === 'function'", ""]
+	});
+	observability._addDataProvider(dataProvider);
+	return observability;
+});
+var initialize = Effect.fn(function* (_observability) {
+	const observability = yield* _observability;
+	yield* observability.initialize();
+	return observability;
+});
+var cli_observability_secrets_default = {
+	POSTHOG_API_KEY: null,
+	IPDATA_API_KEY: null,
+	OTEL_ENDPOINT: null,
+	OTEL_HEADERS: null
+};
+//#endregion
+//#region src/extensions/stub.ts
+var stubExtension = {
+	initialize: () => Effect.succeed(void 0),
+	enable: () => Effect.succeed(void 0),
+	disable: () => Effect.succeed(void 0),
+	flush: () => Effect.succeed(void 0),
+	setTags: () => void 0,
+	get enabled() {
+		return true;
+	},
+	apis: []
+};
+//#endregion
+//#region src/extensions/otel/extension.ts
+var __dxlog_file$3 = "/__w/dxos/dxos/packages/sdk/observability/src/extensions/otel/extension.ts";
+/** Create an OTEL-backed observability extension for logs, metrics, and/or traces. */
+var extensions$1 = Effect.fn(function* ({ serviceName, serviceVersion, environment, config, endpoint: _endpoint, headers: _headers, logs: logsEnabled = false, logLevel = LogLevel.INFO, metrics: metricsEnabled = false, traces: tracesEnabled = false }) {
+	const { OtelLogs } = yield* Effect.promise(() => import("./chunk-logs.mjs"));
+	const { OtelMetrics } = yield* Effect.promise(() => import("./chunk-metrics.mjs"));
+	const { OtelTraces } = yield* Effect.promise(() => import("./chunk-traces-browser.mjs"));
+	const disabled = (yield* Effect.promise(() => isObservabilityDisabled(serviceName))) || isObservabilityDisabledSync(serviceName);
+	const storedLogLevel = yield* Effect.promise(() => getOtelLogLevel(serviceName));
+	const resolvedLogLevel = storedLogLevel != null ? LogLevel[storedLogLevel.toUpperCase()] ?? logLevel : logLevel;
+	const enabledRef = yield* Ref.make(!disabled);
+	const tags = /* @__PURE__ */ new Map();
+	const rawEndpoint = isNode() ? process.env.DX_OTEL_ENDPOINT ?? _endpoint ?? cli_observability_secrets_default.OTEL_ENDPOINT : config.values.runtime?.app?.env?.DX_OTEL_ENDPOINT ?? _endpoint;
+	const endpoint = !isNode() && rawEndpoint?.startsWith("/") ? resolveRelativeEndpoint(rawEndpoint) : rawEndpoint;
+	const headers = _headers ?? Match.value(isNode()).pipe(Match.when(true, () => Option.fromNullable(process.env.DX_OTEL_HEADERS ?? cli_observability_secrets_default.OTEL_HEADERS)), Match.when(false, () => Option.fromNullable(config.values.runtime?.app?.env?.DX_OTEL_HEADERS)), Match.exhaustive, Option.map((raw) => parseHeaders(raw)), Option.getOrElse(() => void 0));
+	if (!endpoint) {
+		log.info("Missing OTEL_ENDPOINT", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 85,
+			S: this
+		});
+		return stubExtension;
+	}
+	const resolvedHeaders = headers ?? {};
+	const resolvedEndpoint = !isNode() && endpoint.startsWith("/") ? `${globalThis.location.origin}${endpoint}` : endpoint;
+	const clientTag = resolveTelemetryTag(config);
+	if (clientTag) tags.set("ctx.tag", clientTag);
+	const resource = defaultResource().merge(resourceFromAttributes({
+		[ATTR_SERVICE_NAME]: serviceName,
+		[ATTR_SERVICE_VERSION]: serviceVersion,
+		"session.id": crypto.randomUUID(),
+		"deployment.environment": environment,
+		"dxos.process.type": detectProcessType(),
+		...clientTag ? { "ctx.tag": clientTag } : {}
+	}));
+	const logs = logsEnabled ? new OtelLogs({
+		endpoint: resolvedEndpoint,
+		headers: resolvedHeaders,
+		resource,
+		getTags: () => Object.fromEntries(tags),
+		logLevel: resolvedLogLevel
+	}) : void 0;
+	const metrics = metricsEnabled ? new OtelMetrics({
+		endpoint: resolvedEndpoint,
+		headers: resolvedHeaders,
+		resource,
+		getTags: () => Object.fromEntries(tags)
+	}) : void 0;
+	const traces = tracesEnabled ? new OtelTraces({
+		endpoint: resolvedEndpoint,
+		headers: resolvedHeaders,
+		resource,
+		getTags: () => Object.fromEntries(tags)
+	}) : void 0;
+	return {
+		initialize: () => Effect.sync(() => {
+			if (disabled) return;
+			if (logs) log.runtimeConfig.processors.push(logs.logProcessor);
+			if (traces) traces.start();
+		}),
+		enable: Effect.fn(function* () {
+			yield* Effect.promise(() => storeObservabilityDisabled(serviceName, false));
+			yield* Ref.update(enabledRef, () => true);
+		}),
+		disable: Effect.fn(function* () {
+			yield* Effect.promise(() => storeObservabilityDisabled(serviceName, true));
+			yield* Ref.update(enabledRef, () => false);
+		}),
+		close: () => Effect.promise(async () => {
+			const results = await Promise.allSettled([logs?.close(), metrics?.close()]);
+			for (const result of results) if (result.status === "rejected") log.catch(result.reason, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$3,
+				L: 183,
+				S: this
+			});
+			await traces?.close();
+		}),
+		flush: () => Effect.promise(async () => {
+			const results = await Promise.allSettled([logs?.flush(), metrics?.flush()]);
+			for (const result of results) if (result.status === "rejected") log.catch(result.reason, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$3,
+				L: 196,
+				S: this
+			});
+			await traces?.flush();
+		}),
+		setTags: (incomingTags) => {
+			for (const [key, value] of Object.entries(incomingTags)) tags.set(key, value);
+		},
+		get enabled() {
+			return Ref.get(enabledRef).pipe(Effect.runSync);
+		},
+		apis: [
+			{
+				kind: "logs",
+				isAvailable: () => Effect.succeed(!!logs)
+			},
+			metrics ? {
+				kind: "metrics",
+				isAvailable: () => Effect.succeed(true),
+				gauge: (name, value, tags) => metrics.gauge(name, value, tags),
+				increment: (name, value, tags) => metrics.increment(name, value, tags),
+				distribution: (name, value, tags) => metrics.distribution(name, value, tags)
+			} : void 0,
+			traces ? {
+				kind: "traces",
+				isAvailable: () => Effect.succeed(true)
+			} : void 0
+		].filter(isNonNullable)
+	};
+});
+/**
+* Synchronous best-effort check for observability opt-out.
+* Prevents telemetry from being emitted before the async storage check completes.
+*/
+var isObservabilityDisabledSync = (serviceName) => {
+	if (isNode()) return process.env.DX_DISABLE_OBSERVABILITY === "true";
+	try {
+		if (typeof localStorage !== "undefined") return localStorage.getItem(`${serviceName}/observability-disabled`) === "true";
+	} catch {}
+	return false;
+};
+/** Best-effort detection of the JavaScript execution context type. */
+var detectProcessType = () => {
+	if (isNode()) return "node";
+	if (typeof window !== "undefined") return "browser";
+	if (typeof globalThis.ServiceWorkerGlobalScope !== "undefined") return "service-worker";
+	if (typeof globalThis.SharedWorkerGlobalScope !== "undefined") return "shared-worker";
+	return "dedicated-worker";
+};
+/**
+* Resolves a relative OTLP endpoint path against the current global origin.
+* Workers expose the same `globalThis.location` as the page that spawned them;
+* if neither is available we fall back to the original path and let the OTLP
+* exporter surface the configuration error.
+*/
+var resolveRelativeEndpoint = (path) => {
+	const origin = globalThis.location?.origin;
+	return origin ? `${origin}${path}` : path;
+};
+var parseHeaders = (unparsedHeaders) => {
+	return unparsedHeaders.split(";").reduce((acc, header) => {
+		const [key, ...rest] = header.split(":");
+		if (key && rest.length > 0) acc[key.trim().toLowerCase()] = rest.join(":").trim();
+		return acc;
+	}, {});
+};
+//#endregion
+//#region src/extensions/otel/index.ts
+var otel_exports = /* @__PURE__ */ __exportAll({ extensions: () => extensions$1 });
+//#endregion
+//#region src/extensions/posthog/extension.ts
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/sdk/observability/src/extensions/posthog/extension.ts";
+/** Upload serialized logs to the feedback-logs endpoint. Returns the R2 key on success. */
+var uploadLogs = async (body) => {
+	try {
+		const response = await fetch("/api/feedback-logs", {
+			method: "POST",
+			headers: { "Content-Type": "application/x-ndjson" },
+			body
+		});
+		if (!response.ok) {
+			log.warn("feedback log upload failed", { status: response.status }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 45,
+				S: void 0
+			});
+			return;
+		}
+		const { key } = await response.json();
+		return key;
+	} catch (err) {
+		log.warn("feedback log upload error", { error: err }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 51,
+			S: void 0
+		});
+		return;
+	}
+};
+/** Create a PostHog-backed observability extension for events, errors, and feedback. */
+var extensions = Effect.fn(function* ({ config, release, environment, posthog: posthogConfig, logStore, feedbackLogMaxSize }) {
+	if (typeof window === "undefined") {
+		log("PostHog is being stubbed because it is running in a worker.", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 66,
+			S: this
+		});
+		return stubExtension;
+	}
+	const feedbackSurveyId = config.get("runtime.app.env.DX_POSTHOG_FEEDBACK_SURVEY_ID");
+	const apiKey = config.get("runtime.app.env.DX_POSTHOG_API_KEY");
+	const api_host = config.get("runtime.app.env.DX_POSTHOG_API_HOST");
+	if (!apiKey || !api_host) {
+		log.info("Missing POSTHOG_API_KEY or POSTHOG_API_HOST", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 74,
+			S: this
+		});
+		return stubExtension;
+	}
+	const { default: posthog } = yield* Effect.promise(() => import("posthog-js"));
+	const { logProcessor } = yield* Effect.promise(() => import("./chunk-log-processor.mjs"));
+	let feedbackSurveyAvailable = null;
+	let unregisterPosthogProcessors;
+	const checkFeedbackSurveyAvailable = () => feedbackSurveyId ? Effect.promise(() => {
+		if (feedbackSurveyAvailable !== null) return Promise.resolve(feedbackSurveyAvailable);
+		return new Promise((resolve) => {
+			posthog.getSurveys((surveys) => {
+				const found = surveys.some((s) => s.id === feedbackSurveyId);
+				feedbackSurveyAvailable = found;
+				resolve(found);
+			});
+		});
+	}) : Effect.succeed(false);
+	return {
+		initialize: () => Effect.sync(() => {
+			posthog.init(apiKey, {
+				api_host,
+				mask_all_text: true,
+				capture_exceptions: true,
+				cross_subdomain_cookie: false,
+				...posthogConfig
+			});
+			if (release || environment) posthog.register({
+				...release ? { release } : {},
+				...environment ? { environment } : {}
+			});
+			unregisterPosthogProcessors?.();
+			const removePosthogLog = log.addProcessor(logProcessor, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 118,
+				S: this
+			});
+			unregisterPosthogProcessors = () => {
+				removePosthogLog();
+			};
+		}),
+		close: () => Effect.sync(() => {
+			unregisterPosthogProcessors?.();
+			unregisterPosthogProcessors = void 0;
+		}),
+		enable: () => Effect.sync(() => posthog.opt_in_capturing()),
+		disable: () => Effect.sync(() => posthog.opt_out_capturing()),
+		identify: (distinctId, attributes, setOnceAttributes) => {
+			posthog.identify(distinctId, attributes, setOnceAttributes);
+		},
+		alias: (distinctId, previousId) => {
+			posthog.alias(distinctId, previousId);
+		},
+		setTags: (tags) => {
+			posthog.register_for_session(tags);
+		},
+		get enabled() {
+			return posthog.is_capturing();
+		},
+		apis: [
+			{
+				kind: "events",
+				isAvailable: () => Effect.succeed(true),
+				captureEvent: (event, attributes) => {
+					posthog.capture(event, attributes);
+				}
+			},
+			{
+				kind: "errors",
+				isAvailable: () => Effect.succeed(true),
+				captureException: (error, attributes) => {
+					posthog.captureException(error, attributes);
+				}
+			},
+			{
+				kind: "feedback",
+				captureUserFeedback: (form) => {
+					return new Promise((resolve, reject) => {
+						posthog.getSurveys((surveys) => {
+							(async () => {
+								try {
+									const survey = surveys.find((survey) => survey.id === feedbackSurveyId);
+									if (!survey || survey.questions.length === 0) {
+										log.error("Missing feedback survey or survey has no questions", { feedbackSurveyId }, {
+											"~LogMeta": "~LogMeta",
+											F: __dxlog_file$2,
+											L: 167,
+											S: this
+										});
+										resolve(void 0);
+										return;
+									}
+									let debugLogDumpKey = null;
+									if (form.includeLogs !== false && logStore !== void 0) {
+										const ndjson = await logStore.export({ maxSize: feedbackLogMaxSize });
+										if (ndjson.length > 0) debugLogDumpKey = await uploadLogs(ndjson) ?? "failed";
+									}
+									const question = survey.questions[0];
+									resolve(posthog.capture("survey sent", {
+										$survey_id: survey.id,
+										$survey_questions: [{
+											id: question.id,
+											question: question.question
+										}],
+										[`$survey_response_${question.id}`]: form.message,
+										$survey_completed: true,
+										debug_log_dump_key: debugLogDumpKey
+									})?.uuid);
+								} catch (err) {
+									log.error("Failed to capture user feedback", { err }, {
+										"~LogMeta": "~LogMeta",
+										F: __dxlog_file$2,
+										L: 192,
+										S: this
+									});
+									reject(err);
+								}
+							})();
+						});
+					});
+				},
+				isAvailable: checkFeedbackSurveyAvailable
+			}
+		]
+	};
+});
+//#endregion
+//#region src/extensions/posthog/index.ts
+var posthog_exports = /* @__PURE__ */ __exportAll({ extensions: () => extensions });
+//#endregion
+//#region src/observability-extension.ts
+var observability_extension_exports = /* @__PURE__ */ __exportAll({
+	Otel: () => otel_exports,
+	PostHog: () => posthog_exports
+});
+//#endregion
+//#region src/providers/client-observability.ts
+var client_observability_exports = /* @__PURE__ */ __exportAll({
+	identityProvider: () => identityProvider,
+	networkMetricsProvider: () => networkMetricsProvider,
+	runtimeMetricsProvider: () => runtimeMetricsProvider,
+	spacesMetricsProvider: () => spacesMetricsProvider
+});
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/sdk/observability/src/providers/client-observability.ts";
+var SPACE_METRICS_MIN_INTERVAL = 1e3 * 60 * 10;
+var NETWORK_METRICS_MIN_INTERVAL = 1e3 * 60 * 10;
+var RUNTIME_METRICS_MIN_INTERVAL = 1e3 * 60 * 10;
+/** Subscribes to identity and device changes and sets observability tags accordingly. */
+var identityProvider = (clientServices) => Effect.fn(function* (observability) {
+	clientServices.IdentityService.queryIdentity().subscribe((idqr) => {
+		if (!idqr?.identity?.did) return;
+		observability.identify(idqr.identity.did);
+		observability.setTags({ did: idqr.identity.did });
+	});
+	clientServices.DevicesService.queryDevices().subscribe((dqr) => {
+		if (!dqr?.devices || dqr.devices.length === 0) return;
+		const thisDevice = dqr.devices.find((device) => device.kind === DeviceKind.CURRENT);
+		if (!thisDevice) return;
+		observability.setTags({ deviceKey: thisDevice.deviceKey.truncate() });
+		if (thisDevice.profile?.label) observability.setTags({ deviceProfile: thisDevice.profile.label });
+	});
+});
+/** Periodically publishes network connection and buffer metrics. */
+var networkMetricsProvider = (clientServices) => Effect.fn(function* (observability) {
+	const ctx = new Context(void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 61
+	});
+	let lastNetworkStatus;
+	const updateSignalMetrics = new Event().debounce(NETWORK_METRICS_MIN_INTERVAL);
+	updateSignalMetrics.on(ctx, async () => {
+		log("send signal metrics", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 67,
+			S: this
+		});
+		(lastNetworkStatus?.signaling)?.forEach(({ server, state }) => {
+			observability.metrics.gauge("dxos.client.network.signal.connectionState", state, { server });
+		});
+		let swarmCount = 0;
+		const connectionStates = /* @__PURE__ */ new Map();
+		for (const state in ConnectionState) connectionStates.set(state, 0);
+		let totalReadBufferSize = 0;
+		let totalWriteBufferSize = 0;
+		let totalChannelBufferSize = 0;
+		lastNetworkStatus?.connectionInfo?.forEach((connectionInfo) => {
+			swarmCount++;
+			for (const conn of connectionInfo.connections ?? []) {
+				connectionStates.set(conn.state, (connectionStates.get(conn.state) ?? 0) + 1);
+				totalReadBufferSize += conn.readBufferSize ?? 0;
+				totalWriteBufferSize += conn.writeBufferSize ?? 0;
+				for (const stream of conn.streams ?? []) totalChannelBufferSize += stream.writeBufferSize ?? 0;
+			}
+			observability.metrics.gauge("dxos.client.network.swarm.count", swarmCount);
+			for (const state in ConnectionState) observability.metrics.gauge("dxos.client.network.connection.count", connectionStates.get(state) ?? 0, { state });
+			observability.metrics.gauge("dxos.client.network.totalReadBufferSize", totalReadBufferSize);
+			observability.metrics.gauge("dxos.client.network.totalWriteBufferSize", totalWriteBufferSize);
+			observability.metrics.gauge("dxos.client.network.totalChannelBufferSize", totalChannelBufferSize);
+		});
+	});
+	clientServices.NetworkService.queryStatus().subscribe((networkStatus) => {
+		lastNetworkStatus = networkStatus;
+		updateSignalMetrics.emit();
+	});
+	scheduleTaskInterval(ctx, async () => updateSignalMetrics.emit(), NETWORK_METRICS_MIN_INTERVAL);
+	return async () => {
+		await ctx.dispose();
+	};
+});
+/** Periodically publishes platform and heap memory metrics. */
+var runtimeMetricsProvider = (clientServices) => Effect.fn(function* (observability) {
+	const ctx = new Context(void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 121
+	});
+	log("runtimeMetricsProvider: requesting platform from SystemService", void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 122,
+		S: this
+	});
+	const platform = yield* Effect.promise(() => clientServices.SystemService.getPlatform());
+	log("runtimeMetricsProvider: platform received", void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 124,
+		S: this
+	});
+	invariant(platform, "platform is required", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 125,
+		S: this,
+		A: ["platform", "'platform is required'"]
+	});
+	observability.setTags({
+		platformType: Platform.PLATFORM_TYPE[platform.type].toLowerCase(),
+		platform: platform.platform,
+		arch: platform.arch,
+		runtime: platform.runtime
+	});
+	scheduleTaskInterval(ctx, async () => {
+		if (clientServices.constructor.name === "WorkerClientServices") {
+			const memory = window.performance.memory;
+			if (memory) {
+				observability.metrics.gauge("dxos.client.runtime.heapTotal", memory.totalJSHeapSize);
+				observability.metrics.gauge("dxos.client.runtime.heapUsed", memory.usedJSHeapSize);
+				observability.metrics.gauge("dxos.client.runtime.heapSizeLimit", memory.jsHeapSizeLimit);
+			}
+		}
+		clientServices.SystemService?.getPlatform().then((platform) => {
+			if (platform.memory) {
+				observability.metrics.gauge("dxos.client.services.runtime.rss", platform.memory.rss);
+				observability.metrics.gauge("dxos.client.services.runtime.heapTotal", platform.memory.heapTotal);
+				observability.metrics.gauge("dxos.client.services.runtime.heapUsed", platform.memory.heapUsed);
+			}
+		}).catch((error) => log("platform error", { error }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 154,
+			S: this
+		}));
+	}, RUNTIME_METRICS_MIN_INTERVAL);
+	return async () => {
+		await ctx.dispose();
+	};
+});
+/** Periodically publishes space membership, object count, and pipeline progress metrics. */
+var spacesMetricsProvider = (client) => Effect.fn(function* (observability) {
+	const ctx = new Context(void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 167
+	});
+	const spaces = client.spaces.get();
+	const subscriptions = /* @__PURE__ */ new Map();
+	ctx.onDispose(() => subscriptions.forEach((subscription) => subscription.unsubscribe()));
+	const updateSpaceMetrics = new Event().debounce(SPACE_METRICS_MIN_INTERVAL);
+	updateSpaceMetrics.on(ctx, async () => {
+		log("send space metrics", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 175,
+			S: this
+		});
+		for (const data of mapSpaces(spaces, { truncateKeys: true })) {
+			observability.metrics.gauge("dxos.client.space.members", data.members, { key: data.key });
+			observability.metrics.gauge("dxos.client.space.objects", data.objects, { key: data.key });
+			observability.metrics.gauge("dxos.client.space.epoch", data.epoch, { key: data.key });
+			observability.metrics.gauge("dxos.client.space.currentDataMutations", data.currentDataMutations, { key: data.key });
+		}
+	});
+	const subscribeToSpaceUpdate = (space) => space.pipeline.subscribe({ next: () => {
+		updateSpaceMetrics.emit();
+	} });
+	spaces.forEach((space) => {
+		subscriptions.set(space.id, subscribeToSpaceUpdate(space));
+	});
+	client.spaces.subscribe({ next: async (spaces) => {
+		spaces.filter((space) => !subscriptions.has(space.id)).forEach((space) => {
+			subscriptions.set(space.id, subscribeToSpaceUpdate(space));
+		});
+	} });
+	scheduleTaskInterval(ctx, async () => updateSpaceMetrics.emit(), SPACE_METRICS_MIN_INTERVAL);
+	return async () => {
+		await ctx.dispose();
+	};
+});
+var mapSpaces = (spaces, options = {
+	verbose: false,
+	truncateKeys: false
+}) => {
+	return spaces.map((space) => {
+		const { open, ready } = space.internal.data.metrics ?? {};
+		const startup = open && ready && ready.getTime() - open.getTime();
+		const pipeline = space.internal.data.pipeline;
+		const startDataMutations = pipeline?.currentEpoch?.subject.assertion.timeframe.totalMessages() ?? 0;
+		const epoch = pipeline?.currentEpoch?.subject.assertion.number;
+		const currentDataMutations = pipeline?.currentDataTimeframe?.totalMessages() ?? 0;
+		const totalDataMutations = pipeline?.targetDataTimeframe?.totalMessages() ?? 0;
+		return {
+			key: space.key.truncate(),
+			open: space.isOpen,
+			members: space.members.get().length,
+			objects: space.internal.db.getAllObjectIds().length,
+			startup,
+			epoch,
+			startDataMutations,
+			currentDataMutations,
+			totalDataMutations,
+			progress: (Math.min(Math.abs((currentDataMutations - startDataMutations) / (totalDataMutations - startDataMutations)), 1) * 100).toFixed(0)
+		};
+	});
+};
+//#endregion
+//#region src/providers/ip-data.ts
+var ip_data_exports = /* @__PURE__ */ __exportAll({ provider: () => provider$1 });
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/observability/src/providers/ip-data.ts";
+var IP_DATA_CACHE_TIMEOUT = 360 * 60 * 1e3;
+var IPData = Schema.Struct({
+	city: Schema.NullOr(Schema.String),
+	region: Schema.NullOr(Schema.String),
+	country_name: Schema.String,
+	latitude: Schema.NullOr(Schema.Number),
+	longitude: Schema.NullOr(Schema.Number)
+});
+var getIPData = Effect.fn(function* (config) {
+	const httpClientNoTrace = (yield* HttpClient.HttpClient).pipe(HttpClient.withTracerDisabledWhen(() => true));
+	const cachedData = yield* Effect.promise(() => localForage.getItem("dxos:observability:ipdata:v2"));
+	if (cachedData && cachedData.timestamp > Date.now() - IP_DATA_CACHE_TIMEOUT) return cachedData.data;
+	const IPDATA_API_KEY = config.get("runtime.app.env.DX_IPDATA_API_KEY");
+	if (!IPDATA_API_KEY) {
+		log.warn("DX_IPDATA_API_KEY is not configured; IP geolocation tags will be absent from telemetry", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 52,
+			S: this
+		});
+		return cachedData?.data;
+	}
+	const data = yield* HttpClientRequest.get(`https://api.ipdata.co?api-key=${IPDATA_API_KEY}`).pipe(httpClientNoTrace.execute, Effect.flatMap((res) => res.json), Effect.flatMap(Schema.decodeUnknown(IPData)), Effect.catchAll((err) => Effect.sync(() => {
+		log.warn("ipdata fetch failed; IP geolocation tags will be absent or stale", { err }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 63,
+			S: this
+		});
+		return cachedData?.data;
+	})));
+	if (data) yield* Effect.promise(() => localForage.setItem("dxos:observability:ipdata:v2", {
+		data,
+		timestamp: Date.now()
+	}));
+	return data;
+});
+/** Fetches IP geolocation data and sets city/region/country tags on the observability instance. */
+var provider$1 = (config) => (observability) => Effect.gen(function* () {
+	const ipData = yield* getIPData(config);
+	if (!ipData) return;
+	observability.setTags({
+		...ipData.city != null && { city: ipData.city },
+		...ipData.region != null && { region: ipData.region },
+		country: ipData.country_name,
+		...ipData.latitude != null && { latitude: ipData.latitude },
+		...ipData.longitude != null && { longitude: ipData.longitude }
+	});
+}).pipe(Effect.provide(FetchHttpClient.layer), Effect.catchAll((err) => Effect.sync(() => {
+	log.warn("ipdata provider failed", { err }, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 97,
+		S: void 0
+	});
+})));
+//#endregion
+//#region src/providers/storage.ts
+var storage_exports = /* @__PURE__ */ __exportAll({ provider: () => provider });
+var provider = Effect.fn(function* (observability) {
+	if (typeof navigator !== "undefined" && navigator.storage?.estimate) {
+		const fiber = Effect.gen(function* () {
+			const storageEstimate = yield* Effect.tryPromise(() => navigator.storage.estimate());
+			storageEstimate.usage && observability.metrics.gauge("storageUsage", storageEstimate.usage);
+			storageEstimate.quota && observability.metrics.gauge("storageQuota", storageEstimate.quota);
+		}).pipe(Effect.repeat(Schedule.fixed(Duration.hours(1))), Effect.runFork);
+		return () => Effect.runSync(Fiber.interrupt(fiber));
+	}
+});
+//#endregion
+//#region src/providers/index.ts
+var providers_exports = /* @__PURE__ */ __exportAll({
+	Client: () => client_observability_exports,
+	IPData: () => ip_data_exports,
+	Storage: () => storage_exports
+});
+//#endregion
+export { observability_exports as Observability, observability_extension_exports as ObservabilityExtension, providers_exports as ObservabilityProvider };
+
+//# sourceMappingURL=index.mjs.map