dd-trace 4.41.0 → 4.43.0

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

@@ -2,7 +2,7 @@ const semver = require('semver')
 
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
-const { parseAnnotations, getTestSuitePath } = require('../../dd-trace/src/plugins/util/test')
+const { parseAnnotations, getTestSuitePath, NUM_FAILED_TEST_RETRIES } = require('../../dd-trace/src/plugins/util/test')
 const log = require('../../dd-trace/src/log')
 
 const testStartCh = channel('ci:playwright:test:start')
@@ -21,6 +21,7 @@ const testToAr = new WeakMap()
 const testSuiteToAr = new Map()
 const testSuiteToTestStatuses = new Map()
 const testSuiteToErrors = new Map()
+const testSessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
 let applyRepeatEachIndex = null
 
@@ -35,6 +36,7 @@ const STATUS_TO_TEST_STATUS = {
 
 let remainingTestsByFile = {}
 let isEarlyFlakeDetectionEnabled = false
+let isFlakyTestRetriesEnabled = false
 let earlyFlakeDetectionNumRetries = 0
 let knownTests = {}
 let rootDir = ''
@@ -196,6 +198,31 @@ function getTestSuiteError (testSuiteAbsolutePath) {
   return new Error(`${errors.length} errors in this test suite:\n${errors.map(e => e.message).join('\n------\n')}`)
 }
 
+function getTestByTestId (dispatcher, testId) {
+  if (dispatcher._testById) {
+    return dispatcher._testById.get(testId)?.test
+  }
+  const allTests = dispatcher._allTests || dispatcher._ddAllTests
+  if (allTests) {
+    return allTests.find(({ id }) => id === testId)
+  }
+}
+
+function getChannelPromise (channelToPublishTo) {
+  return new Promise(resolve => {
+    testSessionAsyncResource.runInAsyncScope(() => {
+      channelToPublishTo.publish({ onDone: resolve })
+    })
+  })
+}
+// eslint-disable-next-line
+// Inspired by https://github.com/microsoft/playwright/blob/2b77ed4d7aafa85a600caa0b0d101b72c8437eeb/packages/playwright/src/reporters/base.ts#L293
+// We can't use test.outcome() directly because it's set on follow up handlers:
+// our `testEndHandler` is called before the outcome is set.
+function testWillRetry (test, testStatus) {
+  return testStatus === 'fail' && test.results.length <= test.retries
+}
+
 function testBeginHandler (test, browserName) {
   const {
     _requireFile: testSuiteAbsolutePath,
@@ -249,7 +276,8 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout) {
   testAsyncResource.runInAsyncScope(() => {
     testFinishCh.publish({
       testStatus,
-      steps: testResult.steps,
+      steps: testResult?.steps || [],
+      isRetry: testResult?.retry > 0,
       error,
       extraTags: annotationTags,
       isNew: test._ddIsNew,
@@ -267,8 +295,10 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout) {
     addErrorToTestSuite(testSuiteAbsolutePath, error)
   }
 
-  remainingTestsByFile[testSuiteAbsolutePath] = remainingTestsByFile[testSuiteAbsolutePath]
-    .filter(currentTest => currentTest !== test)
+  if (!testWillRetry(test, testStatus)) {
+    remainingTestsByFile[testSuiteAbsolutePath] = remainingTestsByFile[testSuiteAbsolutePath]
+      .filter(currentTest => currentTest !== test)
+  }
 
   // Last test, we finish the suite
   if (!remainingTestsByFile[testSuiteAbsolutePath].length) {
@@ -335,16 +365,6 @@ function dispatcherHook (dispatcherExport) {
   return dispatcherExport
 }
 
-function getTestByTestId (dispatcher, testId) {
-  if (dispatcher._testById) {
-    return dispatcher._testById.get(testId)?.test
-  }
-  const allTests = dispatcher._allTests || dispatcher._ddAllTests
-  if (allTests) {
-    return allTests.find(({ id }) => id === testId)
-  }
-}
-
 function dispatcherHookNew (dispatcherExport, runWrapper) {
   shimmer.wrap(dispatcherExport.Dispatcher.prototype, 'run', runWrapper)
   shimmer.wrap(dispatcherExport.Dispatcher.prototype, '_createWorker', createWorker => function () {
@@ -373,8 +393,6 @@ function runnerHook (runnerExport, playwrightVersion) {
   shimmer.wrap(runnerExport.Runner.prototype, 'runAllTests', runAllTests => async function () {
     let onDone
 
-    const testSessionAsyncResource = new AsyncResource('bound-anonymous-fn')
-
     rootDir = getRootDir(this)
 
     const processArgv = process.argv.slice(2).join(' ')
@@ -383,46 +401,42 @@ function runnerHook (runnerExport, playwrightVersion) {
       testSessionStartCh.publish({ command, frameworkVersion: playwrightVersion, rootDir })
     })
 
-    const configurationPromise = new Promise((resolve) => {
-      onDone = resolve
-    })
-
-    testSessionAsyncResource.runInAsyncScope(() => {
-      libraryConfigurationCh.publish({ onDone })
-    })
-
     try {
-      const { err, libraryConfig } = await configurationPromise
+      const { err, libraryConfig } = await getChannelPromise(libraryConfigurationCh)
       if (!err) {
         isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+        isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
       }
     } catch (e) {
+      isEarlyFlakeDetectionEnabled = false
       log.error(e)
     }
 
     if (isEarlyFlakeDetectionEnabled && semver.gte(playwrightVersion, MINIMUM_SUPPORTED_VERSION_EFD)) {
-      const knownTestsPromise = new Promise((resolve) => {
-        onDone = resolve
-      })
-      testSessionAsyncResource.runInAsyncScope(() => {
-        knownTestsCh.publish({ onDone })
-      })
-
       try {
-        const { err, knownTests: receivedKnownTests } = await knownTestsPromise
+        const { err, knownTests: receivedKnownTests } = await getChannelPromise(knownTestsCh)
         if (!err) {
           knownTests = receivedKnownTests
         } else {
           isEarlyFlakeDetectionEnabled = false
         }
       } catch (err) {
+        isEarlyFlakeDetectionEnabled = false
         log.error(err)
       }
     }
 
     const projects = getProjectsFromRunner(this)
 
+    if (isFlakyTestRetriesEnabled) {
+      projects.forEach(project => {
+        if (project.retries === 0) { // Only if it hasn't been set by the user
+          project.retries = NUM_FAILED_TEST_RETRIES
+        }
+      })
+    }
+
     const runAllTestsReturn = await runAllTests.apply(this, arguments)
 
     Object.values(remainingTestsByFile).forEach(tests => {

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

@@ -51,7 +51,7 @@ function wrapFn (fn) {
 
     try {
       const result = fn.apply(this, arguments)
-      if (result && typeof result === 'object' && typeof result.then === 'function') {
+      if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
         return result.then(function () {
           nextChannel.publish({ req })
           finishChannel.publish({ req })

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

@@ -0,0 +1,349 @@
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+const { NUM_FAILED_TEST_RETRIES } = require('../../dd-trace/src/plugins/util/test')
+
+// test hooks
+const testStartCh = channel('ci:vitest:test:start')
+const testFinishTimeCh = channel('ci:vitest:test:finish-time')
+const testPassCh = channel('ci:vitest:test:pass')
+const testErrorCh = channel('ci:vitest:test:error')
+const testSkipCh = channel('ci:vitest:test:skip')
+
+// test suite hooks
+const testSuiteStartCh = channel('ci:vitest:test-suite:start')
+const testSuiteFinishCh = channel('ci:vitest:test-suite:finish')
+const testSuiteErrorCh = channel('ci:vitest:test-suite:error')
+
+// test session hooks
+const testSessionStartCh = channel('ci:vitest:session:start')
+const testSessionFinishCh = channel('ci:vitest:session:finish')
+const libraryConfigurationCh = channel('ci:vitest:library-configuration')
+
+const taskToAsync = new WeakMap()
+
+const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
+
+function isReporterPackage (vitestPackage) {
+  return vitestPackage.B?.name === 'BaseSequencer'
+}
+
+// from 2.0.0
+function isReporterPackageNew (vitestPackage) {
+  return vitestPackage.e?.name === 'BaseSequencer'
+}
+
+function getChannelPromise (channelToPublishTo) {
+  return new Promise(resolve => {
+    sessionAsyncResource.runInAsyncScope(() => {
+      channelToPublishTo.publish({ onDone: resolve })
+    })
+  })
+}
+
+function getSessionStatus (state) {
+  if (state.getCountOfFailedTests() > 0) {
+    return 'fail'
+  }
+  if (state.pathsSet.size === 0) {
+    return 'skip'
+  }
+  return 'pass'
+}
+
+// eslint-disable-next-line
+// From https://github.com/vitest-dev/vitest/blob/51c04e2f44d91322b334f8ccbcdb368facc3f8ec/packages/runner/src/run.ts#L243-L250
+function getVitestTestStatus (test, retryCount) {
+  if (test.result.state !== 'fail') {
+    if (!test.repeats) {
+      return 'pass'
+    } else if (test.repeats && (test.retry ?? 0) === retryCount) {
+      return 'pass'
+    }
+  }
+  return 'fail'
+}
+
+function getTypeTasks (fileTasks, type = 'test') {
+  const typeTasks = []
+
+  function getTasks (tasks) {
+    for (const task of tasks) {
+      if (task.type === type) {
+        typeTasks.push(task)
+      } else if (task.tasks) {
+        getTasks(task.tasks)
+      }
+    }
+  }
+
+  getTasks(fileTasks)
+
+  return typeTasks
+}
+
+function getTestName (task) {
+  let testName = task.name
+  let currentTask = task.suite
+
+  while (currentTask) {
+    if (currentTask.name) {
+      testName = `${currentTask.name} ${testName}`
+    }
+    currentTask = currentTask.suite
+  }
+
+  return testName
+}
+
+function getSortWrapper (sort) {
+  return async function () {
+    if (!testSessionFinishCh.hasSubscribers) {
+      return sort.apply(this, arguments)
+    }
+    // There isn't any other async function that we seem to be able to hook into
+    // So we will use the sort from BaseSequencer. This means that a custom sequencer
+    // will not work. This will be a known limitation.
+    let isFlakyTestRetriesEnabled = false
+
+    try {
+      const { err, libraryConfig } = await getChannelPromise(libraryConfigurationCh)
+      if (!err) {
+        isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
+      }
+    } catch (e) {
+      isFlakyTestRetriesEnabled = false
+    }
+    if (isFlakyTestRetriesEnabled && !this.ctx.config.retry) {
+      this.ctx.config.retry = NUM_FAILED_TEST_RETRIES
+    }
+
+    shimmer.wrap(this.ctx, 'exit', exit => async function () {
+      let onFinish
+
+      const flushPromise = new Promise(resolve => {
+        onFinish = resolve
+      })
+      const failedSuites = this.state.getFailedFilepaths()
+      let error
+      if (failedSuites.length) {
+        error = new Error(`Test suites failed: ${failedSuites.length}.`)
+      }
+
+      sessionAsyncResource.runInAsyncScope(() => {
+        testSessionFinishCh.publish({
+          status: getSessionStatus(this.state),
+          onFinish,
+          error
+        })
+      })
+
+      await flushPromise
+
+      return exit.apply(this, arguments)
+    })
+
+    return sort.apply(this, arguments)
+  }
+}
+
+addHook({
+  name: 'vitest',
+  versions: ['>=1.6.0'],
+  file: 'dist/runners.js'
+}, (vitestPackage) => {
+  const { VitestTestRunner } = vitestPackage
+  // test start (only tests that are not marked as skip or todo)
+  shimmer.wrap(VitestTestRunner.prototype, 'onBeforeTryTask', onBeforeTryTask => async function (task, retryInfo) {
+    if (!testStartCh.hasSubscribers) {
+      return onBeforeTryTask.apply(this, arguments)
+    }
+    const { retry: numAttempt } = retryInfo
+    // We finish the previous test here because we know it has failed already
+    if (numAttempt > 0) {
+      const asyncResource = taskToAsync.get(task)
+      const testError = task.result?.errors?.[0]
+      if (asyncResource) {
+        asyncResource.runInAsyncScope(() => {
+          testErrorCh.publish({ error: testError })
+        })
+      }
+    }
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    taskToAsync.set(task, asyncResource)
+
+    asyncResource.runInAsyncScope(() => {
+      testStartCh.publish({
+        testName: getTestName(task),
+        testSuiteAbsolutePath: task.file.filepath,
+        isRetry: numAttempt > 0
+      })
+    })
+    return onBeforeTryTask.apply(this, arguments)
+  })
+
+  // test finish (only passed tests)
+  shimmer.wrap(VitestTestRunner.prototype, 'onAfterTryTask', onAfterTryTask =>
+    async function (task, { retry: retryCount }) {
+      if (!testFinishTimeCh.hasSubscribers) {
+        return onAfterTryTask.apply(this, arguments)
+      }
+      const result = await onAfterTryTask.apply(this, arguments)
+
+      const status = getVitestTestStatus(task, retryCount)
+      const asyncResource = taskToAsync.get(task)
+
+      if (asyncResource) {
+        // We don't finish here because the test might fail in a later hook
+        asyncResource.runInAsyncScope(() => {
+          testFinishTimeCh.publish({ status, task })
+        })
+      }
+
+      return result
+    })
+
+  return vitestPackage
+})
+
+addHook({
+  name: 'vitest',
+  versions: ['>=2.0.0'],
+  filePattern: 'dist/vendor/index.*'
+}, (vitestPackage) => {
+  // there are multiple index* files so we have to check the exported values
+  if (isReporterPackageNew(vitestPackage)) {
+    shimmer.wrap(vitestPackage.e.prototype, 'sort', getSortWrapper)
+  }
+
+  return vitestPackage
+})
+
+addHook({
+  name: 'vitest',
+  versions: ['>=1.6.0'],
+  filePattern: 'dist/vendor/index.*'
+}, (vitestPackage) => {
+  // there are multiple index* files so we have to check the exported values
+  if (isReporterPackage(vitestPackage)) {
+    shimmer.wrap(vitestPackage.B.prototype, 'sort', getSortWrapper)
+  }
+
+  return vitestPackage
+})
+
+// Can't specify file because compiled vitest includes hashes in their files
+addHook({
+  name: 'vitest',
+  versions: ['>=1.6.0'],
+  filePattern: 'dist/vendor/cac.*'
+}, (vitestPackage, frameworkVersion) => {
+  shimmer.wrap(vitestPackage, 'c', oldCreateCli => function () {
+    if (!testSessionStartCh.hasSubscribers) {
+      return oldCreateCli.apply(this, arguments)
+    }
+    sessionAsyncResource.runInAsyncScope(() => {
+      const processArgv = process.argv.slice(2).join(' ')
+      testSessionStartCh.publish({ command: `vitest ${processArgv}`, frameworkVersion })
+    })
+    return oldCreateCli.apply(this, arguments)
+  })
+
+  return vitestPackage
+})
+
+// test suite start and finish
+// only relevant for workers
+addHook({
+  name: '@vitest/runner',
+  versions: ['>=1.6.0'],
+  file: 'dist/index.js'
+}, vitestPackage => {
+  shimmer.wrap(vitestPackage, 'startTests', startTests => async function (testPath) {
+    let testSuiteError = null
+    if (!testSuiteStartCh.hasSubscribers) {
+      return startTests.apply(this, arguments)
+    }
+
+    const testSuiteAsyncResource = new AsyncResource('bound-anonymous-fn')
+    testSuiteAsyncResource.runInAsyncScope(() => {
+      testSuiteStartCh.publish(testPath[0])
+    })
+    const startTestsResponse = await startTests.apply(this, arguments)
+
+    let onFinish = null
+    const onFinishPromise = new Promise(resolve => {
+      onFinish = resolve
+    })
+
+    const testTasks = getTypeTasks(startTestsResponse[0].tasks)
+
+    // Only one test task per test, even if there are retries
+    testTasks.forEach(task => {
+      const testAsyncResource = taskToAsync.get(task)
+      const { result } = task
+
+      if (result) {
+        const { state, duration, errors } = result
+        if (state === 'skip') { // programmatic skip
+          testSkipCh.publish({ testName: getTestName(task), testSuiteAbsolutePath: task.file.filepath })
+        } else if (state === 'pass') {
+          if (testAsyncResource) {
+            testAsyncResource.runInAsyncScope(() => {
+              testPassCh.publish({ task })
+            })
+          }
+        } else if (state === 'fail') {
+          // If it's failing, we have no accurate finish time, so we have to use `duration`
+          let testError
+
+          if (errors?.length) {
+            testError = errors[0]
+          }
+
+          if (testAsyncResource) {
+            const isRetry = task.result?.retryCount > 0
+            // `duration` is the duration of all the retries, so it can't be used if there are retries
+            testAsyncResource.runInAsyncScope(() => {
+              testErrorCh.publish({ duration: !isRetry ? duration : undefined, error: testError })
+            })
+          }
+          if (errors?.length) {
+            testSuiteError = testError // we store the error to bubble it up to the suite
+          }
+        }
+      } else { // test.skip or test.todo
+        testSkipCh.publish({ testName: getTestName(task), testSuiteAbsolutePath: task.file.filepath })
+      }
+    })
+
+    const testSuiteResult = startTestsResponse[0].result
+
+    if (testSuiteResult.errors?.length) { // Errors from root level hooks
+      testSuiteError = testSuiteResult.errors[0]
+    } else if (testSuiteResult.state === 'fail') { // Errors from `describe` level hooks
+      const suiteTasks = getTypeTasks(startTestsResponse[0].tasks, 'suite')
+      const failedSuites = suiteTasks.filter(task => task.result?.state === 'fail')
+      if (failedSuites.length && failedSuites[0].result?.errors?.length) {
+        testSuiteError = failedSuites[0].result.errors[0]
+      }
+    }
+
+    if (testSuiteError) {
+      testSuiteAsyncResource.runInAsyncScope(() => {
+        testSuiteErrorCh.publish({ error: testSuiteError })
+      })
+    }
+
+    testSuiteAsyncResource.runInAsyncScope(() => {
+      testSuiteFinishCh.publish({ status: testSuiteResult.state, onFinish })
+    })
+
+    // TODO: fix too frequent flushes
+    await onFinishPromise
+
+    return startTestsResponse
+  })
+
+  return vitestPackage
+})

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

@@ -64,11 +64,17 @@ class BaseAwsSdkPlugin extends ClientPlugin {
       span.setTag('region', region)
     })
 
-    this.addSub(`apm:aws:request:complete:${this.serviceIdentifier}`, ({ response }) => {
+    this.addSub(`apm:aws:request:complete:${this.serviceIdentifier}`, ({ response, cbExists = false }) => {
       const store = storage.getStore()
       if (!store) return
       const { span } = store
       if (!span) return
+      // try to extract DSM context from response if no callback exists as extraction normally happens in CB
+      if (!cbExists && this.serviceIdentifier === 'sqs') {
+        const params = response.request.params
+        const operation = response.request.operation
+        this.responseExtractDSMContext(operation, params, response.data ?? response, span)
+      }
       this.addResponseTags(span, response)
       this.finish(span, response, response.error)
     })
@@ -159,6 +165,7 @@ function normalizeConfig (config, serviceIdentifier) {
 
   return Object.assign({}, config, specificConfig, {
     splitByAwsService: config.splitByAwsService !== false,
+    batchPropagationEnabled: config.batchPropagationEnabled !== false,
     hooks
   })
 }

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

@@ -21,7 +21,7 @@ class DynamoDb extends BaseAwsSdkPlugin {
       // batch operations have different format, collect table name for batch
       // https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html#batchGetItem-property`
       // dynamoDB batch TableName
-      if (params.RequestItems) {
+      if (params.RequestItems !== null) {
         if (typeof params.RequestItems === 'object') {
           if (Object.keys(params.RequestItems).length === 1) {
             const tableName = Object.keys(params.RequestItems)[0]

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

@@ -52,7 +52,7 @@ class Kinesis extends BaseAwsSdkPlugin {
 
         // extract DSM context after as we might not have a parent-child but may have a DSM context
         this.responseExtractDSMContext(
-          request.operation, response, span || null, streamName
+          request.operation, request.params, response, span || null, { streamName }
         )
       }
     })
@@ -100,7 +100,8 @@ class Kinesis extends BaseAwsSdkPlugin {
     }
   }
 
-  responseExtractDSMContext (operation, response, span, streamName) {
+  responseExtractDSMContext (operation, params, response, span, kwargs = {}) {
+    const { streamName } = kwargs
     if (!this.config.dsmEnabled) return
     if (operation !== 'getRecords') return
     if (!response || !response.Records || !response.Records[0]) return
@@ -151,7 +152,12 @@ class Kinesis extends BaseAwsSdkPlugin {
       case 'putRecords':
         stream = params.StreamArn ? params.StreamArn : (params.StreamName ? params.StreamName : '')
         for (let i = 0; i < params.Records.length; i++) {
-          this.injectToMessage(span, params.Records[i], stream, i === 0)
+          this.injectToMessage(
+            span,
+            params.Records[i],
+            stream,
+            i === 0 || (this.config.kinesis && this.config.kinesis.batchPropagationEnabled)
+          )
         }
     }
   }

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

@@ -59,7 +59,12 @@ class Sns extends BaseAwsSdkPlugin {
         break
       case 'publishBatch':
         for (let i = 0; i < params.PublishBatchRequestEntries.length; i++) {
-          this.injectToMessage(span, params.PublishBatchRequestEntries[i], params.TopicArn, i === 0)
+          this.injectToMessage(
+            span,
+            params.PublishBatchRequestEntries[i],
+            params.TopicArn,
+            i === 0 || (this.config.sns && this.config.sns.batchPropagationEnabled)
+          )
         }
         break
     }

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

@@ -23,7 +23,7 @@ class Sqs extends BaseAwsSdkPlugin {
       const plugin = this
       const contextExtraction = this.responseExtract(request.params, request.operation, response)
       let span
-      let parsedMessageAttributes
+      let parsedMessageAttributes = null
       if (contextExtraction && contextExtraction.datadogContext) {
         obj.needsFinish = true
         const options = {
@@ -39,8 +39,9 @@ class Sqs extends BaseAwsSdkPlugin {
         this.enter(span, store)
       }
       // extract DSM context after as we might not have a parent-child but may have a DSM context
+
       this.responseExtractDSMContext(
-        request.operation, request.params, response, span || null, parsedMessageAttributes || null
+        request.operation, request.params, response, span || null, { parsedMessageAttributes }
       )
     })
 
@@ -165,7 +166,8 @@ class Sqs extends BaseAwsSdkPlugin {
     }
   }
 
-  responseExtractDSMContext (operation, params, response, span, parsedAttributes) {
+  responseExtractDSMContext (operation, params, response, span, kwargs = {}) {
+    let { parsedAttributes } = kwargs
     if (!this.config.dsmEnabled) return
     if (operation !== 'receiveMessage') return
     if (!response || !response.Messages || !response.Messages[0]) return
@@ -188,7 +190,7 @@ class Sqs extends BaseAwsSdkPlugin {
             // SQS to SQS
           }
         }
-        if (message.MessageAttributes && message.MessageAttributes._datadog) {
+        if (!parsedAttributes && message.MessageAttributes && message.MessageAttributes._datadog) {
           parsedAttributes = this.parseDatadogAttributes(message.MessageAttributes._datadog)
         }
       }
@@ -216,7 +218,23 @@ class Sqs extends BaseAwsSdkPlugin {
         break
       case 'sendMessageBatch':
         for (let i = 0; i < params.Entries.length; i++) {
-          this.injectToMessage(span, params.Entries[i], params.QueueUrl, i === 0)
+          this.injectToMessage(
+            span,
+            params.Entries[i],
+            params.QueueUrl,
+            i === 0 || (this.config.sqs && this.config.sqs.batchPropagationEnabled)
+          )
+        }
+        break
+      case 'receiveMessage':
+        if (!params.MessageAttributeNames) {
+          params.MessageAttributeNames = ['_datadog']
+        } else if (
+          !params.MessageAttributeNames.includes('_datadog') &&
+          !params.MessageAttributeNames.includes('.*') &&
+          !params.MessageAttributeNames.includes('All')
+        ) {
+          params.MessageAttributeNames.push('_datadog')
         }
         break
     }

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

@@ -47,7 +47,7 @@ class Stepfunctions extends BaseAwsSdkPlugin {
 
       try {
         const inputObj = JSON.parse(input)
-        if (inputObj && typeof inputObj === 'object') {
+        if (inputObj !== null && typeof inputObj === 'object') {
           // We've parsed the input JSON string
           inputObj._datadog = {}
           this.tracer.inject(span, 'text_map', inputObj._datadog)

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

@@ -54,7 +54,7 @@ class ChildProcessPlugin extends TracingPlugin {
     }
 
     this.startSpan('command_execution', {
-      service: this.config.service,
+      service: this.config.service || this._tracerConfig.service,
       resource: (shell === true) ? 'sh' : cmdFields[0],
       type: 'system',
       meta