dd-trace 5.102.0 → 5.103.0

package/packages/datadog-plugin-grpc/src/util.js

@@ -3,46 +3,81 @@
 const pick = require('../../datadog-core/src/utils/src/pick')
 const log = require('../../dd-trace/src/log')
 
+/**
+ * @typedef {object} ParsedMethodPath
+ * @property {string} name
+ * @property {string} service
+ * @property {string} package
+ */
+
+// Sentinel returned by `getFilter` when the user has not configured a metadata
+// filter. `addMetadataTags` short-circuits on this identity to skip the
+// `metadata.getMap()` clone in the default no-filter case.
 function getEmptyObject () {
   return {}
 }
 
-module.exports = {
-  getMethodMetadata (path, kind) {
-    const tags = {
-      path,
-      kind,
-      name: '',
-      service: '',
-      package: '',
+/**
+ * gRPC method paths are stable per service definition (e.g.
+ * `/pkg.Service/Method`); a service typically only has a small finite set.
+ * Cache the parsed `{name, service, package}` triple by path so we skip the
+ * `path.split('/')` + `serviceParts.split('.')` + `serviceParts.pop()` work
+ * on every call.
+ *
+ * @type {Map<string, ParsedMethodPath>}
+ */
+const methodPathCache = new Map()
+
+/**
+ * @param {string} path
+ * @returns {ParsedMethodPath}
+ */
+function parseMethodPath (path) {
+  const methodParts = path.split('/')
+
+  if (methodParts.length > 2) {
+    const serviceParts = methodParts[1].split('.')
+    return {
+      name: methodParts[2],
+      service: serviceParts.pop(),
+      package: serviceParts.join('.'),
     }
+  }
 
-    if (typeof path !== 'string') return tags
+  return { name: methodParts.at(-1), service: '', package: '' }
+}
 
-    const methodParts = path.split('/')
+module.exports = {
+  getEmptyObject,
 
-    if (methodParts.length > 2) {
-      const serviceParts = methodParts[1].split('.')
-      const name = methodParts[2]
-      const service = serviceParts.pop()
-      const pkg = serviceParts.join('.')
+  getMethodMetadata (path, kind) {
+    if (typeof path !== 'string') {
+      return { path, kind, name: '', service: '', package: '' }
+    }
 
-      tags.name = name
-      tags.service = service
-      tags.package = pkg
-    } else {
-      tags.name = methodParts.at(-1)
+    let parsed = methodPathCache.get(path)
+    if (parsed === undefined) {
+      parsed = parseMethodPath(path)
+      methodPathCache.set(path, parsed)
     }
 
-    return tags
+    return {
+      path,
+      kind,
+      name: parsed.name,
+      service: parsed.service,
+      package: parsed.package,
+    }
   },
 
   addMetadataTags (span, metadata, filter, type) {
     if (!metadata || typeof metadata.getMap !== 'function') return
+    // Default no-op filter: skip the full metadata clone via `getMap()`.
+    if (filter === getEmptyObject) return
 
     const values = filter(metadata.getMap())
 
-    for (const key in values) {
+    for (const key of Object.keys(values)) {
       span.setTag(`grpc.${type}.metadata.${key}`, values[key])
     }
   },

package/packages/datadog-plugin-http/src/client.js

@@ -39,10 +39,10 @@ class HttpClientPlugin extends ClientPlugin {
     // TODO delegate to super.startspan
     const span = this.startSpan(this.operationName(), {
       childOf,
-      integrationName: this.constructor.id,
+      integrationName: this.component,
       service: this.serviceName({ pluginConfig: this.config, sessionDetails: extractSessionDetails(options) }),
       meta: {
-        [COMPONENT]: this.constructor.id,
+        [COMPONENT]: this.component,
         'span.kind': 'client',
         'resource.name': method,
         'span.type': 'http',

package/packages/datadog-plugin-jest/src/index.js

@@ -21,6 +21,7 @@ const {
   TEST_SOURCE_START,
   TEST_ITR_UNSKIPPABLE,
   TEST_ITR_FORCED_RUN,
+  TEST_ITR_SKIPPING_ENABLED,
   TEST_CODE_OWNERS,
   ITR_CORRELATION_ID,
   TEST_SOURCE_FILE,
@@ -107,6 +108,7 @@ class JestPlugin extends CiPlugin {
       process.on('message', handler)
     }
     this.testSuiteSpanPerTestSuiteAbsolutePath = new Map()
+    this.pendingTestSuiteFinishes = new Set()
 
     this.addSub('ci:jest:session:finish', ({
       status,
@@ -123,58 +125,66 @@ class JestPlugin extends CiPlugin {
       isTestManagementTestsEnabled,
       onDone,
     }) => {
-      this.testSessionSpan.setTag(TEST_STATUS, status)
-      this.testModuleSpan.setTag(TEST_STATUS, status)
+      const finishSession = () => {
+        this.testSessionSpan.setTag(TEST_STATUS, status)
+        this.testModuleSpan.setTag(TEST_STATUS, status)
 
-      if (error) {
-        this.testSessionSpan.setTag('error', error)
-        this.testModuleSpan.setTag('error', error)
-      }
-
-      addIntelligentTestRunnerSpanTags(
-        this.testSessionSpan,
-        this.testModuleSpan,
-        {
-          isSuitesSkipped,
-          isSuitesSkippingEnabled,
-          isCodeCoverageEnabled,
-          testCodeCoverageLinesTotal,
-          skippingType: 'suite',
-          skippingCount: numSkippedSuites,
-          hasUnskippableSuites,
-          hasForcedToRunSuites,
+        if (error) {
+          this.testSessionSpan.setTag('error', error)
+          this.testModuleSpan.setTag('error', error)
         }
-      )
 
-      if (isEarlyFlakeDetectionEnabled) {
-        this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ENABLED, 'true')
-      }
-      if (isEarlyFlakeDetectionFaulty) {
-        this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ABORT_REASON, 'faulty')
-      }
-      if (isTestManagementTestsEnabled) {
-        this.testSessionSpan.setTag(TEST_MANAGEMENT_ENABLED, 'true')
-      }
+        addIntelligentTestRunnerSpanTags(
+          this.testSessionSpan,
+          this.testModuleSpan,
+          {
+            isSuitesSkipped,
+            isSuitesSkippingEnabled,
+            isCodeCoverageEnabled,
+            testCodeCoverageLinesTotal,
+            skippingType: 'suite',
+            skippingCount: numSkippedSuites,
+            hasUnskippableSuites,
+            hasForcedToRunSuites,
+          }
+        )
 
-      this.testModuleSpan.finish()
-      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
-      this.testSessionSpan.finish()
-      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session', {
-        hasFailedTestReplay: this.libraryConfig?.isDiEnabled || undefined,
-      })
-      finishAllTraceSpans(this.testSessionSpan)
+        if (isEarlyFlakeDetectionEnabled) {
+          this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ENABLED, 'true')
+        }
+        if (isEarlyFlakeDetectionFaulty) {
+          this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ABORT_REASON, 'faulty')
+        }
+        if (isTestManagementTestsEnabled) {
+          this.testSessionSpan.setTag(TEST_MANAGEMENT_ENABLED, 'true')
+        }
 
-      this.telemetry.count(TELEMETRY_TEST_SESSION, {
-        provider: this.ciProviderName,
-        autoInjected: !!this._tracerConfig.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
-      })
+        this.testModuleSpan.finish()
+        this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
+        this.testSessionSpan.finish()
+        this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session', {
+          hasFailedTestReplay: this.libraryConfig?.isDiEnabled || undefined,
+        })
+        finishAllTraceSpans(this.testSessionSpan)
+
+        this.telemetry.count(TELEMETRY_TEST_SESSION, {
+          provider: this.ciProviderName,
+          autoInjected: !!this._tracerConfig.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
+        })
+
+        appClosingTelemetry()
+        this.tracer._exporter.flush(() => {
+          if (onDone) {
+            onDone()
+          }
+        })
+      }
 
-      appClosingTelemetry()
-      this.tracer._exporter.flush(() => {
-        if (onDone) {
-          onDone()
-        }
-      })
+      if (this.pendingTestSuiteFinishes.size > 0) {
+        Promise.all(this.pendingTestSuiteFinishes).then(finishSession)
+      } else {
+        finishSession()
+      }
     })
 
     // Test suites can be run in a different process from jest's main one.
@@ -197,6 +207,7 @@ class JestPlugin extends CiPlugin {
         config._ddIsDiEnabled = this.libraryConfig?.isDiEnabled ?? false
         config._ddIsKnownTestsEnabled = this.libraryConfig?.isKnownTestsEnabled ?? false
         config._ddIsImpactedTestsEnabled = this.libraryConfig?.isImpactedTestsEnabled ?? false
+        config._ddItrSkippingEnabledTags = this.getSessionItrSkippingEnabledTags()
       }
     })
 
@@ -217,6 +228,7 @@ class JestPlugin extends CiPlugin {
         _ddForcedToRun,
         _ddUnskippable,
         _ddTestCodeCoverageEnabled,
+        _ddItrSkippingEnabledTags: itrSkippingEnabledTags,
       } = testEnvironmentOptions
 
       const testSessionSpanContext = this.tracer.extract('text_map', {
@@ -228,6 +240,7 @@ class JestPlugin extends CiPlugin {
         ...getTestSuiteCommonTags(testCommand, frameworkVersion, testSuite, 'jest'),
         // requestErrorTags from test env options may be undefined
         ...(requestErrorTags !== undefined && requestErrorTags !== null ? requestErrorTags : {}),
+        ...(itrSkippingEnabledTags !== undefined && itrSkippingEnabledTags !== null ? itrSkippingEnabledTags : {}),
       }
 
       if (_ddUnskippable) {
@@ -305,10 +318,18 @@ class JestPlugin extends CiPlugin {
       }
     })
 
-    this.addSub('ci:jest:test-suite:finish', ({ status, errorMessage, error, testSuiteAbsolutePath }) => {
+    this.addSub('ci:jest:test-suite:finish', ({
+      status,
+      errorMessage,
+      error,
+      testSuiteAbsolutePath,
+      waitForFinish,
+      onDone,
+    }) => {
       const testSuiteSpan = this.testSuiteSpanPerTestSuiteAbsolutePath.get(testSuiteAbsolutePath)
       if (!testSuiteSpan) {
         log.warn('"ci:jest:test-suite:finish": no span found for test suite absolute path %s', testSuiteAbsolutePath)
+        onDone?.()
         return
       }
       testSuiteSpan.setTag(TEST_STATUS, status)
@@ -319,8 +340,13 @@ class JestPlugin extends CiPlugin {
         testSuiteSpan.setTag('error', new Error(errorMessage))
         testSuiteSpan.setTag(TEST_STATUS, 'fail')
       }
-      // We need to give the potential error in 'ci:jest:test-suite:error' time to be published
-      process.nextTick(() => {
+      let resolvePendingFinish
+      const pendingFinish = new Promise(resolve => {
+        resolvePendingFinish = resolve
+      })
+      this.pendingTestSuiteFinishes.add(pendingFinish)
+
+      const finish = () => {
         testSuiteSpan.finish()
         this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
         // Suites potentially run in a different process than the session,
@@ -334,7 +360,19 @@ class JestPlugin extends CiPlugin {
         }
         this.removeAllDiProbes()
         this.testSuiteSpanPerTestSuiteAbsolutePath.delete(testSuiteAbsolutePath)
-      })
+        this.pendingTestSuiteFinishes.delete(pendingFinish)
+        resolvePendingFinish()
+        if (onDone) {
+          onDone()
+        }
+      }
+
+      if (waitForFinish) {
+        // Give late async work time to run before Jest restarts a worker because of workerIdleMemoryLimit.
+        realSetTimeout(finish)
+      } else {
+        process.nextTick(finish)
+      }
     })
 
     this.addSub('ci:jest:test-suite:error', ({ error, errorMessage, testSuiteAbsolutePath }) => {
@@ -558,6 +596,10 @@ class JestPlugin extends CiPlugin {
       extraTags[TEST_HAS_DYNAMIC_NAME] = 'true'
     }
     const testSuiteSpan = this.testSuiteSpanPerTestSuiteAbsolutePath.get(testSuiteAbsolutePath) || this.testSuiteSpan
+    const skippingEnabled = testSuiteSpan?.context()._tags?.[TEST_ITR_SKIPPING_ENABLED]
+    if (skippingEnabled !== undefined) {
+      extraTags[TEST_ITR_SKIPPING_ENABLED] = skippingEnabled
+    }
 
     return super.startTestSpan(name, suite, testSuiteSpan, extraTags)
   }

package/packages/datadog-plugin-mocha/src/index.js

@@ -105,6 +105,7 @@ class MochaPlugin extends CiPlugin {
           'mocha'
         ),
         ...this.getSessionRequestErrorTags(),
+        ...this.getSessionItrSkippingEnabledTags(),
       }
       if (isUnskippable) {
         testSuiteMetadata[TEST_ITR_UNSKIPPABLE] = 'true'

package/packages/datadog-plugin-mongodb-core/src/index.js

@@ -90,9 +90,8 @@ class MongodbCorePlugin extends DatabasePlugin {
   }
 }
 
-function sanitizeBigInt (data) {
-  return JSON.stringify(data, (_key, value) => typeof value === 'bigint' ? value.toString() : value)
-}
+const MAX_DEPTH = 10
+const MAX_QUERY_LENGTH = 10_000
 
 function extractQuery (statements) {
   if (statements.length === 1 && statements[0].q) return statements[0].q
@@ -100,7 +99,7 @@ function extractQuery (statements) {
   const extractedQueries = []
   for (let i = 0; i < statements.length; i++) {
     if (statements[i].q) {
-      extractedQueries.push(limitDepth(statements[i].q))
+      extractedQueries.push(statements[i].q)
     }
   }
 
@@ -110,12 +109,12 @@ function extractQuery (statements) {
 function getQuery (cmd) {
   if (!cmd || (typeof cmd !== 'object' && !Array.isArray(cmd))) return
 
-  if (Array.isArray(cmd)) return sanitizeBigInt(extractQuery(cmd))
-  if (cmd.query) return sanitizeBigInt(limitDepth(cmd.query))
-  if (cmd.filter) return sanitizeBigInt(limitDepth(cmd.filter))
-  if (cmd.pipeline) return sanitizeBigInt(limitDepth(cmd.pipeline))
-  if (cmd.deletes) return sanitizeBigInt(extractQuery(cmd.deletes))
-  if (cmd.updates) return sanitizeBigInt(extractQuery(cmd.updates))
+  if (Array.isArray(cmd)) return sanitiseAndStringify(extractQuery(cmd))
+  if (cmd.query) return sanitiseAndStringify(cmd.query)
+  if (cmd.filter) return sanitiseAndStringify(cmd.filter)
+  if (cmd.pipeline) return sanitiseAndStringify(cmd.pipeline)
+  if (cmd.deletes) return sanitiseAndStringify(extractQuery(cmd.deletes))
+  if (cmd.updates) return sanitiseAndStringify(extractQuery(cmd.updates))
 }
 
 function getResource (plugin, ns, query, operationName) {
@@ -129,73 +128,40 @@ function getResource (plugin, ns, query, operationName) {
 }
 
 function truncate (input) {
-  return input.slice(0, Math.min(input.length, 10_000))
-}
-
-function shouldSimplify (input) {
-  return !isObject(input) || typeof input.toJSON === 'function'
+  return input.length > MAX_QUERY_LENGTH ? input.slice(0, MAX_QUERY_LENGTH) : input
 }
 
-function shouldHide (input) {
-  return Buffer.isBuffer(input) || typeof input === 'function' || isBinary(input)
-}
-
-function limitDepth (input) {
-  if (isBSON(input)) {
-    input = input.toJSON()
-  }
-
-  if (shouldHide(input)) return '?'
-  if (shouldSimplify(input)) return input
-
-  const output = {}
-  const queue = [{
-    input,
-    output,
-    depth: 0,
-  }]
-
-  while (queue.length) {
-    const {
-      input, output, depth,
-    } = queue.pop()
-    const nextDepth = depth + 1
-    for (const key of Object.keys(input)) {
-      let child = input[key]
-      if (typeof child === 'function') continue
-
-      if (isBSON(child)) {
-        child = typeof child.toJSON === 'function' ? child.toJSON() : '?'
-      }
-
-      if (depth >= 10 || shouldHide(child)) {
-        output[key] = '?'
-      } else if (shouldSimplify(child)) {
-        output[key] = child
-      } else {
-        output[key] = {}
-        queue.push({
-          input: child,
-          output: output[key],
-          depth: nextDepth,
-        })
+// Single-pass sanitisation. The replacer:
+// - skips functions and coerces bigint to its decimal string,
+// - returns '?' for Buffer / BSON Binary on the *original* value (JSON.stringify already invoked
+//   toJSON before calling us; Buffer / Binary do have toJSON outputs we want to suppress),
+// - lets JSON.stringify call toJSON on other BSON types (ObjectId, Long, Decimal128, Date, Timestamp, ...)
+//   so the result lands here as a primitive or plain object,
+// - returns '?' for BSON types without toJSON (MinKey, MaxKey) where `value === original`,
+// - tracks depth via an ancestor stack so cycles and depth >= MAX_DEPTH collapse to '?'.
+function sanitiseAndStringify (input) {
+  const ancestors = []
+  return JSON.stringify(input, function (key, value) {
+    if (typeof value === 'function') return
+    if (typeof value === 'bigint') return value.toString()
+
+    const original = key === '' ? value : this[key]
+    if (typeof original === 'object' && original !== null) {
+      if (Buffer.isBuffer(original)) return '?'
+      const bsontype = original._bsontype
+      if (bsontype !== undefined && (bsontype === 'Binary' || value === original)) {
+        return '?'
       }
     }
-  }
 
-  return output
-}
+    if (value === null || typeof value !== 'object') return value
 
-function isObject (val) {
-  return val !== null && typeof val === 'object' && !Array.isArray(val)
-}
-
-function isBSON (val) {
-  return val && val._bsontype && !isBinary(val)
-}
+    while (ancestors.length > 0 && ancestors.at(-1) !== this) ancestors.pop()
+    if (ancestors.length >= MAX_DEPTH || ancestors.includes(value)) return '?'
+    ancestors.push(value)
 
-function isBinary (val) {
-  return val && val._bsontype === 'Binary'
+    return value
+  })
 }
 
 function isHeartbeat (ops, config) {

package/packages/datadog-plugin-mysql/src/index.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { storage } = require('../../datadog-core')
-const CLIENT_PORT_KEY = require('../../dd-trace/src/constants')
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const DatabasePlugin = require('../../dd-trace/src/plugins/database')
 
 class MySQLPlugin extends DatabasePlugin {

package/packages/datadog-plugin-openai/src/services.js

@@ -36,7 +36,8 @@ module.exports.init = function (tracerConfig) {
 
   interval = setInterval(() => {
     metrics.flush()
-  }, FLUSH_INTERVAL).unref()
+  }, FLUSH_INTERVAL)
+  interval.unref?.()
 
   return { metrics, logger }
 }

package/packages/datadog-plugin-pg/src/index.js

@@ -9,9 +9,9 @@ class PGPlugin extends DatabasePlugin {
   static system = 'postgres'
 
   bindStart (ctx) {
-    const { params = {}, query, processId, stream } = ctx
+    const { params = {}, query, originalText, processId, stream } = ctx
     const service = this.serviceName({ pluginConfig: this.config, params })
-    const originalStatement = this.maybeTruncate(query.text)
+    const originalStatement = this.maybeTruncate(originalText)
 
     const span = this.startSpan(this.operationName(), {
       service,
@@ -32,7 +32,7 @@ class PGPlugin extends DatabasePlugin {
       span.setTag('db.stream', 1)
     }
 
-    query.__ddInjectableQuery = this.injectDbmQuery(span, query.text, service.name, !!query.name)
+    ctx.injected = this.injectDbmQuery(span, originalText, service.name, !!query.name)
 
     return ctx.currentStore
   }

package/packages/datadog-plugin-playwright/src/index.js

@@ -321,6 +321,7 @@ class PlaywrightPlugin extends CiPlugin {
       isAtrRetry,
       isModified,
       finalStatus,
+      earlyFlakeAbortReason,
       onDone,
     }) => {
       if (!span) return
@@ -384,6 +385,9 @@ class PlaywrightPlugin extends CiPlugin {
       if (finalStatus) {
         span.setTag(TEST_FINAL_STATUS, finalStatus)
       }
+      if (earlyFlakeAbortReason) {
+        span.setTag(TEST_EARLY_FLAKE_ABORT_REASON, earlyFlakeAbortReason)
+      }
       for (const step of steps) {
         const stepStartTime = step.startTime.getTime()
         const stepSpan = this.tracer.startSpan('playwright.step', {

package/packages/datadog-plugin-redis/src/index.js

@@ -4,6 +4,9 @@ const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const CachePlugin = require('../../dd-trace/src/plugins/cache')
 const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
 
+const MAX_ARG_LENGTH = 100
+const MAX_COMMAND_LENGTH = 1000
+
 class RedisPlugin extends CachePlugin {
   static id = 'redis'
   static system = 'redis'
@@ -14,7 +17,7 @@ class RedisPlugin extends CachePlugin {
   }
 
   bindStart (ctx) {
-    const { db, command, args, connectionOptions, connectionName } = ctx
+    const { db, command, args, argsStartIndex, connectionOptions, connectionName } = ctx
 
     const resource = command
     const normalizedCommand = command.toUpperCase()
@@ -29,7 +32,7 @@ class RedisPlugin extends CachePlugin {
       meta: {
         'db.type': this._spanType,
         'db.name': db || '0',
-        [`${this._spanType}.raw_command`]: formatCommand(normalizedCommand, args),
+        [`${this._spanType}.raw_command`]: formatCommand(normalizedCommand, args, argsStartIndex),
         'out.host': connectionOptions.host,
         [CLIENT_PORT_KEY]: connectionOptions.port,
       },
@@ -43,36 +46,28 @@ class RedisPlugin extends CachePlugin {
   }
 }
 
-function formatCommand (command, args) {
+function formatCommand (command, args, argsStartIndex = 0) {
   if (!args || command === 'AUTH') return command
 
-  for (let i = 0, l = args.length; i < l; i++) {
-    if (typeof args[i] === 'function') continue
-
-    command = `${command} ${formatArg(args[i])}`
+  let result = command
+  for (let i = argsStartIndex, l = args.length; i < l; i++) {
+    const arg = args[i]
+    if (typeof arg === 'function') continue
 
-    if (command.length > 1000) return trim(command, 1000)
+    result = `${result} ${formatArg(arg)}`
+    if (result.length > MAX_COMMAND_LENGTH) return result.slice(0, MAX_COMMAND_LENGTH - 3) + '...'
   }
 
-  return command
+  return result
 }
 
 function formatArg (arg) {
-  switch (typeof arg) {
-    case 'string':
-    case 'number':
-      return trim(String(arg), 100)
-    default:
-      return '?'
-  }
-}
-
-function trim (str, maxlen) {
-  if (str.length > maxlen) {
-    str = str.slice(0, maxlen - 3) + '...'
+  if (typeof arg === 'string') {
+    return arg.length > MAX_ARG_LENGTH ? arg.slice(0, MAX_ARG_LENGTH - 3) + '...' : arg
   }
-
-  return str
+  // Number stringification is bounded (~23 chars max), so it never hits MAX_ARG_LENGTH.
+  if (typeof arg === 'number') return String(arg)
+  return '?'
 }
 
 function normalizeConfig (config) {

package/packages/dd-trace/src/aiguard/index.js

@@ -3,6 +3,7 @@
 const log = require('../log')
 const { incomingHttpRequestStart, aiguardChannel } = require('./channels')
 const AIGuard = require('./sdk')
+const { SOURCE_AUTO, INTEGRATION_NONE } = require('./tags')
 
 let isEnabled = false
 let aiguard
@@ -51,7 +52,8 @@ function onEvaluate (ctx) {
     return
   }
 
-  aiguard.evaluate(ctx.messages, { block })
+  const opts = { block, source: SOURCE_AUTO, integration: ctx.integration || INTEGRATION_NONE }
+  aiguard.evaluate(ctx.messages, opts)
     .then(() => {
       ctx.resolve()
     })