dd-trace 3.13.2 → 3.14.1

package/ci/init.js

@@ -8,7 +8,8 @@ const options = {
   tags: {
     [ORIGIN_KEY]: 'ciapp-test'
   },
-  isCiVisibility: true
+  isCiVisibility: true,
+  flushInterval: 5000
 }
 
 let shouldInit = true

package/index.d.ts

@@ -221,6 +221,21 @@ export declare interface SpanSamplingRule {
   name?: string
 }
 
+/**
+ * Selection and priority order of context propagation injection and extraction mechanisms.
+ */
+export declare interface PropagationStyle {
+  /**
+   * Selection of context propagation injection mechanisms.
+   */
+  inject: string[],
+
+  /**
+   * Selection and priority order of context propagation extraction mechanisms.
+   */
+  extract: string[]
+}
+
 /**
  * List of options available to the tracer.
  */
@@ -550,6 +565,11 @@ export declare interface TracerOptions {
    * Custom header name to source the http.client_ip tag from.
    */
   clientIpHeader?: string,
+
+  /**
+   * The selection and priority order of context propagation injection and extraction mechanisms.
+   */
+  propagationStyle?: string[] | PropagationStyle
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "3.13.2",
+  "version": "3.14.1",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

package/packages/datadog-instrumentations/src/aws-sdk.js

@@ -39,6 +39,77 @@ function wrapRequest (send) {
   }
 }
 
+function wrapSmithySend (send) {
+  return function (command, ...args) {
+    const cb = args[args.length - 1]
+    const innerAr = new AsyncResource('apm:aws:request:inner')
+    const outerAr = new AsyncResource('apm:aws:request:outer')
+    const serviceIdentifier = this.config.serviceId.toLowerCase()
+    const channelSuffix = getChannelSuffix(serviceIdentifier)
+    const commandName = command.constructor.name
+    const clientName = this.constructor.name.replace(/Client$/, '')
+    const operation = `${commandName[0].toLowerCase()}${commandName.slice(1).replace(/Command$/, '')}`
+    const request = {
+      operation,
+      params: command.input
+    }
+
+    const startCh = channel(`apm:aws:request:start:${channelSuffix}`)
+    const regionCh = channel(`apm:aws:request:region:${channelSuffix}`)
+    const completeChannel = channel(`apm:aws:request:complete:${channelSuffix}`)
+    const responseStartChannel = channel(`apm:aws:response:start:${channelSuffix}`)
+    const responseFinishChannel = channel(`apm:aws:response:finish:${channelSuffix}`)
+
+    return innerAr.runInAsyncScope(() => {
+      startCh.publish({
+        serviceIdentifier,
+        operation,
+        awsService: clientName,
+        request
+      })
+
+      // When the region is not set this never resolves so we can't await.
+      this.config.region().then(region => {
+        regionCh.publish(region)
+      })
+
+      if (typeof cb === 'function') {
+        args[args.length - 1] = function (err, result) {
+          const message = getMessage(request, err, result)
+
+          completeChannel.publish(message)
+
+          outerAr.runInAsyncScope(() => {
+            responseStartChannel.publish(message)
+
+            cb.apply(this, arguments)
+
+            if (message.needsFinish) {
+              responseFinishChannel.publish(message.response.error)
+            }
+          })
+        }
+      } else { // always a promise
+        return send.call(this, command, ...args)
+          .then(
+            result => {
+              const message = getMessage(request, null, result)
+              completeChannel.publish(message)
+              return result
+            },
+            error => {
+              const message = getMessage(request, error)
+              completeChannel.publish(message)
+              throw error
+            }
+          )
+      }
+
+      return send.call(this, command, ...args)
+    })
+  }
+}
+
 function wrapCb (cb, serviceName, request, ar) {
   return function wrappedCb (err, response) {
     const obj = { request, response }
@@ -71,6 +142,16 @@ function wrapCb (cb, serviceName, request, ar) {
   }
 }
 
+function getMessage (request, error, result) {
+  const response = { request, error, ...result }
+
+  if (result && result.$metadata) {
+    response.requestId = result.$metadata.requestId
+  }
+
+  return { request, response }
+}
+
 function getChannelSuffix (name) {
   return [
     'cloudwatchlogs',
@@ -85,6 +166,11 @@ function getChannelSuffix (name) {
   ].includes(name) ? name : 'default'
 }
 
+addHook({ name: '@aws-sdk/smithy-client', versions: ['>=3'] }, smithy => {
+  shimmer.wrap(smithy.Client.prototype, 'send', wrapSmithySend)
+  return smithy
+})
+
 addHook({ name: 'aws-sdk', versions: ['>=2.3.0'] }, AWS => {
   shimmer.wrap(AWS.Request.prototype, 'promise', wrapRequest)
   shimmer.wrap(AWS.config, 'setPromisesDependency', setPromisesDependency => {

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

@@ -3,15 +3,35 @@
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
-const runStartCh = channel('ci:cucumber:run:start')
-const runFinishCh = channel('ci:cucumber:run:finish')
-const runStepStartCh = channel('ci:cucumber:run-step:start')
+const testStartCh = channel('ci:cucumber:test:start')
+const testFinishCh = channel('ci:cucumber:test:finish') // used for test steps too
+
+const testStepStartCh = channel('ci:cucumber:test-step:start')
+
 const errorCh = channel('ci:cucumber:error')
+
+const testSuiteStartCh = channel('ci:cucumber:test-suite:start')
+const testSuiteFinishCh = channel('ci:cucumber:test-suite:finish')
+
+const sessionStartCh = channel('ci:cucumber:session:start')
 const sessionFinishCh = channel('ci:cucumber:session:finish')
 
 // TODO: remove in a later major version
 const patched = new WeakSet()
 
+let pickleByFile = {}
+const pickleResultByFile = {}
+
+function getSuiteStatusFromTestStatuses (testStatuses) {
+  if (testStatuses.some(status => status === 'fail')) {
+    return 'fail'
+  }
+  if (testStatuses.every(status => status === 'skip')) {
+    return 'skip'
+  }
+  return 'pass'
+}
+
 function getStatusFromResult (result) {
   if (result.status === 1) {
     return { status: 'pass' }
@@ -44,13 +64,18 @@ function wrapRun (pl, isLatestVersion) {
   patched.add(pl)
 
   shimmer.wrap(pl.prototype, 'run', run => function () {
-    if (!runStartCh.hasSubscribers) {
+    if (!testStartCh.hasSubscribers) {
       return run.apply(this, arguments)
     }
 
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     return asyncResource.runInAsyncScope(() => {
-      runStartCh.publish({ testName: this.pickle.name, fullTestSuite: this.pickle.uri })
+      const testSuiteFullPath = this.pickle.uri
+
+      if (!pickleResultByFile[testSuiteFullPath]) { // first test in suite
+        testSuiteStartCh.publish(testSuiteFullPath)
+      }
+      testStartCh.publish({ testName: this.pickle.name, fullTestSuite: testSuiteFullPath })
       try {
         const promise = run.apply(this, arguments)
         promise.finally(() => {
@@ -58,7 +83,17 @@ function wrapRun (pl, isLatestVersion) {
           const { status, skipReason, errorMessage } = isLatestVersion
             ? getStatusFromResultLatest(result) : getStatusFromResult(result)
 
-          runFinishCh.publish({ status, skipReason, errorMessage })
+          if (!pickleResultByFile[testSuiteFullPath]) {
+            pickleResultByFile[testSuiteFullPath] = [status]
+          } else {
+            pickleResultByFile[testSuiteFullPath].push(status)
+          }
+          // last test in suite
+          if (pickleResultByFile[testSuiteFullPath].length === pickleByFile[testSuiteFullPath].length) {
+            const testSuiteStatus = getSuiteStatusFromTestStatuses(pickleResultByFile[testSuiteFullPath])
+            testSuiteFinishCh.publish(testSuiteStatus)
+          }
+          testFinishCh.publish({ status, skipReason, errorMessage })
         })
         return promise
       } catch (err) {
@@ -68,7 +103,7 @@ function wrapRun (pl, isLatestVersion) {
     })
   })
   shimmer.wrap(pl.prototype, 'runStep', runStep => function () {
-    if (!runStepStartCh.hasSubscribers) {
+    if (!testStepStartCh.hasSubscribers) {
       return runStep.apply(this, arguments)
     }
     const testStep = arguments[0]
@@ -82,7 +117,7 @@ function wrapRun (pl, isLatestVersion) {
 
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     return asyncResource.runInAsyncScope(() => {
-      runStepStartCh.publish({ resource })
+      testStepStartCh.publish({ resource })
       try {
         const promise = runStep.apply(this, arguments)
 
@@ -90,7 +125,7 @@ function wrapRun (pl, isLatestVersion) {
           const { status, skipReason, errorMessage } = isLatestVersion
             ? getStatusFromResultLatest(result) : getStatusFromResult(result)
 
-          runFinishCh.publish({ isStep: true, status, skipReason, errorMessage })
+          testFinishCh.publish({ isStep: true, status, skipReason, errorMessage })
         })
         return promise
       } catch (err) {
@@ -129,16 +164,40 @@ addHook({
   file: 'lib/runtime/test_case_runner.js'
 }, testCaseHook)
 
+function getPickleByFile (runtime) {
+  return runtime.pickleIds.reduce((acc, pickleId) => {
+    const test = runtime.eventDataCollector.getPickle(pickleId)
+    if (acc[test.uri]) {
+      acc[test.uri].push(test)
+    } else {
+      acc[test.uri] = [test]
+    }
+    return acc
+  }, {})
+}
+
 addHook({
   name: '@cucumber/cucumber',
   versions: ['>=7.0.0'],
   file: 'lib/runtime/index.js'
-}, (Runtime) => {
-  shimmer.wrap(Runtime.default.prototype, 'start', start => async function () {
-    const result = await start.apply(this, arguments)
-    sessionFinishCh.publish(undefined)
-    return result
+}, (runtimePackage, cucumberVersion) => {
+  shimmer.wrap(runtimePackage.default.prototype, 'start', start => async function () {
+    pickleByFile = getPickleByFile(this)
+
+    const processArgv = process.argv.slice(2).join(' ')
+    const command = process.env.npm_lifecycle_script || `cucumber-js ${processArgv}`
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    asyncResource.runInAsyncScope(() => {
+      sessionStartCh.publish({ command, frameworkVersion: cucumberVersion })
+    })
+    const success = await start.apply(this, arguments)
+
+    asyncResource.runInAsyncScope(() => {
+      sessionFinishCh.publish(success ? 'pass' : 'fail')
+    })
+    return success
   })
 
-  return Runtime
+  return runtimePackage
 })

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

@@ -5,4 +5,4 @@ const { addHook } = require('./helpers/instrument')
 addHook({
   name: 'cypress',
   versions: ['>=6.7.0']
-})
+}, lib => lib)

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -1,6 +1,7 @@
 'use strict'
 
 module.exports = {
+  '@aws-sdk/smithy-client': () => require('../aws-sdk'),
   '@cucumber/cucumber': () => require('../cucumber'),
   '@playwright/test': () => require('../playwright'),
   '@elastic/elasticsearch': () => require('../elasticsearch'),

package/packages/datadog-instrumentations/src/helpers/register.js

@@ -32,7 +32,7 @@ for (const packageName of names) {
           try {
             loadChannel.publish({ name, version, file })
 
-            moduleExports = hook(moduleExports)
+            moduleExports = hook(moduleExports, version)
           } catch (e) {
             log.error(e)
           }

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

@@ -72,7 +72,7 @@ function getTestEnvironmentOptions (config) {
   return {}
 }
 
-function getWrappedEnvironment (BaseEnvironment) {
+function getWrappedEnvironment (BaseEnvironment, jestVersion) {
   return class DatadogEnvironment extends BaseEnvironment {
     constructor (config, context) {
       super(config, context)
@@ -116,7 +116,8 @@ function getWrappedEnvironment (BaseEnvironment) {
             name: getJestTestName(event.test),
             suite: this.testSuite,
             runner: 'jest-circus',
-            testParameters
+            testParameters,
+            frameworkVersion: jestVersion
           })
           originalTestFns.set(event.test, event.test.fn)
           event.test.fn = asyncResource.bind(event.test.fn)
@@ -142,7 +143,8 @@ function getWrappedEnvironment (BaseEnvironment) {
           testSkippedCh.publish({
             name: getJestTestName(event.test),
             suite: this.testSuite,
-            runner: 'jest-circus'
+            runner: 'jest-circus',
+            frameworkVersion: jestVersion
           })
         })
       }
@@ -150,14 +152,14 @@ function getWrappedEnvironment (BaseEnvironment) {
   }
 }
 
-function getTestEnvironment (pkg) {
+function getTestEnvironment (pkg, jestVersion) {
   if (pkg.default) {
-    const wrappedTestEnvironment = getWrappedEnvironment(pkg.default)
+    const wrappedTestEnvironment = getWrappedEnvironment(pkg.default, jestVersion)
     pkg.default = wrappedTestEnvironment
     pkg.TestEnvironment = wrappedTestEnvironment
     return pkg
   }
-  return getWrappedEnvironment(pkg)
+  return getWrappedEnvironment(pkg, jestVersion)
 }
 
 addHook({
@@ -170,7 +172,7 @@ addHook({
   versions: ['>=24.8.0']
 }, getTestEnvironment)
 
-function cliWrapper (cli) {
+function cliWrapper (cli, jestVersion) {
   const wrapped = shimmer.wrap(cli, 'runCLI', runCLI => async function () {
     let onDone
     const configurationPromise = new Promise((resolve) => {
@@ -186,13 +188,12 @@ function cliWrapper (cli) {
 
     try {
       const { err, itrConfig } = await configurationPromise
-      if (err) {
-        log.error(err)
+      if (!err) {
+        isCodeCoverageEnabled = itrConfig.isCodeCoverageEnabled
+        isSuitesSkippingEnabled = itrConfig.isSuitesSkippingEnabled
       }
-      isCodeCoverageEnabled = itrConfig.isCodeCoverageEnabled
-      isSuitesSkippingEnabled = itrConfig.isSuitesSkippingEnabled
-    } catch (e) {
-      log.error(e)
+    } catch (err) {
+      log.error(err)
     }
 
     if (isSuitesSkippingEnabled) {
@@ -206,31 +207,19 @@ function cliWrapper (cli) {
 
       try {
         const { err, skippableSuites: receivedSkippableSuites } = await skippableSuitesPromise
-        if (err) {
-          log.error(err)
-        } else {
+        if (!err) {
           skippableSuites = receivedSkippableSuites
         }
-      } catch (e) {
-        log.error(e)
+      } catch (err) {
+        log.error(err)
       }
     }
 
     const isSuitesSkipped = !!skippableSuites.length
 
-    let testFrameworkVersion
-    try {
-      testFrameworkVersion = this.getVersion()
-    } catch (e) {
-      try {
-        testFrameworkVersion = this.default.getVersion()
-      } catch (e) {
-        // ignore errors
-      }
-    }
     const processArgv = process.argv.slice(2).join(' ')
     sessionAsyncResource.runInAsyncScope(() => {
-      testSessionStartCh.publish({ command: `jest ${processArgv}`, testFrameworkVersion })
+      testSessionStartCh.publish({ command: `jest ${processArgv}`, frameworkVersion: jestVersion })
     })
 
     const result = await runCLI.apply(this, arguments)
@@ -298,7 +287,7 @@ addHook({
   versions: ['>=24.8.0']
 }, cliWrapper)
 
-function jestAdapterWrapper (jestAdapter) {
+function jestAdapterWrapper (jestAdapter, jestVersion) {
   const adapter = jestAdapter.default ? jestAdapter.default : jestAdapter
   const newAdapter = shimmer.wrap(adapter, function () {
     const environment = arguments[2]
@@ -309,7 +298,8 @@ function jestAdapterWrapper (jestAdapter) {
     return asyncResource.runInAsyncScope(() => {
       testSuiteStartCh.publish({
         testSuite: environment.testSuite,
-        testEnvironmentOptions: environment.testEnvironmentOptions
+        testEnvironmentOptions: environment.testEnvironmentOptions,
+        frameworkVersion: jestVersion
       })
       return adapter.apply(this, arguments).then(suiteResults => {
         const { numFailingTests, skipped, failureMessage: errorMessage } = suiteResults
@@ -450,7 +440,7 @@ addHook({
   versions: ['24.8.0 - 24.9.0']
 }, jestConfigSyncWrapper)
 
-function jasmineAsyncInstallWraper (jasmineAsyncInstallExport) {
+function jasmineAsyncInstallWraper (jasmineAsyncInstallExport, jestVersion) {
   return function (globalConfig, globalInput) {
     globalInput._ddtrace = global._ddtrace
     shimmer.wrap(globalInput.jasmine.Spec.prototype, 'execute', execute => function (onComplete) {
@@ -460,7 +450,8 @@ function jasmineAsyncInstallWraper (jasmineAsyncInstallExport) {
         testStartCh.publish({
           name: this.getFullName(),
           suite: testSuite,
-          runner: 'jest-jasmine2'
+          runner: 'jest-jasmine2',
+          frameworkVersion: jestVersion
         })
         const spec = this
         const callback = asyncResource.bind(function () {

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

@@ -2,7 +2,6 @@ const { createCoverageMap } = require('istanbul-lib-coverage')
 
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
-const log = require('../../dd-trace/src/log')
 const {
   getCoveredFilenamesFromCoverage,
   resetCoverage,
@@ -39,7 +38,7 @@ const testFileToSuiteAr = new Map()
 const originalCoverageMap = createCoverageMap()
 
 let suitesToSkip = []
-let mochaVersion
+let frameworkVersion
 
 function getSuitesByTestFile (root) {
   const suitesByTestFile = {}
@@ -129,7 +128,7 @@ function mochaHook (Runner) {
     this.once('start', testRunAsyncResource.bind(function () {
       const processArgv = process.argv.slice(2).join(' ')
       const command = `mocha ${processArgv}`
-      testSessionStartCh.publish({ command, frameworkVersion: mochaVersion })
+      testSessionStartCh.publish({ command, frameworkVersion })
     }))
 
     this.on('suite', function (suite) {
@@ -314,14 +313,14 @@ addHook({
   name: 'mocha',
   versions: ['>=5.2.0'],
   file: 'lib/mocha.js'
-}, (Mocha) => {
+}, (Mocha, mochaVersion) => {
+  frameworkVersion = mochaVersion
   const mochaRunAsyncResource = new AsyncResource('bound-anonymous-fn')
   /**
    * Get ITR configuration and skippable suites
    * If ITR is disabled, `onDone` is called immediately on the subscriber
    */
   shimmer.wrap(Mocha.prototype, 'run', run => function () {
-    mochaVersion = this.version
     if (!itrConfigurationCh.hasSubscribers) {
       return run.apply(this, arguments)
     }
@@ -331,7 +330,6 @@ addHook({
 
     const onReceivedSkippableSuites = ({ err, skippableSuites }) => {
       if (err) {
-        log.error(err)
         suitesToSkip = []
       } else {
         suitesToSkip = skippableSuites
@@ -343,7 +341,6 @@ addHook({
 
     const onReceivedConfiguration = ({ err }) => {
       if (err) {
-        log.error(err)
         return global.run()
       }
       if (!skippableSuitesCh.hasSubscribers) {

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

@@ -181,17 +181,15 @@ function dispatcherHookNew (dispatcherExport) {
   return dispatcherExport
 }
 
-function runnerHook (runnerExport) {
+function runnerHook (runnerExport, playwrightVersion) {
   shimmer.wrap(runnerExport.Runner.prototype, 'runAllTests', runAllTests => async function () {
     const testSessionAsyncResource = new AsyncResource('bound-anonymous-fn')
-    const { version: frameworkVersion } = getPlaywrightConfig(this)
-
     const rootDir = getRootDir(this)
 
     const processArgv = process.argv.slice(2).join(' ')
     const command = `playwright ${processArgv}`
     testSessionAsyncResource.runInAsyncScope(() => {
-      testSessionStartCh.publish({ command, frameworkVersion, rootDir })
+      testSessionStartCh.publish({ command, frameworkVersion: playwrightVersion, rootDir })
     })
 
     const res = await runAllTests.apply(this, arguments)

package/packages/datadog-plugin-aws-sdk/src/base.js

@@ -23,13 +23,12 @@ class BaseAwsSdkPlugin extends Plugin {
       request,
       operation,
       awsRegion,
-      awsService,
-      serviceIdentifier
+      awsService
     }) => {
       if (!this.isEnabled(request)) {
         return
       }
-      const serviceName = this.getServiceName(serviceIdentifier)
+      const serviceName = this.getServiceName()
       const childOf = this.tracer.scope().active()
       const tags = {
         'span.kind': 'client',
@@ -52,6 +51,14 @@ class BaseAwsSdkPlugin extends Plugin {
       this.enter(span, store)
     })
 
+    this.addSub(`apm:aws:request:region:${this.serviceIdentifier}`, region => {
+      const store = storage.getStore()
+      if (!store) return
+      const { span } = store
+      if (!span) return
+      span.setTag('aws.region', region)
+    })
+
     this.addSub(`apm:aws:request:complete:${this.serviceIdentifier}`, ({ response }) => {
       const store = storage.getStore()
       if (!store) return
@@ -109,10 +116,10 @@ class BaseAwsSdkPlugin extends Plugin {
   }
 
   // TODO: test splitByAwsService when the test suite is fixed
-  getServiceName (serviceIdentifier) {
+  getServiceName () {
     return this.config.service
       ? this.config.service
-      : `${this.tracer._service}-aws-${serviceIdentifier}`
+      : `${this.tracer._service}-aws-${this.serviceIdentifier}`
   }
 }
 

package/packages/datadog-plugin-aws-sdk/src/services/kinesis.js

@@ -48,8 +48,8 @@ class Kinesis extends BaseAwsSdkPlugin {
       const parsedData = this._tryParse(injectPath.Data)
       if (parsedData) {
         parsedData._datadog = traceData
-        const finalData = JSON.stringify(parsedData)
-        const byteSize = Buffer.byteLength(finalData, 'ascii')
+        const finalData = Buffer.from(JSON.stringify(parsedData))
+        const byteSize = finalData.length
         // Kinesis max payload size is 1MB
         // So we must ensure adding DD context won't go over that (512b is an estimate)
         if (byteSize >= 1048576) {

package/packages/datadog-plugin-aws-sdk/src/services/sns.js

@@ -18,30 +18,35 @@ class Sns extends BaseAwsSdkPlugin {
   }
 
   requestInject (span, request) {
-    const operation = request.operation
-    if (operation === 'publish' || operation === 'publishBatch') {
-      if (!request.params) {
-        request.params = {}
-      }
-      let injectPath
-      if (request.params.PublishBatchRequestEntries && request.params.PublishBatchRequestEntries.length > 0) {
-        injectPath = request.params.PublishBatchRequestEntries[0]
-      } else if (request.params.Message) {
-        injectPath = request.params
-      }
-      if (!injectPath.MessageAttributes) {
-        injectPath.MessageAttributes = {}
-      }
-      if (Object.keys(injectPath.MessageAttributes).length >= 10) { // SNS quota
-        log.info('Message attributes full, skipping trace context injection')
-        return
-      }
-      const ddInfo = {}
-      this.tracer.inject(span, 'text_map', ddInfo)
-      injectPath.MessageAttributes._datadog = {
-        DataType: 'Binary',
-        BinaryValue: JSON.stringify(ddInfo) // BINARY types are automatically base64 encoded
-      }
+    const { operation, params } = request
+
+    if (!params) return
+
+    switch (operation) {
+      case 'publish':
+        this._injectMessageAttributes(span, params)
+        break
+      case 'publishBatch':
+        if (params.PublishBatchRequestEntries && params.PublishBatchRequestEntries.length > 0) {
+          this._injectMessageAttributes(span, params.PublishBatchRequestEntries[0])
+        }
+        break
+    }
+  }
+
+  _injectMessageAttributes (span, params) {
+    if (!params.MessageAttributes) {
+      params.MessageAttributes = {}
+    }
+    if (Object.keys(params.MessageAttributes).length >= 10) { // SNS quota
+      log.info('Message attributes full, skipping trace context injection')
+      return
+    }
+    const ddInfo = {}
+    this.tracer.inject(span, 'text_map', ddInfo)
+    params.MessageAttributes._datadog = {
+      DataType: 'Binary',
+      BinaryValue: Buffer.from(JSON.stringify(ddInfo)) // BINARY types are automatically base64 encoded
     }
   }
 }