dd-trace 5.89.0 → 5.91.0

package/packages/dd-trace/src/plugins/util/ci.js

@@ -1,6 +1,7 @@
 'use strict'
 
-const { readFileSync } = require('fs')
+const { readFileSync, readdirSync, existsSync } = require('fs')
+const path = require('path')
 const { getEnvironmentVariable, getEnvironmentVariables, getValueFromEnvSources } = require('../../config/helper')
 const {
   GIT_BRANCH,
@@ -102,8 +103,92 @@ function getGitHubEventPayload () {
   return JSON.parse(readFileSync(path, 'utf8'))
 }
 
+function getJobIDFromDiagFile (runnerTemp) {
+  if (!runnerTemp || !existsSync(runnerTemp)) { return null }
+
+  // RUNNER_TEMP usually looks like:
+  // Linux/mac hosted:   /home/runner/work/_temp
+  // Windows hosted:     C:\actions-runner\_work\_temp
+  // Self-hosted (unix): /opt/actions-runner/_work/_temp
+
+  const workDir = path.dirname(runnerTemp) // .../work or .../_work
+  const runnerRoot = path.dirname(workDir) // /home/runner/ (runner root)
+
+  const dirs = [
+    path.join(runnerRoot, 'cached', '_diag'),
+    path.join(runnerRoot, '_diag'),
+    path.join(runnerRoot, 'actions-runner', 'cached', '_diag'),
+    path.join(runnerRoot, 'actions-runner', '_diag'),
+  ]
+
+  const isWin = process.platform === 'win32'
+
+  // Hardcoded fallbacks
+  if (isWin) {
+    dirs.push(
+      'C:/actions-runner/cached/_diag',
+      'C:/actions-runner/_diag',
+    )
+  } else {
+    dirs.push(
+      '/home/runner/actions-runner/cached/_diag',
+      '/home/runner/actions-runner/_diag',
+      '/opt/actions-runner/_diag',
+    )
+  }
+
+  // Remove duplicates
+  const possibleDiagsPaths = [...new Set(dirs)]
+
+  // This will hold the names of the worker log files that (potentially) contain the Job ID
+  let workerLogFiles = []
+
+  // This will hold the chosen diagnostics path (between the ones that are contemplated in possibleDiagsPath)
+  let chosenDiagPath = ''
+
+  for (const diagPath of possibleDiagsPaths) {
+    try {
+      // Obtain a list of fs.Dirent objects of the files in diagPath
+      const files = readdirSync(diagPath, { withFileTypes: true })
+
+      // Check if there are valid potential log files
+      const potentialLogs = files
+        .filter((file) => file.isFile() && file.name.startsWith('Worker_'))
+        .map((file) => file.name)
+
+      if (potentialLogs.length > 0) {
+        chosenDiagPath = diagPath
+        workerLogFiles = potentialLogs
+        break // No need to keep looking for more log files
+      }
+    } catch (error) {
+      // If the directory was not found, just look in the next one
+      if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+        continue
+      }
+
+      // Any other kind of error must force a return
+      return null
+    }
+  }
+
+  // Get the job ID via regex
+  for (const logFile of workerLogFiles) {
+    const filePath = path.posix.join(chosenDiagPath, logFile)
+    const content = readFileSync(filePath, 'utf8')
+
+    const match = content.match(/"job":\s*{[\s\S]*?"v"\s*:\s*(\d+)(?:\.0)?/)
+
+    // match[1] is the captured group with the display name
+    if (match && match[1]) { return match[1] }
+  }
+
+  return null
+}
+
 module.exports = {
   normalizeRef,
+  getJobIDFromDiagFile,
   getCIMetadata () {
     const env = getEnvironmentVariables()
 
@@ -281,6 +366,8 @@ module.exports = {
         GITHUB_RUN_ATTEMPT,
         GITHUB_JOB,
         GITHUB_BASE_REF,
+        RUNNER_TEMP,
+        JOB_CHECK_RUN_ID,
       } = env
 
       const repositoryURL = `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}.git`
@@ -290,7 +377,12 @@ module.exports = {
         pipelineURL = `${pipelineURL}/attempts/${GITHUB_RUN_ATTEMPT}`
       }
 
-      const jobUrl = `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/commit/${GITHUB_SHA}/checks`
+      // Build the job url extracting the job ID. If extraction fails, job url is constructed as a generalized url
+      const GITHUB_JOB_ID = JOB_CHECK_RUN_ID ?? getJobIDFromDiagFile(RUNNER_TEMP)
+      const jobUrl =
+        GITHUB_JOB_ID === null
+          ? `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/commit/${GITHUB_SHA}/checks`
+          : `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}/job/${GITHUB_JOB_ID}`
 
       const ref = GITHUB_HEAD_REF || GITHUB_REF || ''
       const refKey = ref.includes('tags/') ? GIT_TAG : GIT_BRANCH
@@ -315,7 +407,7 @@ module.exports = {
           GITHUB_RUN_ID,
           GITHUB_RUN_ATTEMPT,
         }),
-        [CI_JOB_ID]: GITHUB_JOB,
+        [CI_JOB_ID]: GITHUB_JOB_ID ?? GITHUB_JOB,
       }
       if (GITHUB_BASE_REF) { // `pull_request` or `pull_request_target` event
         tags[GIT_PULL_REQUEST_BASE_BRANCH] = GITHUB_BASE_REF

package/packages/dd-trace/src/plugins/util/inferred_proxy.js

@@ -5,8 +5,10 @@ const tags = require('../../../../../ext/tags')
 
 const RESOURCE_NAME = tags.RESOURCE_NAME
 const SPAN_TYPE = tags.SPAN_TYPE
+const SPAN_KIND = tags.SPAN_KIND
 const HTTP_URL = tags.HTTP_URL
 const HTTP_METHOD = tags.HTTP_METHOD
+const HTTP_ROUTE = tags.HTTP_ROUTE
 
 const PROXY_HEADER_SYSTEM = 'x-dd-proxy'
 const PROXY_HEADER_START_TIME_MS = 'x-dd-proxy-request-time-ms'
@@ -15,12 +17,20 @@ const PROXY_HEADER_HTTPMETHOD = 'x-dd-proxy-httpmethod'
 const PROXY_HEADER_DOMAIN = 'x-dd-proxy-domain-name'
 const PROXY_HEADER_STAGE = 'x-dd-proxy-stage'
 const PROXY_HEADER_REGION = 'x-dd-proxy-region'
+const PROXY_HEADER_RESOURCE_PATH = 'x-dd-proxy-resource-path'
+const PROXY_HEADER_ACCOUNT_ID = 'x-dd-proxy-account-id'
+const PROXY_HEADER_API_ID = 'x-dd-proxy-api-id'
+const PROXY_HEADER_AWS_USER = 'x-dd-proxy-user'
 
 const supportedProxies = {
   'aws-apigateway': {
     spanName: 'aws.apigateway',
     component: 'aws-apigateway',
   },
+  'aws-httpapi': {
+    spanName: 'aws.httpapi',
+    component: 'aws-httpapi',
+  },
   'azure-apim': {
     spanName: 'azure.apim',
     component: 'azure-apim',
@@ -55,10 +65,16 @@ function createInferredProxySpan (headers, childOf, tracer, reqCtx, traceCtx, co
       service: proxyContext.domainName || tracer._config.service,
       component: proxySpanInfo.component,
       [SPAN_TYPE]: 'web',
+      [SPAN_KIND]: 'server',
       [HTTP_METHOD]: proxyContext.method,
-      [HTTP_URL]: proxyContext.domainName + proxyContext.path,
+      [HTTP_URL]: 'https://' + proxyContext.domainName + proxyContext.path,
       stage: proxyContext.stage,
       region: proxyContext.region,
+      ...(proxyContext.resourcePath && { [HTTP_ROUTE]: proxyContext.resourcePath }),
+      ...(proxyContext.accountId && { account_id: proxyContext.accountId }),
+      ...(proxyContext.apiId && { apiid: proxyContext.apiId }),
+      ...(proxyContext.region && { region: proxyContext.region }),
+      ...(proxyContext.awsUser && { aws_user: proxyContext.awsUser }),
     },
   }, traceCtx, config)
 
@@ -73,8 +89,22 @@ function createInferredProxySpan (headers, childOf, tracer, reqCtx, traceCtx, co
 }
 
 function setInferredProxySpanTags (span, proxyContext) {
-  span.setTag(RESOURCE_NAME, `${proxyContext.method} ${proxyContext.path}`)
+  const resourcePath = proxyContext.resourcePath || proxyContext.path
+  span.setTag(RESOURCE_NAME, `${proxyContext.method} ${resourcePath}`)
   span.setTag('_dd.inferred_span', 1)
+
+  // Set dd_resource_key as API Gateway ARN if we have the required components
+  if (proxyContext.apiId && proxyContext.region) {
+    const partition = 'aws'
+    // API Gateway v1 (REST): arn:{partition}:apigateway:{region}::/restapis/{api-id}
+    // API Gateway v2 (HTTP): arn:{partition}:apigateway:{region}::/apis/{api-id}
+    const apiType = proxyContext.proxySystemName === 'aws-httpapi' ? 'apis' : 'restapis'
+    span.setTag(
+      'dd_resource_key',
+      `arn:${partition}:apigateway:${proxyContext.region}::/${apiType}/${proxyContext.apiId}`
+    )
+  }
+
   return span
 }
 
@@ -98,6 +128,10 @@ function extractInferredProxyContext (headers) {
     domainName: headers[PROXY_HEADER_DOMAIN],
     proxySystemName: headers[PROXY_HEADER_SYSTEM],
     region: headers[PROXY_HEADER_REGION],
+    resourcePath: headers[PROXY_HEADER_RESOURCE_PATH],
+    accountId: headers[PROXY_HEADER_ACCOUNT_ID],
+    apiId: headers[PROXY_HEADER_API_ID],
+    awsUser: headers[PROXY_HEADER_AWS_USER],
   }
 }
 

package/packages/dd-trace/src/plugins/util/test.js

@@ -150,7 +150,6 @@ const DD_CAPABILITIES_FAILED_TEST_REPLAY = '_dd.library_capabilities.failed_test
 const DD_CI_LIBRARY_CONFIGURATION_ERROR = '_dd.ci.library_configuration_error'
 
 const UNSUPPORTED_TIA_FRAMEWORKS = new Set(['playwright', 'vitest'])
-const UNSUPPORTED_TIA_FRAMEWORKS_PARALLEL_MODE = new Set(['cucumber', 'mocha'])
 const MINIMUM_FRAMEWORK_VERSION_FOR_EFD = {
   playwright: '>=1.38.0',
 }
@@ -170,7 +169,6 @@ const MINIMUM_FRAMEWORK_VERSION_FOR_FAILED_TEST_REPLAY = {
   playwright: '>=1.38.0',
 }
 
-const UNSUPPORTED_ATTEMPT_TO_FIX_FRAMEWORKS_PARALLEL_MODE = new Set(['mocha'])
 const NOT_SUPPORTED_GRANULARITY_IMPACTED_TESTS_FRAMEWORKS = new Set(['mocha', 'playwright', 'vitest'])
 
 const TEST_LEVEL_EVENT_TYPES = [
@@ -987,9 +985,8 @@ function getFormattedError (error, repositoryRoot) {
   return newError
 }
 
-function isTiaSupported (testFramework, isParallel) {
-  return !(UNSUPPORTED_TIA_FRAMEWORKS.has(testFramework) ||
-           (isParallel && UNSUPPORTED_TIA_FRAMEWORKS_PARALLEL_MODE.has(testFramework)))
+function isTiaSupported (testFramework) {
+  return !UNSUPPORTED_TIA_FRAMEWORKS.has(testFramework)
 }
 
 function isEarlyFlakeDetectionSupported (testFramework, frameworkVersion) {
@@ -1016,12 +1013,12 @@ function isDisableSupported (testFramework, frameworkVersion) {
     : true
 }
 
-function isAttemptToFixSupported (testFramework, isParallel, frameworkVersion) {
+function isAttemptToFixSupported (testFramework, frameworkVersion) {
   if (testFramework === 'playwright') {
     return satisfies(frameworkVersion, MINIMUM_FRAMEWORK_VERSION_FOR_ATTEMPT_TO_FIX[testFramework])
   }
 
-  return !(isParallel && UNSUPPORTED_ATTEMPT_TO_FIX_FRAMEWORKS_PARALLEL_MODE.has(testFramework))
+  return true
 }
 
 function isFailedTestReplaySupported (testFramework, frameworkVersion) {
@@ -1030,9 +1027,9 @@ function isFailedTestReplaySupported (testFramework, frameworkVersion) {
     : true
 }
 
-function getLibraryCapabilitiesTags (testFramework, isParallel, frameworkVersion) {
+function getLibraryCapabilitiesTags (testFramework, frameworkVersion) {
   return {
-    [DD_CAPABILITIES_TEST_IMPACT_ANALYSIS]: isTiaSupported(testFramework, isParallel)
+    [DD_CAPABILITIES_TEST_IMPACT_ANALYSIS]: isTiaSupported(testFramework)
       ? '1'
       : undefined,
     [DD_CAPABILITIES_EARLY_FLAKE_DETECTION]: isEarlyFlakeDetectionSupported(testFramework, frameworkVersion)
@@ -1049,7 +1046,7 @@ function getLibraryCapabilitiesTags (testFramework, isParallel, frameworkVersion
       ? '1'
       : undefined,
     [DD_CAPABILITIES_TEST_MANAGEMENT_ATTEMPT_TO_FIX]:
-      isAttemptToFixSupported(testFramework, isParallel, frameworkVersion)
+      isAttemptToFixSupported(testFramework, frameworkVersion)
         ? '5'
         : undefined,
     [DD_CAPABILITIES_FAILED_TEST_REPLAY]: isFailedTestReplaySupported(testFramework, frameworkVersion)

package/packages/dd-trace/src/plugins/util/web.js

@@ -410,6 +410,13 @@ const web = {
       },
     })
   },
+  setRouteOrEndpointTag (req) {
+    const context = contexts.get(req)
+
+    if (!context) return
+
+    applyRouteOrEndpointTag(context)
+  },
 }
 
 function addAllowHeaders (req, res, headers) {
@@ -481,18 +488,9 @@ function addRequestTags (context, spanType) {
 }
 
 function addResponseTags (context) {
-  const { req, res, paths, span, inferredProxySpan, config } = context
+  const { req, res, inferredProxySpan, span } = context
 
-  const route = paths.join('')
-  if (route) {
-    // Use http.route from trusted framework instrumentation
-    span.setTag(HTTP_ROUTE, route)
-  } else if (config.resourceRenamingEnabled) {
-    // Route is unavailable, compute http.endpoint instead
-    const url = span.context()._tags[HTTP_URL]
-    const endpoint = url ? calculateHttpEndpoint(url) : '/'
-    span.setTag(HTTP_ENDPOINT, endpoint)
-  }
+  applyRouteOrEndpointTag(context)
 
   span.addTags({
     [HTTP_STATUS_CODE]: res.statusCode,
@@ -504,6 +502,28 @@ function addResponseTags (context) {
   web.addStatusError(req, res.statusCode)
 }
 
+function applyRouteOrEndpointTag (context) {
+  const { paths, span, config } = context
+  if (!span) return
+  const tags = span.context()._tags
+  const route = paths.join('')
+
+  if (route) {
+    // Use http.route from trusted framework instrumentation.
+    span.setTag(HTTP_ROUTE, route)
+    return
+  }
+
+  if (!config.resourceRenamingEnabled || tags[HTTP_ENDPOINT]) {
+    return
+  }
+
+  // Route is unavailable, compute http.endpoint once.
+  const url = tags[HTTP_URL]
+  const endpoint = url ? calculateHttpEndpoint(url) : '/'
+  span.setTag(HTTP_ENDPOINT, endpoint)
+}
+
 function addResourceTag (context) {
   const { req, span } = context
   const tags = span.context()._tags

package/packages/dd-trace/src/priority_sampler.js

@@ -31,10 +31,21 @@ const {
   SAMPLING_LIMIT_DECISION,
   SAMPLING_AGENT_DECISION,
   DECISION_MAKER_KEY,
+  SAMPLING_KNUTH_RATE,
 } = require('./constants')
 
 const DEFAULT_KEY = 'service:,env:'
 
+/**
+ * Formats a sampling rate as a string with up to 6 significant digits and no trailing zeros.
+ *
+ * @param {number} rate
+ * @returns {string}
+ */
+function formatKnuthRate (rate) {
+  return Number(rate.toPrecision(6)).toString()
+}
+
 const defaultSampler = new Sampler(AUTO_KEEP)
 
 /**
@@ -254,6 +265,7 @@ class PrioritySampler {
    */
   #getPriorityByRule (context, rule) {
     context._trace[SAMPLING_RULE_DECISION] = rule.sampleRate
+    context._trace.tags[SAMPLING_KNUTH_RATE] = formatKnuthRate(rule.sampleRate)
     context._sampling.mechanism = SAMPLING_MECHANISM_RULE
     if (rule.provenance === 'customer') context._sampling.mechanism = SAMPLING_MECHANISM_REMOTE_USER
     if (rule.provenance === 'dynamic') context._sampling.mechanism = SAMPLING_MECHANISM_REMOTE_DYNAMIC
@@ -290,9 +302,15 @@ class PrioritySampler {
     // TODO: Change underscored properties to private ones.
     const sampler = this._samplers[key] || this._samplers[DEFAULT_KEY]
 
-    context._trace[SAMPLING_AGENT_DECISION] = sampler.rate()
+    const rate = sampler.rate()
+    context._trace[SAMPLING_AGENT_DECISION] = rate
 
-    context._sampling.mechanism = sampler === defaultSampler ? SAMPLING_MECHANISM_DEFAULT : SAMPLING_MECHANISM_AGENT
+    if (sampler === defaultSampler) {
+      context._sampling.mechanism = SAMPLING_MECHANISM_DEFAULT
+    } else {
+      context._trace.tags[SAMPLING_KNUTH_RATE] = formatKnuthRate(rate)
+      context._sampling.mechanism = SAMPLING_MECHANISM_AGENT
+    }
 
     return sampler.isSampled(context) ? AUTO_KEEP : AUTO_REJECT
   }

package/packages/dd-trace/src/process-tags/index.js

@@ -12,8 +12,19 @@ const ENTRYPOINT_PATH = require.main?.filename || ''
 // entrypoint.basedir = baz
 // package.json.name = <from package.json>
 
-// process tags are constant throughout the lifetime of a process
-function getProcessTags () {
+/**
+ * Sanitize a process tag value
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+function sanitize (value) {
+  return String(value)
+    .toLowerCase()
+    .replaceAll(/[^a-zA-Z0-9/_.-]+/g, '_')
+}
+
+function buildProcessTags (config) {
   // Lazy load pkg to avoid issues with require.main during test initialization
   const pkg = require('../pkg')
 
@@ -35,6 +46,13 @@ function getProcessTags () {
     ['package.json.name', pkg.name || undefined],
   ]
 
+  // If config dependent tags keep growing, we should consider moving this into a function
+  if (config?.isServiceNameInferred) {
+    tags.push(['svc.auto', config.service])
+  } else if (config) {
+    tags.push(['svc.user', true])
+  }
+
   const tagsArray = []
   const tagsObject = {}
 
@@ -46,38 +64,27 @@ function getProcessTags () {
     }
   }
 
-  const serialized = tagsArray.join(',')
-
-  return {
-    tags,
-    serialized,
-    tagsObject,
-    tagsArray,
-  }
+  processTags.tags = tags
+  processTags.serialized = tagsArray.join(',')
+  processTags.tagsObject = tagsObject
+  processTags.tagsArray = tagsArray
 }
 
-// Export the singleton
-module.exports = getProcessTags()
-
-module.exports.TRACING_FIELD_NAME = '_dd.tags.process'
-module.exports.DSM_FIELD_NAME = 'ProcessTags'
-module.exports.PROFILING_FIELD_NAME = 'process_tags'
-module.exports.DYNAMIC_INSTRUMENTATION_FIELD_NAME = 'process_tags'
-module.exports.TELEMETRY_FIELD_NAME = 'process_tags'
-module.exports.REMOTE_CONFIG_FIELD_NAME = 'process_tags'
-module.exports.CRASH_TRACKING_FIELD_NAME = 'process_tags'
-module.exports.CLIENT_TRACE_STATISTICS_FIELD_NAME = 'ProcessTags'
-
-/**
- * Sanitize a process tag value
- *
- * @param {string} value
- * @returns {string}
- */
-function sanitize (value) {
-  return String(value)
-    .toLowerCase()
-    .replaceAll(/[^a-zA-Z0-9/_.-]+/g, '_')
+// Singleton with constant defaults so pre-init reads don't blow up
+const processTags = module.exports = {
+  initialize (config) {
+    // check if one of the properties added during build exist and if so return
+    if (processTags.tags) return
+    buildProcessTags(config)
+  },
+
+  TRACING_FIELD_NAME: '_dd.tags.process',
+  DSM_FIELD_NAME: 'ProcessTags',
+  PROFILING_FIELD_NAME: 'process_tags',
+  DYNAMIC_INSTRUMENTATION_FIELD_NAME: 'process_tags',
+  TELEMETRY_FIELD_NAME: 'process_tags',
+  REMOTE_CONFIG_FIELD_NAME: 'process_tags',
+  CRASH_TRACKING_FIELD_NAME: 'process_tags',
+  CLIENT_TRACE_STATISTICS_FIELD_NAME: 'ProcessTags',
+  sanitize,
 }
-
-module.exports.sanitize = sanitize

package/packages/dd-trace/src/profiling/profilers/wall.js

@@ -290,7 +290,15 @@ class NativeWallProfiler {
       }
 
       profilingContext = { spanId, rootSpanId, webTags }
-      span[ProfilingContext] = profilingContext
+      // Don't cache if endpoint collection is enabled and webTags is undefined but
+      // the span's type hasn't been set yet. TracingPlugin.startSpan() calls
+      // enterWith() before the plugin sets span.type='web' via addRequestTags(),
+      // so the first enterCh event fires before the type is known. Without this
+      // guard we'd cache webTags=undefined and then serve that stale value on the
+      // subsequent activation (when span.type='web' is already set).
+      if (!this.#endpointCollectionEnabled || webTags !== undefined || context._tags['span.type']) {
+        span[ProfilingContext] = profilingContext
+      }
     }
     return profilingContext
   }

package/packages/dd-trace/src/proxy.js

@@ -13,6 +13,7 @@ const nomenclature = require('./service-naming')
 const PluginManager = require('./plugin_manager')
 const NoopDogStatsDClient = require('./noop/dogstatsd')
 const { IS_SERVERLESS } = require('./serverless')
+const processTags = require('./process-tags')
 const {
   setBaggageItem,
   getBaggageItem,
@@ -102,6 +103,9 @@ class Tracer extends NoopProxy {
     try {
       const config = getConfig(options) // TODO: support dynamic code config
 
+      // Add config dependent process tags
+      processTags.initialize(config)
+
       // Configure propagation hash manager for process tags + container tags
       const propagationHash = require('./propagation-hash')
       propagationHash.configure(config)

package/packages/dd-trace/src/runtime_metrics/runtime_metrics.js

@@ -11,6 +11,7 @@ const log = require('../log')
 const { getValueFromEnvSources } = require('../config/helper')
 
 const { NODE_MAJOR } = require('../../../../version')
+const processTags = require('../process-tags')
 // TODO: This environment variable may not be changed, since the agent expects a flush every ten seconds.
 // It is only a variable for testing. Think about alternatives.
 const DD_RUNTIME_METRICS_FLUSH_INTERVAL = getValueFromEnvSources('DD_RUNTIME_METRICS_FLUSH_INTERVAL') ?? '10000'
@@ -38,6 +39,12 @@ module.exports = {
     this.stop()
     const clientConfig = DogStatsDClient.generateClientConfig(config)
 
+    if (config.propagateProcessTags?.enabled) {
+      for (const tag of processTags.tagsArray) {
+        clientConfig.tags.push(tag)
+      }
+    }
+
     const trackEventLoop = config.runtimeMetrics.eventLoop !== false
     const trackGc = config.runtimeMetrics.gc !== false
 

package/packages/dd-trace/src/service-naming/schemas/v0/serverless.js

@@ -8,6 +8,10 @@ const serverless = {
       opName: () => 'azure.functions.invoke',
       serviceName: identityService,
     },
+    'azure-durable-functions': {
+      opName: () => 'azure.functions.invoke',
+      serviceName: identityService,
+    },
   },
 }
 

package/packages/dd-trace/src/service-naming/schemas/v1/serverless.js

@@ -8,6 +8,10 @@ const serverless = {
       opName: () => 'azure.functions.invoke',
       serviceName: identityService,
     },
+    'azure-durable-functions': {
+      opName: () => 'azure.functions.invoke',
+      serviceName: identityService,
+    },
   },
 }
 

package/packages/dd-trace/src/standalone/product.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { SAMPLING_MECHANISM_APPSEC } = require('../constants')
+const { SAMPLING_MECHANISM_APPSEC, SAMPLING_MECHANISM_AI_GUARD } = require('../constants')
 const RateLimiter = require('../rate_limiter')
 
 /**
@@ -26,6 +26,7 @@ const PRODUCTS = {
   DSM: { id: 1 << 2 },
   DJM: { id: 1 << 3 },
   DBM: { id: 1 << 4 },
+  AI_GUARD: { id: 1 << 5, mechanism: SAMPLING_MECHANISM_AI_GUARD },
 }
 
 module.exports = {