@depup/sentry__node 10.75.2-depup.0 → 11.0.0-depup.0

package/build/esm/integrations/node-fetch/undici-instrumentation.js

@@ -0,0 +1,266 @@
+import * as diagch from 'diagnostics_channel';
+import { URL } from 'url';
+import { LRUMap, safeCallback, isTracingSuppressed, debug, getUrlFragment, filterCollectedUrlQuery, getUrlQuery, filterCollectedUrl, stripDataUrlContent, getClient, hasSpanStreamingEnabled, getSanitizedUrlString, parseUrl, startInactiveSpan, httpHeadersToSpanAttributes, getSpanStatusFromHttpCode, SPAN_STATUS_ERROR, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME, HTTP_SPAN_NAME_FALLBACK } from '@sentry/core';
+import { addTracePropagationHeadersToFetchRequest, addFetchRequestBreadcrumb } from '../../utils/outgoingFetchRequest.js';
+import { URL_FRAGMENT, URL_QUERY, URL_PATH, URL_DOMAIN, URL_FULL, HTTP_RESPONSE_STATUS_CODE, URL_SCHEME, HTTP_REQUEST_METHOD, SENTRY_OP, SENTRY_KIND, SERVER_ADDRESS, SERVER_PORT, USER_AGENT_ORIGINAL, NETWORK_PEER_PORT, NETWORK_PEER_ADDRESS } from '@sentry/conventions/attributes';
+import { HTTP_CLIENT } from '@sentry/conventions/op';
+import { DEBUG_BUILD } from '../../debug-build.js';
+
+const ATTR_HTTP_REQUEST_METHOD_ORIGINAL = "http.request.method_original";
+let _isInstrumented = false;
+const spanFromReq = /* @__PURE__ */ new WeakMap();
+const ignoreRequestMap = /* @__PURE__ */ new WeakMap();
+const propagationDecisionMap = new LRUMap(100);
+function instrumentUndici(config = {}) {
+  if (_isInstrumented) {
+    return;
+  }
+  _isInstrumented = true;
+  subscribeToChannel("undici:request:create", (message) => onRequestCreated(config, message));
+  subscribeToChannel(
+    "undici:client:sendHeaders",
+    (message) => onRequestHeaders(config, message)
+  );
+  subscribeToChannel("undici:request:headers", (message) => onResponseHeaders(config, message));
+  subscribeToChannel("undici:request:trailers", (message) => onDone(message));
+  subscribeToChannel("undici:request:error", (message) => onError(message));
+}
+function subscribeToChannel(diagnosticChannel, onMessage) {
+  diagch.subscribe?.(diagnosticChannel, onMessage);
+}
+function parseRequestHeaders(request) {
+  const result = /* @__PURE__ */ new Map();
+  if (Array.isArray(request.headers)) {
+    for (let i = 0; i < request.headers.length; i += 2) {
+      const key = request.headers[i];
+      const value = request.headers[i + 1];
+      if (typeof key === "string" && value !== void 0) {
+        result.set(key.toLowerCase(), value);
+      }
+    }
+  } else if (typeof request.headers === "string") {
+    const headers = request.headers.split("\r\n");
+    for (const line of headers) {
+      if (!line) {
+        continue;
+      }
+      const colonIndex = line.indexOf(":");
+      if (colonIndex === -1) {
+        continue;
+      }
+      const key = line.substring(0, colonIndex).toLowerCase();
+      const value = line.substring(colonIndex + 1).trim();
+      const allValues = result.get(key);
+      if (allValues && Array.isArray(allValues)) {
+        allValues.push(value);
+      } else if (allValues) {
+        result.set(key, [allValues, value]);
+      } else {
+        result.set(key, value);
+      }
+    }
+  }
+  return result;
+}
+function onRequestCreated(config, { request }) {
+  const url = getAbsoluteUrl(request.origin, request.path);
+  const ignoredByCallback = safeCallback(
+    DEBUG_BUILD ? "The `ignoreOutgoingRequests` callback threw an error, not ignoring the request:" : "",
+    () => !!config.ignoreOutgoingRequests?.(url),
+    () => false
+  );
+  const ignoreForBreadcrumbs = isTracingSuppressed() || !!ignoredByCallback;
+  ignoreRequestMap.set(request, ignoreForBreadcrumbs);
+  if (!config.spans) {
+    if (config.tracePropagation !== false && !ignoreForBreadcrumbs) {
+      addTracePropagationHeadersToFetchRequest(request, propagationDecisionMap);
+    }
+    return;
+  }
+  if (request.method === "CONNECT" || ignoredByCallback) {
+    return;
+  }
+  let requestUrl;
+  try {
+    requestUrl = new URL(request.path, request.origin);
+  } catch (err) {
+    DEBUG_BUILD && debug.warn("could not determine url.full:", err);
+    return;
+  }
+  const urlScheme = requestUrl.protocol.replace(":", "");
+  const requestMethod = getRequestMethod(request.method);
+  const attributes = {
+    [SENTRY_KIND]: "client",
+    [SENTRY_OP]: HTTP_CLIENT,
+    [HTTP_REQUEST_METHOD]: requestMethod,
+    [ATTR_HTTP_REQUEST_METHOD_ORIGINAL]: request.method,
+    [URL_FULL]: filterCollectedUrl(requestUrl.toString()),
+    [URL_DOMAIN]: requestUrl.hostname || void 0,
+    [URL_PATH]: requestUrl.pathname,
+    [URL_QUERY]: filterCollectedUrlQuery(getUrlQuery(requestUrl.search)),
+    [URL_FRAGMENT]: getUrlFragment(requestUrl.hash),
+    [URL_SCHEME]: urlScheme,
+    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.http.node_fetch"
+  };
+  if (url.startsWith("data:")) {
+    const sanitizedUrl = stripDataUrlContent(url);
+    attributes[URL_FULL] = sanitizedUrl;
+    attributes[SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME] = `${request.method || "GET"} ${sanitizedUrl}`;
+  }
+  const schemePorts = { https: "443", http: "80" };
+  const serverAddress = requestUrl.hostname;
+  const serverPort = requestUrl.port || schemePorts[urlScheme];
+  attributes[SERVER_ADDRESS] = serverAddress;
+  if (serverPort && !isNaN(Number(serverPort))) {
+    attributes[SERVER_PORT] = Number(serverPort);
+  }
+  const headersMap = parseRequestHeaders(request);
+  const userAgentValues = headersMap.get("user-agent");
+  if (userAgentValues) {
+    const userAgent = Array.isArray(userAgentValues) ? userAgentValues[userAgentValues.length - 1] : userAgentValues;
+    attributes[USER_AGENT_ORIGINAL] = userAgent;
+  }
+  const isDataUrl = url.startsWith("data:");
+  const client = getClient();
+  let spanName;
+  if (requestMethod === "_OTHER") {
+    spanName = HTTP_SPAN_NAME_FALLBACK;
+  } else if (!!client && hasSpanStreamingEnabled(client)) {
+    spanName = requestUrl.hostname ? `${requestMethod} ${requestUrl.hostname}` : requestMethod;
+  } else if (isDataUrl) {
+    spanName = `${request.method || "GET"} ${stripDataUrlContent(url)}`;
+  } else {
+    spanName = `${requestMethod} ${getSanitizedUrlString(parseUrl(requestUrl.toString()))}`;
+  }
+  const span = startInactiveSpan({
+    name: spanName,
+    attributes,
+    onlyIfParent: !client || !hasSpanStreamingEnabled(client)
+  });
+  safeCallback(
+    DEBUG_BUILD ? "The `requestHook` callback threw an error:" : "",
+    () => config.requestHook?.(span, request),
+    () => void 0
+  );
+  addTracePropagationHeadersToFetchRequest(request, propagationDecisionMap, span);
+  spanFromReq.set(request, span);
+}
+function onRequestHeaders(config, { request, socket }) {
+  const span = spanFromReq.get(request);
+  if (!span) {
+    return;
+  }
+  const { remoteAddress, remotePort } = socket;
+  const spanAttributes = {
+    [NETWORK_PEER_ADDRESS]: remoteAddress,
+    [NETWORK_PEER_PORT]: remotePort
+  };
+  const client = getClient();
+  if (config.headersToSpanAttributes?.requestHeaders && client) {
+    const headersToAttribs = new Set(config.headersToSpanAttributes.requestHeaders.map((n) => n.toLowerCase()));
+    const headersMap = parseRequestHeaders(request);
+    const allowlisted = {};
+    for (const [name, value] of headersMap.entries()) {
+      if (headersToAttribs.has(name)) {
+        allowlisted[name] = value;
+      }
+    }
+    Object.assign(spanAttributes, httpHeadersToSpanAttributes(allowlisted, client.getDataCollectionOptions()));
+  }
+  span.setAttributes(spanAttributes);
+}
+function onResponseHeaders(config, { request, response }) {
+  const breadcrumbsEnabled = config.breadcrumbs !== false;
+  if (breadcrumbsEnabled && !ignoreRequestMap.get(request)) {
+    addFetchRequestBreadcrumb(request, response);
+  }
+  const span = spanFromReq.get(request);
+  if (!span) {
+    return;
+  }
+  const spanAttributes = {
+    [HTTP_RESPONSE_STATUS_CODE]: response.statusCode
+  };
+  safeCallback(
+    DEBUG_BUILD ? "The `responseHook` callback threw an error:" : "",
+    () => config.responseHook?.(span, { request, response }),
+    () => void 0
+  );
+  const client = getClient();
+  if (config.headersToSpanAttributes?.responseHeaders && client) {
+    const headersToAttribs = /* @__PURE__ */ new Set();
+    config.headersToSpanAttributes?.responseHeaders.forEach((name) => headersToAttribs.add(name.toLowerCase()));
+    const allowlisted = {};
+    for (let idx = 0; idx < response.headers.length; idx = idx + 2) {
+      const nameBuf = response.headers[idx];
+      const valueBuf = response.headers[idx + 1];
+      if (nameBuf === void 0 || valueBuf === void 0) {
+        continue;
+      }
+      const name = nameBuf.toString().toLowerCase();
+      if (headersToAttribs.has(name)) {
+        (allowlisted[name] ?? (allowlisted[name] = [])).push(valueBuf.toString());
+      }
+    }
+    Object.assign(
+      spanAttributes,
+      httpHeadersToSpanAttributes(allowlisted, client.getDataCollectionOptions(), "response")
+    );
+  }
+  span.setAttributes(spanAttributes);
+  if (response.statusCode >= 400) {
+    span.setStatus(getSpanStatusFromHttpCode(response.statusCode));
+  }
+}
+function onDone({ request }) {
+  const span = spanFromReq.get(request);
+  if (!span) {
+    return;
+  }
+  span.end();
+  spanFromReq.delete(request);
+}
+function onError({ request, error }) {
+  const span = spanFromReq.get(request);
+  if (!span) {
+    return;
+  }
+  span.setStatus({
+    code: SPAN_STATUS_ERROR,
+    message: error.message
+  });
+  span.end();
+  spanFromReq.delete(request);
+}
+function getRequestMethod(original) {
+  const knownMethods = {
+    CONNECT: true,
+    OPTIONS: true,
+    HEAD: true,
+    GET: true,
+    POST: true,
+    PUT: true,
+    PATCH: true,
+    DELETE: true,
+    TRACE: true,
+    // QUERY from https://datatracker.ietf.org/doc/rfc10008/
+    QUERY: true
+  };
+  if (original.toUpperCase() in knownMethods) {
+    return original.toUpperCase();
+  }
+  return "_OTHER";
+}
+function getAbsoluteUrl(origin, path = "/") {
+  const url = `${origin}`;
+  if (url.endsWith("/") && path.startsWith("/")) {
+    return `${url}${path.slice(1)}`;
+  }
+  if (!url.endsWith("/") && !path.startsWith("/")) {
+    return `${url}/${path}`;
+  }
+  return `${url}${path}`;
+}
+
+export { instrumentUndici };
+//# sourceMappingURL=undici-instrumentation.js.map

package/build/esm/integrations/node-fetch/undici-instrumentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"undici-instrumentation.js","sources":["../../../../src/integrations/node-fetch/undici-instrumentation.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/ed97091c9890dd18e52759f2ea98e9d7593b3ae4/packages/instrumentation-undici\n * - Upstream version: @opentelemetry/instrumentation-undici@0.24.0\n * - Tracking issue: https://github.com/getsentry/sentry-javascript/issues/20165\n * - Refactored to use Sentry's span APIs instead of OpenTelemetry tracing APIs\n * - Dropped the OTel metrics (no MeterProvider is wired up) and the dead\n *   `requireParentforSpans` code path (the SDK always passes `false`)\n * - Dropped the `@opentelemetry/instrumentation` base (undici reports via `diagnostics_channel`,\n *   so no module patching was needed) — exposed as a plain `instrumentUndici()` function that the\n *   integration wires up directly\n */\n\n/* eslint-disable max-lines */\n\nimport * as diagch from 'diagnostics_channel';\nimport { URL } from 'url';\n\nimport type { Span, SpanAttributes } from '@sentry/core';\nimport {\n  debug,\n  getClient,\n  getSanitizedUrlString,\n  getSpanStatusFromHttpCode,\n  hasSpanStreamingEnabled,\n  HTTP_SPAN_NAME_FALLBACK,\n  isTracingSuppressed,\n  LRUMap,\n  parseUrl,\n  safeCallback,\n  SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SPAN_STATUS_ERROR,\n  startInactiveSpan,\n  stripDataUrlContent,\n  getUrlFragment,\n  getUrlQuery,\n  filterCollectedUrl,\n  filterCollectedUrlQuery,\n  httpHeadersToSpanAttributes,\n} from '@sentry/core';\nimport { addFetchRequestBreadcrumb, addTracePropagationHeadersToFetchRequest } from '../../utils/outgoingFetchRequest';\nimport {\n  HTTP_REQUEST_METHOD,\n  HTTP_RESPONSE_STATUS_CODE,\n  NETWORK_PEER_ADDRESS,\n  NETWORK_PEER_PORT,\n  SENTRY_KIND,\n  SENTRY_OP,\n  SERVER_ADDRESS,\n  SERVER_PORT,\n  URL_DOMAIN,\n  URL_FRAGMENT,\n  URL_FULL,\n  URL_PATH,\n  URL_QUERY,\n  URL_SCHEME,\n  USER_AGENT_ORIGINAL,\n} from '@sentry/conventions/attributes';\nimport { HTTP_CLIENT } from '@sentry/conventions/op';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport type {\n  NodeFetchOptions,\n  UndiciRequest,\n  RequestErrorMessage,\n  RequestHeadersMessage,\n  RequestMessage,\n  RequestTrailersMessage,\n  ResponseHeadersMessage,\n} from './types';\n\n// `http.request.method_original` is not part of `@sentry/conventions`, so we keep it inline.\nconst ATTR_HTTP_REQUEST_METHOD_ORIGINAL = 'http.request.method_original';\n\nlet _isInstrumented = false;\nconst spanFromReq = new WeakMap<UndiciRequest, Span>();\n// Whether breadcrumbs (and span-less trace propagation) should be skipped for a given request.\n// We evaluate this at request-creation time because the active context is no longer correct by the\n// time the response-headers event fires.\nconst ignoreRequestMap = new WeakMap<UndiciRequest, boolean>();\n// Caches trace-propagation decisions per URL so we don't recompute the `tracePropagationTargets` regexes per request.\nconst propagationDecisionMap = new LRUMap<string, boolean>(100);\n\n/**\n * Instrument outgoing HTTP requests made through `undici` or the global `fetch` API: emit `http.client`\n * spans, record breadcrumbs, and propagate traces into the outgoing request headers.\n *\n * Span creation is gated by the `spans` option (defaults to `true`). When spans are disabled, breadcrumbs\n * are still recorded and trace propagation headers are still injected (gated by `tracePropagation`).\n *\n * undici reports its request lifecycle via `diagnostics_channel`, so rather than patching any module we\n * subscribe to those channels directly. This is idempotent — subsequent calls are no-ops once the\n * channels have been subscribed to, and the config of the first call wins.\n *\n * A combination of https://github.com/elastic/apm-agent-nodejs and\n * https://github.com/gadget-inc/opentelemetry-instrumentations/blob/main/packages/opentelemetry-instrumentation-undici/src/index.ts\n */\nexport function instrumentUndici(config: NodeFetchOptions = {}): void {\n  // Avoid duplicate subscriptions\n  if (_isInstrumented) {\n    return;\n  }\n  _isInstrumented = true;\n\n  subscribeToChannel('undici:request:create', message => onRequestCreated(config, message as RequestMessage));\n  subscribeToChannel('undici:client:sendHeaders', message =>\n    onRequestHeaders(config, message as RequestHeadersMessage),\n  );\n  subscribeToChannel('undici:request:headers', message => onResponseHeaders(config, message as ResponseHeadersMessage));\n  subscribeToChannel('undici:request:trailers', message => onDone(message as RequestTrailersMessage));\n  subscribeToChannel('undici:request:error', message => onError(message as RequestErrorMessage));\n}\n\nfunction subscribeToChannel(\n  diagnosticChannel: string,\n  onMessage: (message: unknown, name: string | symbol) => void,\n): void {\n  diagch.subscribe?.(diagnosticChannel, onMessage);\n}\n\nfunction parseRequestHeaders(request: UndiciRequest): Map<string, string | string[]> {\n  const result = new Map<string, string | string[]>();\n\n  if (Array.isArray(request.headers)) {\n    // headers are an array [k1, v2, k2, v2] (undici v6+)\n    // values could be string or a string[] for multiple values\n    for (let i = 0; i < request.headers.length; i += 2) {\n      const key = request.headers[i];\n      const value = request.headers[i + 1];\n\n      // Key should always be a string, but the types don't know that, and let's be safe\n      if (typeof key === 'string' && value !== undefined) {\n        result.set(key.toLowerCase(), value);\n      }\n    }\n  } else if (typeof request.headers === 'string') {\n    // headers are a raw string (undici v5)\n    // headers could be repeated in several lines for multiple values\n    const headers = request.headers.split('\\r\\n');\n    for (const line of headers) {\n      if (!line) {\n        continue;\n      }\n      const colonIndex = line.indexOf(':');\n      if (colonIndex === -1) {\n        // Invalid header? Probably this can't happen, but again let's be safe.\n        continue;\n      }\n      const key = line.substring(0, colonIndex).toLowerCase();\n      const value = line.substring(colonIndex + 1).trim();\n      const allValues = result.get(key);\n\n      if (allValues && Array.isArray(allValues)) {\n        allValues.push(value);\n      } else if (allValues) {\n        result.set(key, [allValues, value]);\n      } else {\n        result.set(key, value);\n      }\n    }\n  }\n  return result;\n}\n\n// This is the 1st message we receive for each request (fired after request creation). Here we will\n// create the span and populate some atttributes, then link the span to the request for further\n// span processing\nfunction onRequestCreated(config: NodeFetchOptions, { request }: RequestMessage): void {\n  const url = getAbsoluteUrl(request.origin, request.path);\n\n  const ignoredByCallback = safeCallback(\n    DEBUG_BUILD ? 'The `ignoreOutgoingRequests` callback threw an error, not ignoring the request:' : '',\n    () => !!config.ignoreOutgoingRequests?.(url),\n    () => false,\n  );\n\n  // Breadcrumbs & span-less trace propagation are additionally skipped when tracing is suppressed.\n  // We store this here because the active context is no longer correct in later channel events.\n  const ignoreForBreadcrumbs = isTracingSuppressed() || !!ignoredByCallback;\n  ignoreRequestMap.set(request, ignoreForBreadcrumbs);\n\n  // When spans are disabled we do not create a span, but we still inject trace propagation headers\n  // directly (unless disabled via `tracePropagation`).\n  if (!config.spans) {\n    if (config.tracePropagation !== false && !ignoreForBreadcrumbs) {\n      addTracePropagationHeadersToFetchRequest(request, propagationDecisionMap);\n    }\n    return;\n  }\n\n  // Ignore span creation if:\n  // - the outgoing request is ignored via config\n  // - method is 'CONNECT'\n  if (request.method === 'CONNECT' || ignoredByCallback) {\n    return;\n  }\n\n  let requestUrl;\n  try {\n    requestUrl = new URL(request.path, request.origin);\n  } catch (err) {\n    DEBUG_BUILD && debug.warn('could not determine url.full:', err);\n    // Skip instrumenting this request.\n    return;\n  }\n\n  const urlScheme = requestUrl.protocol.replace(':', '');\n  const requestMethod = getRequestMethod(request.method);\n  const attributes: SpanAttributes = {\n    [SENTRY_KIND]: 'client',\n    [SENTRY_OP]: HTTP_CLIENT,\n    [HTTP_REQUEST_METHOD]: requestMethod,\n    [ATTR_HTTP_REQUEST_METHOD_ORIGINAL]: request.method,\n    [URL_FULL]: filterCollectedUrl(requestUrl.toString()),\n    [URL_DOMAIN]: requestUrl.hostname || undefined,\n    [URL_PATH]: requestUrl.pathname,\n    [URL_QUERY]: filterCollectedUrlQuery(getUrlQuery(requestUrl.search)),\n    [URL_FRAGMENT]: getUrlFragment(requestUrl.hash),\n    [URL_SCHEME]: urlScheme,\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.node_fetch',\n  };\n\n  // Sanitize data URLs to prevent long base64 strings in span attributes\n  if (url.startsWith('data:')) {\n    const sanitizedUrl = stripDataUrlContent(url);\n    attributes[URL_FULL] = sanitizedUrl;\n    attributes[SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME] = `${request.method || 'GET'} ${sanitizedUrl}`;\n  }\n\n  const schemePorts: Record<string, string> = { https: '443', http: '80' };\n  const serverAddress = requestUrl.hostname;\n  const serverPort = requestUrl.port || schemePorts[urlScheme];\n\n  attributes[SERVER_ADDRESS] = serverAddress;\n  if (serverPort && !isNaN(Number(serverPort))) {\n    attributes[SERVER_PORT] = Number(serverPort);\n  }\n\n  // Get user agent from headers\n  const headersMap = parseRequestHeaders(request);\n  const userAgentValues = headersMap.get('user-agent');\n\n  if (userAgentValues) {\n    // NOTE: having multiple user agents is not expected so\n    // we're going to take last one like `curl` does\n    // ref: https://curl.se/docs/manpage.html#-A\n    const userAgent = Array.isArray(userAgentValues) ? userAgentValues[userAgentValues.length - 1] : userAgentValues;\n    attributes[USER_AGENT_ORIGINAL] = userAgent;\n  }\n\n  // Outside of span streaming, only record an `http.client` span when it has a parent. An orphan\n  // one (no local parent) is left to the server for the downstream sampling decision: `onlyIfParent`\n  // still creates a non-recording span so trace propagation headers are injected, but it isn't\n  // emitted as a standalone transaction. This rule also lives in `SentrySampler`, but that only runs\n  // when an OpenTelemetry SDK tracer provider is set up, so we enforce it here too, which covers\n  // SDKs that don't use an OpenTelemetry tracer provider at all.\n  const isDataUrl = url.startsWith('data:');\n  const client = getClient();\n\n  let spanName: string;\n  if (requestMethod === '_OTHER') {\n    spanName = HTTP_SPAN_NAME_FALLBACK;\n  } else if (!!client && hasSpanStreamingEnabled(client)) {\n    // With span streaming, span names have to be low cardinality, so the URL path is dropped and only\n    // the domain is kept. Outgoing requests have no route to parameterize, and data URLs have no domain.\n    spanName = requestUrl.hostname ? `${requestMethod} ${requestUrl.hostname}` : requestMethod;\n  } else if (isDataUrl) {\n    spanName = `${request.method || 'GET'} ${stripDataUrlContent(url)}`;\n  } else {\n    spanName = `${requestMethod} ${getSanitizedUrlString(parseUrl(requestUrl.toString()))}`;\n  }\n\n  const span = startInactiveSpan({\n    name: spanName,\n    attributes,\n    onlyIfParent: !client || !hasSpanStreamingEnabled(client),\n  });\n\n  // Execute the request hook if defined\n  safeCallback(\n    DEBUG_BUILD ? 'The `requestHook` callback threw an error:' : '',\n    () => config.requestHook?.(span, request),\n    () => undefined,\n  );\n\n  // Context propagation goes last so no hook can tamper the propagation headers.\n  // We propagate the trace data of the freshly created client span (not the active parent span)\n  // so downstream services are parented to the http.client span, matching the upstream behavior.\n  // This also de-duplicates against any trace headers the user set manually (e.g. via `getTraceData()`).\n  addTracePropagationHeadersToFetchRequest(request, propagationDecisionMap, span);\n\n  spanFromReq.set(request, span);\n}\n\n// This is the 2nd message we receive for each request. It is fired when connection with\n// the remote is established and about to send the first byte. Here we do have info about the\n// remote address and port so we can populate some `network.*` attributes into the span\nfunction onRequestHeaders(config: NodeFetchOptions, { request, socket }: RequestHeadersMessage): void {\n  const span = spanFromReq.get(request);\n\n  if (!span) {\n    return;\n  }\n\n  const { remoteAddress, remotePort } = socket;\n  const spanAttributes: SpanAttributes = {\n    [NETWORK_PEER_ADDRESS]: remoteAddress,\n    [NETWORK_PEER_PORT]: remotePort,\n  };\n\n  // After hooks have been processed (which may modify request headers)\n  // we can collect the headers based on the configuration\n  const client = getClient();\n  if (config.headersToSpanAttributes?.requestHeaders && client) {\n    const headersToAttribs = new Set(config.headersToSpanAttributes.requestHeaders.map(n => n.toLowerCase()));\n    const headersMap = parseRequestHeaders(request);\n\n    const allowlisted: Record<string, string | string[]> = {};\n    for (const [name, value] of headersMap.entries()) {\n      if (headersToAttribs.has(name)) {\n        allowlisted[name] = value;\n      }\n    }\n\n    // An entry in `headersToSpanAttributes` does not exempt a header from the `dataCollection`\n    // filtering, so the allowlisted subset goes through the same pipeline as any other header.\n    Object.assign(spanAttributes, httpHeadersToSpanAttributes(allowlisted, client.getDataCollectionOptions()));\n  }\n\n  span.setAttributes(spanAttributes);\n}\n\n// This is the 3rd message we get for each request and it's fired when the server\n// headers are received, body may not be accessible yet.\n// From the response headers we can set the status and content length\nfunction onResponseHeaders(config: NodeFetchOptions, { request, response }: ResponseHeadersMessage): void {\n  // Breadcrumbs are recorded independently of spans, so this runs even when span creation is disabled.\n  const breadcrumbsEnabled = config.breadcrumbs !== false;\n  if (breadcrumbsEnabled && !ignoreRequestMap.get(request)) {\n    addFetchRequestBreadcrumb(request, response);\n  }\n\n  const span = spanFromReq.get(request);\n\n  if (!span) {\n    return;\n  }\n\n  const spanAttributes: SpanAttributes = {\n    [HTTP_RESPONSE_STATUS_CODE]: response.statusCode,\n  };\n\n  // Execute the response hook if defined\n  safeCallback(\n    DEBUG_BUILD ? 'The `responseHook` callback threw an error:' : '',\n    () => config.responseHook?.(span, { request, response }),\n    () => undefined,\n  );\n\n  const client = getClient();\n  if (config.headersToSpanAttributes?.responseHeaders && client) {\n    const headersToAttribs = new Set<string>();\n    config.headersToSpanAttributes?.responseHeaders.forEach(name => headersToAttribs.add(name.toLowerCase()));\n\n    const allowlisted: Record<string, string[]> = {};\n    for (let idx = 0; idx < response.headers.length; idx = idx + 2) {\n      const nameBuf = response.headers[idx];\n      const valueBuf = response.headers[idx + 1];\n      if (nameBuf === undefined || valueBuf === undefined) {\n        continue;\n      }\n      const name = nameBuf.toString().toLowerCase();\n\n      if (headersToAttribs.has(name)) {\n        (allowlisted[name] ??= []).push(valueBuf.toString());\n      }\n    }\n\n    // An entry in `headersToSpanAttributes` does not exempt a header from the `dataCollection`\n    // filtering, so the allowlisted subset goes through the same pipeline as any other header.\n    Object.assign(\n      spanAttributes,\n      httpHeadersToSpanAttributes(allowlisted, client.getDataCollectionOptions(), 'response'),\n    );\n  }\n\n  span.setAttributes(spanAttributes);\n\n  // Resolve the HTTP status code to a Sentry span status here (like the raw http client/server\n  // instrumentation does) instead of setting a bare error and deferring to downstream inference.\n  // The SentryTracerProvider's status finalization reads the already-stringified span status, which\n  // can no longer be inferred back to `not_found` etc. the way the OpenTelemetry SDK exporter's\n  // `mapStatus` does from the raw `{ code, message }`.\n  if (response.statusCode >= 400) {\n    span.setStatus(getSpanStatusFromHttpCode(response.statusCode));\n  }\n}\n\n// This is the last event we receive if the request went without any errors\nfunction onDone({ request }: RequestTrailersMessage): void {\n  const span = spanFromReq.get(request);\n\n  if (!span) {\n    return;\n  }\n\n  span.end();\n  spanFromReq.delete(request);\n}\n\n// This is the event we get when something is wrong in the request like\n// - invalid options when calling `fetch` global API or any undici method for request\n// - connectivity errors such as unreachable host\n// - requests aborted through an `AbortController.signal`\n// NOTE: server errors are considered valid responses and it's the lib consumer\n// who should deal with that.\nfunction onError({ request, error }: RequestErrorMessage): void {\n  const span = spanFromReq.get(request);\n\n  if (!span) {\n    return;\n  }\n\n  // NOTE: in `undici@6.3.0` when request aborted the error type changes from\n  // a custom error (`RequestAbortedError`) to a built-in `DOMException` carrying\n  // some differences:\n  // - `code` is from DOMEXception (ABORT_ERR: 20)\n  // - `message` changes\n  // - stacktrace is smaller and contains node internal frames\n  span.setStatus({\n    code: SPAN_STATUS_ERROR,\n    message: error.message,\n  });\n  span.end();\n  spanFromReq.delete(request);\n}\n\nfunction getRequestMethod(original: string): string {\n  const knownMethods = {\n    CONNECT: true,\n    OPTIONS: true,\n    HEAD: true,\n    GET: true,\n    POST: true,\n    PUT: true,\n    PATCH: true,\n    DELETE: true,\n    TRACE: true,\n    // QUERY from https://datatracker.ietf.org/doc/rfc10008/\n    QUERY: true,\n  };\n\n  if (original.toUpperCase() in knownMethods) {\n    return original.toUpperCase();\n  }\n\n  return '_OTHER';\n}\n\n// Matching the behavior of the base instrumentation\nfunction getAbsoluteUrl(origin: string, path: string = '/'): string {\n  const url = `${origin}`;\n\n  if (url.endsWith('/') && path.startsWith('/')) {\n    return `${url}${path.slice(1)}`;\n  }\n\n  if (!url.endsWith('/') && !path.startsWith('/')) {\n    return `${url}/${path}`;\n  }\n\n  return `${url}${path}`;\n}\n"],"names":[],"mappings":"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"}

package/build/esm/integrations/nodeRuntimeMetrics.js

@@ -0,0 +1,179 @@
+import { monitorEventLoopDelay, performance } from 'perf_hooks';
+import { defineIntegration, _INTERNAL_safeDateNow, metrics } from '@sentry/core';
+import { _INTERNAL_safeUnref } from '@sentry/core/server';
+
+const INTEGRATION_NAME = "NodeRuntimeMetrics";
+const DEFAULT_INTERVAL_MS = 3e4;
+const MIN_COLLECTION_INTERVAL_MS = 1e3;
+const EVENT_LOOP_DELAY_RESOLUTION_MS = 10;
+function _INTERNAL_normalizeCollectionInterval(rawInterval, integrationName, defaultInterval) {
+  if (!Number.isFinite(rawInterval)) {
+    console.warn(
+      `[Sentry] ${integrationName}: collectionIntervalMs (${rawInterval}) is invalid. Using default of ${defaultInterval}ms.`
+    );
+    return defaultInterval;
+  }
+  if (rawInterval < MIN_COLLECTION_INTERVAL_MS) {
+    console.warn(
+      `[Sentry] ${integrationName}: collectionIntervalMs (${rawInterval}) is below the minimum of ${MIN_COLLECTION_INTERVAL_MS}ms. Using minimum of ${MIN_COLLECTION_INTERVAL_MS}ms.`
+    );
+    return MIN_COLLECTION_INTERVAL_MS;
+  }
+  return rawInterval;
+}
+const nodeRuntimeMetricsIntegration = defineIntegration((options = {}) => {
+  const collectionIntervalMs = _INTERNAL_normalizeCollectionInterval(
+    options.collectionIntervalMs ?? DEFAULT_INTERVAL_MS,
+    INTEGRATION_NAME,
+    DEFAULT_INTERVAL_MS
+  );
+  const collect = {
+    // Default on
+    cpuUtilization: true,
+    memHeapUsed: true,
+    memHeapTotal: true,
+    memRss: true,
+    eventLoopDelayP50: true,
+    eventLoopDelayP99: true,
+    eventLoopUtilization: true,
+    uptime: true,
+    // Default off
+    cpuTime: false,
+    memExternal: false,
+    eventLoopDelayMin: false,
+    eventLoopDelayMax: false,
+    eventLoopDelayMean: false,
+    eventLoopDelayP90: false,
+    ...options.collect
+  };
+  const needsEventLoopDelay = collect.eventLoopDelayP99 || collect.eventLoopDelayMin || collect.eventLoopDelayMax || collect.eventLoopDelayMean || collect.eventLoopDelayP50 || collect.eventLoopDelayP90;
+  const needsCpu = collect.cpuUtilization || collect.cpuTime;
+  let intervalId;
+  let prevCpuUsage;
+  let prevElu;
+  let prevFlushTime = 0;
+  let eventLoopDelayHistogram;
+  const resolutionNs = EVENT_LOOP_DELAY_RESOLUTION_MS * 1e6;
+  const nsToS = (ns) => Math.max(0, (ns - resolutionNs) / 1e9);
+  const METRIC_ATTRIBUTES = { attributes: { "sentry.origin": "auto.node.runtime_metrics" } };
+  const METRIC_ATTRIBUTES_BYTE = { unit: "byte", attributes: { "sentry.origin": "auto.node.runtime_metrics" } };
+  const METRIC_ATTRIBUTES_SECOND = { unit: "second", attributes: { "sentry.origin": "auto.node.runtime_metrics" } };
+  function collectMetrics() {
+    const now = _INTERNAL_safeDateNow();
+    const elapsed = now - prevFlushTime;
+    if (needsCpu && prevCpuUsage !== void 0) {
+      const delta = process.cpuUsage(prevCpuUsage);
+      if (collect.cpuTime) {
+        metrics.gauge("node.runtime.cpu.user", delta.user / 1e6, METRIC_ATTRIBUTES_SECOND);
+        metrics.gauge("node.runtime.cpu.system", delta.system / 1e6, METRIC_ATTRIBUTES_SECOND);
+      }
+      if (collect.cpuUtilization && elapsed > 0) {
+        metrics.gauge(
+          "node.runtime.cpu.utilization",
+          (delta.user + delta.system) / (elapsed * 1e3),
+          METRIC_ATTRIBUTES
+        );
+      }
+      prevCpuUsage = process.cpuUsage();
+    }
+    if (collect.memRss || collect.memHeapUsed || collect.memHeapTotal || collect.memExternal) {
+      const mem = process.memoryUsage();
+      if (collect.memRss) {
+        metrics.gauge("node.runtime.mem.rss", mem.rss, METRIC_ATTRIBUTES_BYTE);
+      }
+      if (collect.memHeapUsed) {
+        metrics.gauge("node.runtime.mem.heap_used", mem.heapUsed, METRIC_ATTRIBUTES_BYTE);
+      }
+      if (collect.memHeapTotal) {
+        metrics.gauge("node.runtime.mem.heap_total", mem.heapTotal, METRIC_ATTRIBUTES_BYTE);
+      }
+      if (collect.memExternal) {
+        metrics.gauge("node.runtime.mem.external", mem.external, METRIC_ATTRIBUTES_BYTE);
+        metrics.gauge("node.runtime.mem.array_buffers", mem.arrayBuffers, METRIC_ATTRIBUTES_BYTE);
+      }
+    }
+    if (needsEventLoopDelay && eventLoopDelayHistogram) {
+      if (collect.eventLoopDelayMin) {
+        metrics.gauge(
+          "node.runtime.event_loop.delay.min",
+          nsToS(eventLoopDelayHistogram.min),
+          METRIC_ATTRIBUTES_SECOND
+        );
+      }
+      if (collect.eventLoopDelayMax) {
+        metrics.gauge(
+          "node.runtime.event_loop.delay.max",
+          nsToS(eventLoopDelayHistogram.max),
+          METRIC_ATTRIBUTES_SECOND
+        );
+      }
+      if (collect.eventLoopDelayMean) {
+        metrics.gauge(
+          "node.runtime.event_loop.delay.mean",
+          nsToS(eventLoopDelayHistogram.mean),
+          METRIC_ATTRIBUTES_SECOND
+        );
+      }
+      if (collect.eventLoopDelayP50) {
+        metrics.gauge(
+          "node.runtime.event_loop.delay.p50",
+          nsToS(eventLoopDelayHistogram.percentile(50)),
+          METRIC_ATTRIBUTES_SECOND
+        );
+      }
+      if (collect.eventLoopDelayP90) {
+        metrics.gauge(
+          "node.runtime.event_loop.delay.p90",
+          nsToS(eventLoopDelayHistogram.percentile(90)),
+          METRIC_ATTRIBUTES_SECOND
+        );
+      }
+      if (collect.eventLoopDelayP99) {
+        metrics.gauge(
+          "node.runtime.event_loop.delay.p99",
+          nsToS(eventLoopDelayHistogram.percentile(99)),
+          METRIC_ATTRIBUTES_SECOND
+        );
+      }
+      eventLoopDelayHistogram.reset();
+    }
+    if (collect.eventLoopUtilization && prevElu !== void 0) {
+      const currentElu = performance.eventLoopUtilization();
+      const delta = performance.eventLoopUtilization(currentElu, prevElu);
+      metrics.gauge("node.runtime.event_loop.utilization", delta.utilization, METRIC_ATTRIBUTES);
+      prevElu = currentElu;
+    }
+    if (collect.uptime && elapsed > 0) {
+      metrics.count("node.runtime.process.uptime", elapsed / 1e3, METRIC_ATTRIBUTES_SECOND);
+    }
+    prevFlushTime = now;
+  }
+  return {
+    name: INTEGRATION_NAME,
+    setup() {
+      if (needsEventLoopDelay) {
+        eventLoopDelayHistogram?.disable();
+        try {
+          eventLoopDelayHistogram = monitorEventLoopDelay({ resolution: EVENT_LOOP_DELAY_RESOLUTION_MS });
+          eventLoopDelayHistogram.enable();
+        } catch {
+          eventLoopDelayHistogram = void 0;
+        }
+      }
+      if (needsCpu) {
+        prevCpuUsage = process.cpuUsage();
+      }
+      if (collect.eventLoopUtilization) {
+        prevElu = performance.eventLoopUtilization();
+      }
+      prevFlushTime = _INTERNAL_safeDateNow();
+      if (intervalId) {
+        clearInterval(intervalId);
+      }
+      intervalId = _INTERNAL_safeUnref(setInterval(collectMetrics, collectionIntervalMs));
+    }
+  };
+});
+
+export { _INTERNAL_normalizeCollectionInterval, nodeRuntimeMetricsIntegration };
+//# sourceMappingURL=nodeRuntimeMetrics.js.map

package/build/esm/integrations/nodeRuntimeMetrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeRuntimeMetrics.js","sources":["../../../src/integrations/nodeRuntimeMetrics.ts"],"sourcesContent":["import { monitorEventLoopDelay, performance } from 'perf_hooks';\nimport { _INTERNAL_safeDateNow, defineIntegration, metrics } from '@sentry/core';\nimport { _INTERNAL_safeUnref } from '@sentry/core/server';\n\nconst INTEGRATION_NAME = 'NodeRuntimeMetrics' as const;\nconst DEFAULT_INTERVAL_MS = 30_000;\nconst MIN_COLLECTION_INTERVAL_MS = 1_000;\nconst EVENT_LOOP_DELAY_RESOLUTION_MS = 10;\n\n/**\n * Normalizes a `collectionIntervalMs` value, enforcing a minimum of 1000ms.\n * - Non-finite values (NaN, Infinity): warns and falls back to `defaultInterval`.\n * - Values below the minimum: warns and clamps to 1000ms.\n * @internal\n */\nexport function _INTERNAL_normalizeCollectionInterval(\n  rawInterval: number,\n  integrationName: string,\n  defaultInterval: number,\n): number {\n  if (!Number.isFinite(rawInterval)) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      `[Sentry] ${integrationName}: collectionIntervalMs (${rawInterval}) is invalid. Using default of ${defaultInterval}ms.`,\n    );\n    return defaultInterval;\n  }\n  if (rawInterval < MIN_COLLECTION_INTERVAL_MS) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      `[Sentry] ${integrationName}: collectionIntervalMs (${rawInterval}) is below the minimum of ${MIN_COLLECTION_INTERVAL_MS}ms. Using minimum of ${MIN_COLLECTION_INTERVAL_MS}ms.`,\n    );\n    return MIN_COLLECTION_INTERVAL_MS;\n  }\n  return rawInterval;\n}\n\nexport interface NodeRuntimeMetricsOptions {\n  /**\n   * Which metrics to collect.\n   *\n   * Default on (8 metrics):\n   * - `cpuUtilization` — CPU utilization ratio\n   * - `memRss` — Resident Set Size (actual memory footprint)\n   * - `memHeapUsed` — V8 heap currently in use\n   * - `memHeapTotal` — total V8 heap allocated (headroom paired with `memHeapUsed`)\n   * - `eventLoopDelayP50` — median event loop delay (baseline latency)\n   * - `eventLoopDelayP99` — 99th percentile event loop delay (tail latency / spikes)\n   * - `eventLoopUtilization` — fraction of time the event loop was active\n   * - `uptime` — process uptime (detect restarts/crashes)\n   *\n   * Default off (opt-in):\n   * - `cpuTime` — raw user/system CPU time in seconds\n   * - `memExternal` — external/ArrayBuffer memory (relevant for native addons)\n   * - `eventLoopDelayMin` / `eventLoopDelayMax` / `eventLoopDelayMean` / `eventLoopDelayP90`\n   */\n  collect?: {\n    // Default on\n    cpuUtilization?: boolean;\n    memHeapUsed?: boolean;\n    memRss?: boolean;\n    eventLoopDelayP99?: boolean;\n    eventLoopUtilization?: boolean;\n    uptime?: boolean;\n    // Default off\n    cpuTime?: boolean;\n    memHeapTotal?: boolean;\n    memExternal?: boolean;\n    eventLoopDelayMin?: boolean;\n    eventLoopDelayMax?: boolean;\n    eventLoopDelayMean?: boolean;\n    eventLoopDelayP50?: boolean;\n    eventLoopDelayP90?: boolean;\n  };\n  /**\n   * How often to collect metrics, in milliseconds.\n   * Minimum allowed value is 1000ms.\n   * @default 30000\n   * @minimum 1000\n   */\n  collectionIntervalMs?: number;\n}\n\n/**\n * Automatically collects Node.js runtime metrics and emits them to Sentry.\n *\n * @example\n * ```ts\n * Sentry.init({\n *   integrations: [\n *     Sentry.nodeRuntimeMetricsIntegration(),\n *   ],\n * });\n * ```\n */\nexport const nodeRuntimeMetricsIntegration = defineIntegration((options: NodeRuntimeMetricsOptions = {}) => {\n  const collectionIntervalMs = _INTERNAL_normalizeCollectionInterval(\n    options.collectionIntervalMs ?? DEFAULT_INTERVAL_MS,\n    INTEGRATION_NAME,\n    DEFAULT_INTERVAL_MS,\n  );\n  const collect = {\n    // Default on\n    cpuUtilization: true,\n    memHeapUsed: true,\n    memHeapTotal: true,\n    memRss: true,\n    eventLoopDelayP50: true,\n    eventLoopDelayP99: true,\n    eventLoopUtilization: true,\n    uptime: true,\n    // Default off\n    cpuTime: false,\n    memExternal: false,\n    eventLoopDelayMin: false,\n    eventLoopDelayMax: false,\n    eventLoopDelayMean: false,\n    eventLoopDelayP90: false,\n    ...options.collect,\n  };\n\n  const needsEventLoopDelay =\n    collect.eventLoopDelayP99 ||\n    collect.eventLoopDelayMin ||\n    collect.eventLoopDelayMax ||\n    collect.eventLoopDelayMean ||\n    collect.eventLoopDelayP50 ||\n    collect.eventLoopDelayP90;\n\n  const needsCpu = collect.cpuUtilization || collect.cpuTime;\n\n  let intervalId: ReturnType<typeof setInterval> | undefined;\n  let prevCpuUsage: NodeJS.CpuUsage | undefined;\n  let prevElu: ReturnType<typeof performance.eventLoopUtilization> | undefined;\n  let prevFlushTime: number = 0;\n  let eventLoopDelayHistogram: ReturnType<typeof monitorEventLoopDelay> | undefined;\n\n  const resolutionNs = EVENT_LOOP_DELAY_RESOLUTION_MS * 1e6;\n  const nsToS = (ns: number): number => Math.max(0, (ns - resolutionNs) / 1e9);\n\n  const METRIC_ATTRIBUTES = { attributes: { 'sentry.origin': 'auto.node.runtime_metrics' } };\n  const METRIC_ATTRIBUTES_BYTE = { unit: 'byte', attributes: { 'sentry.origin': 'auto.node.runtime_metrics' } };\n  const METRIC_ATTRIBUTES_SECOND = { unit: 'second', attributes: { 'sentry.origin': 'auto.node.runtime_metrics' } };\n\n  function collectMetrics(): void {\n    const now = _INTERNAL_safeDateNow();\n    const elapsed = now - prevFlushTime;\n\n    if (needsCpu && prevCpuUsage !== undefined) {\n      const delta = process.cpuUsage(prevCpuUsage);\n\n      if (collect.cpuTime) {\n        metrics.gauge('node.runtime.cpu.user', delta.user / 1e6, METRIC_ATTRIBUTES_SECOND);\n        metrics.gauge('node.runtime.cpu.system', delta.system / 1e6, METRIC_ATTRIBUTES_SECOND);\n      }\n      if (collect.cpuUtilization && elapsed > 0) {\n        // Ratio of CPU time to wall-clock time. Can exceed 1.0 on multi-core systems.\n        // TODO: In cluster mode, add a runtime_id/process_id attribute to disambiguate per-worker metrics.\n        metrics.gauge(\n          'node.runtime.cpu.utilization',\n          (delta.user + delta.system) / (elapsed * 1000),\n          METRIC_ATTRIBUTES,\n        );\n      }\n\n      prevCpuUsage = process.cpuUsage();\n    }\n\n    if (collect.memRss || collect.memHeapUsed || collect.memHeapTotal || collect.memExternal) {\n      const mem = process.memoryUsage();\n      if (collect.memRss) {\n        metrics.gauge('node.runtime.mem.rss', mem.rss, METRIC_ATTRIBUTES_BYTE);\n      }\n      if (collect.memHeapUsed) {\n        metrics.gauge('node.runtime.mem.heap_used', mem.heapUsed, METRIC_ATTRIBUTES_BYTE);\n      }\n      if (collect.memHeapTotal) {\n        metrics.gauge('node.runtime.mem.heap_total', mem.heapTotal, METRIC_ATTRIBUTES_BYTE);\n      }\n      if (collect.memExternal) {\n        metrics.gauge('node.runtime.mem.external', mem.external, METRIC_ATTRIBUTES_BYTE);\n        metrics.gauge('node.runtime.mem.array_buffers', mem.arrayBuffers, METRIC_ATTRIBUTES_BYTE);\n      }\n    }\n\n    if (needsEventLoopDelay && eventLoopDelayHistogram) {\n      if (collect.eventLoopDelayMin) {\n        metrics.gauge(\n          'node.runtime.event_loop.delay.min',\n          nsToS(eventLoopDelayHistogram.min),\n          METRIC_ATTRIBUTES_SECOND,\n        );\n      }\n      if (collect.eventLoopDelayMax) {\n        metrics.gauge(\n          'node.runtime.event_loop.delay.max',\n          nsToS(eventLoopDelayHistogram.max),\n          METRIC_ATTRIBUTES_SECOND,\n        );\n      }\n      if (collect.eventLoopDelayMean) {\n        metrics.gauge(\n          'node.runtime.event_loop.delay.mean',\n          nsToS(eventLoopDelayHistogram.mean),\n          METRIC_ATTRIBUTES_SECOND,\n        );\n      }\n      if (collect.eventLoopDelayP50) {\n        metrics.gauge(\n          'node.runtime.event_loop.delay.p50',\n          nsToS(eventLoopDelayHistogram.percentile(50)),\n          METRIC_ATTRIBUTES_SECOND,\n        );\n      }\n      if (collect.eventLoopDelayP90) {\n        metrics.gauge(\n          'node.runtime.event_loop.delay.p90',\n          nsToS(eventLoopDelayHistogram.percentile(90)),\n          METRIC_ATTRIBUTES_SECOND,\n        );\n      }\n      if (collect.eventLoopDelayP99) {\n        metrics.gauge(\n          'node.runtime.event_loop.delay.p99',\n          nsToS(eventLoopDelayHistogram.percentile(99)),\n          METRIC_ATTRIBUTES_SECOND,\n        );\n      }\n\n      eventLoopDelayHistogram.reset();\n    }\n\n    if (collect.eventLoopUtilization && prevElu !== undefined) {\n      const currentElu = performance.eventLoopUtilization();\n      const delta = performance.eventLoopUtilization(currentElu, prevElu);\n      metrics.gauge('node.runtime.event_loop.utilization', delta.utilization, METRIC_ATTRIBUTES);\n      prevElu = currentElu;\n    }\n\n    if (collect.uptime && elapsed > 0) {\n      metrics.count('node.runtime.process.uptime', elapsed / 1000, METRIC_ATTRIBUTES_SECOND);\n    }\n\n    prevFlushTime = now;\n  }\n\n  return {\n    name: INTEGRATION_NAME,\n\n    setup(): void {\n      if (needsEventLoopDelay) {\n        // Disable any previous histogram before overwriting (prevents native resource leak on re-init).\n        eventLoopDelayHistogram?.disable();\n        try {\n          eventLoopDelayHistogram = monitorEventLoopDelay({ resolution: EVENT_LOOP_DELAY_RESOLUTION_MS });\n          eventLoopDelayHistogram.enable();\n        } catch {\n          // Not available in all runtimes (e.g. Bun throws NotImplementedError).\n          eventLoopDelayHistogram = undefined;\n        }\n      }\n\n      // Prime baselines before the first collection interval.\n      if (needsCpu) {\n        prevCpuUsage = process.cpuUsage();\n      }\n      if (collect.eventLoopUtilization) {\n        prevElu = performance.eventLoopUtilization();\n      }\n      prevFlushTime = _INTERNAL_safeDateNow();\n\n      // Guard against double setup (e.g. re-init).\n      if (intervalId) {\n        clearInterval(intervalId);\n      }\n      intervalId = _INTERNAL_safeUnref(setInterval(collectMetrics, collectionIntervalMs));\n    },\n  };\n});\n"],"names":[],"mappings":"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"}

package/build/esm/integrations/onuncaughtexception.js

@@ -0,0 +1,89 @@
+import { defineIntegration, getClient, captureException, debug } from '@sentry/core';
+import { isMainThread } from 'worker_threads';
+import { DEBUG_BUILD } from '../debug-build.js';
+import { logAndExitProcess } from '../utils/errorhandling.js';
+
+const INTEGRATION_NAME = "OnUncaughtException";
+const onUncaughtExceptionIntegration = defineIntegration((options = {}) => {
+  const optionsWithDefaults = {
+    exitEvenIfOtherHandlersAreRegistered: false,
+    ...options
+  };
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      if (!isMainThread) {
+        return;
+      }
+      global.process.on("uncaughtException", makeErrorHandler(client, optionsWithDefaults));
+    }
+  };
+});
+function makeErrorHandler(client, options) {
+  const timeout = 2e3;
+  let caughtFirstError = false;
+  let caughtSecondError = false;
+  let calledFatalError = false;
+  let firstError;
+  const clientOptions = client.getOptions();
+  return Object.assign(
+    (error) => {
+      let onFatalError = logAndExitProcess;
+      if (options.onFatalError) {
+        onFatalError = options.onFatalError;
+      } else if (clientOptions.onFatalError) {
+        onFatalError = clientOptions.onFatalError;
+      }
+      const userProvidedListenersCount = global.process.listeners("uncaughtException").filter((listener) => {
+        return (
+          // as soon as we're using domains this listener is attached by node itself
+          listener.name !== "domainUncaughtExceptionClear" && // the handler we register in this integration
+          listener._errorHandler !== true
+        );
+      }).length;
+      const processWouldExit = userProvidedListenersCount === 0;
+      const shouldApplyFatalHandlingLogic = options.exitEvenIfOtherHandlersAreRegistered || processWouldExit;
+      if (!caughtFirstError) {
+        firstError = error;
+        caughtFirstError = true;
+        if (getClient() === client) {
+          captureException(error, {
+            originalException: error,
+            captureContext: {
+              level: "fatal"
+            },
+            mechanism: {
+              handled: false,
+              type: "auto.node.onuncaughtexception"
+            }
+          });
+        }
+        if (!calledFatalError && shouldApplyFatalHandlingLogic) {
+          calledFatalError = true;
+          onFatalError(error);
+        }
+      } else {
+        if (shouldApplyFatalHandlingLogic) {
+          if (calledFatalError) {
+            DEBUG_BUILD && debug.warn(
+              "uncaught exception after calling fatal error shutdown callback - this is bad! forcing shutdown"
+            );
+            logAndExitProcess(error);
+          } else if (!caughtSecondError) {
+            caughtSecondError = true;
+            setTimeout(() => {
+              if (!calledFatalError) {
+                calledFatalError = true;
+                onFatalError(firstError, error);
+              }
+            }, timeout);
+          }
+        }
+      }
+    },
+    { _errorHandler: true }
+  );
+}
+
+export { makeErrorHandler, onUncaughtExceptionIntegration };
+//# sourceMappingURL=onuncaughtexception.js.map

package/build/esm/integrations/onuncaughtexception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onuncaughtexception.js","sources":["../../../src/integrations/onuncaughtexception.ts"],"sourcesContent":["import { captureException, debug, defineIntegration, getClient } from '@sentry/core';\nimport { isMainThread } from 'worker_threads';\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { NodeClient } from '../sdk/client';\nimport { logAndExitProcess } from '../utils/errorhandling';\n\ntype OnFatalErrorHandler = (firstError: Error, secondError?: Error) => void;\n\ninterface OnUncaughtExceptionOptions {\n  /**\n   * Controls if the SDK should register a handler to exit the process on uncaught errors:\n   * - `true`: The SDK will exit the process on all uncaught errors.\n   * - `false`: The SDK will only exit the process when there are no other `uncaughtException` handlers attached.\n   *\n   * Default: `false`\n   */\n  exitEvenIfOtherHandlersAreRegistered: boolean;\n\n  /**\n   * This is called when an uncaught error would cause the process to exit.\n   *\n   * @param firstError Uncaught error causing the process to exit\n   * @param secondError Will be set if the handler was called multiple times. This can happen either because\n   * `onFatalError` itself threw, or because an independent error happened somewhere else while `onFatalError`\n   * was running.\n   */\n  onFatalError?(this: void, firstError: Error, secondError?: Error): void;\n}\n\nconst INTEGRATION_NAME = 'OnUncaughtException' as const;\n\n/**\n * Add a global exception handler.\n */\nexport const onUncaughtExceptionIntegration = defineIntegration((options: Partial<OnUncaughtExceptionOptions> = {}) => {\n  const optionsWithDefaults = {\n    exitEvenIfOtherHandlersAreRegistered: false,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    setup(client: NodeClient) {\n      // errors in worker threads are already handled by the childProcessIntegration\n      // also we don't want to exit the Node process on worker thread errors\n      if (!isMainThread) {\n        return;\n      }\n\n      global.process.on('uncaughtException', makeErrorHandler(client, optionsWithDefaults));\n    },\n  };\n});\n\ntype ErrorHandler = { _errorHandler: boolean } & ((error: Error) => void);\n\n/** Exported only for tests */\nexport function makeErrorHandler(client: NodeClient, options: OnUncaughtExceptionOptions): ErrorHandler {\n  const timeout = 2000;\n  let caughtFirstError: boolean = false;\n  let caughtSecondError: boolean = false;\n  let calledFatalError: boolean = false;\n  let firstError: Error;\n\n  const clientOptions = client.getOptions();\n\n  return Object.assign(\n    (error: Error): void => {\n      let onFatalError: OnFatalErrorHandler = logAndExitProcess;\n\n      if (options.onFatalError) {\n        onFatalError = options.onFatalError;\n      } else if (clientOptions.onFatalError) {\n        onFatalError = clientOptions.onFatalError;\n      }\n\n      // Attaching a listener to `uncaughtException` will prevent the node process from exiting. We generally do not\n      // want to alter this behaviour so we check for other listeners that users may have attached themselves and adjust\n      // exit behaviour of the SDK accordingly:\n      // - If other listeners are attached, do not exit.\n      // - If the only listener attached is ours, exit.\n      const userProvidedListenersCount = global.process.listeners('uncaughtException').filter(listener => {\n        // There are 3 listeners we ignore:\n        return (\n          // as soon as we're using domains this listener is attached by node itself\n          listener.name !== 'domainUncaughtExceptionClear' &&\n          // the handler we register in this integration\n          (listener as ErrorHandler)._errorHandler !== true\n        );\n      }).length;\n\n      const processWouldExit = userProvidedListenersCount === 0;\n      const shouldApplyFatalHandlingLogic = options.exitEvenIfOtherHandlersAreRegistered || processWouldExit;\n\n      if (!caughtFirstError) {\n        // this is the first uncaught error and the ultimate reason for shutting down\n        // we want to do absolutely everything possible to ensure it gets captured\n        // also we want to make sure we don't go recursion crazy if more errors happen after this one\n        firstError = error;\n        caughtFirstError = true;\n\n        if (getClient() === client) {\n          captureException(error, {\n            originalException: error,\n            captureContext: {\n              level: 'fatal',\n            },\n            mechanism: {\n              handled: false,\n              type: 'auto.node.onuncaughtexception',\n            },\n          });\n        }\n\n        if (!calledFatalError && shouldApplyFatalHandlingLogic) {\n          calledFatalError = true;\n          onFatalError(error);\n        }\n      } else {\n        if (shouldApplyFatalHandlingLogic) {\n          if (calledFatalError) {\n            // we hit an error *after* calling onFatalError - pretty boned at this point, just shut it down\n            DEBUG_BUILD &&\n              debug.warn(\n                'uncaught exception after calling fatal error shutdown callback - this is bad! forcing shutdown',\n              );\n            logAndExitProcess(error);\n          } else if (!caughtSecondError) {\n            // two cases for how we can hit this branch:\n            //   - capturing of first error blew up and we just caught the exception from that\n            //     - quit trying to capture, proceed with shutdown\n            //   - a second independent error happened while waiting for first error to capture\n            //     - want to avoid causing premature shutdown before first error capture finishes\n            // it's hard to immediately tell case 1 from case 2 without doing some fancy/questionable domain stuff\n            // so let's instead just delay a bit before we proceed with our action here\n            // in case 1, we just wait a bit unnecessarily but ultimately do the same thing\n            // in case 2, the delay hopefully made us wait long enough for the capture to finish\n            // two potential nonideal outcomes:\n            //   nonideal case 1: capturing fails fast, we sit around for a few seconds unnecessarily before proceeding correctly by calling onFatalError\n            //   nonideal case 2: case 2 happens, 1st error is captured but slowly, timeout completes before capture and we treat second error as the sendErr of (nonexistent) failure from trying to capture first error\n            // note that after hitting this branch, we might catch more errors where (caughtSecondError && !calledFatalError)\n            //   we ignore them - they don't matter to us, we're just waiting for the second error timeout to finish\n            caughtSecondError = true;\n            setTimeout(() => {\n              if (!calledFatalError) {\n                // it was probably case 1, let's treat err as the sendErr and call onFatalError\n                calledFatalError = true;\n                onFatalError(firstError, error);\n              } else {\n                // it was probably case 2, our first error finished capturing while we waited, cool, do nothing\n              }\n            }, timeout); // capturing could take at least sendTimeout to fail, plus an arbitrary second for how long it takes to collect surrounding source etc\n          }\n        }\n      }\n    },\n    { _errorHandler: true },\n  );\n}\n"],"names":[],"mappings":"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"}