@dxos/observability 0.3.11-main.e19f39d → 0.3.11-main.e28df4f

package/dist/lib/browser/chunk-STWCJK52.mjs

@@ -0,0 +1,748 @@
+import {
+  DatadogMetrics
+} from "./chunk-2J5YS65Q.mjs";
+import {
+  SegmentTelemetry
+} from "./chunk-ROSK6U3K.mjs";
+import {
+  captureException,
+  configureTracing,
+  enableSentryLogProcessor,
+  init,
+  setTag
+} from "./chunk-6KUJPLEH.mjs";
+
+// packages/sdk/observability/src/observability.ts
+import { Event, scheduleTaskInterval } from "@dxos/async";
+import { Context } from "@dxos/context";
+import { invariant } from "@dxos/invariant";
+import { log as log2 } from "@dxos/log";
+import { ConnectionState } from "@dxos/network-manager";
+import { DeviceKind, Platform } from "@dxos/protocols/proto/dxos/client/services";
+import { isNode } from "@dxos/util";
+
+// packages/sdk/observability/src/cli-observability-secrets.json
+var cli_observability_secrets_default = {
+  SENTRY_DESTINATION: "https://2647916221e643869965e78469479aa4@o4504012000067584.ingest.sentry.io/4504012027265029",
+  TELEMETRY_API_KEY: "B00QG6PtJJrJ0VVFe0H5a6bcUUShKyZM",
+  IPDATA_API_KEY: "73dfdecdf979c18f07d50cf841bbdd9e589f237256326ac8cca23786",
+  DATADOG_API_KEY: null,
+  DATADOG_APP_KEY: null
+};
+
+// packages/sdk/observability/src/helpers/app-observability.ts
+import * as localForage from "localforage";
+import { log } from "@dxos/log";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/sdk/observability/src/helpers/app-observability.ts";
+var BASE_TELEMETRY_PROPERTIES = {};
+var OBSERVABILITY_DISABLED_KEY = "telemetry-disabled";
+var OBSERVABILITY_GROUP_KEY = "telemetry-group";
+if (typeof navigator !== "undefined" && navigator.storage?.estimate) {
+  setInterval(async () => {
+    try {
+      const storageEstimate = await navigator.storage.estimate();
+      BASE_TELEMETRY_PROPERTIES.storageUsage = storageEstimate.usage;
+      BASE_TELEMETRY_PROPERTIES.storageQuota = storageEstimate.quota;
+    } catch (error) {
+      log.warn("Failed to run estimate()", error, {
+        F: __dxlog_file,
+        L: 27,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+    }
+  }, 1e4);
+}
+var getTelemetryIdentifier = (client) => {
+  if (!client?.initialized) {
+    return void 0;
+  }
+  const identity = client.halo.identity.get();
+  if (identity) {
+    return identity.identityKey.truncate();
+  }
+  return void 0;
+};
+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: 54,
+      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: 63,
+      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: 71,
+      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: 79,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  }
+};
+var initializeAppObservability = async ({ namespace, config, mode = "basic", tracingEnable = true, replayEnable = true }) => {
+  log("initializeAppObservability", {
+    config
+  }, {
+    F: __dxlog_file,
+    L: 104,
+    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");
+  BASE_TELEMETRY_PROPERTIES.group = group;
+  BASE_TELEMETRY_PROPERTIES.release = release;
+  BASE_TELEMETRY_PROPERTIES.environment = environment;
+  const observabilityDisabled = await isObservabilityDisabled(namespace);
+  const { Observability: Observability2 } = await import("./observability-XIDFB6PJ.mjs");
+  const observability = new Observability2({
+    namespace,
+    group,
+    mode,
+    config,
+    errorLog: {
+      sentryInitOptions: {
+        environment,
+        release,
+        tracing: tracingEnable,
+        replay: replayEnable,
+        // TODO(wittjosiah): Configure these.
+        sampleRate: 1,
+        replaySampleRate: 0.1,
+        replaySampleRateOnError: 1
+      }
+    }
+  });
+  if (observabilityDisabled) {
+    observability.setMode("disabled");
+    log.info("observability disabled", void 0, {
+      F: __dxlog_file,
+      L: 147,
+      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:telemetry: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:telemetry:ipdata", {
+            data,
+            timestamp: Date.now()
+          }).catch((err) => observability.captureException(err));
+          return data;
+        }).catch((err) => observability.captureException(err));
+      }
+    };
+    const ipData = await getIPData(config);
+    if (ipData && ipData.city) {
+      BASE_TELEMETRY_PROPERTIES.city = ipData.city;
+      BASE_TELEMETRY_PROPERTIES.region = ipData.region;
+      BASE_TELEMETRY_PROPERTIES.country = ipData.country;
+      BASE_TELEMETRY_PROPERTIES.latitude = ipData.latitude;
+      BASE_TELEMETRY_PROPERTIES.longitude = ipData.longitude;
+    }
+    observability.initialize();
+  } catch (err) {
+    log.error("Failed to initialize app observability", err, {
+      F: __dxlog_file,
+      L: 201,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  }
+  return observability;
+};
+
+// packages/sdk/observability/src/helpers/map-spaces.ts
+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.db.query().objects.length,
+      startup,
+      epoch,
+      // appliedEpoch,
+      startDataMutations,
+      currentDataMutations,
+      totalDataMutations,
+      // TODO(burdon): Negative?
+      progress: (Math.min(Math.abs((currentDataMutations - startDataMutations) / (totalDataMutations - startDataMutations)), 1) * 100).toFixed(0)
+    };
+  });
+};
+
+// packages/sdk/observability/src/helpers/setup-telemetry-listeners.ts
+var lastFocusEvent = /* @__PURE__ */ new Date();
+var totalTime = 0;
+var setupTelemetryListeners = (namespace, client, observability) => {
+  const clickCallback = (event) => {
+    if (BASE_TELEMETRY_PROPERTIES.group === "dxos" && event.target && !event.target.id) {
+      console.warn("Click event on element without id:", event.target);
+    }
+    setTimeout(() => observability.event({
+      identityId: getTelemetryIdentifier(client),
+      name: `${namespace}.window.click`,
+      properties: {
+        ...BASE_TELEMETRY_PROPERTIES,
+        href: window.location.href,
+        id: event.target?.id,
+        path: event.path?.filter((el) => Boolean(el.tagName)).map((el) => `${el.tagName.toLowerCase()}${el.id ? `#${el.id}` : ""}`).reverse().join(">")
+      }
+    }));
+  };
+  const focusCallback = () => {
+    const now = /* @__PURE__ */ new Date();
+    setTimeout(() => observability.event({
+      identityId: getTelemetryIdentifier(client),
+      name: `${namespace}.window.focus`,
+      properties: {
+        ...BASE_TELEMETRY_PROPERTIES,
+        href: window.location.href,
+        timeAway: now.getTime() - lastFocusEvent.getTime()
+      }
+    }));
+    lastFocusEvent = now;
+  };
+  const blurCallback = () => {
+    const now = /* @__PURE__ */ new Date();
+    const timeSpent = now.getTime() - lastFocusEvent.getTime();
+    setTimeout(() => observability.event({
+      identityId: getTelemetryIdentifier(client),
+      name: `${namespace}.window.blur`,
+      properties: {
+        ...BASE_TELEMETRY_PROPERTIES,
+        href: window.location.href,
+        timeSpent
+      }
+    }));
+    lastFocusEvent = now;
+    totalTime = totalTime + timeSpent;
+  };
+  const unloadCallback = () => {
+    setTimeout(() => observability.event({
+      identityId: getTelemetryIdentifier(client),
+      name: `${namespace}.page.unload`,
+      properties: {
+        ...BASE_TELEMETRY_PROPERTIES,
+        href: window.location.href,
+        timeSpent: totalTime
+      }
+    }));
+  };
+  const errorCallback = (event) => {
+    setTimeout(() => observability.event({
+      identityId: getTelemetryIdentifier(client),
+      name: `${namespace}.window.error`,
+      properties: {
+        ...BASE_TELEMETRY_PROPERTIES,
+        href: window.location.href,
+        message: event.message,
+        filename: event.filename,
+        stack: event.error.stack
+      }
+    }));
+  };
+  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);
+  };
+};
+
+// packages/sdk/observability/src/observability.ts
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/sdk/observability/src/observability.ts";
+var SPACE_METRICS_MIN_INTERVAL = 1e3 * 60;
+var DATADOG_IDLE_INTERVAL = 1e3 * 60 * 1;
+var ERROR_TAGS = [
+  "identityKey",
+  "username",
+  "deviceKey",
+  "group"
+];
+var Observability = class {
+  // TODO(nf): make platform a required extension?
+  constructor({ namespace, config, secrets, group, mode, telemetry, errorLog }) {
+    this._mode = "disabled";
+    // TODO(nf): accept upstream context?
+    this._ctx = new Context();
+    this._tags = /* @__PURE__ */ new Map();
+    this._namespace = namespace;
+    this._config = config;
+    this._mode = mode ?? "disabled";
+    this._group = group;
+    this._secrets = this._loadSecrets(config, secrets);
+    this._telemetryBatchSize = telemetry?.batchSize ?? 30;
+    this._errorReportingOptions = errorLog?.sentryInitOptions;
+    this._errorLogProcessor = errorLog?.logProcessor ?? false;
+    if (this._group) {
+      this.setTag("group", this._group);
+    }
+    this.setTag("namespace", this._namespace);
+    if (this._mode === "full") {
+    }
+  }
+  _loadSecrets(config, secrets) {
+    if (isNode()) {
+      return cli_observability_secrets_default;
+    } else {
+      invariant(config, "runtime config is required", {
+        F: __dxlog_file2,
+        L: 117,
+        S: this,
+        A: [
+          "config",
+          "'runtime config is required'"
+        ]
+      });
+      log2("config", {
+        rtc: this._secrets,
+        config
+      }, {
+        F: __dxlog_file2,
+        L: 118,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return {
+        DX_ENVIRONMENT: config.get("runtime.app.env.DX_ENVIRONMENT"),
+        DX_RELEASE: config.get("runtime.app.env.DX_RELEASE"),
+        SENTRY_DESTINATION: config.get("runtime.app.env.DX_SENTRY_DESTINATION"),
+        TELEMETRY_API_KEY: config.get("runtime.app.env.DX_TELEMETRY_API_KEY"),
+        IPDATA_API_KEY: config.get("runtime.app.env.DX_IPDATA_API_KEY"),
+        DATADOG_API_KEY: config.get("runtime.app.env.DX_DATADOG_API_KEY"),
+        DATADOG_APP_KEY: config.get("runtime.app.env.DX_DATADOG_APP_KEY"),
+        ...secrets
+      };
+    }
+  }
+  initialize() {
+    this._initMetrics();
+    this._initTelemetry();
+    this._initErrorLogs();
+  }
+  async close() {
+    await this._ctx.dispose();
+  }
+  setMode(mode) {
+    this._mode = mode;
+  }
+  get mode() {
+    return this._mode;
+  }
+  get enabled() {
+    return this._mode !== "disabled";
+  }
+  //
+  // Tags
+  //
+  /**
+  * Set a tag for all observability services.
+  */
+  setTag(key, value) {
+    if (this.enabled && ERROR_TAGS.includes(key)) {
+      setTag(key, value);
+    }
+    this._tags.set(key, value);
+  }
+  // TODO(wittjosiah): Improve privacy of telemetry identifiers. See `getTelemetryIdentifier`.
+  async setIdentityTags(client) {
+    client.services.services.IdentityService.queryIdentity().subscribe((idqr) => {
+      if (!idqr?.identity?.identityKey) {
+        log2("empty response from identity service", {
+          idqr
+        }, {
+          F: __dxlog_file2,
+          L: 175,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      this.setTag("identityKey", idqr.identity.identityKey.truncate());
+    });
+    client.services.services.DevicesService.queryDevices().subscribe((dqr) => {
+      if (!dqr || !dqr.devices || dqr.devices.length === 0) {
+        log2("empty response from device service", {
+          device: dqr
+        }, {
+          F: __dxlog_file2,
+          L: 184,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      invariant(dqr, "empty response from device service", {
+        F: __dxlog_file2,
+        L: 187,
+        S: this,
+        A: [
+          "dqr",
+          "'empty response from device service'"
+        ]
+      });
+      const thisDevice = dqr.devices.find((device) => device.kind === DeviceKind.CURRENT);
+      if (!thisDevice) {
+        log2("no current device", {
+          device: dqr
+        }, {
+          F: __dxlog_file2,
+          L: 191,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      this.setTag("deviceKey", thisDevice.deviceKey.truncate());
+      if (thisDevice.profile?.label) {
+        this.setTag("deviceProfile", thisDevice.profile.label);
+      }
+    });
+  }
+  //
+  // Metrics
+  //
+  _initMetrics() {
+    if (this.enabled && this._secrets.DATADOG_API_KEY) {
+      this._metrics = new DatadogMetrics({
+        apiKey: this._secrets.DATADOG_API_KEY,
+        getTags: () => this._tags,
+        // TODO(nf): move/refactor from telementryContext, needed to read CORS proxy
+        config: this._config
+      });
+    } else {
+      log2("datadog disabled", void 0, {
+        F: __dxlog_file2,
+        L: 214,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  /**
+  * Gauge metric.
+  *
+  * The default implementation uses Datadog.
+  */
+  gauge(name, value, extraTags) {
+    this._metrics?.gauge(name, value, extraTags);
+  }
+  // TODO(nf): Refactor into ObservabilityExtensions.
+  startNetworkMetrics(client) {
+    const updateSignalMetrics = new Event();
+    updateSignalMetrics.on(this._ctx, async (networkStatus) => {
+      log2("send signal metrics", void 0, {
+        F: __dxlog_file2,
+        L: 234,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      networkStatus.signaling.forEach(({ server, state }) => {
+        this.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;
+      networkStatus.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;
+          }
+        }
+        this.gauge("dxos.client.network.swarm.count", swarmCount);
+        for (const state in ConnectionState) {
+          this.gauge("dxos.client.network.connection.count", connectionStates.get(state) ?? 0, {
+            state
+          });
+        }
+        this.gauge("dxox.client.network.totalReadBufferSize", totalReadBufferSize);
+        this.gauge("dxos.client.network.totalWriteBufferSize", totalWriteBufferSize);
+        this.gauge("dxos.client.network.totalChannelBufferSize", totalChannelBufferSize);
+      });
+    });
+    client.services.services.NetworkService?.queryStatus().subscribe((networkStatus) => {
+      updateSignalMetrics.emit(networkStatus);
+    });
+  }
+  startSpacesMetrics(client, namespace) {
+    const spaces = client.spaces.get();
+    const subscriptions = /* @__PURE__ */ new Map();
+    this._ctx.onDispose(() => subscriptions.forEach((subscription) => subscription.unsubscribe()));
+    const updateSpaceMetrics = new Event().debounce(SPACE_METRICS_MIN_INTERVAL);
+    updateSpaceMetrics.on(this._ctx, async () => {
+      log2("send space update", void 0, {
+        F: __dxlog_file2,
+        L: 286,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      for (const data of mapSpaces(spaces, {
+        truncateKeys: true
+      })) {
+        this.gauge("dxos.client.space.members", data.members, {
+          key: data.key
+        });
+        this.gauge("dxos.client.space.objects", data.objects, {
+          key: data.key
+        });
+        this.gauge("dxos.client.space.epoch", data.epoch, {
+          key: data.key
+        });
+        this.gauge("dxos.client.space.currentDataMutations", data.currentDataMutations, {
+          key: data.key
+        });
+        this.event({
+          identityId: getTelemetryIdentifier(client),
+          name: `${namespace}.space.update`,
+          properties: {
+            ...BASE_TELEMETRY_PROPERTIES,
+            ...data
+          }
+        });
+      }
+    });
+    const subscribeToSpaceUpdate = (space) => space.pipeline.subscribe({
+      next: () => {
+        updateSpaceMetrics.emit();
+      }
+    });
+    spaces.forEach((space) => {
+      subscriptions.set(space.key.toHex(), subscribeToSpaceUpdate(space));
+    });
+    client.spaces.subscribe({
+      next: async (spaces2) => {
+        spaces2.filter((space) => !subscriptions.has(space.key.toHex())).forEach((space) => {
+          subscriptions.set(space.key.toHex(), subscribeToSpaceUpdate(space));
+        });
+      }
+    });
+    scheduleTaskInterval(this._ctx, async () => updateSpaceMetrics.emit(), DATADOG_IDLE_INTERVAL);
+  }
+  async startRuntimeMetrics(client, frequency = DATADOG_IDLE_INTERVAL) {
+    const platform = await client.services.services.SystemService?.getPlatform();
+    invariant(platform, "platform is required", {
+      F: __dxlog_file2,
+      L: 332,
+      S: this,
+      A: [
+        "platform",
+        "'platform is required'"
+      ]
+    });
+    this.setTag("platform_type", Platform.PLATFORM_TYPE[platform.type].toLowerCase());
+    if (this._mode === "full") {
+      if (platform.platform) {
+        this.setTag("platform", platform.platform);
+      }
+      if (platform.arch) {
+        this.setTag("arch", platform.arch);
+      }
+      if (platform.runtime) {
+        this.setTag("runtime", platform.runtime);
+      }
+    }
+    scheduleTaskInterval(this._ctx, async () => {
+      log2("platform", void 0, {
+        F: __dxlog_file2,
+        L: 350,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      client.services.services.SystemService?.getPlatform().then((platform2) => {
+        log2("platform", {
+          platform: platform2
+        }, {
+          F: __dxlog_file2,
+          L: 353,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        if (platform2.memory) {
+          this.gauge("dxos.client.runtime.rss", platform2.memory.rss);
+          this.gauge("dxos.client.runtime.heapTotal", platform2.memory.heapTotal);
+          this.gauge("dxos.client.runtime.heapUsed", platform2.memory.heapUsed);
+        }
+      }).catch((error) => log2("platform error", {
+        error
+      }, {
+        F: __dxlog_file2,
+        L: 360,
+        S: this,
+        C: (f, a) => f(...a)
+      }));
+    }, frequency);
+  }
+  //
+  // Telemetry
+  //
+  _initTelemetry() {
+    if (this._secrets.TELEMETRY_API_KEY && this._mode !== "disabled") {
+      this._telemetry = new SegmentTelemetry({
+        apiKey: this._secrets.TELEMETRY_API_KEY,
+        batchSize: this._telemetryBatchSize,
+        getTags: () => this._tags
+      });
+    } else {
+      log2("segment disabled", void 0, {
+        F: __dxlog_file2,
+        L: 378,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  /**
+  * A telemetry event.
+  *
+  * The default implementation uses Segment.
+  */
+  event(options) {
+    this._telemetry?.event(options);
+  }
+  /**
+  * A telemetry page view.
+  *
+  * The default implementation uses Segment.
+  */
+  page(options) {
+    this._telemetry?.page(options);
+  }
+  //
+  // Error Logs
+  //
+  _initErrorLogs() {
+    if (this._secrets.SENTRY_DESTINATION && this._mode !== "disabled") {
+      log2.info("Initializing Sentry", {
+        dest: this._secrets.SENTRY_DESTINATION,
+        options: this._errorReportingOptions
+      }, {
+        F: __dxlog_file2,
+        L: 407,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      init({
+        ...this._errorReportingOptions,
+        destination: this._secrets.SENTRY_DESTINATION,
+        scrubFilenames: this._mode !== "full"
+      });
+      if (this._errorReportingOptions?.tracing) {
+        configureTracing();
+      }
+      if (this._errorLogProcessor) {
+        enableSentryLogProcessor();
+      }
+      this._tags.forEach((v, k) => {
+        if (ERROR_TAGS.includes(k)) {
+          setTag(k, v);
+        }
+      });
+    } else {
+      log2("sentry disabled", void 0, {
+        F: __dxlog_file2,
+        L: 430,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  /**
+  * Manually capture an exception.
+  *
+  * The default implementation uses Sentry.
+  */
+  captureException(err) {
+    if (this.enabled) {
+      captureException(err);
+    }
+  }
+};
+
+export {
+  Observability,
+  BASE_TELEMETRY_PROPERTIES,
+  OBSERVABILITY_DISABLED_KEY,
+  OBSERVABILITY_GROUP_KEY,
+  getTelemetryIdentifier,
+  isObservabilityDisabled,
+  storeObservabilityDisabled,
+  getObservabilityGroup,
+  storeObservabilityGroup,
+  initializeAppObservability,
+  mapSpaces,
+  setupTelemetryListeners
+};
+//# sourceMappingURL=chunk-STWCJK52.mjs.map