apply request data to segment span

Author: Lms24

packages/core/src/client.ts

@@ -8,7 +8,7 @@ import type { IntegrationIndex } from './integration';
 import { afterSetupIntegrations, setupIntegration, setupIntegrations } from './integration';
 import { _INTERNAL_flushLogsBuffer } from './logs/internal';
 import { _INTERNAL_flushMetricsBuffer } from './metrics/internal';
-import type { Scope } from './scope';
+import type { Scope, ScopeData } from './scope';
 import { updateSession } from './session';
 import { getDynamicSamplingContextFromScope } from './tracing/dynamicSamplingContext';
 import { DEFAULT_TRANSPORT_BUFFER_SIZE } from './transports/base';
@@ -629,10 +629,16 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
    */
   public on(hook: 'enqueueSpan', callback: (spanJSON: SpanV2JSONWithSegmentRef) => void): () => void;
   /**
-   * Register a callback for when a span JSON is processed, to add some attributes to the span JSON.
+   * Register a callback for when a span JSON is processed, to add some data to the span JSON.
    */
   public on(hook: 'processSpan', callback: (spanJSON: SpanV2JSON, hint: { readOnlySpan: Span }) => void): () => void;
-
+  /**
+   * Register a callback for when a segment span JSON is processed, to add some data to the segment span JSON.
+   */
+  public on(
+    hook: 'processSegmentSpan',
+    callback: (spanJSON: SpanV2JSON, hint: { scopeData: ScopeData }) => void,
+  ): () => void;
   /**
    * Register a callback for when an idle span is allowed to auto-finish.
    * @returns {() => void} A function that, when executed, removes the registered callback.
@@ -910,6 +916,8 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
   public emit(hook: 'afterSpanEnd', span: Span): void;
   /** Fire a hook after a span is processed, to add some attributes to the span JSON. */
   public emit(hook: 'processSpan', spanJSON: SpanV2JSON, hint: { readOnlySpan: Span }): void;
+  /** Fire a hook after a span is processed, to add some attributes to the span JSON. */
+  public emit(hook: 'processSegmentSpan', spanJSON: SpanV2JSON, hint: { scopeData: ScopeData }): void;
   /** Fire a hook after the `segmentSpanEnd` hook is fired. */
   public emit(hook: 'afterSegmentSpanEnd', span: Span): void;
   /** Fire a hook after a span ready to be enqueued into the span buffer. */

packages/core/src/integrations/requestdata.ts

@@ -1,8 +1,19 @@
+import type { Client } from '../client';
 import { defineIntegration } from '../integration';
+import {
+  SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD,
+  SEMANTIC_ATTRIBUTE_URL_FULL,
+  SEMANTIC_ATTRIBUTE_URL_QUERY,
+  SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS,
+} from '../semanticAttributes';
+import { safeSetSpanJSONAttributes } from '../spans/spanFirstUtils';
 import type { Event } from '../types-hoist/event';
 import type { IntegrationFn } from '../types-hoist/integration';
+import type { ClientOptions } from '../types-hoist/options';
 import type { RequestEventData } from '../types-hoist/request';
+import type { BaseTransportOptions } from '../types-hoist/transport';
 import { parseCookie } from '../utils/cookie';
+import { httpHeadersToSpanAttributes } from '../utils/request';
 import { getClientIPAddress, ipHeaderNames } from '../vendor/getIpAddress';
 
 interface RequestDataIncludeOptions {
@@ -40,16 +51,67 @@ const _requestDataIntegration = ((options: RequestDataIntegrationOptions = {}) =
 
   return {
     name: INTEGRATION_NAME,
+    setup(client) {
+      client.on('processSegmentSpan', (spanJSON, { scopeData }) => {
+        const { sdkProcessingMetadata = {} } = scopeData;
+        const { normalizedRequest, ipAddress } = sdkProcessingMetadata;
+
+        if (!normalizedRequest) {
+          return;
+        }
+
+        const includeWithDefaultPiiApplied: RequestDataIncludeOptions = getIncludeWithDefaultPiiApplied(
+          include,
+          client,
+        );
+
+        // no need to check for include after calling `extractNormalizedRequestData`
+        // because it already internally only return what's permitted by `include`
+        const { method, url, query_string, headers, data, env } = extractNormalizedRequestData(
+          normalizedRequest,
+          includeWithDefaultPiiApplied,
+        );
+
+        safeSetSpanJSONAttributes(spanJSON, {
+          ...(method ? { [SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD]: method } : {}),
+          ...(url ? { [SEMANTIC_ATTRIBUTE_URL_FULL]: url } : {}),
+          ...(query_string ? { [SEMANTIC_ATTRIBUTE_URL_QUERY]: query_string } : {}),
+          ...(headers ? httpHeadersToSpanAttributes(headers, client.getOptions().sendDefaultPii) : {}),
+          // TODO: Apparently, Relay still needs Pii rule updates, so I'm leaving this out for now
+          // ...(cookies
+          //   ? Object.keys(cookies).reduce(
+          //       (acc, cookieName) => ({
+          //         ...acc,
+          //         [`http.request.header.cookie.${cookieName}`]: cookies[cookieName] ?? '',
+          //       }),
+          //       {} as Record<string, string>,
+          //     )
+          //   : {}),
+          ...(include.ip
+            ? {
+                [SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS]:
+                  (normalizedRequest.headers && getClientIPAddress(normalizedRequest.headers)) || ipAddress,
+              }
+            : {}),
+          ...(data ? { 'http.request.body.content': data } : {}),
+          ...(env
+            ? {
+                'http.request.env': Object.keys(env).reduce(
+                  (acc, key) => ({ ...acc, [key]: env[key] ?? '' }),
+                  {} as Record<string, string>,
+                ),
+              }
+            : {}),
+        });
+      });
+    },
     // TODO (span-streaming): probably fine to leave as-is for errors.
     // For spans, we go through global context -> attribute conversion or omit this completely (TBD)
     processEvent(event, _hint, client) {
       const { sdkProcessingMetadata = {} } = event;
       const { normalizedRequest, ipAddress } = sdkProcessingMetadata;
 
-      const includeWithDefaultPiiApplied: RequestDataIncludeOptions = {
-        ...include,
-        ip: include.ip ?? client.getOptions().sendDefaultPii,
-      };
+      const includeWithDefaultPiiApplied: RequestDataIncludeOptions = getIncludeWithDefaultPiiApplied(include, client);
 
       if (normalizedRequest) {
         addNormalizedRequestDataToEvent(event, normalizedRequest, { ipAddress }, includeWithDefaultPiiApplied);
@@ -66,6 +128,21 @@ const _requestDataIntegration = ((options: RequestDataIntegrationOptions = {}) =
  */
 export const requestDataIntegration = defineIntegration(_requestDataIntegration);
 
+const getIncludeWithDefaultPiiApplied = (
+  include: {
+    cookies?: boolean;
+    data?: boolean;
+    headers?: boolean;
+    ip?: boolean;
+    query_string?: boolean;
+    url?: boolean;
+  },
+  client: Client<ClientOptions<BaseTransportOptions>>,
+): RequestDataIncludeOptions => ({
+  ...include,
+  ip: include.ip ?? client.getOptions().sendDefaultPii,
+});
+
 /**
  * Add already normalized request data to an event.
  * This mutates the passed in event.
@@ -105,14 +182,14 @@ function extractNormalizedRequestData(
 
     // Remove the Cookie header in case cookie data should not be included in the event
     if (!include.cookies) {
-      delete (headers as { cookie?: string }).cookie;
+      delete headers.cookie;
     }
 
     // Remove IP headers in case IP data should not be included in the event
     if (!include.ip) {
       ipHeaderNames.forEach(ipHeaderName => {
         // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-        delete (headers as Record<string, unknown>)[ipHeaderName];
+        delete headers[ipHeaderName];
       });
     }
   }

packages/core/src/semanticAttributes.ts

@@ -65,6 +65,7 @@ export const SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE = 'cache.item_size';
 /** TODO: Remove these once we update to latest semantic conventions */
 export const SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD = 'http.request.method';
 export const SEMANTIC_ATTRIBUTE_URL_FULL = 'url.full';
+export const SEMANTIC_ATTRIBUTE_URL_QUERY = 'url.query';
 
 /**
  * A span link attribute to mark the link as a special span link.

packages/core/src/spans/captureSpan.ts

@@ -47,6 +47,7 @@ export function captureSpan(span: Span, client = getClient()): void {
 
   if (span === segmentSpan) {
     applyScopeToSegmentSpan(spanJSON, finalScopeData);
+    client.emit('processSegmentSpan', spanJSON, { scopeData: finalScopeData });
   }
 
   // Allow integrations to add additional data to the span JSON