dd-trace 4.28.0 → 4.30.0

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

@@ -14,6 +14,7 @@ const testSuiteFinishCh = channel('ci:playwright:test-suite:finish')
 const testToAr = new WeakMap()
 const testSuiteToAr = new Map()
 const testSuiteToTestStatuses = new Map()
+const testSuiteToErrors = new Map()
 
 let startedSuites = []
 
@@ -81,7 +82,12 @@ function getRootDir (playwrightRunner) {
 
 function getProjectsFromRunner (runner) {
   const config = getPlaywrightConfig(runner)
-  return config.projects?.map(({ project }) => project)
+  return config.projects?.map((project) => {
+    if (project.project) {
+      return project.project
+    }
+    return project
+  })
 }
 
 function getProjectsFromDispatcher (dispatcher) {
@@ -93,13 +99,55 @@ function getProjectsFromDispatcher (dispatcher) {
   return dispatcher._loader?.fullConfig()?.projects
 }
 
-function getBrowserNameFromProjects (projects, projectId) {
-  if (!projects) {
+function getBrowserNameFromProjects (projects, test) {
+  if (!projects || !test) {
     return null
   }
-  return projects.find(project =>
-    project.__projectId === projectId || project._id === projectId
-  )?.name
+  const { _projectIndex, _projectId: testProjectId } = test
+
+  if (_projectIndex !== undefined) {
+    return projects[_projectIndex]?.name
+  }
+
+  return projects.find(({ __projectId, _id, name }) => {
+    if (__projectId !== undefined) {
+      return __projectId === testProjectId
+    }
+    if (_id !== undefined) {
+      return _id === testProjectId
+    }
+    return name === testProjectId
+  })?.name
+}
+
+function formatTestHookError (error, hookType, isTimeout) {
+  let hookError = error
+  if (error) {
+    hookError.message = `Error in ${hookType} hook: ${error.message}`
+  }
+  if (!hookError && isTimeout) {
+    hookError = new Error(`${hookType} hook timed out`)
+  }
+  return hookError
+}
+
+function addErrorToTestSuite (testSuiteAbsolutePath, error) {
+  if (testSuiteToErrors.has(testSuiteAbsolutePath)) {
+    testSuiteToErrors.get(testSuiteAbsolutePath).push(error)
+  } else {
+    testSuiteToErrors.set(testSuiteAbsolutePath, [error])
+  }
+}
+
+function getTestSuiteError (testSuiteAbsolutePath) {
+  const errors = testSuiteToErrors.get(testSuiteAbsolutePath)
+  if (!errors) {
+    return null
+  }
+  if (errors.length === 1) {
+    return errors[0]
+  }
+  return new Error(`${errors.length} errors in this test suite:\n${errors.map(e => e.message).join('\n------\n')}`)
 }
 
 function testBeginHandler (test, browserName) {
@@ -131,7 +179,7 @@ function testBeginHandler (test, browserName) {
   })
 }
 
-function testEndHandler (test, annotations, testStatus, error) {
+function testEndHandler (test, annotations, testStatus, error, isTimeout) {
   let annotationTags
   if (annotations.length) {
     annotationTags = parseAnnotations(annotations)
@@ -139,6 +187,11 @@ function testEndHandler (test, annotations, testStatus, error) {
   const { _requireFile: testSuiteAbsolutePath, results, _type } = test
 
   if (_type === 'beforeAll' || _type === 'afterAll') {
+    const hookError = formatTestHookError(error, _type, isTimeout)
+
+    if (hookError) {
+      addErrorToTestSuite(testSuiteAbsolutePath, hookError)
+    }
     return
   }
 
@@ -148,15 +201,20 @@ function testEndHandler (test, annotations, testStatus, error) {
     testFinishCh.publish({ testStatus, steps: testResult.steps, error, extraTags: annotationTags })
   })
 
-  if (!testSuiteToTestStatuses.has(testSuiteAbsolutePath)) {
-    testSuiteToTestStatuses.set(testSuiteAbsolutePath, [testStatus])
-  } else {
+  if (testSuiteToTestStatuses.has(testSuiteAbsolutePath)) {
     testSuiteToTestStatuses.get(testSuiteAbsolutePath).push(testStatus)
+  } else {
+    testSuiteToTestStatuses.set(testSuiteAbsolutePath, [testStatus])
+  }
+
+  if (error) {
+    addErrorToTestSuite(testSuiteAbsolutePath, error)
   }
 
   remainingTestsByFile[testSuiteAbsolutePath] = remainingTestsByFile[testSuiteAbsolutePath]
     .filter(currentTest => currentTest !== test)
 
+  // Last test, we finish the suite
   if (!remainingTestsByFile[testSuiteAbsolutePath].length) {
     const testStatuses = testSuiteToTestStatuses.get(testSuiteAbsolutePath)
 
@@ -167,9 +225,10 @@ function testEndHandler (test, annotations, testStatus, error) {
       testSuiteStatus = 'skip'
     }
 
+    const suiteError = getTestSuiteError(testSuiteAbsolutePath)
     const testSuiteAsyncResource = testSuiteToAr.get(testSuiteAbsolutePath)
     testSuiteAsyncResource.runInAsyncScope(() => {
-      testSuiteFinishCh.publish(testSuiteStatus)
+      testSuiteFinishCh.publish({ status: testSuiteStatus, error: suiteError })
     })
   }
 }
@@ -197,7 +256,7 @@ function dispatcherHook (dispatcherExport) {
       if (method === 'testBegin') {
         const { test } = dispatcher._testById.get(params.testId)
         const projects = getProjectsFromDispatcher(dispatcher)
-        const browser = getBrowserNameFromProjects(projects, test._projectId)
+        const browser = getBrowserNameFromProjects(projects, test)
         testBeginHandler(test, browser)
       } else if (method === 'testEnd') {
         const { test } = dispatcher._testById.get(params.testId)
@@ -205,7 +264,8 @@ function dispatcherHook (dispatcherExport) {
         const { results } = test
         const testResult = results[results.length - 1]
 
-        testEndHandler(test, params.annotations, STATUS_TO_TEST_STATUS[testResult.status], testResult.error)
+        const isTimeout = testResult.status === 'timedOut'
+        testEndHandler(test, params.annotations, STATUS_TO_TEST_STATUS[testResult.status], testResult.error, isTimeout)
       }
     })
 
@@ -232,13 +292,14 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
     worker.on('testBegin', ({ testId }) => {
       const test = getTestByTestId(dispatcher, testId)
       const projects = getProjectsFromDispatcher(dispatcher)
-      const browser = getBrowserNameFromProjects(projects, test._projectId)
+      const browser = getBrowserNameFromProjects(projects, test)
       testBeginHandler(test, browser)
     })
     worker.on('testEnd', ({ testId, status, errors, annotations }) => {
       const test = getTestByTestId(dispatcher, testId)
 
-      testEndHandler(test, annotations, STATUS_TO_TEST_STATUS[status], errors && errors[0])
+      const isTimeout = status === 'timedOut'
+      testEndHandler(test, annotations, STATUS_TO_TEST_STATUS[status], errors && errors[0], isTimeout)
     })
 
     return worker
@@ -265,7 +326,7 @@ function runnerHook (runnerExport, playwrightVersion) {
       // there were tests that did not go through `testBegin` or `testEnd`,
       // because they were skipped
       tests.forEach(test => {
-        const browser = getBrowserNameFromProjects(projects, test._projectId)
+        const browser = getBrowserNameFromProjects(projects, test)
         testBeginHandler(test, browser)
         testEndHandler(test, [], 'skip')
       })
@@ -327,6 +388,7 @@ addHook({
   file: 'lib/runner/runner.js',
   versions: ['>=1.38.0']
 }, runnerHook)
+
 addHook({
   name: 'playwright',
   file: 'lib/runner/dispatcher.js',

package/packages/datadog-plugin-amqplib/src/consumer.js

@@ -2,7 +2,8 @@
 
 const { TEXT_MAP } = require('../../../ext/formats')
 const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
-const { getAmqpMessageSize, CONTEXT_PROPAGATION_KEY } = require('../../dd-trace/src/datastreams/processor')
+const { getAmqpMessageSize } = require('../../dd-trace/src/datastreams/processor')
+const { DsmPathwayCodec } = require('../../dd-trace/src/datastreams/pathway')
 const { getResourceName } = require('./util')
 
 class AmqplibConsumerPlugin extends ConsumerPlugin {
@@ -28,10 +29,13 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
       }
     })
 
-    if (this.config.dsmEnabled && message) {
+    if (
+      this.config.dsmEnabled && message?.properties?.headers &&
+      DsmPathwayCodec.contextExists(message.properties.headers)
+    ) {
       const payloadSize = getAmqpMessageSize({ headers: message.properties.headers, content: message.content })
-      const queue = fields.queue ?? fields.routingKey
-      this.tracer.decodeDataStreamsContext(message.properties.headers[CONTEXT_PROPAGATION_KEY])
+      const queue = fields.queue ? fields.queue : fields.routingKey
+      this.tracer.decodeDataStreamsContext(message.properties.headers)
       this.tracer
         .setCheckpoint(['direction:in', `topic:${queue}`, 'type:rabbitmq'], span, payloadSize)
     }

package/packages/datadog-plugin-amqplib/src/producer.js

@@ -3,8 +3,8 @@
 const { TEXT_MAP } = require('../../../ext/formats')
 const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
-const { encodePathwayContext } = require('../../dd-trace/src/datastreams/pathway')
-const { getAmqpMessageSize, CONTEXT_PROPAGATION_KEY } = require('../../dd-trace/src/datastreams/processor')
+const { DsmPathwayCodec } = require('../../dd-trace/src/datastreams/pathway')
+const { getAmqpMessageSize } = require('../../dd-trace/src/datastreams/processor')
 const { getResourceName } = require('./util')
 
 class AmqplibProducerPlugin extends ProducerPlugin {
@@ -40,8 +40,7 @@ class AmqplibProducerPlugin extends ProducerPlugin {
         .setCheckpoint(
           ['direction:out', `exchange:${fields.exchange}`, `has_routing_key:${hasRoutingKey}`, 'type:rabbitmq']
           , span, payloadSize)
-      const pathwayCtx = encodePathwayContext(dataStreamsContext)
-      fields.headers[CONTEXT_PROPAGATION_KEY] = pathwayCtx
+      DsmPathwayCodec.encode(dataStreamsContext, fields.headers)
     }
   }
 }

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

@@ -126,8 +126,9 @@ class BaseAwsSdkPlugin extends ClientPlugin {
     if (err) {
       span.setTag('error', err)
 
-      if (err.requestId) {
-        span.addTags({ 'aws.response.request_id': err.requestId })
+      const requestId = err.RequestId || err.requestId
+      if (requestId) {
+        span.addTags({ 'aws.response.request_id': requestId })
       }
     }
 

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

@@ -1,9 +1,8 @@
 'use strict'
 const {
-  CONTEXT_PROPAGATION_KEY,
   getSizeOrZero
 } = require('../../../dd-trace/src/datastreams/processor')
-const { encodePathwayContext } = require('../../../dd-trace/src/datastreams/pathway')
+const { DsmPathwayCodec } = require('../../../dd-trace/src/datastreams/pathway')
 const log = require('../../../dd-trace/src/log')
 const BaseAwsSdkPlugin = require('../base')
 const { storage } = require('../../../datadog-core')
@@ -53,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, response, span || null, streamName
         )
       }
     })
@@ -113,13 +112,10 @@ class Kinesis extends BaseAwsSdkPlugin {
       const parsedAttributes = JSON.parse(Buffer.from(record.Data).toString())
 
       if (
-        parsedAttributes &&
-        parsedAttributes._datadog &&
-        parsedAttributes._datadog[CONTEXT_PROPAGATION_KEY] &&
-        streamName
+        parsedAttributes?._datadog && streamName && DsmPathwayCodec.contextExists(parsedAttributes._datadog)
       ) {
         const payloadSize = getSizeOrZero(record.Data)
-        this.tracer.decodeDataStreamsContext(Buffer.from(parsedAttributes._datadog[CONTEXT_PROPAGATION_KEY]))
+        this.tracer.decodeDataStreamsContext(parsedAttributes._datadog)
         this.tracer
           .setCheckpoint(['direction:in', `topic:${streamName}`, 'type:kinesis'], span, payloadSize)
       }
@@ -143,62 +139,69 @@ class Kinesis extends BaseAwsSdkPlugin {
   }
 
   requestInject (span, request) {
-    const operation = request.operation
-    if (operation === 'putRecord' || operation === 'putRecords') {
-      if (!request.params) {
-        return
-      }
-      const traceData = {}
-
-      // inject data with DD context
-      this.tracer.inject(span, 'text_map', traceData)
-      let injectPath
-      if (request.params.Records && request.params.Records.length > 0) {
-        injectPath = request.params.Records[0]
-      } else if (request.params.Data) {
-        injectPath = request.params
-      } else {
-        log.error('No valid payload passed, unable to pass trace context')
+    const { operation, params } = request
+    if (!params) return
+
+    let stream
+    switch (operation) {
+      case 'putRecord':
+        stream = params.StreamArn ? params.StreamArn : (params.StreamName ? params.StreamName : '')
+        this.injectToMessage(span, params, stream, true)
+        break
+      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)
+        }
+    }
+  }
+
+  injectToMessage (span, params, stream, injectTraceContext) {
+    if (!params) {
+      return
+    }
+
+    let parsedData
+    if (injectTraceContext || this.config.dsmEnabled) {
+      parsedData = this._tryParse(params.Data)
+      if (!parsedData) {
+        log.error('Unable to parse payload, unable to pass trace context or set DSM checkpoint (if enabled)')
         return
       }
+    }
 
-      const parsedData = this._tryParse(injectPath.Data)
-      if (parsedData) {
-        parsedData._datadog = traceData
-
-        // set DSM hash if enabled
-        if (this.config.dsmEnabled) {
-          // get payload size of request data
-          const payloadSize = Buffer.from(JSON.stringify(parsedData)).byteLength
-          let stream
-          // users can optionally use either stream name or stream arn
-          if (request.params && request.params.StreamArn) {
-            stream = request.params.StreamArn
-          } else if (request.params && request.params.StreamName) {
-            stream = request.params.StreamName
-          }
-          const dataStreamsContext = this.tracer
-            .setCheckpoint(['direction:out', `topic:${stream}`, 'type:kinesis'], span, payloadSize)
-          if (dataStreamsContext) {
-            const pathwayCtx = encodePathwayContext(dataStreamsContext)
-            parsedData._datadog[CONTEXT_PROPAGATION_KEY] = pathwayCtx.toJSON()
-          }
-        }
+    const ddInfo = {}
+    // for now, we only want to inject to the first message, this may change for batches in the future
+    if (injectTraceContext) { this.tracer.inject(span, 'text_map', ddInfo) }
 
-        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) {
-          log.info('Payload size too large to pass context')
-          return
-        }
-        injectPath.Data = finalData
-      } else {
-        log.error('Unable to parse payload, unable to pass trace context')
+    // set DSM hash if enabled
+    if (this.config.dsmEnabled) {
+      parsedData._datadog = ddInfo
+      const dataStreamsContext = this.setDSMCheckpoint(span, parsedData, stream)
+      DsmPathwayCodec.encode(dataStreamsContext, ddInfo)
+    }
+
+    if (Object.keys(ddInfo).length !== 0) {
+      parsedData._datadog = ddInfo
+      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) {
+        log.info('Payload size too large to pass context')
+        return
       }
+      params.Data = finalData
     }
   }
+
+  setDSMCheckpoint (span, parsedData, stream) {
+    // get payload size of request data
+    const payloadSize = Buffer.from(JSON.stringify(parsedData)).byteLength
+    const dataStreamsContext = this.tracer
+      .setCheckpoint(['direction:out', `topic:${stream}`, 'type:kinesis'], span, payloadSize)
+    return dataStreamsContext
+  }
 }
 
 module.exports = Kinesis

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

@@ -1,6 +1,6 @@
 'use strict'
-const { CONTEXT_PROPAGATION_KEY, getHeadersSize } = require('../../../dd-trace/src/datastreams/processor')
-const { encodePathwayContext } = require('../../../dd-trace/src/datastreams/pathway')
+const { getHeadersSize } = require('../../../dd-trace/src/datastreams/processor')
+const { DsmPathwayCodec } = require('../../../dd-trace/src/datastreams/pathway')
 const log = require('../../../dd-trace/src/log')
 const BaseAwsSdkPlugin = require('../base')
 
@@ -55,17 +55,17 @@ class Sns extends BaseAwsSdkPlugin {
 
     switch (operation) {
       case 'publish':
-        this._injectMessageAttributes(span, params)
+        this.injectToMessage(span, params, params.TopicArn, true)
         break
       case 'publishBatch':
-        if (params.PublishBatchRequestEntries && params.PublishBatchRequestEntries.length > 0) {
-          this._injectMessageAttributes(span, params.PublishBatchRequestEntries[0])
+        for (let i = 0; i < params.PublishBatchRequestEntries.length; i++) {
+          this.injectToMessage(span, params.PublishBatchRequestEntries[i], params.TopicArn, i === 0)
         }
         break
     }
   }
 
-  _injectMessageAttributes (span, params) {
+  injectToMessage (span, params, topicArn, injectTraceContext) {
     if (!params.MessageAttributes) {
       params.MessageAttributes = {}
     }
@@ -73,27 +73,47 @@ class Sns extends BaseAwsSdkPlugin {
       log.info('Message attributes full, skipping trace context injection')
       return
     }
+
     const ddInfo = {}
-    this.tracer.inject(span, 'text_map', ddInfo)
-    // add ddInfo before checking DSM so we can include DD attributes in payload size
-    params.MessageAttributes._datadog = {
-      DataType: 'Binary',
-      BinaryValue: ddInfo
+    // for now, we only want to inject to the first message, this may change for batches in the future
+    if (injectTraceContext) {
+      this.tracer.inject(span, 'text_map', ddInfo)
+      // add ddInfo before checking DSM so we can include DD attributes in payload size
+      params.MessageAttributes._datadog = {
+        DataType: 'Binary',
+        BinaryValue: ddInfo
+      }
     }
+
     if (this.config.dsmEnabled) {
-      const payloadSize = getHeadersSize({
-        Message: params.Message,
-        MessageAttributes: params.MessageAttributes
-      })
-      const dataStreamsContext = this.tracer
-        .setCheckpoint(['direction:out', `topic:${params.TopicArn}`, 'type:sns'], span, payloadSize)
-      if (dataStreamsContext) {
-        const pathwayCtx = encodePathwayContext(dataStreamsContext)
-        ddInfo[CONTEXT_PROPAGATION_KEY] = pathwayCtx.toJSON()
+      if (!params.MessageAttributes._datadog) {
+        params.MessageAttributes._datadog = {
+          DataType: 'Binary',
+          BinaryValue: ddInfo
+        }
       }
+
+      const dataStreamsContext = this.setDSMCheckpoint(span, params, topicArn)
+      DsmPathwayCodec.encode(dataStreamsContext, ddInfo)
+    }
+
+    if (Object.keys(ddInfo).length !== 0) {
+      // BINARY types are automatically base64 encoded
+      params.MessageAttributes._datadog.BinaryValue = Buffer.from(JSON.stringify(ddInfo))
+    } else if (params.MessageAttributes._datadog) {
+      // let's avoid adding any additional information to payload if we failed to inject
+      delete params.MessageAttributes._datadog
+    }
+  }
+
+  setDSMCheckpoint (span, params, topicArn) {
+    // only set a checkpoint if publishing to a topic
+    if (topicArn) {
+      const payloadSize = getHeadersSize(params)
+      const dataStreamsContext = this.tracer
+        .setCheckpoint(['direction:out', `topic:${topicArn}`, 'type:sns'], span, payloadSize)
+      return dataStreamsContext
     }
-    // BINARY types are automatically base64 encoded
-    params.MessageAttributes._datadog.BinaryValue = Buffer.from(JSON.stringify(ddInfo))
   }
 }
 

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

@@ -3,8 +3,8 @@
 const log = require('../../../dd-trace/src/log')
 const BaseAwsSdkPlugin = require('../base')
 const { storage } = require('../../../datadog-core')
-const { CONTEXT_PROPAGATION_KEY, getHeadersSize } = require('../../../dd-trace/src/datastreams/processor')
-const { encodePathwayContext } = require('../../../dd-trace/src/datastreams/pathway')
+const { getHeadersSize } = require('../../../dd-trace/src/datastreams/processor')
+const { DsmPathwayCodec } = require('../../../dd-trace/src/datastreams/pathway')
 
 class Sqs extends BaseAwsSdkPlugin {
   static get id () { return 'sqs' }
@@ -40,7 +40,7 @@ class Sqs extends BaseAwsSdkPlugin {
       }
       // 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 || null
       )
     })
 
@@ -192,13 +192,13 @@ class Sqs extends BaseAwsSdkPlugin {
           parsedAttributes = this.parseDatadogAttributes(message.MessageAttributes._datadog)
         }
       }
-      if (parsedAttributes && parsedAttributes[CONTEXT_PROPAGATION_KEY]) {
+      if (parsedAttributes && DsmPathwayCodec.contextExists(parsedAttributes)) {
         const payloadSize = getHeadersSize({
           Body: message.Body,
           MessageAttributes: message.MessageAttributes
         })
         const queue = params.QueueUrl.split('/').pop()
-        this.tracer.decodeDataStreamsContext(Buffer.from(parsedAttributes[CONTEXT_PROPAGATION_KEY]))
+        this.tracer.decodeDataStreamsContext(parsedAttributes)
         this.tracer
           .setCheckpoint(['direction:in', `topic:${queue}`, 'type:sqs'], span, payloadSize)
       }
@@ -206,39 +206,73 @@ class Sqs extends BaseAwsSdkPlugin {
   }
 
   requestInject (span, request) {
-    const operation = request.operation
-    if (operation === 'sendMessage') {
-      if (!request.params) {
-        request.params = {}
-      }
-      if (!request.params.MessageAttributes) {
-        request.params.MessageAttributes = {}
-      } else if (Object.keys(request.params.MessageAttributes).length >= 10) { // SQS quota
-        // TODO: add test when the test suite is fixed
-        return
-      }
-      const ddInfo = {}
+    const { operation, params } = request
+
+    if (!params) return
+
+    switch (operation) {
+      case 'sendMessage':
+        this.injectToMessage(span, params, params.QueueUrl, true)
+        break
+      case 'sendMessageBatch':
+        for (let i = 0; i < params.Entries.length; i++) {
+          this.injectToMessage(span, params.Entries[i], params.QueueUrl, i === 0)
+        }
+        break
+    }
+  }
+
+  injectToMessage (span, params, queueUrl, injectTraceContext) {
+    if (!params) {
+      params = {}
+    }
+    if (!params.MessageAttributes) {
+      params.MessageAttributes = {}
+    } else if (Object.keys(params.MessageAttributes).length >= 10) { // SQS quota
+      // TODO: add test when the test suite is fixed
+      return
+    }
+    const ddInfo = {}
+    // for now, we only want to inject to the first message, this may change for batches in the future
+    if (injectTraceContext) {
       this.tracer.inject(span, 'text_map', ddInfo)
-      request.params.MessageAttributes._datadog = {
+      params.MessageAttributes._datadog = {
         DataType: 'String',
         StringValue: JSON.stringify(ddInfo)
       }
-      if (this.config.dsmEnabled) {
-        const payloadSize = getHeadersSize({
-          Body: request.params.MessageBody,
-          MessageAttributes: request.params.MessageAttributes
-        })
-        const queue = request.params.QueueUrl.split('/').pop()
-        const dataStreamsContext = this.tracer
-          .setCheckpoint(['direction:out', `topic:${queue}`, 'type:sqs'], span, payloadSize)
-        if (dataStreamsContext) {
-          const pathwayCtx = encodePathwayContext(dataStreamsContext)
-          ddInfo[CONTEXT_PROPAGATION_KEY] = pathwayCtx.toJSON()
+    }
+
+    if (this.config.dsmEnabled) {
+      if (!params.MessageAttributes._datadog) {
+        params.MessageAttributes._datadog = {
+          DataType: 'String',
+          StringValue: JSON.stringify(ddInfo)
         }
       }
-      request.params.MessageAttributes._datadog.StringValue = JSON.stringify(ddInfo)
+
+      const dataStreamsContext = this.setDSMCheckpoint(span, params, queueUrl)
+      if (dataStreamsContext) {
+        DsmPathwayCodec.encode(dataStreamsContext, ddInfo)
+        params.MessageAttributes._datadog.StringValue = JSON.stringify(ddInfo)
+      }
+    }
+
+    if (params.MessageAttributes._datadog && Object.keys(ddInfo).length === 0) {
+      // let's avoid adding any additional information to payload if we failed to inject
+      delete params.MessageAttributes._datadog
     }
   }
+
+  setDSMCheckpoint (span, params, queueUrl) {
+    const payloadSize = getHeadersSize({
+      Body: params.MessageBody,
+      MessageAttributes: params.MessageAttributes
+    })
+    const queue = queueUrl.split('/').pop()
+    const dataStreamsContext = this.tracer
+      .setCheckpoint(['direction:out', `topic:${queue}`, 'type:sqs'], span, payloadSize)
+    return dataStreamsContext
+  }
 }
 
 module.exports = Sqs