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

package/dist/lib/browser/index.mjs

@@ -1,38 +1,1008 @@
 import {
-  OBSERVABILITY_DISABLED_KEY,
-  OBSERVABILITY_GROUP_KEY,
-  Observability,
-  getObservabilityGroup,
-  getObservabilityState,
-  getTelemetryIdentifier,
-  getTelemetryIdentity,
-  initializeAppObservability,
-  initializeNodeObservability,
-  isObservabilityDisabled,
-  mapSpaces,
-  setupTelemetryListeners,
-  showObservabilityBanner,
-  storeObservabilityDisabled,
-  storeObservabilityGroup
-} from "./chunk-UG3VTDOH.mjs";
-import "./chunk-MWTIKIBZ.mjs";
-import "./chunk-5ICT2XF2.mjs";
-import "./chunk-YEPQFAES.mjs";
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// 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";
+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(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: 26,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return true;
+  }
+};
+var storeObservabilityDisabled = async (namespace, value2) => {
+  try {
+    await localForage.setItem(compositeKey(namespace, OBSERVABILITY_DISABLED_KEY), String(value2));
+  } catch (err) {
+    log.catch("Failed to store observability disabled", err, {
+      F: __dxlog_file,
+      L: 38,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  }
+};
+var getObservabilityGroup = async (namespace) => {
+  try {
+    return await localForage.getItem(compositeKey(namespace, OBSERVABILITY_GROUP_KEY)) ?? void 0;
+  } catch (err) {
+    log.catch("Failed to get observability group", err, {
+      F: __dxlog_file,
+      L: 49,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  }
+};
+var storeObservabilityGroup = async (namespace, value2) => {
+  try {
+    await localForage.setItem(compositeKey(namespace, OBSERVABILITY_GROUP_KEY), value2);
+  } catch (err) {
+    log.catch("Failed to store observability group", err, {
+      F: __dxlog_file,
+      L: 60,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  }
+};
+
+// src/observability.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/sdk/observability/src/observability.ts";
+var ObservabilityImpl = class {
+  _initialized = false;
+  _extensions = [];
+  _dataProviders = [];
+  _subscriptions = new SubscriptionList();
+  initialize() {
+    if (this._initialized) {
+      return Effect.succeed(void 0);
+    }
+    const initializedExtensions = [];
+    return Effect.gen(this, function* () {
+      for (const extension of this._extensions) {
+        if (extension.initialize) {
+          yield* extension.initialize();
+        }
+        initializedExtensions.push(extension);
+      }
+      const cleanups = yield* Effect.all(this._dataProviders.map((provider3) => provider3(this)));
+      this._subscriptions.add(...cleanups.filter((cleanup) => cleanup !== void 0));
+      this._initialized = true;
+    }).pipe(Effect.catchAll((error) => Effect.gen(this, function* () {
+      log2.catch(error, void 0, {
+        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;
+    });
+  }
+  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_file2,
+      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_file2,
+      L: 147,
+      S: this,
+      A: [
+        "!this._initialized",
+        "'Observability is already initialized'"
+      ]
+    });
+    this._dataProviders.push(dataProvider);
+  }
+  /**
+  * Adds a data provider and initializes it.
+  */
+  addDataProvider(dataProvider) {
+    return Effect.gen(this, function* () {
+      this._dataProviders.push(dataProvider);
+      const cleanup = yield* dataProvider(this);
+      if (cleanup) {
+        this._subscriptions.add(cleanup);
+      }
+    });
+  }
+  identify(distinctId, attributes, setOnceAttributes) {
+    for (const extension of this._extensions) {
+      extension.identify?.(distinctId, attributes, setOnceAttributes);
+    }
+  }
+  alias(distinctId, previousId) {
+    for (const extension of this._extensions) {
+      extension.alias?.(distinctId, previousId);
+    }
+  }
+  setTags(tags, kind) {
+    for (const extension of this._extensions) {
+      if (kind && !extension.apis.some((api) => api.kind === kind)) {
+        continue;
+      }
+      const processedTags = Object.fromEntries(Object.entries(tags).filter((entry) => entry[1] !== void 0).map(([key, 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_file2,
+    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_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();
+    }
+    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 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) {
+    log4.warn("feedback log upload error", {
+      error: err
+    }, {
+      F: __dxlog_file4,
+      L: 40,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return void 0;
+  }
+};
+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);
+    }
+    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
+          } : {}
+        });
+      }
+      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)
+    });
+    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, {
+    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();
+  };
+});
+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