@dxos/observability 0.8.4-main.9735255 → 0.8.4-main.9be5663bfe

package/dist/lib/node-esm/index.mjs

@@ -1,192 +1,60 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
-  Observability,
-  getTelemetryIdentifier,
-  getTelemetryIdentity,
-  mapSpaces
-} from "./chunk-KKNY7TRV.mjs";
-import "./chunk-KLJGCUYA.mjs";
-import "./chunk-KVJTNW3F.mjs";
-import "./chunk-UIVXGEGJ.mjs";
-import "./chunk-QUZL7LKE.mjs";
-import "./chunk-M4627SMT.mjs";
+  __export
+} from "./chunk-HSLMI22Q.mjs";
 
-// src/helpers/browser-observability.ts
-import * as localForage from "localforage";
+// 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 } from "@dxos/log";
-var __dxlog_file = "/__w/dxos/dxos/packages/sdk/observability/src/helpers/browser-observability.ts";
-var OBSERVABILITY_DISABLED_KEY = "observability-disabled";
-var OBSERVABILITY_GROUP_KEY = "observability-group";
-var isObservabilityDisabled = async (namespace) => {
-  try {
-    return await localForage.getItem(`${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,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    return true;
-  }
-};
-var storeObservabilityDisabled = async (namespace, value) => {
-  try {
-    await localForage.setItem(`${namespace}:${OBSERVABILITY_DISABLED_KEY}`, String(value));
-  } catch (err) {
-    log.catch("Failed to store observability disabled", err, {
-      F: __dxlog_file,
-      L: 34,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-  }
-};
-var getObservabilityGroup = async (namespace) => {
-  try {
-    return await localForage.getItem(`${namespace}:${OBSERVABILITY_GROUP_KEY}`) ?? void 0;
-  } catch (err) {
-    log.catch("Failed to get observability group", err, {
-      F: __dxlog_file,
-      L: 42,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-  }
-};
-var storeObservabilityGroup = async (namespace, value) => {
-  try {
-    await localForage.setItem(`${namespace}:${OBSERVABILITY_GROUP_KEY}`, value);
-  } catch (err) {
-    log.catch("Failed to store observability group", err, {
-      F: __dxlog_file,
-      L: 50,
-      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-CXQ3CZGB.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
-      }
-    }
-  });
-  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)
-    });
-    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;
-      }
-      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));
-      }
-    };
-    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)
-          });
-        }
-      }, 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
+// src/storage/node.ts
+import yaml from "js-yaml";
 import { existsSync, statSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node: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;
   }
-  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."
-  );
+  bannercb("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 isObservabilityDisabled = async (configDir) => {
+  const observabilityState = await getObservabilityState(configDir);
+  return observabilityState.disabled;
+};
+var storeObservabilityDisabled = async (configDir, value2) => {
+  const observabilityState = await getObservabilityState(configDir);
+  observabilityState.disabled = value2;
+  await writeFile(join(configDir, "observability.yml"), yaml.dump(observabilityState), "utf-8");
+};
+var getObservabilityGroup = async (configDir) => {
+  const observabilityState = await getObservabilityState(configDir);
+  return observabilityState.group;
+};
+var storeObservabilityGroup = async (configDir, value2) => {
+  const observabilityState = await getObservabilityState(configDir);
+  observabilityState.group = value2;
+  await writeFile(join(configDir, "observability.yml"), yaml.dump(observabilityState), "utf-8");
+};
 var getObservabilityState = async (configDir) => {
   if (existsSync(configDir)) {
     if (!statSync(configDir).isDirectory()) {
@@ -207,8 +75,8 @@ var getObservabilityState = async (configDir) => {
 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"
+    disabled: process.env.DX_DISABLE_OBSERVABILITY ? true : false,
+    group: process.env.DX_OBSERVABILITY_GROUP ?? void 0
   };
   await writeFile(idPath, "# This file is automatically generated by the @dxos/cli.\n" + yaml.dump(observabilityState), "utf-8");
   return observabilityState;
@@ -218,149 +86,936 @@ var validate = (contextString) => {
   if (Boolean(context.installationId) && validateUuid(context.installationId)) {
     return {
       ...context,
-      mode: process.env.DX_DISABLE_OBSERVABILITY ? "disabled" : context.mode ?? "basic"
+      disabled: process.env.DX_DISABLE_OBSERVABILITY ? true : context.disabled ?? false
     };
   }
 };
-var initializeNodeObservability = async ({ namespace, version, config, installationId, group, mode = "basic", tracingEnable = true, replayEnable = true }) => {
-  log2("initializeCliObservability", {
-    config
-  }, {
-    F: __dxlog_file2,
-    L: 111,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
-  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
+
+// src/observability.ts
+var __dxlog_file = "/__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* () {
+      log.catch(error, void 0, {
+        F: __dxlog_file,
+        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;
+    });
+  }
+  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", {
+      F: __dxlog_file,
+      L: 142,
+      S: this,
+      A: [
+        "!this._initialized",
+        "'Observability is already initialized'"
+      ]
+    });
+    this._extensions.push(extension);
+  }
+  _addDataProvider(dataProvider) {
+    invariant(!this._initialized, "Observability is already initialized", {
+      F: __dxlog_file,
+      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);
     }
-  });
-  observability.setTag("installationId", installationId);
-  const IPDATA_API_KEY = config.get("runtime.app.env.DX_IPDATA_API_KEY");
-  try {
-    const res = await fetch(`https://api.ipdata.co/?api-key=${IPDATA_API_KEY}`);
-    const ipData = await res.json();
-    ipData && observability.setIPDataTelemetryTags(ipData);
-  } catch (err) {
-    observability?.captureException(err);
   }
+  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 {
+      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, {
+    F: __dxlog_file,
+    L: 276,
+    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, {
+    F: __dxlog_file,
+    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 log2 } 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/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;
+// 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_file2 = "/__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-7J45KLM7.mjs"));
+  const { OtelMetrics } = yield* Effect3.promise(() => import("./metrics-H7DDLYSG.mjs"));
+  const { OtelTraces } = yield* Effect3.promise(() => import("./traces-KMTHMYFX.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) {
+    log2.info("Missing OTEL_ENDPOINT or OTEL_HEADERS", void 0, {
+      F: __dxlog_file2,
+      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) {
+        log2.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();
     }
-    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 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 log3 } from "@dxos/log";
+var __dxlog_file3 = "/__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) {
+      log3.warn("feedback log upload failed", {
+        status: response.status
+      }, {
+        F: __dxlog_file3,
+        L: 34,
+        S: void 0,
+        C: (f, a) => f(...a)
       });
+      return void 0;
+    }
+    const { key } = await response.json();
+    return key;
+  } catch (err) {
+    log3.warn("feedback log upload error", {
+      error: err
+    }, {
+      F: __dxlog_file3,
+      L: 40,
+      S: void 0,
+      C: (f, a) => f(...a)
     });
-  };
-  const focusCallback = () => {
-    const now = /* @__PURE__ */ new Date();
-    setTimeout(() => {
-      observability.track({
-        ...getTelemetryIdentity(client),
-        action: "window.focus",
-        properties: {
-          timeAway: now.getTime() - lastFocusEvent.getTime()
-        }
+    return void 0;
+  }
+};
+var extensions2 = Effect4.fn(function* ({ config, release, environment, posthog: posthogConfig, logBuffer: externalLogBuffer }) {
+  if (typeof window === "undefined") {
+    log3("PostHog is being stubbed because it is running in a worker.", void 0, {
+      F: __dxlog_file3,
+      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) {
+    log3.info("Missing POSTHOG_API_KEY or POSTHOG_API_HOST", void 0, {
+      F: __dxlog_file3,
+      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-TKJVJJSJ.mjs"));
+  const logBuffer = externalLogBuffer ?? new LogBuffer();
+  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);
       });
     });
-    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
+  }) : 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 = log3.addProcessor(logProcessor, void 0, {
+        F: __dxlog_file3,
+        L: 105,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const removeLogBuffer = log3.addProcessor(logBuffer.logProcessor, void 0, {
+        F: __dxlog_file3,
+        L: 106,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      unregisterPosthogProcessors = () => {
+        removePosthogLog();
+        removeLogBuffer();
+      };
+    }),
+    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) => {
+          posthog.getSurveys(async (surveys) => {
+            const survey = surveys.find((survey2) => survey2.id === feedbackSurveyId);
+            if (!survey || survey.questions.length === 0) {
+              log3.error("Missing feedback survey or survey has no questions", {
+                feedbackSurveyId
+              }, {
+                F: __dxlog_file3,
+                L: 153,
+                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 log4 } from "@dxos/log";
+import { ConnectionState, Platform } from "@dxos/protocols/proto/dxos/client/services";
+var __dxlog_file4 = "/__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_file4,
+    L: 61
+  });
+  let lastNetworkStatus;
+  const updateSignalMetrics = new Event().debounce(NETWORK_METRICS_MIN_INTERVAL);
+  updateSignalMetrics.on(ctx, async () => {
+    log4("send signal metrics", void 0, {
+      F: __dxlog_file4,
+      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();
   };
-  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 runtimeMetricsProvider = (clientServices) => Effect5.fn(function* (observability) {
+  const ctx = new Context(void 0, {
+    F: __dxlog_file4,
+    L: 121
+  });
+  const platform = yield* Effect5.promise(() => clientServices.SystemService.getPlatform());
+  invariant2(platform, "platform is required", {
+    F: __dxlog_file4,
+    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) => log4("platform error", {
+      error
+    }, {
+      F: __dxlog_file4,
+      L: 152,
+      S: this,
+      C: (f, a) => f(...a)
+    }));
+  }, RUNTIME_METRICS_MIN_INTERVAL);
+  return async () => {
+    await ctx.dispose();
   };
+});
+var spacesMetricsProvider = (client) => Effect5.fn(function* (observability) {
+  const ctx = new Context(void 0, {
+    F: __dxlog_file4,
+    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 () => {
+    log4("send space metrics", void 0, {
+      F: __dxlog_file4,
+      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 localForage from "localforage";
+import { log as log5 } from "@dxos/log";
+var __dxlog_file5 = "/__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(() => localForage.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(() => localForage.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(() => {
+  log5.verbose("ipdata fetch failed", {
+    err
+  }, {
+    F: __dxlog_file5,
+    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