feat(node): Add tracing without performance to Node Undici (#8449)

Updates the Node Undici integration to always attach `sentry-trace` headers to outgoing requests. This can be controlled with the top level `tracePropagationOptions` option.
getsentry · Jul 11, 2023 · db9523e · db9523e
1 parent 5caec05
commit db9523e
Show file tree

Hide file tree

Showing 3 changed files with 273 additions and 200 deletions.
diff --git a/packages/node/src/integrations/undici/index.ts b/packages/node/src/integrations/undici/index.ts
@@ -1,8 +1,9 @@
-import type { Hub } from '@sentry/core';
-import type { EventProcessor, Integration } from '@sentry/types';
+import { getCurrentHub, getDynamicSamplingContextFromClient } from '@sentry/core';
+import type { EventProcessor, Integration, Span } from '@sentry/types';
 import {
  dynamicRequire,
  dynamicSamplingContextToSentryBaggageHeader,
+ generateSentryTraceHeader,
  getSanitizedUrlString,
  parseUrl,
  stringMatchesSomePattern,
@@ -12,7 +13,13 @@ import { LRUMap } from 'lru_map';
 import type { NodeClient } from '../../client';
 import { NODE_VERSION } from '../../nodeVersion';
 import { isSentryRequest } from '../utils/http';
-import type { DiagnosticsChannel, RequestCreateMessage, RequestEndMessage, RequestErrorMessage } from './types';
+import type {
+ DiagnosticsChannel,
+ RequestCreateMessage,
+ RequestEndMessage,
+ RequestErrorMessage,
+ RequestWithSentry,
+} from './types';
 
 export enum ChannelName {
  // https://github.com/nodejs/undici/blob/e6fc80f809d1217814c044f52ed40ef13f21e43c/docs/api/DiagnosticsChannel.md#undicirequestcreate
@@ -81,7 +88,7 @@ export class Undici implements Integration {
  /**
  * @inheritDoc
  */
- public setupOnce(_addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {
+ public setupOnce(_addGlobalEventProcessor: (callback: EventProcessor) => void): void {
  // Requires Node 16+ to use the diagnostics_channel API.
  if (NODE_VERSION.major && NODE_VERSION.major < 16) {
  return;
@@ -99,169 +106,205 @@ export class Undici implements Integration {
  return;
  }
 
- const shouldCreateSpan = (url: string): boolean => {
- if (this._options.shouldCreateSpanForRequest === undefined) {
+ // https://github.com/nodejs/undici/blob/e6fc80f809d1217814c044f52ed40ef13f21e43c/docs/api/DiagnosticsChannel.md
+ ds.subscribe(ChannelName.RequestCreate, this._onRequestCreate);
+ ds.subscribe(ChannelName.RequestEnd, this._onRequestEnd);
+ ds.subscribe(ChannelName.RequestError, this._onRequestError);
+ }
+
+ /** Helper that wraps shouldCreateSpanForRequest option */
+ private _shouldCreateSpan(url: string): boolean {
+ if (this._options.shouldCreateSpanForRequest === undefined) {
+ return true;
+ }
+
+ const cachedDecision = this._createSpanUrlMap.get(url);
+ if (cachedDecision !== undefined) {
+ return cachedDecision;
+ }
+
+ const decision = this._options.shouldCreateSpanForRequest(url);
+ this._createSpanUrlMap.set(url, decision);
+ return decision;
+ }
+
+ private _onRequestCreate = (message: unknown): void => {
+ const hub = getCurrentHub();
+ if (!hub.getIntegration(Undici)) {
+ return;
+ }
+
+ const { request } = message as RequestCreateMessage;
+
+ const stringUrl = request.origin ? request.origin.toString() + request.path : request.path;
+
+ if (isSentryRequest(stringUrl) || request.__sentry_span__ !== undefined) {
+ return;
+ }
+
+ const client = hub.getClient<NodeClient>();
+ if (!client) {
+ return;
+ }
+
+ const clientOptions = client.getOptions();
+ const scope = hub.getScope();
+
+ const parentSpan = scope.getSpan();
+
+ const span = this._shouldCreateSpan(stringUrl) ? createRequestSpan(parentSpan, request, stringUrl) : undefined;
+ if (span) {
+ request.__sentry_span__ = span;
+ }
+
+ const shouldAttachTraceData = (url: string): boolean => {
+ if (clientOptions.tracePropagationTargets === undefined) {
  return true;
  }
 
- const cachedDecision = this._createSpanUrlMap.get(url);
+ const cachedDecision = this._headersUrlMap.get(url);
  if (cachedDecision !== undefined) {
  return cachedDecision;
  }
 
- const decision = this._options.shouldCreateSpanForRequest(url);
- this._createSpanUrlMap.set(url, decision);
+ const decision = stringMatchesSomePattern(url, clientOptions.tracePropagationTargets);
+ this._headersUrlMap.set(url, decision);
  return decision;
  };
 
- // https://github.com/nodejs/undici/blob/e6fc80f809d1217814c044f52ed40ef13f21e43c/docs/api/DiagnosticsChannel.md
- ds.subscribe(ChannelName.RequestCreate, message => {
- const hub = getCurrentHub();
- if (!hub.getIntegration(Undici)) {
- return;
+ if (shouldAttachTraceData(stringUrl)) {
+ if (span) {
+ const dynamicSamplingContext = span?.transaction?.getDynamicSamplingContext();
+ const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
+
+ setHeadersOnRequest(request, span.toTraceparent(), sentryBaggageHeader);
+ } else {
+ const { traceId, sampled, dsc } = scope.getPropagationContext();
+ const sentryTrace = generateSentryTraceHeader(traceId, undefined, sampled);
+ const dynamicSamplingContext = dsc || getDynamicSamplingContextFromClient(traceId, client, scope);
+ const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
+ setHeadersOnRequest(request, sentryTrace, sentryBaggageHeader);
  }
+ }
+ };
 
- const { request } = message as RequestCreateMessage;
+ private _onRequestEnd = (message: unknown): void => {
+ const hub = getCurrentHub();
+ if (!hub.getIntegration(Undici)) {
+ return;
+ }
 
- const stringUrl = request.origin ? request.origin.toString() + request.path : request.path;
- const url = parseUrl(stringUrl);
+ const { request, response } = message as RequestEndMessage;
 
- if (isSentryRequest(stringUrl) || request.__sentry__ !== undefined) {
- return;
- }
+ const stringUrl = request.origin ? request.origin.toString() + request.path : request.path;
 
- const client = hub.getClient<NodeClient>();
- const scope = hub.getScope();
-
- const activeSpan = scope.getSpan();
-
- if (activeSpan && client) {
- const clientOptions = client.getOptions();
-
- if (shouldCreateSpan(stringUrl)) {
- const method = request.method || 'GET';
- const data: Record<string, unknown> = {
- 'http.method': method,
- };
- if (url.search) {
- data['http.query'] = url.search;
- }
- if (url.hash) {
- data['http.fragment'] = url.hash;
- }
- const span = activeSpan.startChild({
- op: 'http.client',
- description: `${method} ${getSanitizedUrlString(url)}`,
- data,
- });
- request.__sentry__ = span;
-
- const shouldAttachTraceData = (url: string): boolean => {
- if (clientOptions.tracePropagationTargets === undefined) {
- return true;
- }
-
- const cachedDecision = this._headersUrlMap.get(url);
- if (cachedDecision !== undefined) {
- return cachedDecision;
- }
-
- const decision = stringMatchesSomePattern(url, clientOptions.tracePropagationTargets);
- this._headersUrlMap.set(url, decision);
- return decision;
- };
-
- if (shouldAttachTraceData(stringUrl)) {
- request.addHeader('sentry-trace', span.toTraceparent());
- if (span.transaction) {
- const dynamicSamplingContext = span.transaction.getDynamicSamplingContext();
- const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
- if (sentryBaggageHeader) {
- request.addHeader('baggage', sentryBaggageHeader);
- }
- }
- }
- }
- }
- });
+ if (isSentryRequest(stringUrl)) {
+ return;
+ }
 
- ds.subscribe(ChannelName.RequestEnd, message => {
-  const hub = getCurrentHub();
- if (!hub.getIntegration(Undici)) {
-  return;
-  }
+ const span = request.__sentry_span__;
+ if (span) {
+ span.setHttpStatus(response.statusCode);
+ span.finish();
+ }
 
- const { request, response } = message as RequestEndMessage;
+ if (this._options.breadcrumbs) {
+ hub.addBreadcrumb(
+ {
+ category: 'http',
+ data: {
+ method: request.method,
+ status_code: response.statusCode,
+ url: stringUrl,
+ },
+ type: 'http',
+ },
+ {
+ event: 'response',
+ request,
+ response,
+ },
+ );
+ }
+ };
 
- const stringUrl = request.origin ? request.origin.toString() + request.path : request.path;
+ private _onRequestError = (message: unknown): void => {
+ const hub = getCurrentHub();
+ if (!hub.getIntegration(Undici)) {
+ return;
+ }
 
- if (isSentryRequest(stringUrl)) {
- return;
- }
+ const { request } = message as RequestErrorMessage;
 
- const span = request.__sentry__;
- if (span) {
- span.setHttpStatus(response.statusCode);
- span.finish();
- }
+ const stringUrl = request.origin ? request.origin.toString() + request.path : request.path;
 
- if (this._options.breadcrumbs) {
- hub.addBreadcrumb(
- {
- category: 'http',
- data: {
- method: request.method,
- status_code: response.statusCode,
- url: stringUrl,
- },
- type: 'http',
- },
- {
- event: 'response',
- request,
- response,
- },
- );
- }
- });
+ if (isSentryRequest(stringUrl)) {
+ return;
+ }
 
- ds.subscribe(ChannelName.RequestError, message => {
-  const hub = getCurrentHub();
- if (!hub.getIntegration(Undici)) {
-  return;
-  }
+ const span = request.__sentry_span__;
+ if (span) {
+ span.setStatus('internal_error');
+ span.finish();
+ }
 
- const { request } = message as RequestErrorMessage;
+ if (this._options.breadcrumbs) {
+ hub.addBreadcrumb(
+ {
+ category: 'http',
+ data: {
+ method: request.method,
+ url: stringUrl,
+ },
+ level: 'error',
+ type: 'http',
+ },
+ {
+ event: 'error',
+ request,
+ },
+ );
+ }
+ };
+}
 
- const stringUrl = request.origin ? request.origin.toString() + request.path : request.path;
+function setHeadersOnRequest(
+ request: RequestWithSentry,
+ sentryTrace: string,
+ sentryBaggageHeader: string | undefined,
+): void {
+ if (request.__sentry_has_headers__) {
+ return;
+ }
 
- if (isSentryRequest(stringUrl)) {
- return;
- }
+ request.addHeader('sentry-trace', sentryTrace);
+ if (sentryBaggageHeader) {
+ request.addHeader('baggage', sentryBaggageHeader);
+ }
 
- const span = request.__sentry__;
- if (span) {
- span.setStatus('internal_error');
- span.finish();
- }
+ request.__sentry_has_headers__ = true;
+}
 
- if (this._options.breadcrumbs) {
- hub.addBreadcrumb(
- {
- category: 'http',
- data: {
- method: request.method,
- url: stringUrl,
- },
- level: 'error',
- type: 'http',
- },
- {
- event: 'error',
- request,
- },
- );
- }
- });
+function createRequestSpan(
+ activeSpan: Span | undefined,
+ request: RequestWithSentry,
+ stringUrl: string,
+): Span | undefined {
+ const url = parseUrl(stringUrl);
+
+ const method = request.method || 'GET';
+ const data: Record<string, unknown> = {
+ 'http.method': method,
+ };
+ if (url.search) {
+ data['http.query'] = url.search;
+ }
+ if (url.hash) {
+ data['http.fragment'] = url.hash;
  }
+ return activeSpan?.startChild({
+ op: 'http.client',
+ description: `${method} ${getSanitizedUrlString(url)}`,
+ data,
+ });
 }
diff --git a/packages/node/src/integrations/undici/types.ts b/packages/node/src/integrations/undici/types.ts
@@ -234,7 +234,8 @@ export interface UndiciResponse {
 }
 
 export interface RequestWithSentry extends UndiciRequest {
- __sentry__?: Span;
+ __sentry_span__?: Span;
+ __sentry_has_headers__?: boolean;
 }
 
 export interface RequestCreateMessage {