@dxos/observability 0.3.11-main.0999ea0

package/dist/lib/browser/sentry/index.mjs

@@ -0,0 +1,25 @@
+import {
+  SENTRY_PROCESSOR,
+  addBreadcrumb,
+  captureException,
+  configureTracing,
+  enableSentryLogProcessor,
+  finish,
+  init,
+  setTag,
+  setTags,
+  setUser
+} from "../chunk-6KUJPLEH.mjs";
+export {
+  SENTRY_PROCESSOR,
+  addBreadcrumb,
+  captureException,
+  configureTracing,
+  enableSentryLogProcessor,
+  finish,
+  init,
+  setTag,
+  setTags,
+  setUser
+};
+//# sourceMappingURL=index.mjs.map

package/dist/lib/browser/sentry/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/lib/node/chunk-FSAOBKO2.cjs

@@ -0,0 +1,352 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_FSAOBKO2_exports = {};
+__export(chunk_FSAOBKO2_exports, {
+  SENTRY_LOG_PROCESSOR: () => SENTRY_LOG_PROCESSOR,
+  addBreadcrumb: () => addBreadcrumb,
+  captureException: () => captureException,
+  configureTracing: () => configureTracing,
+  enableSentryLogProcessor: () => enableSentryLogProcessor,
+  init: () => init,
+  setTag: () => import_node2.setTag,
+  setTags: () => import_node2.setTags,
+  setUser: () => import_node2.setUser
+});
+module.exports = __toCommonJS(chunk_FSAOBKO2_exports);
+var import_integrations = require("@sentry/integrations");
+var import_node = require("@sentry/node");
+var import_log = require("@dxos/log");
+var import_node2 = require("@sentry/node");
+var import_browser = require("@sentry/browser");
+var import_async = require("@dxos/async");
+var import_context = require("@dxos/context");
+var import_invariant = require("@dxos/invariant");
+var import_log2 = require("@dxos/log");
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/sdk/observability/src/sentry/node.ts";
+var init = (options) => {
+  try {
+    if (options.tracing) {
+      void import("@sentry/tracing");
+    }
+    (0, import_node.init)({
+      enabled: options.enable ?? true,
+      dsn: options.destination,
+      serverName: options.installationId,
+      release: options.release,
+      environment: options.environment ?? process.env.DX_ENVIRONMENT,
+      integrations: [
+        (0, import_integrations.captureConsoleIntegration)({
+          levels: [
+            "error",
+            "warn"
+          ]
+        })
+      ],
+      tracesSampleRate: options.sampleRate,
+      transport: options.transport,
+      beforeSend: (event) => {
+        options.scrubFilenames && scrub(event);
+        options.onError?.(event);
+        return event;
+      }
+    });
+    Object.entries(options.properties ?? {}).forEach(([key, value]) => {
+      (0, import_node.setTag)(key, value);
+    });
+  } catch (err) {
+    import_log.log.catch("Failed to initialize sentry", err, {
+      F: __dxlog_file,
+      L: 57,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  }
+};
+var scrub = (event) => {
+  event.exception?.values?.forEach((value) => {
+    value.stacktrace?.frames?.forEach((frame) => {
+      const filename = frame.filename?.split("/");
+      frame.filename = filename && filename[filename.length - 1];
+    });
+  });
+};
+var addBreadcrumb = (breadcrumb) => {
+  try {
+    (0, import_node.addBreadcrumb)(breadcrumb);
+    (0, import_log.log)("add breadcrumb", breadcrumb, {
+      F: __dxlog_file,
+      L: 82,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  } catch (err) {
+    import_log.log.catch("Failed to add breadcrumb", err, {
+      F: __dxlog_file,
+      L: 84,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  }
+};
+var captureException = (exception, captureContext) => {
+  try {
+    const eventId = (0, import_node.captureException)(exception, captureContext);
+    (0, import_log.log)("capture exception", {
+      exception,
+      eventId,
+      ...captureContext
+    }, {
+      F: __dxlog_file,
+      L: 98,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return eventId;
+  } catch (err) {
+    import_log.log.catch("Failed to capture exception", err, {
+      F: __dxlog_file,
+      L: 101,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return "unknown";
+  }
+};
+var enableSentryLogProcessor = (filter) => {
+  import_log.log.runtimeConfig.processors.push(SENTRY_LOG_PROCESSOR);
+};
+var SENTRY_LOG_PROCESSOR = (config, entry) => {
+  const { message, level, meta, error } = entry;
+  if (!(0, import_log.shouldLog)(entry, config.captureFilters)) {
+    return;
+  }
+  (0, import_node.withScope)((scope) => {
+    scope.setLevel(convertLevel(level));
+    scope.setContext("dxoslog", entry.context);
+    if (meta) {
+      scope.setTransactionName(`${getRelativeFilename(meta.F)}:${meta.L}`);
+    }
+    if (error) {
+      scope.setExtra("message", message);
+      return (0, import_node.captureException)(error);
+    }
+    (0, import_node.captureMessage)(message);
+  });
+};
+var convertLevel = (level) => {
+  if (level === import_log.LogLevel.TRACE) {
+    return "debug";
+  }
+  if (level === import_log.LogLevel.WARN) {
+    return "warning";
+  }
+  return import_log.LogLevel[level].toLowerCase();
+};
+var getRelativeFilename = (filename) => {
+  const match = filename.match(/.+\/(packages\/.+\/.+)/);
+  if (match) {
+    const [, filePath] = match;
+    return filePath;
+  }
+  return filename;
+};
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/sdk/observability/src/sentry/tracing.ts";
+var REPORT_SPANS = false;
+var TX;
+var SPAN_MAP = /* @__PURE__ */ new Map();
+var SENTRY_INITIALIZED = new import_async.Trigger();
+var ctx = new import_context.Context({
+  onError: (err) => import_log2.log.warn("Unhandled error in Sentry context", err, {
+    F: __dxlog_file2,
+    L: 20,
+    S: void 0,
+    C: (f, a) => f(...a)
+  })
+});
+ctx.maxSafeDisposeCallbacks = 1e4;
+var tracingConfigured = false;
+var configureTracing = () => {
+  tracingConfigured = true;
+  (0, import_async.runInContext)(ctx, () => {
+    TX = (0, import_browser.getCurrentHub)().startTransaction({
+      name: "DXOS Core Tracing",
+      op: "dxos"
+    });
+    (0, import_invariant.invariant)(TX, "Failed to create trace", {
+      F: __dxlog_file2,
+      L: 33,
+      S: void 0,
+      A: [
+        "TX",
+        "'Failed to create trace'"
+      ]
+    });
+    if (typeof window !== "undefined") {
+      window.addEventListener("beforeunload", () => {
+        finish();
+      });
+    }
+    if (typeof process !== "undefined") {
+      process.on("exit", () => {
+        finish();
+      });
+    }
+    SENTRY_INITIALIZED.wake();
+  });
+};
+var finish = () => {
+  for (const span of Array.from(SPAN_MAP.values()).reverse()) {
+    try {
+      span.finish();
+    } catch (err) {
+      import_log2.log.warn("Failed to finish span", err, {
+        F: __dxlog_file2,
+        L: 54,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  TX.finish();
+};
+var SENTRY_PROCESSOR = (config, entry) => {
+  if (!tracingConfigured) {
+    return;
+  }
+  const { message, level, error } = entry;
+  const context = (0, import_log2.getContextFromEntry)(entry);
+  if (level !== import_log2.LogLevel.TRACE) {
+    return;
+  }
+  (0, import_async.scheduleMicroTask)(ctx, async () => {
+    await SENTRY_INITIALIZED.wait();
+    if (REPORT_SPANS && context?.span) {
+      switch (context.span.command) {
+        case "begin": {
+          const id = context.span.id;
+          if (!id || SPAN_MAP.has(id)) {
+            import_log2.log.warn("Cannot begin span", id, {
+              F: __dxlog_file2,
+              L: 82,
+              S: void 0,
+              C: (f, a) => f(...a)
+            });
+            return;
+          }
+          let parentSpan = TX;
+          if (context.span.parent) {
+            parentSpan = SPAN_MAP.get(context.span.parent) ?? TX;
+          }
+          let logContext;
+          try {
+            logContext = JSON.stringify({
+              ...context,
+              message,
+              level,
+              error
+            });
+          } catch (err) {
+            logContext = JSON.stringify(context);
+          }
+          const span = parentSpan.startChild({
+            op: message,
+            data: {
+              ...context.span.data,
+              "@dxos/log": logContext
+            }
+          });
+          SPAN_MAP.set(context.span.id, span);
+          break;
+        }
+        case "end": {
+          const span = SPAN_MAP.get(context.span.id);
+          if (span) {
+            span.setStatus(getSpanStatus(context.span.status));
+            context.span.data && Object.entries(context.span.data).forEach(([key, value]) => span.setData(key, value));
+            span.finish();
+            SPAN_MAP.delete(context.span.id);
+          } else {
+            import_log2.log.warn("Cannot end span", context.span.id, {
+              F: __dxlog_file2,
+              L: 117,
+              S: void 0,
+              C: (f, a) => f(...a)
+            });
+          }
+          break;
+        }
+        case "update": {
+          const span = SPAN_MAP.get(context.span.id);
+          if (span) {
+            context.span.data && Object.entries(context.span.data).forEach(([key, value]) => span.setData(key, value));
+          } else {
+            import_log2.log.warn("Cannot update span", context.span.id, {
+              F: __dxlog_file2,
+              L: 127,
+              S: void 0,
+              C: (f, a) => f(...a)
+            });
+          }
+          break;
+        }
+        default: {
+          import_log2.log.warn("Unknown span command", context.span.command, {
+            F: __dxlog_file2,
+            L: 133,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+        }
+      }
+    }
+  });
+};
+import_log2.log.runtimeConfig.processors.push(SENTRY_PROCESSOR);
+var getSpanStatus = (status) => {
+  switch (status) {
+    case "ok":
+      return "ok";
+    case "error":
+      return "not_found";
+  }
+  return status ?? "ok";
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SENTRY_LOG_PROCESSOR,
+  addBreadcrumb,
+  captureException,
+  configureTracing,
+  enableSentryLogProcessor,
+  init,
+  setTag,
+  setTags,
+  setUser
+});
+//# sourceMappingURL=chunk-FSAOBKO2.cjs.map

package/dist/lib/node/chunk-FSAOBKO2.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/sentry/node.ts", "../../../src/sentry/tracing.ts"],
+  "sourcesContent": ["//\n// Copyright 2022 DXOS.org\n//\n\nimport { captureConsoleIntegration } from '@sentry/integrations';\nimport {\n  init as naturalInit,\n  setTag,\n  addBreadcrumb as naturalAddBreadcrumb,\n  captureException as naturalCaptureException,\n  captureMessage as naturalCaptureMessage,\n  withScope,\n} from '@sentry/node';\nimport type { Event } from '@sentry/node';\nimport type { SeverityLevel } from '@sentry/types';\n\nimport { log, LogLevel, shouldLog } from '@dxos/log';\n\nimport { type InitOptions } from './types';\n\n// Polyfill export.\nexport { setTag, setTags, setUser } from '@sentry/node';\n\n/**\n * To use this SDK, call the init function as early as possible in the main entry module.\n * To set context information or send manual events, use the provided methods.\n *\n * @param options {InitOptions}\n */\nexport const init = (options: InitOptions) => {\n  try {\n    if (options.tracing) {\n      void import('@sentry/tracing');\n    }\n\n    naturalInit({\n      enabled: options.enable ?? true,\n      dsn: options.destination,\n      serverName: options.installationId,\n      release: options.release,\n      environment: options.environment ?? process.env.DX_ENVIRONMENT,\n      integrations: [captureConsoleIntegration({ levels: ['error', 'warn'] })],\n      tracesSampleRate: options.sampleRate,\n      transport: options.transport,\n      beforeSend: (event) => {\n        options.scrubFilenames && scrub(event);\n        options.onError?.(event);\n\n        return event;\n      },\n    });\n\n    Object.entries(options.properties ?? {}).forEach(([key, value]) => {\n      setTag(key, value);\n    });\n  } catch (err) {\n    log.catch('Failed to initialize sentry', err);\n  }\n};\n\nconst scrub = (event: Event) => {\n  event.exception?.values?.forEach((value) => {\n    value.stacktrace?.frames?.forEach((frame) => {\n      const filename = frame.filename?.split('/');\n      frame.filename = filename && filename[filename.length - 1];\n    });\n  });\n};\n\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on user's actions prior to an error or crash.\n *\n * https://docs.sentry.io/platforms/javascript/enriching-events/breadcrumbs/\n *\n * @param breadcrumb — The breadcrumb to record.\n */\nexport const addBreadcrumb: typeof naturalAddBreadcrumb = (breadcrumb) => {\n  try {\n    naturalAddBreadcrumb(breadcrumb);\n    log('add breadcrumb', breadcrumb);\n  } catch (err) {\n    log.catch('Failed to add breadcrumb', err);\n  }\n};\n\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception — An exception-like object.\n * @param captureContext — Additional scope data to apply to exception event.\n * @returns — The generated eventId.\n */\nexport const captureException: typeof naturalCaptureException = (exception, captureContext) => {\n  try {\n    const eventId = naturalCaptureException(exception, captureContext);\n    log('capture exception', { exception, eventId, ...captureContext });\n    return eventId;\n  } catch (err) {\n    log.catch('Failed to capture exception', err);\n    return 'unknown';\n  }\n};\n\n// TODO(nf): move to log package as a first-class processor.\nexport const enableSentryLogProcessor = (filter?: string | string[] | LogLevel) => {\n  log.runtimeConfig.processors.push(SENTRY_LOG_PROCESSOR);\n};\n\nexport const SENTRY_LOG_PROCESSOR = (config: any, entry: any) => {\n  const { message, level, meta, error } = entry;\n  if (!shouldLog(entry, config.captureFilters)) {\n    return;\n  }\n  // TODO(nf): add rate limiting to avoid spamming Sentry/consuming excessive quota.\n  withScope((scope) => {\n    scope.setLevel(convertLevel(level));\n    scope.setContext('dxoslog', entry.context);\n    if (meta) {\n      scope.setTransactionName(`${getRelativeFilename(meta.F)}:${meta.L}`);\n    }\n    // Is this ever used?\n    if (error) {\n      scope.setExtra('message', message);\n      return naturalCaptureException(error);\n    }\n\n    naturalCaptureMessage(message);\n  });\n};\n\nconst convertLevel = (level: LogLevel): SeverityLevel => {\n  if (level === LogLevel.TRACE) {\n    return 'debug';\n  }\n  if (level === LogLevel.WARN) {\n    return 'warning';\n  }\n  return LogLevel[level].toLowerCase() as SeverityLevel;\n};\n\nconst getRelativeFilename = (filename: string) => {\n  // TODO(burdon): Hack uses \"packages\" as an anchor (pre-parse NX?)\n  // Including `packages/` part of the path so that excluded paths (e.g. from dist) are clickable in vscode.\n  const match = filename.match(/.+\\/(packages\\/.+\\/.+)/);\n  if (match) {\n    const [, filePath] = match;\n    return filePath;\n  }\n\n  return filename;\n};\n", "//\n// Copyright 2023 DXOS.org\n//\n\n// NOTE: Browser only API. There is no node polyfill.\n\nimport { getCurrentHub } from '@sentry/browser';\nimport { type Transaction, type Span } from '@sentry/types';\n\nimport { runInContext, scheduleMicroTask, Trigger } from '@dxos/async';\nimport { Context } from '@dxos/context';\nimport { invariant } from '@dxos/invariant';\nimport { getContextFromEntry, log, LogLevel, type LogProcessor } from '@dxos/log';\n\nconst REPORT_SPANS = false;\n\nlet TX!: Transaction;\nconst SPAN_MAP = new Map<string, Span>();\nconst SENTRY_INITIALIZED = new Trigger();\nconst ctx = new Context({ onError: (err) => log.warn('Unhandled error in Sentry context', err) });\nctx.maxSafeDisposeCallbacks = 10_000;\n\nlet tracingConfigured = false;\n\nexport const configureTracing = () => {\n  tracingConfigured = true;\n  runInContext(ctx, () => {\n    // Configure root transaction.\n    TX = getCurrentHub().startTransaction({\n      name: 'DXOS Core Tracing',\n      op: 'dxos',\n    });\n    invariant(TX, 'Failed to create trace');\n    if (typeof window !== 'undefined') {\n      window.addEventListener('beforeunload', () => {\n        finish();\n      });\n    }\n    if (typeof process !== 'undefined') {\n      process.on('exit', () => {\n        finish();\n      });\n    }\n\n    SENTRY_INITIALIZED.wake();\n  });\n};\n\nexport const finish = () => {\n  for (const span of Array.from(SPAN_MAP.values()).reverse()) {\n    try {\n      span.finish();\n    } catch (err) {\n      log.warn('Failed to finish span', err);\n    }\n  }\n  TX.finish();\n};\n\nexport const SENTRY_PROCESSOR: LogProcessor = (config, entry) => {\n  if (!tracingConfigured) {\n    return;\n  }\n\n  const { message, level, error } = entry;\n  const context = getContextFromEntry(entry);\n\n  if (level !== LogLevel.TRACE) {\n    return;\n  }\n\n  // NOTE: Make sure `entry` is not captured in this closure to avoid a memory leak.\n  scheduleMicroTask(ctx, async () => {\n    await SENTRY_INITIALIZED.wait();\n\n    if (REPORT_SPANS && context?.span) {\n      switch (context.span.command) {\n        case 'begin': {\n          const id = context.span.id;\n\n          if (!id || SPAN_MAP.has(id)) {\n            log.warn('Cannot begin span', id);\n            return;\n          }\n\n          let parentSpan: Span = TX;\n          if (context.span.parent) {\n            parentSpan = SPAN_MAP.get(context.span.parent) ?? TX;\n          }\n\n          let logContext: string;\n          try {\n            logContext = JSON.stringify({ ...context, message, level, error });\n          } catch (err) {\n            logContext = JSON.stringify(context);\n          }\n\n          const span = parentSpan.startChild({\n            op: message,\n            data: {\n              ...context.span.data,\n              '@dxos/log': logContext,\n            },\n          });\n          SPAN_MAP.set(context.span.id, span);\n          break;\n        }\n\n        case 'end': {\n          const span = SPAN_MAP.get(context.span.id);\n          if (span) {\n            span.setStatus(getSpanStatus(context.span.status));\n            context.span.data && Object.entries(context.span.data).forEach(([key, value]) => span.setData(key, value));\n            span.finish();\n            SPAN_MAP.delete(context.span.id);\n          } else {\n            log.warn('Cannot end span', context.span.id);\n          }\n          break;\n        }\n\n        case 'update': {\n          const span = SPAN_MAP.get(context.span.id);\n          if (span) {\n            context.span.data && Object.entries(context.span.data).forEach(([key, value]) => span.setData(key, value));\n          } else {\n            log.warn('Cannot update span', context.span.id);\n          }\n          break;\n        }\n\n        default: {\n          log.warn('Unknown span command', context.span.command);\n        }\n      }\n    }\n  });\n};\n\nlog.runtimeConfig.processors.push(SENTRY_PROCESSOR);\n\n/**\n * @see https://develop.sentry.dev/sdk/event-payloads/span/#:~:text=this%20value%20explicitly.-,status,-Optional.%20Describes%20the\n */\nconst getSpanStatus = (status?: 'ok' | 'error') => {\n  switch (status) {\n    case 'ok':\n      return 'ok';\n    case 'error':\n      return 'not_found';\n  }\n  return status ?? 'ok';\n};\n"],
+  "mappings": "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",
+  "names": ["import_node", "import_log", "init", "options", "tracing", "naturalInit", "enabled", "enable", "dsn", "destination", "serverName", "installationId", "release", "environment", "process", "env", "DX_ENVIRONMENT", "integrations", "captureConsoleIntegration", "levels", "tracesSampleRate", "sampleRate", "transport", "beforeSend", "event", "scrubFilenames", "scrub", "onError", "Object", "entries", "properties", "forEach", "key", "value", "setTag", "err", "log", "catch", "exception", "values", "stacktrace", "frames", "frame", "filename", "split", "length", "addBreadcrumb", "breadcrumb", "naturalAddBreadcrumb", "captureException", "captureContext", "eventId", "naturalCaptureException", "enableSentryLogProcessor", "filter", "runtimeConfig", "processors", "push", "SENTRY_LOG_PROCESSOR", "config", "entry", "message", "level", "meta", "error", "shouldLog", "captureFilters", "withScope", "scope", "setLevel", "convertLevel", "setContext", "context", "setTransactionName", "getRelativeFilename", "F", "L", "setExtra", "naturalCaptureMessage", "LogLevel", "TRACE", "WARN", "toLowerCase", "match", "filePath", "REPORT_SPANS", "TX", "SPAN_MAP", "Map", "SENTRY_INITIALIZED", "Trigger", "ctx", "Context", "warn", "maxSafeDisposeCallbacks", "tracingConfigured", "configureTracing", "runInContext", "getCurrentHub", "startTransaction", "name", "op", "invariant", "window", "addEventListener", "finish", "on", "wake", "span", "Array", "from", "reverse", "SENTRY_PROCESSOR", "getContextFromEntry", "scheduleMicroTask", "wait", "command", "id", "has", "parentSpan", "parent", "get", "logContext", "JSON", "stringify", "startChild", "data", "set", "setStatus", "getSpanStatus", "status", "setData", "delete"]
+}

package/dist/lib/node/chunk-VDBBIYH6.cjs

@@ -0,0 +1,101 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_VDBBIYH6_exports = {};
+__export(chunk_VDBBIYH6_exports, {
+  DatadogMetrics: () => DatadogMetrics,
+  defaultOptions: () => defaultOptions
+});
+module.exports = __toCommonJS(chunk_VDBBIYH6_exports);
+var import_node_os = __toESM(require("node:os"));
+var import_log = require("@dxos/log");
+var Datadog = __toESM(require("datadog-metrics"));
+var import_debug = __toESM(require("debug"));
+var import_invariant = require("@dxos/invariant");
+var import_log2 = require("@dxos/log");
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/sdk/observability/src/datadog/node.ts";
+var defaultOptions = ({ apiKey, host }) => {
+  return {
+    apiKey,
+    host: host ?? import_node_os.default.hostname(),
+    onError: (err) => {
+      import_log.log.info("Datadog error", {
+        err
+      }, {
+        F: __dxlog_file,
+        L: 16,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+    }
+  };
+};
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/sdk/observability/src/datadog/metrics.ts";
+import_debug.default.enable("metrics");
+var DatadogMetrics = class {
+  constructor(options) {
+    this._getTags = options.getTags;
+    this._datadogmetrics = Datadog;
+    this._datadogmetrics.init(defaultOptions(options));
+  }
+  gauge(name, value, tags) {
+    (0, import_invariant.invariant)(this._datadogmetrics, "Datadog not initialized", {
+      F: __dxlog_file2,
+      L: 38,
+      S: this,
+      A: [
+        "this._datadogmetrics",
+        "'Datadog not initialized'"
+      ]
+    });
+    const mergedTags = Object.entries({
+      ...Object.fromEntries(this._getTags().entries()),
+      ...tags
+    }).map(([key, value2]) => `${key}:${value2}`);
+    (0, import_log2.log)("datadog gauge", {
+      name,
+      value,
+      tags: mergedTags
+    }, {
+      F: __dxlog_file2,
+      L: 42,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._datadogmetrics.gauge(name, value, mergedTags);
+  }
+  flush() {
+    this._datadogmetrics.flush();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatadogMetrics,
+  defaultOptions
+});
+//# sourceMappingURL=chunk-VDBBIYH6.cjs.map

package/dist/lib/node/chunk-VDBBIYH6.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/datadog/node.ts", "../../../src/datadog/metrics.ts"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport os from 'node:os';\n\nimport { log } from '@dxos/log';\n\nimport { type DatadogOptions } from './metrics';\n\nexport const defaultOptions = ({ apiKey, host }: DatadogOptions) => {\n  return {\n    apiKey,\n    host: host ?? os.hostname(),\n    onError: (err: any) => {\n      log.info('Datadog error', { err });\n    },\n  };\n};\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport * as Datadog from 'datadog-metrics';\nimport debug from 'debug';\n\nimport { type Config } from '@dxos/client';\nimport { invariant } from '@dxos/invariant';\nimport { log } from '@dxos/log';\n\nimport { defaultOptions } from './node';\n// import { tags as globalTags } from '../tags';\n\nexport type DatadogOptions = {\n  apiKey: string;\n  host?: string;\n  site?: String;\n  getTags: () => Map<string, string>;\n  // needed to read CORS proxy\n  config: Config;\n};\n\ndebug.enable('metrics');\n\nexport class DatadogMetrics {\n  private _datadogmetrics?: any;\n  private _getTags: () => Map<string, string>;\n\n  constructor(options: DatadogOptions) {\n    this._getTags = options.getTags;\n    this._datadogmetrics = Datadog;\n\n    this._datadogmetrics.init(defaultOptions(options));\n  }\n\n  gauge(name: string, value: number, tags?: any) {\n    invariant(this._datadogmetrics, 'Datadog not initialized');\n    const mergedTags = Object.entries({ ...Object.fromEntries(this._getTags().entries()), ...tags }).map(\n      ([key, value]) => `${key}:${value}`,\n    );\n    log('datadog gauge', { name, value, tags: mergedTags });\n    this._datadogmetrics.gauge(name, value, mergedTags);\n  }\n\n  flush() {\n    this._datadogmetrics.flush();\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,qBAAe;AAEf,iBAAoB;ACFpB,cAAyB;AACzB,mBAAkB;AAGlB,uBAA0B;AAC1B,IAAAA,cAAoB;;ADCb,IAAMC,iBAAiB,CAAC,EAAEC,QAAQC,KAAI,MAAkB;AAC7D,SAAO;IACLD;IACAC,MAAMA,QAAQC,eAAAA,QAAGC,SAAQ;IACzBC,SAAS,CAACC,QAAAA;AACRC,qBAAIC,KAAK,iBAAiB;QAAEF;MAAI,GAAA;;;;;;IAClC;EACF;AACF;;ACKAG,aAAAA,QAAMC,OAAO,SAAA;AAEN,IAAMC,iBAAN,MAAMA;EAIXC,YAAYC,SAAyB;AACnC,SAAKC,WAAWD,QAAQE;AACxB,SAAKC,kBAAkBC;AAEvB,SAAKD,gBAAgBE,KAAKlB,eAAea,OAAAA,CAAAA;EAC3C;EAEAM,MAAMC,MAAcC,OAAeC,MAAY;AAC7CC,oCAAU,KAAKP,iBAAiB,2BAAA;;;;;;;;;AAChC,UAAMQ,aAAaC,OAAOC,QAAQ;MAAE,GAAGD,OAAOE,YAAY,KAAKb,SAAQ,EAAGY,QAAO,CAAA;MAAK,GAAGJ;IAAK,CAAA,EAAGM,IAC/F,CAAC,CAACC,KAAKR,MAAAA,MAAW,GAAGQ,GAAAA,IAAOR,MAAAA,EAAO;AAErCd,oBAAAA,KAAI,iBAAiB;MAAEa;MAAMC;MAAOC,MAAME;IAAW,GAAA;;;;;;AACrD,SAAKR,gBAAgBG,MAAMC,MAAMC,OAAOG,UAAAA;EAC1C;EAEAM,QAAQ;AACN,SAAKd,gBAAgBc,MAAK;EAC5B;AACF;",
+  "names": ["import_log", "defaultOptions", "apiKey", "host", "os", "hostname", "onError", "err", "log", "info", "debug", "enable", "DatadogMetrics", "constructor", "options", "_getTags", "getTags", "_datadogmetrics", "Datadog", "init", "gauge", "name", "value", "tags", "invariant", "mergedTags", "Object", "entries", "fromEntries", "map", "key", "flush"]
+}

package/dist/lib/node/datadog/index.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var datadog_exports = {};
+__export(datadog_exports, {
+  DatadogMetrics: () => import_chunk_VDBBIYH6.DatadogMetrics,
+  defaultOptions: () => import_chunk_VDBBIYH6.defaultOptions
+});
+module.exports = __toCommonJS(datadog_exports);
+var import_chunk_VDBBIYH6 = require("../chunk-VDBBIYH6.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatadogMetrics,
+  defaultOptions
+});
+//# sourceMappingURL=index.cjs.map

package/dist/lib/node/datadog/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["index.cjs"],
+  "sourcesContent": ["import {\n  DatadogMetrics,\n  defaultOptions\n} from \"../chunk-VDBBIYH6.cjs\";\nexport {\n  DatadogMetrics,\n  defaultOptions\n};\n//# sourceMappingURL=index.cjs.map\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4BAGO;",
+  "names": []
+}