dd-trace 2.5.0 → 2.6.0

package/index.d.ts

@@ -428,7 +428,23 @@ export declare interface TracerOptions {
      * Controls the maximum amount of traces sampled by AppSec attacks, per second.
      * @default 100
      */
-    rateLimit?: number
+    rateLimit?: number,
+
+    /**
+     * Controls the maximum amount of time in microseconds the WAF is allowed to run synchronously for.
+     * @default 5000
+     */
+    wafTimeout?: number,
+
+    /**
+     * Specifies a regex that will redact sensitive data by its key in attack reports.
+     */
+    obfuscatorKeyRegex?: string,
+
+    /**
+     * Specifies a regex that will redact sensitive data by its value in attack reports.
+     */
+    obfuscatorValueRegex?: string
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -61,9 +61,9 @@
     "node": ">=12"
   },
   "dependencies": {
-    "@datadog/native-appsec": "^1.0.1",
-    "@datadog/native-metrics": "^1.1.0",
-    "@datadog/pprof": "^0.3.0",
+    "@datadog/native-appsec": "^1.1.1",
+    "@datadog/native-metrics": "^1.2.0",
+    "@datadog/pprof": "^0.4.0",
     "@datadog/sketches-js": "^1.0.4",
     "@types/node": ">=12",
     "crypto-randomuuid": "^1.0.0",

package/packages/datadog-instrumentations/index.js

@@ -12,6 +12,7 @@ require('./src/elasticsearch')
 require('./src/generic-pool')
 require('./src/http')
 require('./src/ioredis')
+require('./src/jest')
 require('./src/memcached')
 require('./src/mongodb-core')
 require('./src/mongoose')

package/packages/datadog-instrumentations/src/jest.js

@@ -0,0 +1,170 @@
+'use strict'
+
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const testStartCh = channel('ci:jest:test:start')
+const testSkippedCh = channel('ci:jest:test:skip')
+const testRunEndCh = channel('ci:jest:test:end')
+const testErrCh = channel('ci:jest:test:err')
+const testSuiteEnd = channel('ci:jest:test-suite:end')
+
+const {
+  getTestSuitePath,
+  getTestParametersString
+} = require('../../dd-trace/src/plugins/util/test')
+
+const { getFormattedJestTestParameters } = require('../../datadog-plugin-jest/src/util')
+
+const specStatusToTestStatus = {
+  'pending': 'skip',
+  'disabled': 'skip',
+  'todo': 'skip',
+  'passed': 'pass',
+  'failed': 'fail'
+}
+
+const asyncResources = new WeakMap()
+const originalTestFns = new WeakMap()
+
+// based on https://github.com/facebook/jest/blob/main/packages/jest-circus/src/formatNodeAssertErrors.ts#L41
+function formatJestError (errors) {
+  let error
+  if (Array.isArray(errors)) {
+    const [originalError, asyncError] = errors
+    if (originalError === null || !originalError.stack) {
+      error = asyncError
+      error.message = originalError
+    } else {
+      error = originalError
+    }
+  } else {
+    error = errors
+  }
+  return error
+}
+
+function getWrappedEnvironment (BaseEnvironment) {
+  return class DatadogEnvironment extends BaseEnvironment {
+    constructor (config, context) {
+      super(config, context)
+      this.testSuite = getTestSuitePath(context.testPath, config.rootDir)
+      this.nameToParams = {}
+      this.global._ddtrace = global._ddtrace
+    }
+    async teardown () {
+      super.teardown().finally(() => {
+        testSuiteEnd.publish()
+      })
+    }
+
+    async handleTestEvent (event, state) {
+      if (super.handleTestEvent) {
+        await super.handleTestEvent(event, state)
+      }
+
+      let context
+      if (this.getVmContext) {
+        context = this.getVmContext()
+      } else {
+        context = this.context
+      }
+
+      const setNameToParams = (name, params) => { this.nameToParams[name] = params }
+
+      if (event.name === 'setup') {
+        shimmer.wrap(this.global.test, 'each', each => function () {
+          const testParameters = getFormattedJestTestParameters(arguments)
+          const eachBind = each.apply(this, arguments)
+          return function () {
+            const [testName] = arguments
+            setNameToParams(testName, testParameters)
+            return eachBind.apply(this, arguments)
+          }
+        })
+      }
+      if (event.name === 'test_start') {
+        const testParameters = getTestParametersString(this.nameToParams, event.test.name)
+
+        // Async resource for this test is created here
+        // It is used later on by the test_done handler
+        const asyncResource = new AsyncResource('bound-anonymous-fn')
+        asyncResources.set(event.test, asyncResource)
+        asyncResource.runInAsyncScope(() => {
+          testStartCh.publish({
+            name: context.expect.getState().currentTestName,
+            suite: this.testSuite,
+            runner: 'jest-circus',
+            testParameters
+          })
+          originalTestFns.set(event.test, event.test.fn)
+          event.test.fn = asyncResource.bind(event.test.fn)
+        })
+      }
+      if (event.name === 'test_done') {
+        const asyncResource = asyncResources.get(event.test)
+        asyncResource.runInAsyncScope(() => {
+          let status = 'pass'
+          if (event.test.errors && event.test.errors.length) {
+            status = 'fail'
+            const formattedError = formatJestError(event.test.errors[0])
+            testErrCh.publish(formattedError)
+          }
+          testRunEndCh.publish(status)
+          // restore in case it is retried
+          event.test.fn = originalTestFns.get(event.test)
+        })
+      }
+      if (event.name === 'test_skip' || event.name === 'test_todo') {
+        testSkippedCh.publish({
+          name: context.expect.getState().currentTestName,
+          suite: this.testSuite,
+          runner: 'jest-circus'
+        })
+      }
+    }
+  }
+}
+
+addHook({
+  name: 'jest-environment-node',
+  versions: ['>=24.8.0']
+}, getWrappedEnvironment)
+
+addHook({
+  name: 'jest-environment-jsdom',
+  versions: ['>=24.8.0']
+}, getWrappedEnvironment)
+
+addHook({
+  name: 'jest-jasmine2',
+  versions: ['>=24.8.0'],
+  file: 'build/jasmineAsyncInstall.js'
+}, (jasmineAsyncInstallExport) => {
+  return function (globalConfig, globalInput) {
+    globalInput._ddtrace = global._ddtrace
+    shimmer.wrap(globalInput.jasmine.Spec.prototype, 'execute', execute => function (onComplete) {
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
+      asyncResource.runInAsyncScope(() => {
+        const testSuite = getTestSuitePath(this.result.testPath, globalConfig.rootDir)
+        testStartCh.publish({
+          name: this.getFullName(),
+          suite: testSuite,
+          runner: 'jest-jasmine2'
+        })
+        const spec = this
+        const callback = asyncResource.bind(function () {
+          if (spec.result.failedExpectations && spec.result.failedExpectations.length) {
+            const formattedError = formatJestError(spec.result.failedExpectations[0].error)
+            testErrCh.publish(formattedError)
+          }
+          testRunEndCh.publish(specStatusToTestStatus[spec.result.status])
+          onComplete.apply(this, arguments)
+        })
+        arguments[0] = callback
+        execute.apply(this, arguments)
+      })
+    })
+    return jasmineAsyncInstallExport.default(globalConfig, globalInput)
+  }
+})

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

@@ -5,11 +5,7 @@ const { storage } = require('../../datadog-core')
 
 const {
   CI_APP_ORIGIN,
-  TEST_TYPE,
-  TEST_NAME,
-  TEST_SUITE,
   TEST_SKIP_REASON,
-  TEST_FRAMEWORK_VERSION,
   ERROR_MESSAGE,
   TEST_STATUS,
   TEST_CODE_OWNERS,
@@ -17,11 +13,10 @@ const {
   getTestEnvironmentMetadata,
   getTestSuitePath,
   getCodeOwnersFileEntries,
-  getCodeOwnersForFilename
+  getCodeOwnersForFilename,
+  getTestCommonTags
 } = require('../../dd-trace/src/plugins/util/test')
-const { SPAN_TYPE, RESOURCE_NAME, SAMPLING_PRIORITY } = require('../../../ext/tags')
-const { SAMPLING_RULE_DECISION } = require('../../dd-trace/src/constants')
-const { AUTO_KEEP } = require('../../../ext/priority')
+const { RESOURCE_NAME } = require('../../../ext/tags')
 
 class CucumberPlugin extends Plugin {
   static get name () {
@@ -40,26 +35,19 @@ class CucumberPlugin extends Plugin {
       const childOf = store ? store.span : store
       const testSuite = getTestSuitePath(pickleUri, sourceRoot)
 
-      const testSpanMetadata = {
-        [SPAN_TYPE]: 'test',
-        [RESOURCE_NAME]: pickleName,
-        [TEST_TYPE]: 'test',
-        [TEST_NAME]: pickleName,
-        [TEST_SUITE]: testSuite,
-        [SAMPLING_RULE_DECISION]: 1,
-        [SAMPLING_PRIORITY]: AUTO_KEEP,
-        [TEST_FRAMEWORK_VERSION]: this.tracer._version,
-        ...testEnvironmentMetadata
-      }
+      const commonTags = getTestCommonTags(pickleName, testSuite, this.tracer._version)
 
       const codeOwners = getCodeOwnersForFilename(testSuite, codeOwnersEntries)
       if (codeOwners) {
-        testSpanMetadata[TEST_CODE_OWNERS] = codeOwners
+        commonTags[TEST_CODE_OWNERS] = codeOwners
       }
 
       const span = this.tracer.startSpan('cucumber.test', {
         childOf,
-        tags: testSpanMetadata
+        tags: {
+          ...commonTags,
+          ...testEnvironmentMetadata
+        }
       })
 
       span.context()._trace.origin = CI_APP_ORIGIN

package/packages/datadog-plugin-cypress/src/plugin.js

@@ -1,21 +1,16 @@
 const {
-  TEST_TYPE,
-  TEST_NAME,
-  TEST_SUITE,
   TEST_STATUS,
-  TEST_FRAMEWORK_VERSION,
   TEST_IS_RUM_ACTIVE,
   TEST_CODE_OWNERS,
   getTestEnvironmentMetadata,
   CI_APP_ORIGIN,
   getTestParentSpan,
   getCodeOwnersFileEntries,
-  getCodeOwnersForFilename
+  getCodeOwnersForFilename,
+  getTestCommonTags
 } = require('../../dd-trace/src/plugins/util/test')
 
-const { SAMPLING_RULE_DECISION, ORIGIN_KEY } = require('../../dd-trace/src/constants')
-const { SAMPLING_PRIORITY, SPAN_TYPE, RESOURCE_NAME } = require('../../../ext/tags')
-const { AUTO_KEEP } = require('../../../ext/priority')
+const { ORIGIN_KEY } = require('../../dd-trace/src/constants')
 
 const CYPRESS_STATUS_TO_TEST_STATUS = {
   passed: 'pass',
@@ -27,15 +22,11 @@ const CYPRESS_STATUS_TO_TEST_STATUS = {
 function getTestSpanMetadata (tracer, testName, testSuite, cypressConfig) {
   const childOf = getTestParentSpan(tracer)
 
+  const commonTags = getTestCommonTags(testName, testSuite, cypressConfig.version)
+
   return {
     childOf,
-    resource: `${testSuite}.${testName}`,
-    [TEST_TYPE]: 'test',
-    [TEST_NAME]: testName,
-    [TEST_SUITE]: testSuite,
-    [SAMPLING_RULE_DECISION]: 1,
-    [SAMPLING_PRIORITY]: AUTO_KEEP,
-    [TEST_FRAMEWORK_VERSION]: cypressConfig.version
+    ...commonTags
   }
 }
 
@@ -71,8 +62,6 @@ module.exports = (on, config) => {
         activeSpan = tracer.startSpan('cypress.test', {
           childOf,
           tags: {
-            [SPAN_TYPE]: 'test',
-            [RESOURCE_NAME]: resource,
             [ORIGIN_KEY]: CI_APP_ORIGIN,
             ...testSpanMetadata,
             ...testEnvironmentMetadata

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

@@ -60,6 +60,7 @@ function createWrapCreateReadStream (config, tracer) {
       const tags = makeFSFlagTags('ReadStream', path, options, 'r', config, tracer)
       return tracer.trace('fs.operation', { tags, orphanable }, (span, done) => {
         const stream = createReadStream.apply(this, arguments)
+        stream.once('close', done)
         stream.once('end', done)
         stream.once('error', done)
         return stream
@@ -74,6 +75,7 @@ function createWrapCreateWriteStream (config, tracer) {
       const tags = makeFSFlagTags('WriteStream', path, options, 'w', config, tracer)
       return tracer.trace('fs.operation', { tags, orphanable }, (span, done) => {
         const stream = createWriteStream.apply(this, arguments)
+        stream.once('close', done)
         stream.once('finish', done)
         stream.once('error', done)
         return stream

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

@@ -4,9 +4,6 @@ const Plugin = require('../../dd-trace/src/plugins/plugin')
 const { storage } = require('../../datadog-core')
 const web = require('../../dd-trace/src/plugins/util/web')
 const { incomingHttpRequestStart } = require('../../dd-trace/src/appsec/gateway/channels')
-const tags = require('../../../ext/tags')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-const SERVICE_NAME = tags.SERVICE_NAME
 
 class HttpServerPlugin extends Plugin {
   static get name () {
@@ -20,11 +17,6 @@ class HttpServerPlugin extends Plugin {
       const store = storage.getStore()
       const span = web.startSpan(this.tracer, this.config, req, res, 'http.request')
 
-      if (this.config.service) {
-        span.setTag(SERVICE_NAME, this.config.service)
-      }
-
-      analyticsSampler.sample(span, this.config.measured, true)
       this.enter(span, store)
 
       const context = web.getContext(req)

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

@@ -1,4 +1,102 @@
-const jestEnvironment = require('./jest-environment')
-const jestJasmine2 = require('./jest-jasmine2')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 
-module.exports = [].concat(jestEnvironment, jestJasmine2)
+const {
+  CI_APP_ORIGIN,
+  TEST_STATUS,
+  JEST_TEST_RUNNER,
+  finishAllTraceSpans,
+  getTestEnvironmentMetadata,
+  getTestParentSpan,
+  getTestCommonTags,
+  TEST_PARAMETERS,
+  getCodeOwnersFileEntries,
+  getCodeOwnersForFilename,
+  TEST_CODE_OWNERS
+} = require('../../dd-trace/src/plugins/util/test')
+
+function getTestSpanMetadata (tracer, test) {
+  const childOf = getTestParentSpan(tracer)
+
+  const { suite, name, runner, testParameters } = test
+
+  const commonTags = getTestCommonTags(name, suite, tracer._version)
+
+  return {
+    childOf,
+    ...commonTags,
+    [JEST_TEST_RUNNER]: runner,
+    [TEST_PARAMETERS]: testParameters
+  }
+}
+
+class JestPlugin extends Plugin {
+  static get name () {
+    return 'jest'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.testEnvironmentMetadata = getTestEnvironmentMetadata('jest', this.config)
+    this.codeOwnersEntries = getCodeOwnersFileEntries()
+
+    this.addSub('ci:jest:test:start', (test) => {
+      const store = storage.getStore()
+      const span = this.startTestSpan(test)
+
+      this.enter(span, store)
+    })
+
+    this.addSub('ci:jest:test:end', (status) => {
+      const span = storage.getStore().span
+      span.setTag(TEST_STATUS, status)
+      span.finish()
+      finishAllTraceSpans(span)
+      this.exit()
+    })
+
+    this.addSub('ci:jest:test-suite:end', () => {
+      this.tracer._exporter._writer.flush()
+    })
+
+    this.addSub('ci:jest:test:err', (error) => {
+      if (error) {
+        const span = storage.getStore().span
+        span.setTag(TEST_STATUS, 'fail')
+        span.setTag('error', error)
+      }
+    })
+
+    this.addSub('ci:jest:test:skip', (test) => {
+      const span = this.startTestSpan(test)
+      span.setTag(TEST_STATUS, 'skip')
+      span.finish()
+    })
+  }
+
+  startTestSpan (test) {
+    const { childOf, ...testSpanMetadata } = getTestSpanMetadata(this.tracer, test)
+
+    const codeOwners = getCodeOwnersForFilename(test.suite, this.codeOwnersEntries)
+
+    if (codeOwners) {
+      testSpanMetadata[TEST_CODE_OWNERS] = codeOwners
+    }
+
+    const testSpan = this.tracer
+      .startSpan('jest.test', {
+        childOf,
+        tags: {
+          ...this.testEnvironmentMetadata,
+          ...testSpanMetadata
+        }
+      })
+
+    testSpan.context()._trace.origin = CI_APP_ORIGIN
+
+    return testSpan
+  }
+}
+
+module.exports = JestPlugin

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

@@ -1,8 +1,3 @@
-const { SAMPLING_RULE_DECISION } = require('../../dd-trace/src/constants')
-const { SAMPLING_PRIORITY, SPAN_TYPE } = require('../../../ext/tags')
-const { AUTO_KEEP } = require('../../../ext/priority')
-const { TEST_TYPE, TEST_STATUS, getTestParentSpan } = require('../../dd-trace/src/plugins/util/test')
-
 /**
  * There are two ways to call `test.each` in `jest`:
  * 1. With an array of arrays: https://jestjs.io/docs/api#1-testeachtablename-fn-timeout
@@ -38,27 +33,4 @@ function getFormattedJestTestParameters (testParameters) {
   return formattedParameters
 }
 
-function getTestSpanTags (tracer, testEnvironmentMetadata) {
-  const childOf = getTestParentSpan(tracer)
-
-  const commonSpanTags = {
-    [TEST_TYPE]: 'test',
-    [SAMPLING_RULE_DECISION]: 1,
-    [SAMPLING_PRIORITY]: AUTO_KEEP,
-    [SPAN_TYPE]: 'test',
-    ...testEnvironmentMetadata
-  }
-  return {
-    childOf,
-    commonSpanTags
-  }
-}
-
-function setSuppressedErrors (suppressedErrors, testSpan) {
-  if (suppressedErrors && suppressedErrors.length) {
-    testSpan.setTag('error', suppressedErrors[0])
-    testSpan.setTag(TEST_STATUS, 'fail')
-  }
-}
-
-module.exports = { getFormattedJestTestParameters, getTestSpanTags, setSuppressedErrors }
+module.exports = { getFormattedJestTestParameters }

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

@@ -6,10 +6,7 @@ const { storage } = require('../../datadog-core')
 const {
   CI_APP_ORIGIN,
   TEST_CODE_OWNERS,
-  TEST_TYPE,
-  TEST_NAME,
   TEST_SUITE,
-  TEST_FRAMEWORK_VERSION,
   TEST_STATUS,
   TEST_PARAMETERS,
   finishAllTraceSpans,
@@ -18,11 +15,9 @@ const {
   getTestParentSpan,
   getTestParametersString,
   getCodeOwnersFileEntries,
-  getCodeOwnersForFilename
+  getCodeOwnersForFilename,
+  getTestCommonTags
 } = require('../../dd-trace/src/plugins/util/test')
-const { SPAN_TYPE, RESOURCE_NAME, SAMPLING_PRIORITY } = require('../../../ext/tags')
-const { SAMPLING_RULE_DECISION } = require('../../dd-trace/src/constants')
-const { AUTO_KEEP } = require('../../../ext/priority')
 
 const skippedTests = new WeakSet()
 
@@ -33,16 +28,11 @@ function getTestSpanMetadata (tracer, test, sourceRoot) {
   const fullTestName = test.fullTitle()
   const testSuite = getTestSuitePath(testSuiteAbsolutePath, sourceRoot)
 
+  const commonTags = getTestCommonTags(fullTestName, testSuite, tracer._version)
+
   return {
     childOf,
-    [SPAN_TYPE]: 'test',
-    [TEST_TYPE]: 'test',
-    [TEST_NAME]: fullTestName,
-    [TEST_SUITE]: testSuite,
-    [SAMPLING_RULE_DECISION]: 1,
-    [SAMPLING_PRIORITY]: AUTO_KEEP,
-    [TEST_FRAMEWORK_VERSION]: tracer._version,
-    [RESOURCE_NAME]: `${testSuite}.${fullTestName}`
+    ...commonTags
   }
 }
 

package/packages/dd-trace/lib/version.js

@@ -1 +1 @@
-module.exports = '2.5.0'
+module.exports = '2.6.0'

package/packages/dd-trace/src/appsec/callbacks/ddwaf.js

@@ -7,16 +7,14 @@ const Reporter = require('../reporter')
 
 const validAddressSet = new Set(Object.values(addresses))
 
-const DEFAULT_MAX_BUDGET = 5e3 // µs
-
 // TODO: put reusable code in a base class
 class WAFCallback {
-  static loadDDWAF (rules) {
+  static loadDDWAF (rules, config) {
     try {
       // require in `try/catch` because this can throw at require time
       const { DDWAF } = require('@datadog/native-appsec')
 
-      return new DDWAF(rules)
+      return new DDWAF(rules, config)
     } catch (err) {
       log.error('AppSec could not load native package. In-app WAF features will not be available.')
 
@@ -24,8 +22,24 @@ class WAFCallback {
     }
   }
 
-  constructor (rules) {
-    this.ddwaf = WAFCallback.loadDDWAF(rules)
+  constructor (rules, config) {
+    const { wafTimeout, obfuscatorKeyRegex, obfuscatorValueRegex } = config
+
+    this.ddwaf = WAFCallback.loadDDWAF(rules, { obfuscatorKeyRegex, obfuscatorValueRegex })
+
+    this.wafTimeout = wafTimeout
+
+    const version = this.ddwaf.constructor.version()
+
+    Reporter.metricsQueue.set('_dd.appsec.waf.version', `${version.major}.${version.minor}.${version.patch}`)
+
+    const { loaded, failed } = this.ddwaf.rulesInfo
+
+    Reporter.metricsQueue.set('_dd.appsec.event_rules.loaded', loaded)
+    Reporter.metricsQueue.set('_dd.appsec.event_rules.error_count', failed)
+
+    Reporter.metricsQueue.set('manual.keep', true)
+
     this.wafContextCache = new WeakMap()
 
     // closures are faster than binds
@@ -81,7 +95,7 @@ class WAFCallback {
 
     try {
       // TODO: possible optimizaion: only send params that haven't already been sent to this wafContext
-      const result = wafContext.run(params, DEFAULT_MAX_BUDGET)
+      const result = wafContext.run(params, this.wafTimeout)
 
       return this.applyResult(result, store)
     } catch (err) {
@@ -93,13 +107,14 @@ class WAFCallback {
   }
 
   applyResult (result, store) {
+    Reporter.reportMetrics({
+      duration: result.totalRuntime,
+      rulesVersion: this.ddwaf.rulesInfo.version
+    }, store)
+
     if (result.data && result.data !== '[]') {
       Reporter.reportAttack(result.data, store)
     }
-
-    // TODO: use these values later for budget management
-    // result.perfData
-    // result.perfTotalRuntime
   }
 
   clear () {

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

@@ -16,7 +16,7 @@ function enable (config) {
     let rules = fs.readFileSync(config.appsec.rules)
     rules = JSON.parse(rules)
 
-    RuleManager.applyRules(rules)
+    RuleManager.applyRules(rules, config.appsec)
   } catch (err) {
     log.error('Unable to start AppSec')
     log.error(err)
@@ -94,12 +94,16 @@ function incomingHttpEndTranslator (data) {
   }
 
   if (data.req.cookies && typeof data.req.cookies === 'object') {
-    payload[addresses.HTTP_INCOMING_COOKIES] = data.req.cookies
+    payload[addresses.HTTP_INCOMING_COOKIES] = {}
+
+    for (const k of Object.keys(data.req.cookies)) {
+      payload[addresses.HTTP_INCOMING_COOKIES][k] = [ data.req.cookies[k] ]
+    }
   }
 
   Gateway.propagate(payload, context)
 
-  Reporter.finishAttacks(data.req, context)
+  Reporter.finishRequest(data.req, context)
 }
 
 function disable () {