@dxos/observability 0.3.11-next.e28df4f → 0.3.11-next.f4c1077

package/dist/lib/browser/{chunk-STWCJK52.mjs → chunk-JVT4FOCC.mjs}

@@ -1,9 +1,9 @@
 import {
   DatadogMetrics
-} from "./chunk-2J5YS65Q.mjs";
+} from "./chunk-6ZTMPKEG.mjs";
 import {
   SegmentTelemetry
-} from "./chunk-ROSK6U3K.mjs";
+} from "./chunk-HPGC4HC7.mjs";
 import {
   captureException,
   configureTracing,
@@ -16,7 +16,7 @@ import {
 import { Event, scheduleTaskInterval } from "@dxos/async";
 import { Context } from "@dxos/context";
 import { invariant } from "@dxos/invariant";
-import { log as log2 } from "@dxos/log";
+import { log as log3 } from "@dxos/log";
 import { ConnectionState } from "@dxos/network-manager";
 import { DeviceKind, Platform } from "@dxos/protocols/proto/dxos/client/services";
 import { isNode } from "@dxos/util";
@@ -30,46 +30,19 @@ var cli_observability_secrets_default = {
   DATADOG_APP_KEY: null
 };
 
-// packages/sdk/observability/src/helpers/app-observability.ts
+// packages/sdk/observability/src/helpers/browser-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 __dxlog_file = "/home/runner/work/dxos/dxos/packages/sdk/observability/src/helpers/browser-observability.ts";
+var OBSERVABILITY_DISABLED_KEY = "observability-disabled";
+var OBSERVABILITY_GROUP_KEY = "observability-group";
 var isObservabilityDisabled = async (namespace) => {
   try {
     return await localForage.getItem(`${namespace}:${OBSERVABILITY_DISABLED_KEY}`) === "true";
   } catch (err) {
     log.catch("Failed to check if observability is disabled, assuming it is", err, {
       F: __dxlog_file,
-      L: 54,
+      L: 24,
       S: void 0,
       C: (f, a) => f(...a)
     });
@@ -82,7 +55,7 @@ var storeObservabilityDisabled = async (namespace, value) => {
   } catch (err) {
     log.catch("Failed to store observability disabled", err, {
       F: __dxlog_file,
-      L: 63,
+      L: 33,
       S: void 0,
       C: (f, a) => f(...a)
     });
@@ -94,7 +67,7 @@ var getObservabilityGroup = async (namespace) => {
   } catch (err) {
     log.catch("Failed to get observability group", err, {
       F: __dxlog_file,
-      L: 71,
+      L: 41,
       S: void 0,
       C: (f, a) => f(...a)
     });
@@ -106,7 +79,7 @@ var storeObservabilityGroup = async (namespace, value) => {
   } catch (err) {
     log.catch("Failed to store observability group", err, {
       F: __dxlog_file,
-      L: 79,
+      L: 49,
       S: void 0,
       C: (f, a) => f(...a)
     });
@@ -117,18 +90,15 @@ var initializeAppObservability = async ({ namespace, config, mode = "basic", tra
     config
   }, {
     F: __dxlog_file,
-    L: 104,
+    L: 72,
     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: Observability2 } = await import("./observability-3UVQW6ZL.mjs");
   const observability = new Observability2({
     namespace,
     group,
@@ -151,7 +121,7 @@ var initializeAppObservability = async ({ namespace, config, mode = "basic", tra
     observability.setMode("disabled");
     log.info("observability disabled", void 0, {
       F: __dxlog_file,
-      L: 147,
+      L: 113,
       S: void 0,
       C: (f, a) => f(...a)
     });
@@ -160,14 +130,14 @@ var initializeAppObservability = async ({ namespace, config, mode = "basic", tra
   try {
     const getIPData = async (config2) => {
       const IP_DATA_CACHE_TIMEOUT = 6 * 60 * 60 * 1e3;
-      const cachedData = await localForage.getItem("dxos:telemetry:ipdata");
+      const cachedData = await localForage.getItem("dxos:observability:ipdata");
       if (cachedData && cachedData.timestamp > Date.now() - IP_DATA_CACHE_TIMEOUT) {
         return cachedData.data;
       }
       const IPDATA_API_KEY = config2.get("runtime.app.env.DX_IPDATA_API_KEY");
       if (IPDATA_API_KEY) {
         return fetch(`https://api.ipdata.co?api-key=${IPDATA_API_KEY}`).then((res) => res.json()).then((data) => {
-          localForage.setItem("dxos:telemetry:ipdata", {
+          localForage.setItem("dxos:observability:ipdata", {
             data,
             timestamp: Date.now()
           }).catch((err) => observability.captureException(err));
@@ -175,19 +145,29 @@ var initializeAppObservability = async ({ namespace, config, mode = "basic", tra
         }).catch((err) => observability.captureException(err));
       }
     };
+    observability.initialize();
     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;
+    ipData && observability.addIPDataTelemetryTags(ipData);
+    if (typeof navigator !== "undefined" && navigator.storage?.estimate) {
+      setInterval(async () => {
+        try {
+          const storageEstimate = await navigator.storage.estimate();
+          storageEstimate.usage && observability.setTag("storageUsage", storageEstimate.usage.toString(), "telemetry");
+          storageEstimate.quota && observability.setTag("storageQuota", storageEstimate.quota.toString(), "telemetry");
+        } catch (error) {
+          log.warn("Failed to run estimate()", error, {
+            F: __dxlog_file,
+            L: 168,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+        }
+      }, 1e4);
     }
-    observability.initialize();
   } catch (err) {
     log.error("Failed to initialize app observability", err, {
       F: __dxlog_file,
-      L: 201,
+      L: 173,
       S: void 0,
       C: (f, a) => f(...a)
     });
@@ -195,6 +175,109 @@ var initializeAppObservability = async ({ namespace, config, mode = "basic", tra
   return observability;
 };
 
+// packages/sdk/observability/src/helpers/common.ts
+var getTelemetryIdentifier = (client) => {
+  if (!client?.initialized) {
+    return void 0;
+  }
+  const identity = client.halo.identity.get();
+  if (identity) {
+    return identity.identityKey.truncate();
+  }
+  return void 0;
+};
+
+// packages/sdk/observability/src/helpers/node-observability.ts
+import yaml from "js-yaml";
+import { existsSync, statSync } from "@dxos/node-std/fs";
+import { mkdir, readFile, writeFile } from "@dxos/node-std/fs/promises";
+import { join } from "@dxos/node-std/path";
+import { v4 as uuid, validate as validateUuid } from "uuid";
+import { log as log2 } from "@dxos/log";
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/sdk/observability/src/helpers/node-observability.ts";
+var showObservabilityBanner = async (configDir, bannercb) => {
+  const path = join(configDir, ".observability-banner-printed");
+  if (existsSync(path)) {
+    return;
+  }
+  bannercb(
+    // eslint-disable-next-line no-multi-str
+    "Basic observability data will be sent to the DXOS team in order to improve the product. This includes     performance metrics, error logs, and usage data. No personally identifiable information, other than your     public key, is included with this data and no private data ever leaves your devices. To disable sending     observability data, set the environment variable DX_DISABLE_OBSERVABILITY=true."
+  );
+  await writeFile(path, "", "utf-8");
+};
+var getObservabilityState = async (configDir) => {
+  if (existsSync(configDir)) {
+    if (!statSync(configDir).isDirectory()) {
+      throw new Error(`Config directory ${configDir} exists but is not a directory`);
+    }
+  } else {
+    await mkdir(configDir, {
+      recursive: true
+    });
+  }
+  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(),
+    group: process.env.DX_OBSERVABILITY_GROUP ?? void 0,
+    mode: process.env.DX_DISABLE_OBSERVABILITY ? "disabled" : process.env.DX_OBSERVABILITY_MODE ?? "basic"
+  };
+  await writeFile(idPath, "# This file is automatically generated by the @dxos/cli.\n" + yaml.dump(observabilityState), "utf-8");
+  return observabilityState;
+};
+var validate = (contextString) => {
+  const context = yaml.load(contextString);
+  if (Boolean(context.installationId) && validateUuid(context.installationId)) {
+    return {
+      ...context,
+      mode: process.env.DX_DISABLE_OBSERVABILITY ? "disabled" : context.mode ?? "basic"
+    };
+  }
+};
+var initializeNodeObservability = async ({ namespace, config, installationId, group, mode = "basic", tracingEnable = true, replayEnable = true }) => {
+  log2("initializeCliObservability", {
+    config
+  }, {
+    F: __dxlog_file2,
+    L: 120,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  const release = `${namespace}@${config.get("runtime.app.build.version")}`;
+  const environment = config.get("runtime.app.env.DX_ENVIRONMENT");
+  const observability = new Observability({
+    namespace,
+    group,
+    mode,
+    errorLog: {
+      sentryInitOptions: {
+        environment,
+        release,
+        // TODO(wittjosiah): Configure this.
+        sampleRate: 1
+      },
+      logProcessor: true
+    }
+  });
+  observability.setTag("installationId", installationId);
+  const IPDATA_API_KEY = config.get("runtime.app.env.DX_IPDATA_API_KEY");
+  try {
+    const res = await fetch(`https://api.ipdata.co/?api-key=${IPDATA_API_KEY}`);
+    const ipData = await res.json();
+    ipData && observability.addIPDataTelemetryTags(ipData);
+  } catch (err) {
+    observability?.captureException(err);
+  }
+  return observability;
+};
+
 // packages/sdk/observability/src/helpers/map-spaces.ts
 var mapSpaces = (spaces, options = {
   verbose: false,
@@ -231,14 +314,13 @@ 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) {
+    if (observability.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(">")
@@ -251,7 +333,6 @@ var setupTelemetryListeners = (namespace, client, observability) => {
       identityId: getTelemetryIdentifier(client),
       name: `${namespace}.window.focus`,
       properties: {
-        ...BASE_TELEMETRY_PROPERTIES,
         href: window.location.href,
         timeAway: now.getTime() - lastFocusEvent.getTime()
       }
@@ -265,7 +346,6 @@ var setupTelemetryListeners = (namespace, client, observability) => {
       identityId: getTelemetryIdentifier(client),
       name: `${namespace}.window.blur`,
       properties: {
-        ...BASE_TELEMETRY_PROPERTIES,
         href: window.location.href,
         timeSpent
       }
@@ -278,7 +358,6 @@ var setupTelemetryListeners = (namespace, client, observability) => {
       identityId: getTelemetryIdentifier(client),
       name: `${namespace}.page.unload`,
       properties: {
-        ...BASE_TELEMETRY_PROPERTIES,
         href: window.location.href,
         timeSpent: totalTime
       }
@@ -289,7 +368,6 @@ var setupTelemetryListeners = (namespace, client, observability) => {
       identityId: getTelemetryIdentifier(client),
       name: `${namespace}.window.error`,
       properties: {
-        ...BASE_TELEMETRY_PROPERTIES,
         href: window.location.href,
         message: event.message,
         filename: event.filename,
@@ -312,15 +390,9 @@ var setupTelemetryListeners = (namespace, client, observability) => {
 };
 
 // packages/sdk/observability/src/observability.ts
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/sdk/observability/src/observability.ts";
+var __dxlog_file3 = "/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 }) {
@@ -328,6 +400,13 @@ var Observability = class {
     // TODO(nf): accept upstream context?
     this._ctx = new Context();
     this._tags = /* @__PURE__ */ new Map();
+    this.addIPDataTelemetryTags = (ipData) => {
+      this.setTag("city", ipData.city, "telemetry");
+      this.setTag("region", ipData.region, "telemetry");
+      this.setTag("country", ipData.country, "telemetry");
+      ipData.latitude && this.setTag("latitude", ipData.latitude.toString(), "telemetry");
+      ipData.longitude && this.setTag("longitude", ipData.longitude.toString(), "telemetry");
+    };
     this._namespace = namespace;
     this._config = config;
     this._mode = mode ?? "disabled";
@@ -345,23 +424,34 @@ var Observability = class {
   }
   _loadSecrets(config, secrets) {
     if (isNode()) {
-      return cli_observability_secrets_default;
+      const mergedSecrets = {
+        ...cli_observability_secrets_default,
+        ...secrets
+      };
+      process.env.DX_ENVIRONMENT && (mergedSecrets.DX_ENVIRONMENT = process.env.DX_ENVIRONMENT);
+      process.env.DX_RELEASE && (mergedSecrets.DX_RELEASE = process.env.DX_RELEASE);
+      process.env.SENTRY_DESTINATION && (mergedSecrets.SENTRY_DESTINATION = process.env.SENTRY_DESTINATION);
+      process.env.TELEMETRY_API_KEY && (mergedSecrets.TELEMETRY_API_KEY = process.env.TELEMETRY_API_KEY);
+      process.env.IPDATA_API_KEY && (mergedSecrets.IPDATA_API_KEY = process.env.IPDATA_API_KEY);
+      process.env.DATADOG_API_KEY && (mergedSecrets.DATADOG_API_KEY = process.env.DATADOG_API_KEY);
+      process.env.DATADOG_APP_KEY && (mergedSecrets.DATADOG_APP_KEY = process.env.DATADOG_APP_KEY);
+      return mergedSecrets;
     } else {
       invariant(config, "runtime config is required", {
-        F: __dxlog_file2,
-        L: 117,
+        F: __dxlog_file3,
+        L: 128,
         S: this,
         A: [
           "config",
           "'runtime config is required'"
         ]
       });
-      log2("config", {
+      log3("config", {
         rtc: this._secrets,
         config
       }, {
-        F: __dxlog_file2,
-        L: 118,
+        F: __dxlog_file3,
+        L: 129,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -391,30 +481,39 @@ var Observability = class {
   get mode() {
     return this._mode;
   }
+  get group() {
+    return this._group;
+  }
   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, scope) {
+    if (this.enabled && (scope === void 0 || scope === "all" || scope === "errors")) {
       setTag(key, value);
     }
-    this._tags.set(key, value);
+    if (!scope) {
+      scope = "all";
+    }
+    this._tags.set(key, {
+      value,
+      scope
+    });
+  }
+  getTag(key) {
+    return this._tags.get(key);
   }
   // 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", {
+        log3("empty response from identity service", {
           idqr
         }, {
-          F: __dxlog_file2,
-          L: 175,
+          F: __dxlog_file3,
+          L: 201,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -424,19 +523,19 @@ var Observability = class {
     });
     client.services.services.DevicesService.queryDevices().subscribe((dqr) => {
       if (!dqr || !dqr.devices || dqr.devices.length === 0) {
-        log2("empty response from device service", {
+        log3("empty response from device service", {
           device: dqr
         }, {
-          F: __dxlog_file2,
-          L: 184,
+          F: __dxlog_file3,
+          L: 210,
           S: this,
           C: (f, a) => f(...a)
         });
         return;
       }
       invariant(dqr, "empty response from device service", {
-        F: __dxlog_file2,
-        L: 187,
+        F: __dxlog_file3,
+        L: 213,
         S: this,
         A: [
           "dqr",
@@ -445,11 +544,11 @@ var Observability = class {
       });
       const thisDevice = dqr.devices.find((device) => device.kind === DeviceKind.CURRENT);
       if (!thisDevice) {
-        log2("no current device", {
+        log3("no current device", {
           device: dqr
         }, {
-          F: __dxlog_file2,
-          L: 191,
+          F: __dxlog_file3,
+          L: 217,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -468,14 +567,19 @@ var Observability = class {
     if (this.enabled && this._secrets.DATADOG_API_KEY) {
       this._metrics = new DatadogMetrics({
         apiKey: this._secrets.DATADOG_API_KEY,
-        getTags: () => this._tags,
+        getTags: () => Object.fromEntries(Array.from(this._tags).filter(([key, value]) => {
+          return value.scope === "all" || value.scope === "metrics";
+        }).map(([key, value]) => [
+          key,
+          value.value
+        ])),
         // 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,
+      log3("datadog disabled", void 0, {
+        F: __dxlog_file3,
+        L: 247,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -493,9 +597,9 @@ var Observability = class {
   startNetworkMetrics(client) {
     const updateSignalMetrics = new Event();
     updateSignalMetrics.on(this._ctx, async (networkStatus) => {
-      log2("send signal metrics", void 0, {
-        F: __dxlog_file2,
-        L: 234,
+      log3("send signal metrics", void 0, {
+        F: __dxlog_file3,
+        L: 267,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -543,9 +647,9 @@ var Observability = class {
     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,
+      log3("send space update", void 0, {
+        F: __dxlog_file3,
+        L: 319,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -567,10 +671,7 @@ var Observability = class {
         this.event({
           identityId: getTelemetryIdentifier(client),
           name: `${namespace}.space.update`,
-          properties: {
-            ...BASE_TELEMETRY_PROPERTIES,
-            ...data
-          }
+          properties: data
         });
       }
     });
@@ -594,8 +695,8 @@ var Observability = class {
   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,
+      F: __dxlog_file3,
+      L: 362,
       S: this,
       A: [
         "platform",
@@ -615,18 +716,18 @@ var Observability = class {
       }
     }
     scheduleTaskInterval(this._ctx, async () => {
-      log2("platform", void 0, {
-        F: __dxlog_file2,
-        L: 350,
+      log3("platform", void 0, {
+        F: __dxlog_file3,
+        L: 380,
         S: this,
         C: (f, a) => f(...a)
       });
       client.services.services.SystemService?.getPlatform().then((platform2) => {
-        log2("platform", {
+        log3("platform", {
           platform: platform2
         }, {
-          F: __dxlog_file2,
-          L: 353,
+          F: __dxlog_file3,
+          L: 383,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -635,11 +736,11 @@ var Observability = class {
           this.gauge("dxos.client.runtime.heapTotal", platform2.memory.heapTotal);
           this.gauge("dxos.client.runtime.heapUsed", platform2.memory.heapUsed);
         }
-      }).catch((error) => log2("platform error", {
+      }).catch((error) => log3("platform error", {
         error
       }, {
-        F: __dxlog_file2,
-        L: 360,
+        F: __dxlog_file3,
+        L: 390,
         S: this,
         C: (f, a) => f(...a)
       }));
@@ -653,12 +754,17 @@ var Observability = class {
       this._telemetry = new SegmentTelemetry({
         apiKey: this._secrets.TELEMETRY_API_KEY,
         batchSize: this._telemetryBatchSize,
-        getTags: () => this._tags
+        getTags: () => Object.fromEntries(Array.from(this._tags).filter(([key, value]) => {
+          return value.scope === "all" || value.scope === "telemetry";
+        }).map(([key, value]) => [
+          key,
+          value.value
+        ]))
       });
     } else {
-      log2("segment disabled", void 0, {
-        F: __dxlog_file2,
-        L: 378,
+      log3("segment disabled", void 0, {
+        F: __dxlog_file3,
+        L: 415,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -685,12 +791,12 @@ var Observability = class {
   //
   _initErrorLogs() {
     if (this._secrets.SENTRY_DESTINATION && this._mode !== "disabled") {
-      log2.info("Initializing Sentry", {
+      log3.info("Initializing Sentry", {
         dest: this._secrets.SENTRY_DESTINATION,
         options: this._errorReportingOptions
       }, {
-        F: __dxlog_file2,
-        L: 407,
+        F: __dxlog_file3,
+        L: 444,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -706,14 +812,14 @@ var Observability = class {
         enableSentryLogProcessor();
       }
       this._tags.forEach((v, k) => {
-        if (ERROR_TAGS.includes(k)) {
-          setTag(k, v);
+        if (v.scope === "all" || v.scope === "errors") {
+          setTag(k, v.value);
         }
       });
     } else {
-      log2("sentry disabled", void 0, {
-        F: __dxlog_file2,
-        L: 430,
+      log3("sentry disabled", void 0, {
+        F: __dxlog_file3,
+        L: 467,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -733,16 +839,18 @@ var Observability = class {
 
 export {
   Observability,
-  BASE_TELEMETRY_PROPERTIES,
   OBSERVABILITY_DISABLED_KEY,
   OBSERVABILITY_GROUP_KEY,
-  getTelemetryIdentifier,
   isObservabilityDisabled,
   storeObservabilityDisabled,
   getObservabilityGroup,
   storeObservabilityGroup,
   initializeAppObservability,
+  getTelemetryIdentifier,
+  showObservabilityBanner,
+  getObservabilityState,
+  initializeNodeObservability,
   mapSpaces,
   setupTelemetryListeners
 };
-//# sourceMappingURL=chunk-STWCJK52.mjs.map
+//# sourceMappingURL=chunk-JVT4FOCC.mjs.map