@sentry/node 10.68.0 → 11.0.0-alpha.0

package/build/cjs/integrations/childProcess.js

@@ -0,0 +1,81 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const diagnosticsChannel = require('node:diagnostics_channel');
+const core = require('@sentry/core');
+
+const INTEGRATION_NAME = "ChildProcess";
+const childProcessIntegration = core.defineIntegration((options = {}) => {
+  return {
+    name: INTEGRATION_NAME,
+    setup() {
+      diagnosticsChannel.channel("child_process").subscribe((event) => {
+        if (core.isObjectLike(event) && "process" in event) {
+          captureChildProcessEvents(event.process, options);
+        }
+      });
+      diagnosticsChannel.channel("worker_threads").subscribe((event) => {
+        if (core.isObjectLike(event) && "worker" in event) {
+          captureWorkerThreadEvents(event.worker, options);
+        }
+      });
+    }
+  };
+});
+function captureChildProcessEvents(child, options) {
+  let hasExited = false;
+  let data;
+  child.on("spawn", () => {
+    if (child.spawnfile === "/usr/bin/sw_vers") {
+      hasExited = true;
+      return;
+    }
+    data = { spawnfile: child.spawnfile };
+    if (options.includeChildProcessArgs) {
+      data.spawnargs = child.spawnargs;
+    }
+  }).on("exit", (code) => {
+    if (!hasExited) {
+      hasExited = true;
+      if (code !== null && code !== 0) {
+        core.addBreadcrumb({
+          category: "child_process",
+          message: `Child process exited with code '${code}'`,
+          level: code === 0 ? "info" : "warning",
+          data
+        });
+      }
+    }
+  }).on("error", (error) => {
+    if (!hasExited) {
+      hasExited = true;
+      core.addBreadcrumb({
+        category: "child_process",
+        message: `Child process errored with '${error.message}'`,
+        level: "error",
+        data
+      });
+    }
+  });
+}
+function captureWorkerThreadEvents(worker, options) {
+  let threadId;
+  worker.on("online", () => {
+    threadId = worker.threadId;
+  }).on("error", (error) => {
+    if (options.captureWorkerErrors !== false) {
+      core.captureException(error, {
+        mechanism: { type: "auto.child_process.worker_thread", handled: false, data: { threadId: String(threadId) } }
+      });
+    } else {
+      core.addBreadcrumb({
+        category: "worker_thread",
+        message: `Worker thread errored with '${error.message}'`,
+        level: "error",
+        data: { threadId }
+      });
+    }
+  });
+}
+
+exports.childProcessIntegration = childProcessIntegration;
+//# sourceMappingURL=childProcess.js.map

package/build/cjs/integrations/childProcess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"childProcess.js","sources":["../../../src/integrations/childProcess.ts"],"sourcesContent":["import type { ChildProcess } from 'node:child_process';\nimport * as diagnosticsChannel from 'node:diagnostics_channel';\nimport type { Worker } from 'node:worker_threads';\nimport { addBreadcrumb, captureException, defineIntegration, isObjectLike } from '@sentry/core';\n\ninterface Options {\n  /**\n   * Whether to include child process arguments in breadcrumbs data.\n   *\n   * @default false\n   */\n  includeChildProcessArgs?: boolean;\n\n  /**\n   * Whether to capture errors from worker threads.\n   *\n   * @default true\n   */\n  captureWorkerErrors?: boolean;\n}\n\nconst INTEGRATION_NAME = 'ChildProcess' as const;\n\n/**\n * Capture breadcrumbs and events for child processes and worker threads.\n */\nexport const childProcessIntegration = defineIntegration((options: Options = {}) => {\n  return {\n    name: INTEGRATION_NAME,\n    setup() {\n      diagnosticsChannel.channel('child_process').subscribe((event: unknown) => {\n        if (isObjectLike(event) && 'process' in event) {\n          captureChildProcessEvents(event.process as ChildProcess, options);\n        }\n      });\n\n      diagnosticsChannel.channel('worker_threads').subscribe((event: unknown) => {\n        if (isObjectLike(event) && 'worker' in event) {\n          captureWorkerThreadEvents(event.worker as Worker, options);\n        }\n      });\n    },\n  };\n});\n\nfunction captureChildProcessEvents(child: ChildProcess, options: Options): void {\n  let hasExited = false;\n  let data: Record<string, unknown> | undefined;\n\n  child\n    .on('spawn', () => {\n      // This is Sentry getting macOS OS context\n      if (child.spawnfile === '/usr/bin/sw_vers') {\n        hasExited = true;\n        return;\n      }\n\n      data = { spawnfile: child.spawnfile };\n      if (options.includeChildProcessArgs) {\n        data.spawnargs = child.spawnargs;\n      }\n    })\n    .on('exit', code => {\n      if (!hasExited) {\n        hasExited = true;\n\n        // Only log for non-zero exit codes\n        if (code !== null && code !== 0) {\n          addBreadcrumb({\n            category: 'child_process',\n            message: `Child process exited with code '${code}'`,\n            level: code === 0 ? 'info' : 'warning',\n            data,\n          });\n        }\n      }\n    })\n    .on('error', error => {\n      if (!hasExited) {\n        hasExited = true;\n\n        addBreadcrumb({\n          category: 'child_process',\n          message: `Child process errored with '${error.message}'`,\n          level: 'error',\n          data,\n        });\n      }\n    });\n}\n\nfunction captureWorkerThreadEvents(worker: Worker, options: Options): void {\n  let threadId: number | undefined;\n\n  worker\n    .on('online', () => {\n      threadId = worker.threadId;\n    })\n    .on('error', error => {\n      if (options.captureWorkerErrors !== false) {\n        captureException(error, {\n          mechanism: { type: 'auto.child_process.worker_thread', handled: false, data: { threadId: String(threadId) } },\n        });\n      } else {\n        addBreadcrumb({\n          category: 'worker_thread',\n          message: `Worker thread errored with '${error.message}'`,\n          level: 'error',\n          data: { threadId },\n        });\n      }\n    });\n}\n"],"names":["defineIntegration","isObjectLike","addBreadcrumb","captureException"],"mappings":"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"}

package/build/cjs/integrations/console.js

@@ -0,0 +1,95 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+const consoleIntegration = core.defineIntegration((options = {}) => {
+  return {
+    name: "Console",
+    setup(client) {
+      if (process.env.LAMBDA_TASK_ROOT) {
+        core.maybeInstrument("console", instrumentConsoleLambda);
+      }
+      const core$1 = core.consoleIntegration({
+        ...options,
+        filter: [
+          ...options.filter || [],
+          // Deprecation on Node 26 for module.require(), which is used by IITM
+          "[DEP0205] DeprecationWarning"
+        ]
+      });
+      core$1.setup?.(client);
+    }
+  };
+});
+function instrumentConsoleLambda() {
+  const consoleObj = core.GLOBAL_OBJ?.console;
+  if (!consoleObj) {
+    return;
+  }
+  core.CONSOLE_LEVELS.forEach((level) => {
+    if (level in consoleObj) {
+      patchWithDefineProperty(consoleObj, level);
+    }
+  });
+}
+function patchWithDefineProperty(consoleObj, level) {
+  const nativeMethod = consoleObj[level];
+  core.originalConsoleMethods[level] = nativeMethod;
+  let delegate = nativeMethod;
+  let savedDelegate;
+  let isExecuting = false;
+  const wrapper = function(...args) {
+    if (isExecuting) {
+      nativeMethod.apply(consoleObj, args);
+      return;
+    }
+    isExecuting = true;
+    try {
+      core.triggerHandlers("console", { args, level });
+      delegate.apply(consoleObj, args);
+    } finally {
+      isExecuting = false;
+    }
+  };
+  core.markFunctionWrapped(wrapper, nativeMethod);
+  const sandboxBypass = nativeMethod.bind(consoleObj);
+  core.originalConsoleMethods[level] = sandboxBypass;
+  try {
+    let current = wrapper;
+    Object.defineProperty(consoleObj, level, {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return current;
+      },
+      set(newValue) {
+        if (newValue === wrapper) {
+          if (savedDelegate !== void 0) {
+            delegate = savedDelegate;
+            savedDelegate = void 0;
+          }
+          current = wrapper;
+        } else if (newValue === sandboxBypass) {
+          savedDelegate = delegate;
+          current = sandboxBypass;
+        } else if (typeof newValue === "function" && !newValue.__sentry_original__) {
+          delegate = newValue;
+          current = wrapper;
+        } else {
+          current = newValue;
+        }
+      }
+    });
+  } catch {
+    core.fill(consoleObj, level, function(originalConsoleMethod) {
+      core.originalConsoleMethods[level] = originalConsoleMethod;
+      return function(...args) {
+        core.triggerHandlers("console", { args, level });
+        core.originalConsoleMethods[level]?.apply(this, args);
+      };
+    });
+  }
+}
+
+exports.consoleIntegration = consoleIntegration;
+//# sourceMappingURL=console.js.map

package/build/cjs/integrations/console.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.js","sources":["../../../src/integrations/console.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { ConsoleLevel, WrappedFunction } from '@sentry/core';\nimport {\n  CONSOLE_LEVELS,\n  GLOBAL_OBJ,\n  consoleIntegration as coreConsoleIntegration,\n  defineIntegration,\n  fill,\n  markFunctionWrapped,\n  maybeInstrument,\n  originalConsoleMethods,\n  triggerHandlers,\n} from '@sentry/core';\n\ninterface ConsoleIntegrationOptions {\n  levels: ConsoleLevel[];\n  /**\n   * Filter out console messages that match the given strings or regular expressions.\n   * These will neither be passed to the handler, and they will also not be logged to the user, unless they have debug enabled.\n   */\n  filter?: (string | RegExp)[];\n}\n\n/**\n * Node-specific console integration that captures breadcrumbs and handles\n * the AWS Lambda runtime replacing console methods after our patch.\n *\n * In Lambda, console methods are patched via `Object.defineProperty` so that\n * external replacements (by the Lambda runtime) are absorbed as the delegate\n * while our wrapper stays in place. Outside Lambda, this delegates entirely\n * to the core `consoleIntegration` which uses the simpler `fill`-based patch.\n */\nexport const consoleIntegration = defineIntegration((options: Partial<ConsoleIntegrationOptions> = {}) => {\n  return {\n    name: 'Console' as const,\n    setup(client) {\n      if (process.env.LAMBDA_TASK_ROOT) {\n        maybeInstrument('console', instrumentConsoleLambda);\n      }\n\n      // Delegate breadcrumb handling to the core console integration.\n      const core = coreConsoleIntegration({\n        ...options,\n        filter: [\n          ...(options.filter || []),\n          // Deprecation on Node 26 for module.require(), which is used by IITM\n          '[DEP0205] DeprecationWarning',\n        ],\n      });\n      core.setup?.(client);\n    },\n  };\n});\n\n/**\n * NOTE: This currently ignores the filter option.\n * We can revisit this later.\n */\nfunction instrumentConsoleLambda(): void {\n  const consoleObj = GLOBAL_OBJ?.console;\n  if (!consoleObj) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach((level: ConsoleLevel) => {\n    if (level in consoleObj) {\n      patchWithDefineProperty(consoleObj, level);\n    }\n  });\n}\n\nfunction patchWithDefineProperty(consoleObj: Console, level: ConsoleLevel): void {\n  const nativeMethod = consoleObj[level] as (...args: unknown[]) => void;\n  originalConsoleMethods[level] = nativeMethod;\n\n  let delegate: Function = nativeMethod;\n  let savedDelegate: Function | undefined;\n  let isExecuting = false;\n\n  const wrapper = function (...args: any[]): void {\n    if (isExecuting) {\n      // Re-entrant call: a third party captured `wrapper` via the getter and calls it from inside their replacement. We must\n      // use `nativeMethod` (not `delegate`) to break the cycle, and we intentionally skip `triggerHandlers` to avoid duplicate\n      // breadcrumbs. The outer invocation already triggered the handlers for this console call.\n      nativeMethod.apply(consoleObj, args);\n      return;\n    }\n    isExecuting = true;\n    try {\n      triggerHandlers('console', { args, level });\n      delegate.apply(consoleObj, args);\n    } finally {\n      isExecuting = false;\n    }\n  };\n  markFunctionWrapped(wrapper, nativeMethod);\n\n  // consoleSandbox reads originalConsoleMethods[level] to temporarily bypass instrumentation. We replace it with a distinct reference (.bind creates a\n  // new function identity) so the setter can tell apart \"consoleSandbox bypass\" from \"external code restoring a native method captured before Sentry init.\"\n  const sandboxBypass = nativeMethod.bind(consoleObj);\n  originalConsoleMethods[level] = sandboxBypass;\n\n  try {\n    let current: any = wrapper;\n\n    Object.defineProperty(consoleObj, level, {\n      configurable: true,\n      enumerable: true,\n      get() {\n        return current;\n      },\n      set(newValue) {\n        if (newValue === wrapper) {\n          // consoleSandbox restoring the wrapper: recover the saved delegate.\n          if (savedDelegate !== undefined) {\n            delegate = savedDelegate;\n            savedDelegate = undefined;\n          }\n          current = wrapper;\n        } else if (newValue === sandboxBypass) {\n          // consoleSandbox entering bypass: save delegate, let getter return sandboxBypass directly so calls skip the wrapper entirely.\n          savedDelegate = delegate;\n          current = sandboxBypass;\n        } else if (typeof newValue === 'function' && !(newValue as WrappedFunction).__sentry_original__) {\n          delegate = newValue;\n          current = wrapper;\n        } else {\n          current = newValue;\n        }\n      },\n    });\n  } catch {\n    // Fall back to fill-based patching if defineProperty fails\n    fill(consoleObj, level, function (originalConsoleMethod: () => any): Function {\n      originalConsoleMethods[level] = originalConsoleMethod;\n\n      return function (this: Console, ...args: any[]): void {\n        triggerHandlers('console', { args, level });\n        originalConsoleMethods[level]?.apply(this, args);\n      };\n    });\n  }\n}\n"],"names":["defineIntegration","maybeInstrument","core","coreConsoleIntegration","GLOBAL_OBJ","CONSOLE_LEVELS","originalConsoleMethods","triggerHandlers","markFunctionWrapped","fill"],"mappings":"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"}

package/build/cjs/integrations/context.js

@@ -0,0 +1,391 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const node_child_process = require('node:child_process');
+const node_fs = require('node:fs');
+const os = require('node:os');
+const node_path = require('node:path');
+const util = require('node:util');
+const core = require('@sentry/core');
+
+const readFileAsync = util.promisify(node_fs.readFile);
+const readDirAsync = util.promisify(node_fs.readdir);
+const INTEGRATION_NAME = "Context";
+const _nodeContextIntegration = ((options = {}) => {
+  const _options = {
+    app: true,
+    os: true,
+    device: true,
+    culture: true,
+    cloudResource: true,
+    ...options
+  };
+  const appContext = _options.app ? getAppContext() : void 0;
+  const deviceContext = _options.device ? getDeviceContext(_options.device) : void 0;
+  const cultureContext = _options.culture ? getCultureContext() : void 0;
+  const cloudResourceContext = _options.cloudResource ? getCloudResourceContext() : void 0;
+  const osContextPromise = _options.os ? getOsContext() : void 0;
+  const cachedSpanAttributes = {
+    "process.runtime.engine.name": "v8",
+    "process.runtime.engine.version": process.versions.v8,
+    ...contextsToSpanAttributes({
+      app: appContext,
+      device: deviceContext,
+      culture: cultureContext,
+      cloud_resource: cloudResourceContext
+    })
+  };
+  if (osContextPromise) {
+    osContextPromise.then((osCtx) => Object.assign(cachedSpanAttributes, contextsToSpanAttributes({ os: osCtx }))).catch(() => {
+    });
+  }
+  const contextsPromise = (async () => {
+    const contexts = {};
+    if (osContextPromise) {
+      contexts.os = await osContextPromise;
+    }
+    if (appContext) {
+      contexts.app = appContext;
+    }
+    if (deviceContext) {
+      contexts.device = deviceContext;
+    }
+    if (cultureContext) {
+      contexts.culture = cultureContext;
+    }
+    if (cloudResourceContext) {
+      contexts.cloud_resource = cloudResourceContext;
+    }
+    return contexts;
+  })();
+  async function addContext(event) {
+    const updatedContext = _updateContext(await contextsPromise);
+    event.contexts = {
+      ...event.contexts,
+      app: { ...updatedContext.app, ...event.contexts?.app },
+      os: { ...updatedContext.os, ...event.contexts?.os },
+      device: { ...updatedContext.device, ...event.contexts?.device },
+      culture: { ...updatedContext.culture, ...event.contexts?.culture },
+      cloud_resource: { ...updatedContext.cloud_resource, ...event.contexts?.cloud_resource }
+    };
+    return event;
+  }
+  return {
+    name: INTEGRATION_NAME,
+    processEvent(event) {
+      return addContext(event);
+    },
+    processSegmentSpan(span) {
+      core.safeSetSpanJSONAttributes(span, cachedSpanAttributes);
+      core.safeSetSpanJSONAttributes(span, getDynamicSpanAttributes(appContext, deviceContext));
+    }
+  };
+});
+const nodeContextIntegration = core.defineIntegration(_nodeContextIntegration);
+function _updateContext(contexts) {
+  if (contexts.app?.app_memory) {
+    contexts.app.app_memory = process.memoryUsage().rss;
+  }
+  if (contexts.app?.free_memory && typeof process.availableMemory === "function") {
+    const freeMemory = process.availableMemory?.();
+    if (freeMemory != null) {
+      contexts.app.free_memory = freeMemory;
+    }
+  }
+  if (contexts.device?.free_memory) {
+    contexts.device.free_memory = os.freemem();
+  }
+  return contexts;
+}
+function contextsToSpanAttributes(contexts) {
+  const attrs = {};
+  const { app, device, os: osCtx, culture, cloud_resource } = contexts;
+  if (app) {
+    if (app.app_start_time) {
+      attrs["app.start_time"] = app.app_start_time;
+    }
+  }
+  if (device) {
+    if (device.arch) {
+      attrs["device.archs"] = [device.arch];
+    }
+    if (device.boot_time) {
+      attrs["device.boot_time"] = device.boot_time;
+    }
+    if (device.memory_size != null) {
+      attrs["device.memory_size"] = device.memory_size;
+    }
+    if (device.processor_count != null) {
+      attrs["device.processor_count"] = device.processor_count;
+    }
+    if (device.cpu_description) {
+      attrs["device.cpu_description"] = device.cpu_description;
+    }
+    if (device.processor_frequency != null) {
+      attrs["device.processor_frequency"] = device.processor_frequency;
+    }
+  }
+  if (osCtx) {
+    if (osCtx.name) {
+      attrs["os.name"] = osCtx.name;
+    }
+    if (osCtx.version) {
+      attrs["os.version"] = osCtx.version;
+    }
+    if (osCtx.kernel_version) {
+      attrs["os.kernel_version"] = osCtx.kernel_version;
+    }
+    if (osCtx.build) {
+      attrs["os.build"] = osCtx.build;
+    }
+  }
+  if (culture) {
+    if (culture.locale) {
+      attrs["culture.locale"] = culture.locale;
+    }
+    if (culture.timezone) {
+      attrs["culture.timezone"] = culture.timezone;
+    }
+  }
+  if (cloud_resource) {
+    for (const [key, value] of Object.entries(cloud_resource)) {
+      if (value != null) {
+        attrs[key] = value;
+      }
+    }
+  }
+  return attrs;
+}
+function getDynamicSpanAttributes(appContext, deviceContext) {
+  const attrs = {};
+  if (appContext) {
+    attrs["app.memory"] = process.memoryUsage().rss;
+    if (typeof process.availableMemory === "function") {
+      const freeMemory = process.availableMemory?.();
+      if (freeMemory != null) {
+        attrs["app.free_memory"] = freeMemory;
+      }
+    }
+  }
+  if (deviceContext?.free_memory != null) {
+    attrs["device.free_memory"] = os.freemem();
+  }
+  return attrs;
+}
+async function getOsContext() {
+  const platformId = os.platform();
+  switch (platformId) {
+    case "darwin":
+      return getDarwinInfo();
+    case "linux":
+      return getLinuxInfo();
+    default:
+      return {
+        name: PLATFORM_NAMES[platformId] || platformId,
+        version: os.release()
+      };
+  }
+}
+function getCultureContext() {
+  try {
+    if (typeof process.versions.icu !== "string") {
+      return;
+    }
+    const january = /* @__PURE__ */ new Date(9e8);
+    const spanish = new Intl.DateTimeFormat("es", { month: "long" });
+    if (spanish.format(january) === "enero") {
+      const options = Intl.DateTimeFormat().resolvedOptions();
+      return {
+        locale: options.locale,
+        timezone: options.timeZone
+      };
+    }
+  } catch {
+  }
+  return;
+}
+function getAppContext() {
+  const app_memory = process.memoryUsage().rss;
+  const app_start_time = new Date(Date.now() - process.uptime() * 1e3).toISOString();
+  const appContext = { app_start_time, app_memory };
+  if (typeof process.availableMemory === "function") {
+    const freeMemory = process.availableMemory?.();
+    if (freeMemory != null) {
+      appContext.free_memory = freeMemory;
+    }
+  }
+  return appContext;
+}
+function getDeviceContext(deviceOpt) {
+  const device = {};
+  let uptime;
+  try {
+    uptime = os.uptime();
+  } catch {
+  }
+  if (typeof uptime === "number") {
+    device.boot_time = new Date(Date.now() - uptime * 1e3).toISOString();
+  }
+  device.arch = os.arch();
+  if (deviceOpt === true || deviceOpt.memory) {
+    device.memory_size = os.totalmem();
+    device.free_memory = os.freemem();
+  }
+  if (deviceOpt === true || deviceOpt.cpu) {
+    const cpuInfo = os.cpus();
+    const firstCpu = cpuInfo?.[0];
+    if (firstCpu) {
+      device.processor_count = cpuInfo.length;
+      device.cpu_description = firstCpu.model;
+      device.processor_frequency = firstCpu.speed;
+    }
+  }
+  return device;
+}
+const PLATFORM_NAMES = {
+  aix: "IBM AIX",
+  freebsd: "FreeBSD",
+  openbsd: "OpenBSD",
+  sunos: "SunOS",
+  win32: "Windows",
+  ohos: "OpenHarmony",
+  android: "Android"
+};
+const LINUX_DISTROS = [
+  { name: "fedora-release", distros: ["Fedora"] },
+  { name: "redhat-release", distros: ["Red Hat Linux", "Centos"] },
+  { name: "redhat_version", distros: ["Red Hat Linux"] },
+  { name: "SuSE-release", distros: ["SUSE Linux"] },
+  { name: "lsb-release", distros: ["Ubuntu Linux", "Arch Linux"] },
+  { name: "debian_version", distros: ["Debian"] },
+  { name: "debian_release", distros: ["Debian"] },
+  { name: "arch-release", distros: ["Arch Linux"] },
+  { name: "gentoo-release", distros: ["Gentoo Linux"] },
+  { name: "novell-release", distros: ["SUSE Linux"] },
+  { name: "alpine-release", distros: ["Alpine Linux"] }
+];
+const LINUX_VERSIONS = {
+  alpine: (content) => content,
+  arch: (content) => matchFirst(/distrib_release=(.*)/, content),
+  centos: (content) => matchFirst(/release ([^ ]+)/, content),
+  debian: (content) => content,
+  fedora: (content) => matchFirst(/release (..)/, content),
+  mint: (content) => matchFirst(/distrib_release=(.*)/, content),
+  red: (content) => matchFirst(/release ([^ ]+)/, content),
+  suse: (content) => matchFirst(/VERSION = (.*)\n/, content),
+  ubuntu: (content) => matchFirst(/distrib_release=(.*)/, content)
+};
+function matchFirst(regex, text) {
+  const match = regex.exec(text);
+  return match ? match[1] : void 0;
+}
+async function getDarwinInfo() {
+  const darwinInfo = {
+    kernel_version: os.release(),
+    name: "Mac OS X",
+    version: `10.${Number(os.release().split(".")[0]) - 4}`
+  };
+  try {
+    const output = await new Promise((resolve, reject) => {
+      node_child_process.execFile("/usr/bin/sw_vers", (error, stdout) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(stdout);
+      });
+    });
+    darwinInfo.name = matchFirst(/^ProductName:\s+(.*)$/m, output);
+    darwinInfo.version = matchFirst(/^ProductVersion:\s+(.*)$/m, output);
+    darwinInfo.build = matchFirst(/^BuildVersion:\s+(.*)$/m, output);
+  } catch {
+  }
+  return darwinInfo;
+}
+function getLinuxDistroId(name) {
+  return name.split(" ")[0].toLowerCase();
+}
+async function getLinuxInfo() {
+  const linuxInfo = {
+    kernel_version: os.release(),
+    name: "Linux"
+  };
+  try {
+    const etcFiles = await readDirAsync("/etc");
+    const distroFile = LINUX_DISTROS.find((file) => etcFiles.includes(file.name));
+    if (!distroFile) {
+      return linuxInfo;
+    }
+    const distroPath = node_path.join("/etc", distroFile.name);
+    const contents = (await readFileAsync(distroPath, { encoding: "utf-8" })).toLowerCase();
+    const { distros } = distroFile;
+    linuxInfo.name = distros.find((d) => contents.indexOf(getLinuxDistroId(d)) >= 0) || distros[0];
+    const id = getLinuxDistroId(linuxInfo.name);
+    linuxInfo.version = LINUX_VERSIONS[id]?.(contents);
+  } catch {
+  }
+  return linuxInfo;
+}
+function getCloudResourceContext() {
+  if (process.env.VERCEL) {
+    return {
+      "cloud.provider": "vercel",
+      "cloud.region": process.env.VERCEL_REGION
+    };
+  } else if (process.env.AWS_REGION) {
+    return {
+      "cloud.provider": "aws",
+      "cloud.region": process.env.AWS_REGION,
+      "cloud.platform": process.env.AWS_EXECUTION_ENV
+    };
+  } else if (process.env.GCP_PROJECT) {
+    return {
+      "cloud.provider": "gcp"
+    };
+  } else if (process.env.ALIYUN_REGION_ID) {
+    return {
+      "cloud.provider": "alibaba_cloud",
+      "cloud.region": process.env.ALIYUN_REGION_ID
+    };
+  } else if (process.env.WEBSITE_SITE_NAME && process.env.REGION_NAME) {
+    return {
+      "cloud.provider": "azure",
+      "cloud.region": process.env.REGION_NAME
+    };
+  } else if (process.env.IBM_CLOUD_REGION) {
+    return {
+      "cloud.provider": "ibm_cloud",
+      "cloud.region": process.env.IBM_CLOUD_REGION
+    };
+  } else if (process.env.TENCENTCLOUD_REGION) {
+    return {
+      "cloud.provider": "tencent_cloud",
+      "cloud.region": process.env.TENCENTCLOUD_REGION,
+      "cloud.account.id": process.env.TENCENTCLOUD_APPID,
+      "cloud.availability_zone": process.env.TENCENTCLOUD_ZONE
+    };
+  } else if (process.env.NETLIFY) {
+    return {
+      "cloud.provider": "netlify"
+    };
+  } else if (process.env.FLY_REGION) {
+    return {
+      "cloud.provider": "fly.io",
+      "cloud.region": process.env.FLY_REGION
+    };
+  } else if (process.env.DYNO) {
+    return {
+      "cloud.provider": "heroku"
+    };
+  } else {
+    return void 0;
+  }
+}
+
+exports.contextsToSpanAttributes = contextsToSpanAttributes;
+exports.getAppContext = getAppContext;
+exports.getDeviceContext = getDeviceContext;
+exports.getDynamicSpanAttributes = getDynamicSpanAttributes;
+exports.nodeContextIntegration = nodeContextIntegration;
+exports.readDirAsync = readDirAsync;
+exports.readFileAsync = readFileAsync;
+//# sourceMappingURL=context.js.map