@dxos/observability 0.8.4-main.fffef41 → 0.9.0

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

@@ -1,39 +1,1021 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
-  OBSERVABILITY_DISABLED_KEY,
-  OBSERVABILITY_GROUP_KEY,
-  Observability,
-  getObservabilityGroup,
-  getObservabilityState,
-  getTelemetryIdentifier,
-  getTelemetryIdentity,
-  initializeAppObservability,
-  initializeNodeObservability,
-  isObservabilityDisabled,
-  mapSpaces,
-  setupTelemetryListeners,
-  showObservabilityBanner,
-  storeObservabilityDisabled,
-  storeObservabilityGroup
-} from "./chunk-MTKIPRBH.mjs";
-import "./chunk-OJV247NY.mjs";
-import "./chunk-QUZL7LKE.mjs";
-import "./chunk-QK5IUYVA.mjs";
+  __export
+} from "./chunk-HSLMI22Q.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 } from "@dxos/log";
+
+// 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 { v4 as uuid, validate as validateUuid } from "uuid";
+var showObservabilityBanner = async (configDir, bannercb) => {
+  const path = join(configDir, ".observability-banner-printed");
+  if (existsSync(path)) {
+    return;
+  }
+  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()) {
+      throw new Error(`Config directory ${configDir} exists but is not a directory`);
+    }
+  } else {
+    await mkdir(configDir, {
+      recursive: true
+    });
+  }
+  const idPath = join(configDir, "observability.yml");
+  if (existsSync(idPath)) {
+    const context = await readFile(idPath, "utf-8");
+    return validate(context) ?? initializeState(idPath);
+  }
+  return initializeState(idPath);
+};
+var initializeState = async (idPath) => {
+  const observabilityState = {
+    installationId: uuid(),
+    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;
+};
+var getOtelLogLevel = async (_namespace) => null;
+var storeOtelLogLevel = async (_namespace, _value) => {
+};
+var validate = (contextString) => {
+  const context = yaml.load(contextString);
+  if (Boolean(context.installationId) && validateUuid(context.installationId)) {
+    return {
+      ...context,
+      disabled: process.env.DX_DISABLE_OBSERVABILITY ? true : context.disabled ?? false
+    };
+  }
+};
+
+// 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, { "~LogMeta": "~LogMeta", F: __dxlog_file, 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_file, 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_file, 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_file, 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_file, 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 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: "/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_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-ARJUVN3T.mjs"));
+  const { OtelMetrics } = yield* Effect3.promise(() => import("./metrics-DREJOOAC.mjs"));
+  const { OtelTraces } = yield* Effect3.promise(() => import("./traces-74F7JUKF.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) {
+    log2.info("Missing OTEL_ENDPOINT", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, 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) {
+        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 () => {
+      const results = await Promise.allSettled([
+        logs?.close(),
+        metrics?.close()
+      ]);
+      for (const result of results) {
+        if (result.status === "rejected") {
+          log2.catch(result.reason, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, 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") {
+          log2.catch(result.reason, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, 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 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
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 17, S: void 0 });
+      return void 0;
+    }
+    const { key } = await response.json();
+    return key;
+  } catch (err) {
+    log3.warn("feedback log upload error", {
+      error: err
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 25, S: void 0 });
+    return void 0;
+  }
+};
+var extensions2 = Effect4.fn(function* ({ config, release, environment, posthog: posthogConfig, logStore, feedbackLogMaxSize }) {
+  if (typeof window === "undefined") {
+    log3("PostHog is being stubbed because it is running in a worker.", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, 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) {
+    log3.info("Missing POSTHOG_API_KEY or POSTHOG_API_HOST", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 40, S: this });
+    return stubExtension;
+  }
+  const { default: posthog } = yield* Effect4.promise(() => import("posthog-js"));
+  const { logProcessor } = yield* Effect4.promise(() => import("./log-processor-GA24XTJF.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 = log3.addProcessor(logProcessor, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, 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) {
+                    log3.error("Missing feedback survey or survey has no questions", {
+                      feedbackSurveyId
+                    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, 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) {
+                  log3.error("Failed to capture user feedback", {
+                    err
+                  }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, 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 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, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 50 });
+  let lastNetworkStatus;
+  const updateSignalMetrics = new Event().debounce(NETWORK_METRICS_MIN_INTERVAL);
+  updateSignalMetrics.on(ctx, async () => {
+    log4("send signal metrics", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, 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_file4, L: 100 });
+  log4("runtimeMetricsProvider: requesting platform from SystemService", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 101, S: this });
+  const platform = yield* Effect5.promise(() => clientServices.SystemService.getPlatform());
+  log4("runtimeMetricsProvider: platform received", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 103, S: this });
+  invariant2(platform, "platform is required", { "~LogMeta": "~LogMeta", F: __dxlog_file4, 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) => log4("platform error", {
+      error
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, 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_file4, 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 () => {
+    log4("send space metrics", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, 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 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.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(() => localForage.getItem("dxos:observability:ipdata:v2"));
+  if (cachedData && cachedData.timestamp > Date.now() - IP_DATA_CACHE_TIMEOUT) {
+    return cachedData.data;
+  }
+  const IPDATA_API_KEY = config.get("runtime.app.env.DX_IPDATA_API_KEY");
+  if (!IPDATA_API_KEY) {
+    log5.warn("DX_IPDATA_API_KEY is not configured; IP geolocation tags will be absent from telemetry", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file5, 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(() => {
+      log5.warn("ipdata fetch failed; IP geolocation tags will be absent or stale", {
+        err
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 40, S: this });
+      return cachedData?.data;
+    }))
+  );
+  if (data) {
+    yield* Effect6.promise(() => localForage.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(() => {
+  log5.warn("ipdata provider failed", {
+    err
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, 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