Merge branch 'staging-37' into beltran.bulbarella/RUM-11247_2

Author: BeltranBulbarellaDD

packages/core/src/domain/telemetry/telemetryEvent.types.ts

@@ -205,6 +205,14 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        * Whether the allowed tracing urls list is used
        */
       use_allowed_tracing_urls?: boolean
+      /**
+       * Whether the allowed GraphQL urls list is used
+       */
+      use_allowed_graph_ql_urls?: boolean
+      /**
+       * Whether GraphQL payload tracking is used for at least one GraphQL endpoint
+       */
+      use_track_graph_ql_payload?: boolean
       /**
        * A list of selected tracing propagators
        */
@@ -443,6 +451,18 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        * The id of the remote configuration
        */
       remote_configuration_id?: string
+      /**
+       * Whether a proxy is used for remote configuration
+       */
+      use_remote_configuration_proxy?: boolean
+      /**
+       * The percentage of sessions with Profiling enabled
+       */
+      profiling_sample_rate?: number
+      /**
+       * Whether trace baggage is propagated to child spans
+       */
+      propagate_trace_baggage?: boolean
       [k: string]: unknown
     }
     [k: string]: unknown

packages/rum-core/src/domain/configuration/configuration.spec.ts

@@ -516,6 +516,60 @@ describe('validateAndBuildRumConfiguration', () => {
       expect(displayWarnSpy).toHaveBeenCalledOnceWith('trackFeatureFlagsForEvents should be an array')
     })
   })
+
+  describe('allowedGraphQlUrls', () => {
+    it('defaults to an empty array', () => {
+      const configuration = validateAndBuildRumConfiguration(DEFAULT_INIT_CONFIGURATION)!
+      expect(configuration.allowedGraphQlUrls).toEqual([])
+    })
+
+    it('should accept string URLs', () => {
+      const configuration = validateAndBuildRumConfiguration({
+        ...DEFAULT_INIT_CONFIGURATION,
+        allowedGraphQlUrls: ['https://api.example.com/graphql', '/graphql'],
+      })!
+      expect(configuration.allowedGraphQlUrls).toEqual([
+        { match: 'https://api.example.com/graphql', trackPayload: false },
+        { match: '/graphql', trackPayload: false },
+      ])
+    })
+
+    it('should accept MatchOption objects', () => {
+      const configuration = validateAndBuildRumConfiguration({
+        ...DEFAULT_INIT_CONFIGURATION,
+        allowedGraphQlUrls: [{ match: /\/graphql$/i }, { match: 'https://api.example.com/graphql' }],
+      })!
+      expect(configuration.allowedGraphQlUrls).toEqual([
+        { match: /\/graphql$/i, trackPayload: false },
+        { match: 'https://api.example.com/graphql', trackPayload: false },
+      ])
+    })
+
+    it('should accept function matchers', () => {
+      const customMatcher = (url: string) => url.includes('graphql')
+      const configuration = validateAndBuildRumConfiguration({
+        ...DEFAULT_INIT_CONFIGURATION,
+        allowedGraphQlUrls: [{ match: customMatcher }],
+      })!
+      expect(configuration.allowedGraphQlUrls).toEqual([{ match: customMatcher, trackPayload: false }])
+    })
+
+    it('should accept GraphQL options with trackPayload', () => {
+      const configuration = validateAndBuildRumConfiguration({
+        ...DEFAULT_INIT_CONFIGURATION,
+        allowedGraphQlUrls: [{ match: '/graphql', trackPayload: true }],
+      })!
+      expect(configuration.allowedGraphQlUrls).toEqual([{ match: '/graphql', trackPayload: true }])
+    })
+
+    it('should reject invalid values', () => {
+      validateAndBuildRumConfiguration({
+        ...DEFAULT_INIT_CONFIGURATION,
+        allowedGraphQlUrls: 'not-an-array' as any,
+      })
+      expect(displayWarnSpy).toHaveBeenCalledOnceWith('allowedGraphQlUrls should be an array')
+    })
+  })
 })
 
 describe('validateAndBuildRumConfiguration errorStack threading', () => {
@@ -541,6 +595,7 @@ describe('serializeRumConfiguration', () => {
       workerUrl: './worker.js',
       compressIntakeRequests: true,
       allowedTracingUrls: ['foo'],
+      allowedGraphQlUrls: ['bar'],
       traceSampleRate: 50,
       traceContextInjection: TraceContextInjection.ALL,
       defaultPrivacyLevel: 'allow',
@@ -564,7 +619,7 @@ describe('serializeRumConfiguration', () => {
 
     type MapRumInitConfigurationKey<Key extends string> = Key extends keyof InitConfiguration
       ? MapInitConfigurationKey<Key>
-      : Key extends 'workerUrl' | 'allowedTracingUrls' | 'excludedActivityUrls'
+      : Key extends 'workerUrl' | 'allowedTracingUrls' | 'excludedActivityUrls' | 'allowedGraphQlUrls'
         ? `use_${CamelToSnakeCase<Key>}`
         : Key extends 'trackLongTasks'
           ? 'track_long_task' // oops
@@ -579,7 +634,9 @@ describe('serializeRumConfiguration', () => {
     // By specifying the type here, we can ensure that serializeConfiguration is returning an
     // object containing all expected properties.
     const serializedConfiguration: ExtractTelemetryConfiguration<
-      MapRumInitConfigurationKey<keyof RumInitConfiguration> | 'selected_tracing_propagators'
+      | MapRumInitConfigurationKey<keyof RumInitConfiguration>
+      | 'selected_tracing_propagators'
+      | 'use_track_graph_ql_payload'
     > = serializeRumConfiguration(exhaustiveRumInitConfiguration)
 
     expect(serializedConfiguration).toEqual({
@@ -588,6 +645,8 @@ describe('serializeRumConfiguration', () => {
       trace_sample_rate: 50,
       trace_context_injection: TraceContextInjection.ALL,
       use_allowed_tracing_urls: true,
+      use_allowed_graph_ql_urls: true,
+      use_track_graph_ql_payload: false,
       selected_tracing_propagators: ['tracecontext', 'datadog'],
       use_excluded_activity_urls: true,
       track_user_interactions: true,

packages/rum-core/src/domain/configuration/configuration.ts

@@ -220,12 +220,24 @@ export interface RumInitConfiguration extends InitConfiguration {
    * @defaultValue 0
    */
   profilingSampleRate?: number | undefined
+
+  /**
+   * A list of GraphQL endpoint URLs to track and enrich with GraphQL-specific metadata.
+   *
+   * @category Data Collection
+   */
+  allowedGraphQlUrls?: Array<MatchOption | GraphQlUrlOption> | undefined
 }
 
 export type HybridInitConfiguration = Omit<RumInitConfiguration, 'applicationId' | 'clientToken'>
 
 export type FeatureFlagsForEvents = 'vital' | 'action' | 'long_task' | 'resource'
 
+export interface GraphQlUrlOption {
+  match: MatchOption
+  trackPayload?: boolean
+}
+
 export interface RumConfiguration extends Configuration {
   // Built from init configuration
   actionNameAttribute: string | undefined
@@ -254,6 +266,7 @@ export interface RumConfiguration extends Configuration {
   trackFeatureFlagsForEvents: FeatureFlagsForEvents[]
   profilingSampleRate: number
   propagateTraceBaggage: boolean
+  allowedGraphQlUrls: GraphQlUrlOption[]
 }
 
 export function validateAndBuildRumConfiguration(
@@ -289,6 +302,8 @@ export function validateAndBuildRumConfiguration(
     return
   }
 
+  const allowedGraphQlUrls = validateAndBuildGraphQlOptions(initConfiguration)
+
   const baseConfiguration = validateAndBuildConfiguration(initConfiguration, errorStack)
   if (!baseConfiguration) {
     return
@@ -330,6 +345,7 @@ export function validateAndBuildRumConfiguration(
     trackFeatureFlagsForEvents: initConfiguration.trackFeatureFlagsForEvents || [],
     profilingSampleRate: initConfiguration.profilingSampleRate ?? 0,
     propagateTraceBaggage: !!initConfiguration.propagateTraceBaggage,
+    allowedGraphQlUrls,
     ...baseConfiguration,
   }
 }
@@ -387,6 +403,35 @@ function getSelectedTracingPropagators(configuration: RumInitConfiguration): Pro
   return Array.from(usedTracingPropagators)
 }
 
+/**
+ * Build GraphQL options from configuration
+ */
+function validateAndBuildGraphQlOptions(initConfiguration: RumInitConfiguration): GraphQlUrlOption[] {
+  if (!initConfiguration.allowedGraphQlUrls) {
+    return []
+  }
+
+  if (!Array.isArray(initConfiguration.allowedGraphQlUrls)) {
+    display.warn('allowedGraphQlUrls should be an array')
+    return []
+  }
+
+  const graphQlOptions: GraphQlUrlOption[] = []
+
+  initConfiguration.allowedGraphQlUrls.forEach((option) => {
+    if (isMatchOption(option)) {
+      graphQlOptions.push({ match: option, trackPayload: false })
+    } else if (option && typeof option === 'object' && 'match' in option && isMatchOption(option.match)) {
+      graphQlOptions.push({
+        match: option.match,
+        trackPayload: !!option.trackPayload,
+      })
+    }
+  })
+
+  return graphQlOptions
+}
+
 export function serializeRumConfiguration(configuration: RumInitConfiguration) {
   const baseSerializedConfiguration = serializeConfiguration(configuration)
 
@@ -398,6 +443,16 @@ export function serializeRumConfiguration(configuration: RumInitConfiguration) {
     action_name_attribute: configuration.actionNameAttribute,
     use_allowed_tracing_urls:
       Array.isArray(configuration.allowedTracingUrls) && configuration.allowedTracingUrls.length > 0,
+    use_allowed_graph_ql_urls:
+      Array.isArray(configuration.allowedGraphQlUrls) && configuration.allowedGraphQlUrls.length > 0,
+    use_track_graph_ql_payload:
+      Array.isArray(configuration.allowedGraphQlUrls) &&
+      configuration.allowedGraphQlUrls.some((option) => {
+        if (typeof option === 'object' && 'trackPayload' in option) {
+          return option.trackPayload === true
+        }
+        return false
+      }),
     selected_tracing_propagators: getSelectedTracingPropagators(configuration),
     default_privacy_level: configuration.defaultPrivacyLevel,
     enable_privacy_for_action_name: configuration.enablePrivacyForActionName,

packages/rum-core/src/domain/resource/graphql.spec.ts

@@ -0,0 +1,144 @@
+import { mockRumConfiguration } from '../../../test'
+import { extractGraphQlMetadata, findGraphQlConfiguration } from './graphql'
+
+describe('GraphQL detection and metadata extraction', () => {
+  describe('findGraphQlConfiguration', () => {
+    it('should detect GraphQL requests matching string URLs', () => {
+      const configuration = mockRumConfiguration({
+        allowedGraphQlUrls: [
+          { match: 'http://localhost/graphql', trackPayload: false },
+          { match: 'https://api.example.com/graphql', trackPayload: false },
+        ],
+      })
+
+      expect(findGraphQlConfiguration('https://api.example.com/graphql', configuration)).toBeTruthy()
+      expect(findGraphQlConfiguration('http://localhost/api', configuration)).toBeUndefined()
+    })
+
+    it('should detect GraphQL requests matching regex patterns', () => {
+      const configuration = mockRumConfiguration({
+        allowedGraphQlUrls: [{ match: /\/graphql$/i, trackPayload: false }],
+      })
+
+      expect(findGraphQlConfiguration('/api/graphql', configuration)).toBeTruthy()
+      expect(findGraphQlConfiguration('/graphql/admin', configuration)).toBeUndefined()
+    })
+
+    it('should detect GraphQL requests matching function matchers', () => {
+      const configuration = mockRumConfiguration({
+        allowedGraphQlUrls: [{ match: (url: string) => url.includes('gql'), trackPayload: false }],
+      })
+
+      expect(findGraphQlConfiguration('/api/gql', configuration)).toBeTruthy()
+      expect(findGraphQlConfiguration('/gql-endpoint', configuration)).toBeTruthy()
+      expect(findGraphQlConfiguration('/api/rest', configuration)).toBeUndefined()
+    })
+  })
+
+  describe('extractGraphQlMetadata', () => {
+    it('should extract query operation type and name', () => {
+      const requestBody = JSON.stringify({
+        query: 'query GetUser { user { id name } }',
+        operationName: 'GetUser',
+        variables: { id: '123' },
+      })
+
+      const result = extractGraphQlMetadata(requestBody, true)
+
+      expect(result).toEqual({
+        operationType: 'query',
+        operationName: 'GetUser',
+        variables: '{"id":"123"}',
+        payload: 'query GetUser { user { id name } }',
+      })
+    })
+
+    it('should handle empty variables object', () => {
+      const requestBody = JSON.stringify({
+        query: 'query GetUser { user { id name } }',
+        operationName: 'GetUser',
+        variables: {},
+      })
+
+      const result = extractGraphQlMetadata(requestBody, true)
+
+      expect(result).toEqual({
+        operationType: 'query',
+        operationName: 'GetUser',
+        variables: '{}',
+        payload: 'query GetUser { user { id name } }',
+      })
+    })
+
+    it('should handle null variables', () => {
+      const requestBody = JSON.stringify({
+        query: 'query GetUser { user { id name } }',
+        operationName: 'GetUser',
+        variables: null,
+      })
+
+      const result = extractGraphQlMetadata(requestBody, true)
+
+      expect(result).toEqual({
+        operationType: 'query',
+        operationName: 'GetUser',
+        variables: undefined,
+        payload: 'query GetUser { user { id name } }',
+      })
+    })
+
+    it('should return undefined for invalid JSON', () => {
+      const result = extractGraphQlMetadata('not valid json', true)
+      expect(result).toBeUndefined()
+    })
+
+    it('should return undefined for non-GraphQL request body', () => {
+      const requestBody = JSON.stringify({ data: 'some data' })
+      const result = extractGraphQlMetadata(requestBody, true)
+      expect(result).toBeUndefined()
+    })
+  })
+
+  describe('payload truncation', () => {
+    it('should not truncate payload under 32KB', () => {
+      const shortQuery = 'query GetUser { user { id } }'
+      const requestBody = JSON.stringify({
+        query: shortQuery,
+      })
+
+      const result = extractGraphQlMetadata(requestBody, true)
+
+      expect(result?.payload).toBe(shortQuery)
+    })
+
+    it('should truncate payload over 32KB', () => {
+      const longQuery = `query LongQuery { ${'a'.repeat(33000)} }`
+      const requestBody = JSON.stringify({
+        query: longQuery,
+      })
+
+      const result = extractGraphQlMetadata(requestBody, true)
+
+      expect(result?.payload?.length).toBe(32768 + 3)
+      expect(result?.payload?.endsWith('...')).toBe(true)
+      expect(result?.payload?.startsWith('query LongQuery {')).toBe(true)
+    })
+
+    it('should not include payload when trackPayload is false', () => {
+      const requestBody = JSON.stringify({
+        query: 'query GetUser { user { id name } }',
+        operationName: 'GetUser',
+        variables: { id: '123' },
+      })
+
+      const result = extractGraphQlMetadata(requestBody, false)
+
+      expect(result).toEqual({
+        operationType: 'query',
+        operationName: 'GetUser',
+        variables: '{"id":"123"}',
+        payload: undefined,
+      })
+    })
+  })
+})