@dxos/observability 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

package/dist/lib/browser/index.mjs

@@ -1,40 +1,62 @@
 import {
-  Observability,
-  getTelemetryIdentifier,
-  getTelemetryIdentity,
-  mapSpaces
-} from "./chunk-JJQT5TQH.mjs";
-import "./chunk-U6JWT3E2.mjs";
-import "./chunk-5LN7D6GM.mjs";
-import "./chunk-5ICT2XF2.mjs";
-import "./chunk-O4BG5MRL.mjs";
+  __export
+} from "./chunk-J5LGTIGS.mjs";
 
-// src/helpers/browser-observability.ts
+// src/observability.ts
+var observability_exports = {};
+__export(observability_exports, {
+  addDataProvider: () => addDataProvider,
+  addExtension: () => addExtension,
+  getObservabilityGroup: () => getObservabilityGroup,
+  initialize: () => initialize,
+  isObservabilityDisabled: () => isObservabilityDisabled,
+  make: () => make,
+  showObservabilityBanner: () => showObservabilityBanner,
+  storeObservabilityDisabled: () => storeObservabilityDisabled,
+  storeObservabilityGroup: () => storeObservabilityGroup
+});
+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";
-var __dxlog_file = "/__w/dxos/dxos/packages/sdk/observability/src/helpers/browser-observability.ts";
+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 showObservabilityBanner = () => {
+  log.warn("showObservabilityBanner is not supported in browser contexts.", void 0, {
+    F: __dxlog_file,
+    L: 16,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+};
 var isObservabilityDisabled = async (namespace) => {
   try {
-    return await localForage.getItem(`${namespace}:${OBSERVABILITY_DISABLED_KEY}`) === "true";
+    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, {
       F: __dxlog_file,
-      L: 25,
+      L: 26,
       S: void 0,
       C: (f, a) => f(...a)
     });
     return true;
   }
 };
-var storeObservabilityDisabled = async (namespace, value) => {
+var storeObservabilityDisabled = async (namespace, value2) => {
   try {
-    await localForage.setItem(`${namespace}:${OBSERVABILITY_DISABLED_KEY}`, String(value));
+    await localForage.setItem(compositeKey(namespace, OBSERVABILITY_DISABLED_KEY), String(value2));
   } catch (err) {
     log.catch("Failed to store observability disabled", err, {
       F: __dxlog_file,
-      L: 34,
+      L: 38,
       S: void 0,
       C: (f, a) => f(...a)
     });
@@ -42,323 +64,945 @@ var storeObservabilityDisabled = async (namespace, value) => {
 };
 var getObservabilityGroup = async (namespace) => {
   try {
-    return await localForage.getItem(`${namespace}:${OBSERVABILITY_GROUP_KEY}`) ?? void 0;
+    return await localForage.getItem(compositeKey(namespace, OBSERVABILITY_GROUP_KEY)) ?? void 0;
   } catch (err) {
     log.catch("Failed to get observability group", err, {
       F: __dxlog_file,
-      L: 42,
+      L: 49,
       S: void 0,
       C: (f, a) => f(...a)
     });
   }
 };
-var storeObservabilityGroup = async (namespace, value) => {
+var storeObservabilityGroup = async (namespace, value2) => {
   try {
-    await localForage.setItem(`${namespace}:${OBSERVABILITY_GROUP_KEY}`, value);
+    await localForage.setItem(compositeKey(namespace, OBSERVABILITY_GROUP_KEY), value2);
   } catch (err) {
     log.catch("Failed to store observability group", err, {
       F: __dxlog_file,
-      L: 50,
+      L: 60,
       S: void 0,
       C: (f, a) => f(...a)
     });
   }
 };
-var initializeAppObservability = async ({
-  namespace,
-  config,
-  // TODO(nf): Configure mode.
-  mode = "basic",
-  tracingEnable = false,
-  replayEnable = false
-}) => {
-  log("initializeAppObservability", {
-    config
-  }, {
-    F: __dxlog_file,
-    L: 74,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
-  const group = await getObservabilityGroup(namespace) ?? void 0;
-  const release = `${namespace}@${config.get("runtime.app.build.version")}`;
-  const environment = config.get("runtime.app.env.DX_ENVIRONMENT");
-  const { Observability: Observability2 } = await import("./observability-XK652NZG.mjs");
-  const observability = new Observability2({
-    namespace,
-    release,
-    environment,
-    group,
-    mode,
-    config,
-    errorLog: {
-      sentryInitOptions: {
-        environment,
-        release,
-        tracing: tracingEnable,
-        replay: replayEnable,
-        // TODO(wittjosiah): Configure these.
-        //   Consider using a sampling function to dynamically configure these values.
-        //   https://docs.sentry.io/platforms/javascript/configuration/sampling/#setting-a-sampling-function
-        sampleRate: 1,
-        replaySampleRate: 1,
-        replaySampleRateOnError: 1
-      }
+
+// 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 observabilityDisabled = await isObservabilityDisabled(namespace);
-  if (observabilityDisabled) {
-    observability.setMode("disabled");
-    log.info("observability disabled", void 0, {
-      F: __dxlog_file,
-      L: 114,
-      S: void 0,
-      C: (f, a) => f(...a)
+    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, {
+        F: __dxlog_file2,
+        L: 85,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      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;
     });
-    return observability;
   }
-  try {
-    const getIPData = async (config2) => {
-      const IP_DATA_CACHE_TIMEOUT = 6 * 60 * 60 * 1e3;
-      const cachedData = await localForage.getItem("dxos:observability:ipdata");
-      if (cachedData && cachedData.timestamp > Date.now() - IP_DATA_CACHE_TIMEOUT) {
-        return cachedData.data;
+  enable() {
+    return Effect.gen(this, function* () {
+      for (const extension of this._extensions) {
+        if (extension.enable) {
+          yield* extension.enable();
+        }
       }
-      const IPDATA_API_KEY = config2.get("runtime.app.env.DX_IPDATA_API_KEY");
-      if (IPDATA_API_KEY) {
-        return fetch(`https://api.ipdata.co?api-key=${IPDATA_API_KEY}`).then((res) => res.json()).then((data) => {
-          localForage.setItem("dxos:observability:ipdata", {
-            data,
-            timestamp: Date.now()
-          }).catch((err) => observability.captureException(err));
-          return data;
-        }).catch((err) => observability.captureException(err));
+    });
+  }
+  disable() {
+    return Effect.gen(this, function* () {
+      for (const extension of this._extensions) {
+        if (extension.disable) {
+          yield* extension.disable();
+        }
       }
-    };
-    await observability.initialize();
-    observability.startErrorLogs();
-    const ipData = await getIPData(config);
-    ipData && observability.setIPDataTelemetryTags(ipData);
-    if (typeof navigator !== "undefined" && navigator.storage?.estimate) {
-      setInterval(async () => {
-        try {
-          const storageEstimate = await navigator.storage.estimate();
-          storageEstimate.usage && observability.setTag("storageUsage", storageEstimate.usage.toString(), "telemetry");
-          storageEstimate.quota && observability.setTag("storageQuota", storageEstimate.quota.toString(), "telemetry");
-        } catch (error) {
-          log.warn("Failed to run estimate()", error, {
-            F: __dxlog_file,
-            L: 169,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
+    });
+  }
+  flush() {
+    return Effect.gen(this, function* () {
+      for (const extension of this._extensions) {
+        if (extension.flush) {
+          yield* extension.flush();
         }
-      }, 1e4);
-    }
-  } catch (err) {
-    log.error("Failed to initialize app observability", err, {
-      F: __dxlog_file,
-      L: 174,
-      S: void 0,
-      C: (f, a) => f(...a)
+      }
     });
   }
-  return observability;
-};
-
-// src/helpers/node-observability.ts
-import { existsSync, statSync } from "@dxos/node-std/fs";
-import { mkdir, readFile, writeFile } from "@dxos/node-std/fs/promises";
-import { join } from "@dxos/node-std/path";
-import yaml from "js-yaml";
-import { v4 as uuid, validate as validateUuid } from "uuid";
-import { log as log2 } from "@dxos/log";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/sdk/observability/src/helpers/node-observability.ts";
-var showObservabilityBanner = async (configDir, bannercb) => {
-  const path = join(configDir, ".observability-banner-printed");
-  if (existsSync(path)) {
-    return;
+  _addExtension(extension) {
+    invariant(!this._initialized, "Observability is already initialized", {
+      F: __dxlog_file2,
+      L: 142,
+      S: this,
+      A: [
+        "!this._initialized",
+        "'Observability is already initialized'"
+      ]
+    });
+    this._extensions.push(extension);
   }
-  bannercb(
-    // eslint-disable-next-line no-multi-str
-    "Basic observability data will be sent to the DXOS team in order to improve the product. This includes     performance metrics, error logs, and usage data. No personally identifiable information, other than your     public key, is included with this data and no private data ever leaves your devices. To disable sending     observability data, set the environment variable DX_DISABLE_OBSERVABILITY=true."
-  );
-  await writeFile(path, "", "utf-8");
-};
-var getObservabilityState = async (configDir) => {
-  if (existsSync(configDir)) {
-    if (!statSync(configDir).isDirectory()) {
-      throw new Error(`Config directory ${configDir} exists but is not a directory`);
-    }
-  } else {
-    await mkdir(configDir, {
-      recursive: true
+  _addDataProvider(dataProvider) {
+    invariant(!this._initialized, "Observability is already initialized", {
+      F: __dxlog_file2,
+      L: 147,
+      S: this,
+      A: [
+        "!this._initialized",
+        "'Observability is already initialized'"
+      ]
     });
+    this._dataProviders.push(dataProvider);
   }
-  const idPath = join(configDir, "observability.yml");
-  if (existsSync(idPath)) {
-    const context = await readFile(idPath, "utf-8");
-    return validate(context) ?? initializeState(idPath);
+  /**
+  * 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);
+      }
+    });
   }
-  return initializeState(idPath);
-};
-var initializeState = async (idPath) => {
-  const observabilityState = {
-    installationId: uuid(),
-    group: process.env.DX_OBSERVABILITY_GROUP ?? void 0,
-    mode: process.env.DX_DISABLE_OBSERVABILITY ? "disabled" : process.env.DX_OBSERVABILITY_MODE ?? "basic"
-  };
-  await writeFile(idPath, "# This file is automatically generated by the @dxos/cli.\n" + yaml.dump(observabilityState), "utf-8");
-  return observabilityState;
-};
-var validate = (contextString) => {
-  const context = yaml.load(contextString);
-  if (Boolean(context.installationId) && validateUuid(context.installationId)) {
+  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: (form) => {
+        for (const extension of this._getExtensions("feedback")) {
+          extension.captureUserFeedback(form);
+        }
+      }
+    };
+  }
+  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 {
-      ...context,
-      mode: process.env.DX_DISABLE_OBSERVABILITY ? "disabled" : context.mode ?? "basic"
+      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 initializeNodeObservability = async ({ namespace, version, config, installationId, group, mode = "basic", tracingEnable = true, replayEnable = true }) => {
-  log2("initializeCliObservability", {
-    config
-  }, {
+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, {
     F: __dxlog_file2,
-    L: 111,
-    S: void 0,
-    C: (f, a) => f(...a)
+    L: 276,
+    S: this,
+    A: [
+      "'_addExtension' in observability && typeof observability._addExtension === 'function'",
+      ""
+    ]
   });
-  const release = `${namespace}@${version}`;
-  const environment = process.env.DX_ENVIRONMENT ?? "unknown";
-  const observability = new Observability({
-    mode,
-    namespace,
-    release,
-    environment,
-    group,
-    errorLog: {
-      sentryInitOptions: {
-        environment,
-        release,
-        // TODO(wittjosiah): Configure this.
-        sampleRate: 1
+  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, {
+    F: __dxlog_file2,
+    L: 284,
+    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 { 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: "https://ingest.eu.signoz.cloud:443",
+  OTEL_HEADERS: "signoz-ingestion-key: 5300e0c9-a5e8-4a10-9c61-f473e539c0b7"
+};
+
+// 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-ATTRIUTL.mjs"));
+  const { OtelMetrics } = yield* Effect3.promise(() => import("./metrics-PKTV6IGF.mjs"));
+  const { OtelTraces } = yield* Effect3.promise(() => import("./traces-browser-PUNCJ5KV.mjs"));
+  const cachedDisabled = yield* Effect3.promise(() => isObservabilityDisabled(serviceName));
+  const enabledRef = yield* Ref.make(!cachedDisabled);
+  const tags = /* @__PURE__ */ new Map();
+  const endpoint = isNode() ? process.env.DX_OTEL_ENDPOINT ?? _endpoint ?? cli_observability_secrets_default.OTEL_ENDPOINT : config.values.runtime?.app?.env?.DX_OTEL_ENDPOINT;
+  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 || !headers) {
+    log3.info("Missing OTEL_ENDPOINT or OTEL_HEADERS", void 0, {
+      F: __dxlog_file3,
+      L: 77,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    return stubExtension;
+  }
+  const resource = defaultResource().merge(resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: serviceName,
+    [ATTR_SERVICE_VERSION]: serviceVersion,
+    "deployment.environment": environment
+  }));
+  const logs = logsEnabled ? new OtelLogs({
+    endpoint,
+    headers,
+    resource,
+    getTags: () => Object.fromEntries(tags),
+    logLevel
+  }) : void 0;
+  const metrics = metricsEnabled ? new OtelMetrics({
+    endpoint,
+    headers,
+    resource,
+    getTags: () => Object.fromEntries(tags)
+  }) : void 0;
+  const traces = tracesEnabled ? new OtelTraces({
+    endpoint,
+    headers,
+    resource,
+    getTags: () => Object.fromEntries(tags)
+  }) : void 0;
+  return {
+    initialize: () => Effect3.sync(() => {
+      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 () => {
+      await logs?.close();
+      await metrics?.close();
+    }),
+    flush: () => Effect3.promise(async () => {
+      await logs?.flush();
+      await metrics?.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)
+  };
+});
+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();
     }
-  });
-  observability.setTag("installationId", installationId);
-  const IPDATA_API_KEY = config.get("runtime.app.env.DX_IPDATA_API_KEY");
+    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 { LogBuffer, 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 res = await fetch(`https://api.ipdata.co/?api-key=${IPDATA_API_KEY}`);
-    const ipData = await res.json();
-    ipData && observability.setIPDataTelemetryTags(ipData);
+    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
+      }, {
+        F: __dxlog_file4,
+        L: 34,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      return void 0;
+    }
+    const { key } = await response.json();
+    return key;
   } catch (err) {
-    observability?.captureException(err);
+    log4.warn("feedback log upload error", {
+      error: err
+    }, {
+      F: __dxlog_file4,
+      L: 40,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return void 0;
   }
-  return observability;
 };
-
-// src/helpers/setup-telemetry-listeners.ts
-var lastFocusEvent = /* @__PURE__ */ new Date();
-var totalTime = 0;
-var setupTelemetryListeners = (namespace, client, observability) => {
-  const clickCallback = (event) => {
-    const id = event.target?.id;
-    if (!id) {
-      return;
+var extensions2 = Effect4.fn(function* ({ config, release, environment, posthog: posthogConfig, logBuffer: externalLogBuffer }) {
+  if (typeof window === "undefined") {
+    log4("PostHog is being stubbed because it is running in a worker.", void 0, {
+      F: __dxlog_file4,
+      L: 54,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    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, {
+      F: __dxlog_file4,
+      L: 62,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    return stubExtension;
+  }
+  const { default: posthog } = yield* Effect4.promise(() => import("posthog-js"));
+  const { logProcessor } = yield* Effect4.promise(() => import("./log-processor-FDLTDQEM.mjs"));
+  const logBuffer = externalLogBuffer ?? new LogBuffer();
+  let feedbackSurveyAvailable = null;
+  const checkFeedbackSurveyAvailable = () => feedbackSurveyId ? Effect4.promise(() => {
+    if (feedbackSurveyAvailable !== null) {
+      return Promise.resolve(feedbackSurveyAvailable);
     }
-    setTimeout(() => {
-      observability.track({
-        ...getTelemetryIdentity(client),
-        action: "window.click",
-        properties: {
-          id: event.target?.id,
-          path: event.composedPath().filter((el) => Boolean(el.tagName)).map((el) => `${el.tagName.toLowerCase()}${el.id ? `#${el.id}` : ""}`).reverse().join(">")
-        }
+    return new Promise((resolve) => {
+      posthog.getSurveys((surveys) => {
+        const found = surveys.some((s) => s.id === feedbackSurveyId);
+        feedbackSurveyAvailable = found;
+        resolve(found);
       });
     });
-  };
-  const focusCallback = () => {
-    const now = /* @__PURE__ */ new Date();
-    setTimeout(() => {
-      observability.track({
-        ...getTelemetryIdentity(client),
-        action: "window.focus",
-        properties: {
-          timeAway: now.getTime() - lastFocusEvent.getTime()
-        }
+  }) : Effect4.succeed(false);
+  return {
+    initialize: () => Effect4.sync(() => {
+      posthog.init(apiKey, {
+        api_host,
+        mask_all_text: true,
+        capture_exceptions: true,
+        ...posthogConfig
       });
-    });
-    lastFocusEvent = now;
-  };
-  const blurCallback = () => {
-    const now = /* @__PURE__ */ new Date();
-    const duration = now.getTime() - lastFocusEvent.getTime();
-    setTimeout(() => {
-      observability.track({
-        ...getTelemetryIdentity(client),
-        action: "window.blur",
-        properties: {
-          duration
+      if (release || environment) {
+        posthog.register({
+          ...release ? {
+            release
+          } : {},
+          ...environment ? {
+            environment
+          } : {}
+        });
+      }
+      log4.runtimeConfig.processors.push(logProcessor);
+      log4.runtimeConfig.processors.push(logBuffer.logProcessor);
+    }),
+    close: () => Effect4.sync(() => {
+      for (const processor of [
+        logProcessor,
+        logBuffer.logProcessor
+      ]) {
+        const index = log4.runtimeConfig.processors.indexOf(processor);
+        if (index !== -1) {
+          log4.runtimeConfig.processors.splice(index, 1);
         }
+      }
+    }),
+    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) => {
+          posthog.getSurveys(async (surveys) => {
+            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
+              }, {
+                F: __dxlog_file4,
+                L: 151,
+                S: this,
+                C: (f, a) => f(...a)
+              });
+              return;
+            }
+            let debugLogDumpKey = null;
+            if (form.includeLogs !== false && logBuffer.size > 0) {
+              debugLogDumpKey = await uploadLogs(logBuffer.serialize()) ?? "failed";
+            }
+            const question = survey.questions[0];
+            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
+            });
+          });
+        },
+        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, {
+    F: __dxlog_file5,
+    L: 61
+  });
+  let lastNetworkStatus;
+  const updateSignalMetrics = new Event().debounce(NETWORK_METRICS_MIN_INTERVAL);
+  updateSignalMetrics.on(ctx, async () => {
+    log5("send signal metrics", void 0, {
+      F: __dxlog_file5,
+      L: 67,
+      S: this,
+      C: (f, a) => f(...a)
     });
-    lastFocusEvent = now;
-    totalTime = totalTime + duration;
-  };
-  const unloadCallback = () => {
-    setTimeout(() => {
-      observability.track({
-        ...getTelemetryIdentity(client),
-        action: "page.unload",
-        properties: {
-          duration: totalTime
-        }
+    lastNetworkStatus?.signaling?.forEach(({ server, state }) => {
+      observability.metrics.gauge("dxos.client.network.signal.connectionState", state, {
+        server
       });
     });
-  };
-  const errorCallback = (event) => {
-    setTimeout(() => {
-      observability.track({
-        ...getTelemetryIdentity(client),
-        action: "window.error",
-        properties: {
-          message: event.message,
-          filename: event.filename,
-          stack: event.error?.stack,
-          cause: event.error?.cause
+    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, {
+    F: __dxlog_file5,
+    L: 121
+  });
+  const platform = yield* Effect5.promise(() => clientServices.SystemService.getPlatform());
+  invariant2(platform, "platform is required", {
+    F: __dxlog_file5,
+    L: 123,
+    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
+    }, {
+      F: __dxlog_file5,
+      L: 152,
+      S: this,
+      C: (f, a) => f(...a)
+    }));
+  }, RUNTIME_METRICS_MIN_INTERVAL);
+  return async () => {
+    await ctx.dispose();
   };
-  window.addEventListener("click", clickCallback, true);
-  window.addEventListener("focus", focusCallback);
-  window.addEventListener("blur", blurCallback);
-  window.addEventListener("beforeunload", unloadCallback);
-  window.addEventListener("error", errorCallback);
-  return () => {
-    window.removeEventListener("click", clickCallback, true);
-    window.removeEventListener("focus", focusCallback);
-    window.removeEventListener("blur", blurCallback);
-    window.removeEventListener("beforeunload", unloadCallback);
-    window.removeEventListener("error", errorCallback);
+});
+var spacesMetricsProvider = (client) => Effect5.fn(function* (observability) {
+  const ctx = new Context(void 0, {
+    F: __dxlog_file5,
+    L: 165
+  });
+  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, {
+      F: __dxlog_file5,
+      L: 173,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    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.coreDatabase.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.String,
+  region: Schema.String,
+  country: Schema.String,
+  latitude: Schema.optional(Schema.Number),
+  longitude: Schema.optional(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"));
+  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) {
+    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)));
+    yield* Effect6.promise(() => localForage2.setItem("dxos:observability:ipdata", {
+      data,
+      timestamp: Date.now()
+    }));
+    return data;
+  }
+});
+var provider = (config) => (observability) => Effect6.gen(function* () {
+  const ipData = yield* getIPData(config);
+  if (!ipData) {
+    return;
+  }
+  observability.setTags({
+    city: ipData.city,
+    region: ipData.region,
+    country: ipData.country,
+    latitude: ipData.latitude,
+    longitude: ipData.longitude
+  });
+}).pipe(Effect6.provide(FetchHttpClient.layer), Effect6.catchAll((err) => Effect6.sync(() => {
+  log6.verbose("ipdata fetch failed", {
+    err
+  }, {
+    F: __dxlog_file6,
+    L: 88,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+})));
+
+// 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