@dxos/observability 0.8.4-main.fffef41 → 0.8.4-staging.60fe92afc8

package/dist/lib/browser/index.mjs

@@ -1,38 +1,1015 @@
 import {
-  OBSERVABILITY_DISABLED_KEY,
-  OBSERVABILITY_GROUP_KEY,
-  Observability,
-  getObservabilityGroup,
-  getObservabilityState,
-  getTelemetryIdentifier,
-  getTelemetryIdentity,
-  initializeAppObservability,
-  initializeNodeObservability,
-  isObservabilityDisabled,
-  mapSpaces,
-  setupTelemetryListeners,
-  showObservabilityBanner,
-  storeObservabilityDisabled,
-  storeObservabilityGroup
-} from "./chunk-VIGEEYDR.mjs";
-import "./chunk-XNAF22QM.mjs";
-import "./chunk-5ICT2XF2.mjs";
-import "./chunk-ZI3ZS3PA.mjs";
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/observability.ts
+var observability_exports = {};
+__export(observability_exports, {
+  addDataProvider: () => addDataProvider,
+  addExtension: () => addExtension,
+  getObservabilityGroup: () => getObservabilityGroup,
+  getOtelLogLevel: () => getOtelLogLevel,
+  initialize: () => initialize,
+  isObservabilityDisabled: () => isObservabilityDisabled,
+  make: () => make,
+  showObservabilityBanner: () => showObservabilityBanner,
+  storeObservabilityDisabled: () => storeObservabilityDisabled,
+  storeObservabilityGroup: () => storeObservabilityGroup,
+  storeOtelLogLevel: () => storeOtelLogLevel
+});
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import { SubscriptionList } from "@dxos/async";
+import { invariant } from "@dxos/invariant";
+import { log as log2 } from "@dxos/log";
+
+// src/storage/browser.ts
+import * as localForage from "localforage";
+import { log } from "@dxos/log";
+import { compositeKey } from "@dxos/util";
+var __dxlog_file = "/__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";
+var showObservabilityBanner = () => {
+  log.warn("showObservabilityBanner is not supported in browser contexts.", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 12, S: void 0 });
+};
+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, L: 20, S: void 0 });
+    return true;
+  }
+};
+var storeObservabilityDisabled = async (namespace, value2) => {
+  try {
+    await localForage.setItem(compositeKey(namespace, OBSERVABILITY_DISABLED_KEY), String(value2));
+  } catch (err) {
+    log.catch("Failed to store observability disabled", err, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 30, S: void 0 });
+  }
+  try {
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem(`${namespace}/${OBSERVABILITY_DISABLED_KEY}`, String(value2));
+    }
+  } catch {
+  }
+};
+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, L: 48, S: void 0 });
+  }
+};
+var storeObservabilityGroup = async (namespace, value2) => {
+  try {
+    await localForage.setItem(compositeKey(namespace, OBSERVABILITY_GROUP_KEY), value2);
+  } catch (err) {
+    log.catch("Failed to store observability group", err, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 57, S: void 0 });
+  }
+};
+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, L: 66, S: void 0 });
+    return null;
+  }
+};
+var storeOtelLogLevel = async (namespace, value2) => {
+  try {
+    if (value2 === null) {
+      await localForage.removeItem(compositeKey(namespace, OTEL_LOG_LEVEL_KEY));
+    } else {
+      await localForage.setItem(compositeKey(namespace, OTEL_LOG_LEVEL_KEY), value2);
+    }
+  } catch (err) {
+    log.catch("Failed to store OTEL log level", err, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 80, S: void 0 });
+  }
+};
+
+// src/observability.ts
+var __dxlog_file2 = "/__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((provider3) => provider3(this)));
+      this._subscriptions.add(...cleanups.filter((cleanup) => cleanup !== void 0));
+      this._initialized = true;
+    }).pipe(Effect.catchAll((error) => Effect.gen(this, function* () {
+      log2.catch(error, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 32, 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_file2, L: 82, 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_file2, L: 86, 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, value2]) => [
+        key,
+        value2.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) {
+        const available = yield* api.isAvailable();
+        if (available) {
+          return true;
+        }
+      }
+      return false;
+    });
+  }
+  get metrics() {
+    return {
+      gauge: (name, value2, attributes) => {
+        for (const extension of this._getExtensions("metrics")) {
+          extension.gauge(name, value2, attributes);
+        }
+      },
+      increment: (name, value2, attributes) => {
+        for (const extension of this._getExtensions("metrics")) {
+          extension.increment(name, value2, attributes);
+        }
+      },
+      distribution: (name, value2, attributes) => {
+        for (const extension of this._getExtensions("metrics")) {
+          extension.distribution(name, value2, 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_file2, L: 196, 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_file2, L: 202, 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;
+});
+
+// src/observability-extension.ts
+var observability_extension_exports = {};
+__export(observability_extension_exports, {
+  Otel: () => otel_exports,
+  PostHog: () => posthog_exports
+});
+
+// src/extensions/otel/index.ts
+var otel_exports = {};
+__export(otel_exports, {
+  extensions: () => extensions
+});
+
+// src/extensions/otel/extension.ts
+import { defaultResource, resourceFromAttributes } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+import * as Effect3 from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
+import { resolveTelemetryTag } from "@dxos/config";
+import { LogLevel, log as log3 } from "@dxos/log";
+import { isNode, isNonNullable } from "@dxos/util";
+
+// src/cli-observability-secrets.json
+var cli_observability_secrets_default = {
+  POSTHOG_API_KEY: null,
+  IPDATA_API_KEY: "73dfdecdf979c18f07d50cf841bbdd9e589f237256326ac8cca23786",
+  OTEL_ENDPOINT: "/api/otel",
+  OTEL_HEADERS: null
+};
+
+// src/extensions/stub.ts
+import * as Effect2 from "effect/Effect";
+var stubExtension = {
+  initialize: () => Effect2.succeed(void 0),
+  enable: () => Effect2.succeed(void 0),
+  disable: () => Effect2.succeed(void 0),
+  flush: () => Effect2.succeed(void 0),
+  setTags: () => void 0,
+  get enabled() {
+    return true;
+  },
+  apis: []
+};
+
+// src/extensions/otel/extension.ts
+var __dxlog_file3 = "/__w/dxos/dxos/packages/sdk/observability/src/extensions/otel/extension.ts";
+var extensions = Effect3.fn(function* ({
+  serviceName,
+  serviceVersion,
+  environment,
+  config,
+  endpoint: _endpoint,
+  headers: _headers,
+  // TODO(wittjosiah): Logging integration.
+  //   - logger should run even if observability is disabled
+  //   - logs should be cached locally in a circular buffer
+  //   - logs should be flushed to the server if user opts to include them in a bug report
+  logs: logsEnabled = false,
+  logLevel = LogLevel.INFO,
+  metrics: metricsEnabled = false,
+  traces: tracesEnabled = false
+}) {
+  const { OtelLogs } = yield* Effect3.promise(() => import("./logs-UTNIFYHF.mjs"));
+  const { OtelMetrics } = yield* Effect3.promise(() => import("./metrics-PRGSYAZJ.mjs"));
+  const { OtelTraces } = yield* Effect3.promise(() => import("./traces-browser-XRINKQUA.mjs"));
+  const cachedDisabled = yield* Effect3.promise(() => isObservabilityDisabled(serviceName));
+  const disabled = cachedDisabled || isObservabilityDisabledSync(serviceName);
+  const storedLogLevel = yield* Effect3.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) {
+    log3.info("Missing OTEL_ENDPOINT", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 37, 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;
+  const extension = {
+    initialize: () => Effect3.sync(() => {
+      if (disabled) {
+        return;
+      }
+      if (logs) {
+        log3.runtimeConfig.processors.push(logs.logProcessor);
+      }
+      if (traces) {
+        traces.start();
+      }
+    }),
+    enable: Effect3.fn(function* () {
+      yield* Effect3.promise(() => storeObservabilityDisabled(serviceName, false));
+      yield* Ref.update(enabledRef, () => true);
+    }),
+    disable: Effect3.fn(function* () {
+      yield* Effect3.promise(() => storeObservabilityDisabled(serviceName, true));
+      yield* Ref.update(enabledRef, () => false);
+    }),
+    close: () => Effect3.promise(async () => {
+      const results = await Promise.allSettled([
+        logs?.close(),
+        metrics?.close()
+      ]);
+      for (const result of results) {
+        if (result.status === "rejected") {
+          log3.catch(result.reason, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 122, S: this });
+        }
+      }
+      await traces?.close();
+    }),
+    flush: () => Effect3.promise(async () => {
+      const results = await Promise.allSettled([
+        logs?.flush(),
+        metrics?.flush()
+      ]);
+      for (const result of results) {
+        if (result.status === "rejected") {
+          log3.catch(result.reason, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 137, S: this });
+        }
+      }
+      await traces?.flush();
+    }),
+    setTags: (incomingTags) => {
+      for (const [key, value2] of Object.entries(incomingTags)) {
+        tags.set(key, value2);
+      }
+    },
+    get enabled() {
+      return Ref.get(enabledRef).pipe(Effect3.runSync);
+    },
+    apis: [
+      {
+        kind: "logs",
+        isAvailable: () => Effect3.succeed(!!logs)
+      },
+      metrics ? {
+        kind: "metrics",
+        isAvailable: () => Effect3.succeed(true),
+        gauge: (name, value2, tags2) => metrics.gauge(name, value2, tags2),
+        increment: (name, value2, tags2) => metrics.increment(name, value2, tags2),
+        distribution: (name, value2, tags2) => metrics.distribution(name, value2, tags2)
+      } : void 0,
+      traces ? {
+        kind: "traces",
+        isAvailable: () => Effect3.succeed(true)
+      } : void 0
+    ].filter(isNonNullable)
+  };
+  return extension;
+});
+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;
+};
+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";
+};
+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;
+  }, {});
+};
+
+// src/extensions/posthog/index.ts
+var posthog_exports = {};
+__export(posthog_exports, {
+  extensions: () => extensions2
+});
+
+// src/extensions/posthog/extension.ts
+import * as Effect4 from "effect/Effect";
+import { log as log4 } from "@dxos/log";
+var __dxlog_file4 = "/__w/dxos/dxos/packages/sdk/observability/src/extensions/posthog/extension.ts";
+var uploadLogs = async (body) => {
+  try {
+    const response = await fetch("/api/feedback-logs", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-ndjson"
+      },
+      body
+    });
+    if (!response.ok) {
+      log4.warn("feedback log upload failed", {
+        status: response.status
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 17, S: void 0 });
+      return void 0;
+    }
+    const { key } = await response.json();
+    return key;
+  } catch (err) {
+    log4.warn("feedback log upload error", {
+      error: err
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 25, S: void 0 });
+    return void 0;
+  }
+};
+var extensions2 = Effect4.fn(function* ({ config, release, environment, posthog: posthogConfig, logStore, feedbackLogMaxSize }) {
+  if (typeof window === "undefined") {
+    log4("PostHog is being stubbed because it is running in a worker.", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 33, 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) {
+    log4.info("Missing POSTHOG_API_KEY or POSTHOG_API_HOST", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 40, S: this });
+    return stubExtension;
+  }
+  const { default: posthog } = yield* Effect4.promise(() => import("posthog-js"));
+  const { logProcessor } = yield* Effect4.promise(() => import("./log-processor-MZCTEVJC.mjs"));
+  let feedbackSurveyAvailable = null;
+  let unregisterPosthogProcessors;
+  const checkFeedbackSurveyAvailable = () => feedbackSurveyId ? Effect4.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);
+      });
+    });
+  }) : Effect4.succeed(false);
+  return {
+    initialize: () => Effect4.sync(() => {
+      posthog.init(apiKey, {
+        api_host,
+        mask_all_text: true,
+        capture_exceptions: true,
+        ...posthogConfig
+      });
+      if (release || environment) {
+        posthog.register({
+          ...release ? {
+            release
+          } : {},
+          ...environment ? {
+            environment
+          } : {}
+        });
+      }
+      unregisterPosthogProcessors?.();
+      const removePosthogLog = log4.addProcessor(logProcessor, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 79, S: this });
+      unregisterPosthogProcessors = () => {
+        removePosthogLog();
+      };
+    }),
+    close: () => Effect4.sync(() => {
+      unregisterPosthogProcessors?.();
+      unregisterPosthogProcessors = void 0;
+    }),
+    enable: () => Effect4.sync(() => posthog.opt_in_capturing()),
+    disable: () => Effect4.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: () => Effect4.succeed(true),
+        captureEvent: (event, attributes) => {
+          posthog.capture(event, attributes);
+        }
+      },
+      {
+        kind: "errors",
+        isAvailable: () => Effect4.succeed(true),
+        captureException: (error, attributes) => {
+          posthog.captureException(error, attributes);
+        }
+      },
+      {
+        kind: "feedback",
+        // TODO(wittjosiah): Support custom surveys.
+        captureUserFeedback: (form) => {
+          return new Promise((resolve, reject) => {
+            posthog.getSurveys((surveys) => {
+              void (async () => {
+                try {
+                  const survey = surveys.find((survey2) => survey2.id === feedbackSurveyId);
+                  if (!survey || survey.questions.length === 0) {
+                    log4.error("Missing feedback survey or survey has no questions", {
+                      feedbackSurveyId
+                    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 127, 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];
+                  const result = posthog.capture("survey sent", {
+                    $survey_id: survey.id,
+                    $survey_questions: [
+                      {
+                        id: question.id,
+                        question: question.question
+                      }
+                    ],
+                    [`$survey_response_${question.id}`]: form.message,
+                    debug_log_dump_key: debugLogDumpKey
+                  });
+                  resolve(result?.uuid);
+                } catch (err) {
+                  log4.error("Failed to capture user feedback", {
+                    err
+                  }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 157, S: this });
+                  reject(err);
+                }
+              })();
+            });
+          });
+        },
+        isAvailable: checkFeedbackSurveyAvailable
+      }
+    ]
+  };
+});
+
+// src/providers/index.ts
+var providers_exports = {};
+__export(providers_exports, {
+  Client: () => client_observability_exports,
+  IPData: () => ip_data_exports,
+  Storage: () => storage_exports
+});
+
+// src/providers/client-observability.ts
+var client_observability_exports = {};
+__export(client_observability_exports, {
+  identityProvider: () => identityProvider,
+  networkMetricsProvider: () => networkMetricsProvider,
+  runtimeMetricsProvider: () => runtimeMetricsProvider,
+  spacesMetricsProvider: () => spacesMetricsProvider
+});
+import * as Effect5 from "effect/Effect";
+import { Event, scheduleTaskInterval } from "@dxos/async";
+import { DeviceKind } from "@dxos/client/halo";
+import { Context } from "@dxos/context";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { log as log5 } from "@dxos/log";
+import { ConnectionState, Platform } from "@dxos/protocols/proto/dxos/client/services";
+var __dxlog_file5 = "/__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;
+var identityProvider = (clientServices) => Effect5.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
+      });
+    }
+  });
+});
+var networkMetricsProvider = (clientServices) => Effect5.fn(function* (observability) {
+  const ctx = new Context(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 50 });
+  let lastNetworkStatus;
+  const updateSignalMetrics = new Event().debounce(NETWORK_METRICS_MIN_INTERVAL);
+  updateSignalMetrics.on(ctx, async () => {
+    log5("send signal metrics", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 55, 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();
+  };
+});
+var runtimeMetricsProvider = (clientServices) => Effect5.fn(function* (observability) {
+  const ctx = new Context(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 100 });
+  log5("runtimeMetricsProvider: requesting platform from SystemService", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 101, S: this });
+  const platform = yield* Effect5.promise(() => clientServices.SystemService.getPlatform());
+  log5("runtimeMetricsProvider: platform received", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 103, S: this });
+  invariant2(platform, "platform is required", { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 104, 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((platform2) => {
+      if (platform2.memory) {
+        observability.metrics.gauge("dxos.client.services.runtime.rss", platform2.memory.rss);
+        observability.metrics.gauge("dxos.client.services.runtime.heapTotal", platform2.memory.heapTotal);
+        observability.metrics.gauge("dxos.client.services.runtime.heapUsed", platform2.memory.heapUsed);
+      }
+    }).catch((error) => log5("platform error", {
+      error
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 126, S: this }));
+  }, RUNTIME_METRICS_MIN_INTERVAL);
+  return async () => {
+    await ctx.dispose();
+  };
+});
+var spacesMetricsProvider = (client) => Effect5.fn(function* (observability) {
+  const ctx = new Context(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 135 });
+  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 () => {
+    log5("send space metrics", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 142, 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 (spaces2) => {
+      spaces2.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 {
+      // TODO(nf): truncate keys for DD?
+      key: space.key.truncate(),
+      open: space.isOpen,
+      members: space.members.get().length,
+      objects: space.internal.db.getAllObjectIds().length,
+      startup,
+      epoch,
+      // appliedEpoch,
+      startDataMutations,
+      currentDataMutations,
+      totalDataMutations,
+      // TODO(burdon): Negative?
+      progress: (Math.min(Math.abs((currentDataMutations - startDataMutations) / (totalDataMutations - startDataMutations)), 1) * 100).toFixed(0)
+    };
+  });
+};
+
+// src/providers/ip-data.ts
+var ip_data_exports = {};
+__export(ip_data_exports, {
+  provider: () => provider
+});
+import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as Effect6 from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as localForage2 from "localforage";
+import { log as log6 } from "@dxos/log";
+var __dxlog_file6 = "/__w/dxos/dxos/packages/sdk/observability/src/providers/ip-data.ts";
+var IP_DATA_CACHE_TIMEOUT = 6 * 60 * 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 = Effect6.fn(function* (config) {
+  const httpClient = yield* HttpClient.HttpClient;
+  const httpClientNoTrace = httpClient.pipe(HttpClient.withTracerDisabledWhen(() => true));
+  const cachedData = yield* Effect6.promise(() => localForage2.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) {
+    log6.warn("DX_IPDATA_API_KEY is not configured; IP geolocation tags will be absent from telemetry", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 35, S: this });
+    return cachedData?.data;
+  }
+  const data = yield* HttpClientRequest.get(`https://api.ipdata.co?api-key=${IPDATA_API_KEY}`).pipe(
+    httpClientNoTrace.execute,
+    Effect6.flatMap((res) => res.json),
+    Effect6.flatMap(Schema.decodeUnknown(IPData)),
+    // On failure fall back to stale cache rather than emitting no tags.
+    Effect6.catchAll((err) => Effect6.sync(() => {
+      log6.warn("ipdata fetch failed; IP geolocation tags will be absent or stale", {
+        err
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 40, S: this });
+      return cachedData?.data;
+    }))
+  );
+  if (data) {
+    yield* Effect6.promise(() => localForage2.setItem("dxos:observability:ipdata:v2", {
+      data,
+      timestamp: Date.now()
+    }));
+  }
+  return data;
+});
+var provider = (config) => (observability) => Effect6.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(Effect6.provide(FetchHttpClient.layer), Effect6.catchAll((err) => Effect6.sync(() => {
+  log6.warn("ipdata provider failed", {
+    err
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 74, S: void 0 });
+})));
+
+// src/providers/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  provider: () => provider2
+});
+import * as Duration from "effect/Duration";
+import * as Effect7 from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as Schedule from "effect/Schedule";
+var provider2 = Effect7.fn(function* (observability) {
+  if (typeof navigator !== "undefined" && navigator.storage?.estimate) {
+    const action = Effect7.gen(function* () {
+      const storageEstimate = yield* Effect7.tryPromise(() => navigator.storage.estimate());
+      storageEstimate.usage && observability.metrics.gauge("storageUsage", storageEstimate.usage);
+      storageEstimate.quota && observability.metrics.gauge("storageQuota", storageEstimate.quota);
+    });
+    const fiber = action.pipe(Effect7.repeat(Schedule.fixed(Duration.hours(1))), Effect7.runFork);
+    return () => Effect7.runSync(Fiber.interrupt(fiber));
+  }
+});
 export {
-  OBSERVABILITY_DISABLED_KEY,
-  OBSERVABILITY_GROUP_KEY,
-  Observability,
-  getObservabilityGroup,
-  getObservabilityState,
-  getTelemetryIdentifier,
-  getTelemetryIdentity,
-  initializeAppObservability,
-  initializeNodeObservability,
-  isObservabilityDisabled,
-  mapSpaces,
-  setupTelemetryListeners,
-  showObservabilityBanner,
-  storeObservabilityDisabled,
-  storeObservabilityGroup
+  observability_exports as Observability,
+  observability_extension_exports as ObservabilityExtension,
+  providers_exports as ObservabilityProvider
 };
 //# sourceMappingURL=index.mjs.map