dd-trace 5.54.0 → 5.55.0

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

@@ -178,9 +178,8 @@ function wrapPoolQuery (query) {
           cb(error)
 
           return
-        } else {
-          return Promise.reject(error)
         }
+        return Promise.reject(error)
       }
 
       if (typeof cb === 'function') {
@@ -192,7 +191,7 @@ function wrapPoolQuery (query) {
 
       const retval = query.apply(this, arguments)
 
-      if (retval && retval.then) {
+      if (retval?.then) {
         retval.then(() => {
           finish()
         }).catch(() => {

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

@@ -1,6 +1,6 @@
 const satisfies = require('semifies')
 
-const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const { addHook, channel } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const {
   parseAnnotations,
@@ -33,7 +33,6 @@ const testSuiteToCtx = new Map()
 const testSuiteToTestStatuses = new Map()
 const testSuiteToErrors = new Map()
 const testsToTestStatuses = new Map()
-const testSessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
 let applyRepeatEachIndex = null
 
@@ -109,7 +108,12 @@ function deepCloneSuite (suite, filterTest, tags = []) {
 
 function getTestsBySuiteFromTestGroups (testGroups) {
   return testGroups.reduce((acc, { requireFile, tests }) => {
-    acc[requireFile] = acc[requireFile] ? acc[requireFile].concat(tests) : tests
+    if (acc[requireFile]) {
+      acc[requireFile].push(...tests)
+    } else {
+      // Copy the tests, otherwise we modify the original tests
+      acc[requireFile] = [...tests]
+    }
     return acc
   }, {})
 }
@@ -238,9 +242,7 @@ function getTestByTestId (dispatcher, testId) {
 
 function getChannelPromise (channelToPublishTo, params) {
   return new Promise(resolve => {
-    testSessionAsyncResource.runInAsyncScope(() => {
-      channelToPublishTo.publish({ onDone: resolve, ...params })
-    })
+    channelToPublishTo.publish({ onDone: resolve, ...params })
   })
 }
 
@@ -417,7 +419,7 @@ function dispatcherRunWrapperNew (run) {
       // Not available from >=1.44.0
       this._ddAllTests = testGroups.flatMap(g => g.tests)
     }
-    remainingTestsByFile = getTestsBySuiteFromTestGroups(arguments[0])
+    remainingTestsByFile = getTestsBySuiteFromTestGroups(testGroups)
     return run.apply(this, arguments)
   }
 }
@@ -511,9 +513,7 @@ function runnerHook (runnerExport, playwrightVersion) {
 
     const processArgv = process.argv.slice(2).join(' ')
     const command = `playwright ${processArgv}`
-    testSessionAsyncResource.runInAsyncScope(() => {
-      testSessionStartCh.publish({ command, frameworkVersion: playwrightVersion, rootDir })
-    })
+    testSessionStartCh.publish({ command, frameworkVersion: playwrightVersion, rootDir })
 
     try {
       const { err, libraryConfig } = await getChannelPromise(libraryConfigurationCh)
@@ -630,13 +630,11 @@ function runnerHook (runnerExport, playwrightVersion) {
     const flushWait = new Promise(resolve => {
       onDone = resolve
     })
-    testSessionAsyncResource.runInAsyncScope(() => {
-      testSessionFinishCh.publish({
-        status: STATUS_TO_TEST_STATUS[sessionStatus],
-        isEarlyFlakeDetectionEnabled,
-        isTestManagementTestsEnabled,
-        onDone
-      })
+    testSessionFinishCh.publish({
+      status: STATUS_TO_TEST_STATUS[sessionStatus],
+      isEarlyFlakeDetectionEnabled,
+      isTestManagementTestsEnabled,
+      onDone
     })
     await flushWait
 
@@ -754,8 +752,7 @@ addHook({
     }
 
     if (isImpactedTestsEnabled) {
-      for (const test of allTests) {
-        const isNew = isKnownTestsEnabled && isNewTest(test)
+      await Promise.all(allTests.map(async (test) => {
         const { isModified } = await getChannelPromise(isModifiedCh, {
           filePath: test._requireFile,
           modifiedTests
@@ -764,6 +761,7 @@ addHook({
           test._ddIsModified = true
         }
         if (isEarlyFlakeDetectionEnabled && test.expectedStatus !== 'skipped') {
+          const isNew = isKnownTestsEnabled && isNewTest(test)
           const fileSuite = getSuiteType(test, 'file')
           const projectSuite = getSuiteType(test, 'project')
           // If something change in the file, all tests in the file are impacted
@@ -778,7 +776,7 @@ addHook({
             projectSuite._addSuite(copyFileSuite)
           }
         }
-      }
+      }))
     }
 
     if (isKnownTestsEnabled) {
@@ -939,9 +937,8 @@ addHook({
                   if (window.DD_RUM && window.DD_RUM.stopSession) {
                     window.DD_RUM.stopSession()
                     return true
-                  } else {
-                    return false
                   }
+                  return false
                 })
 
                 if (isRumActive) {

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

@@ -102,11 +102,10 @@ addHook({
         wrapProtobufClasses(root)
         return root
       })
-    } else {
-      // If result is not a promise, directly wrap the protobuf classes
-      wrapProtobufClasses(result)
-      return result
     }
+    // If result is not a promise, directly wrap the protobuf classes
+    wrapProtobufClasses(result)
+    return result
   })
 
   shimmer.wrap(protobuf.Root.prototype, 'loadSync', original => function () {

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

@@ -45,7 +45,7 @@ function wrapCommandQueueClass (cls) {
         try {
           const parsed = new URL(createClientUrl)
           if (parsed) {
-            this._url = { host: parsed.hostname, port: +parsed.port || 6379 }
+            this._url = { host: parsed.hostname, port: Number(parsed.port) || 6379 }
           }
         } catch {
           // ignore

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

@@ -20,25 +20,21 @@ function wrapSetupRequest (setupRequest) {
 }
 
 function wrapMethod (method) {
-  return function (path, ...rest) {
-    const middleware = wrapMiddleware(rest)
+  return function (path, ...middlewares) {
+    const wrappedMiddlewares = middlewares.map(wrapFn)
 
-    return method.apply(this, [path].concat(middleware))
+    return method.apply(this, [path, ...wrappedMiddlewares])
   }
 }
 
 function wrapHandler (method) {
-  return function () {
-    return method.apply(this, wrapMiddleware(arguments))
+  return function (...middlewares) {
+    return method.apply(this, middlewares.map(wrapFn))
   }
 }
 
-function wrapMiddleware (middleware) {
-  return Array.prototype.map.call(middleware, wrapFn)
-}
-
 function wrapFn (fn) {
-  if (Array.isArray(fn)) return wrapMiddleware(fn)
+  if (Array.isArray(fn)) return fn.map(wrapFn)
 
   return shimmer.wrapFunction(fn, fn => function (req, res, next) {
     if (typeof next === 'function') {
@@ -51,11 +47,11 @@ function wrapFn (fn) {
 
     try {
       const result = fn.apply(this, arguments)
-      if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
-        return result.then(function () {
+      if (typeof result?.then === 'function') {
+        return result.then(function (result) {
           nextChannel.publish({ req })
           finishChannel.publish({ req })
-          return arguments[0]
+          return result
         }).catch(function (error) {
           errorChannel.publish({ req, error })
           nextChannel.publish({ req })

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

@@ -13,10 +13,6 @@ function isFastSlash (layer, matchers) {
   return layer.regexp?.fast_slash ?? matchers.some(matcher => matcher.path === '/')
 }
 
-function flatten (arr) {
-  return arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flatten(val)) : acc.concat(val), [])
-}
-
 // TODO: Move this function to a shared file between Express and Router
 function createWrapRouterMethod (name) {
   const enterChannel = channel(`apm:${name}:middleware:enter`)
@@ -74,8 +70,8 @@ function createWrapRouterMethod (name) {
     })
   }
 
-  function wrapStack (stack, offset, matchers) {
-    [].concat(stack).slice(offset).forEach(layer => {
+  function wrapStack (layers, matchers) {
+    for (const layer of layers) {
       if (layer.__handle) { // express-async-errors
         layer.__handle = wrapLayerHandle(layer, layer.__handle)
       } else {
@@ -93,7 +89,7 @@ function createWrapRouterMethod (name) {
           layer.route[method] = wrapMethod(layer.route[method])
         })
       }
-    })
+    }
   }
 
   function wrapNext (req, next) {
@@ -110,7 +106,7 @@ function createWrapRouterMethod (name) {
   }
 
   function extractMatchers (fn) {
-    const arg = flatten([].concat(fn))
+    const arg = Array.isArray(fn) ? fn : [fn]
 
     if (typeof arg[0] === 'function') {
       return []
@@ -139,7 +135,10 @@ function createWrapRouterMethod (name) {
 
   function wrapMethod (original) {
     return shimmer.wrapFunction(original, original => function methodWithTrace (fn) {
-      const offset = this.stack ? [].concat(this.stack).length : 0
+      let offset = 0
+      if (this.stack) {
+        offset = Array.isArray(this.stack) ? this.stack.length : 1
+      }
       const router = original.apply(this, arguments)
 
       if (typeof this.stack === 'function') {
@@ -150,7 +149,9 @@ function createWrapRouterMethod (name) {
         routeAddedChannel.publish({ topOfStackFunc: methodWithTrace, layer: this.stack[0] })
       }
 
-      wrapStack(this.stack, offset, extractMatchers(fn))
+      if (this.stack.length > offset) {
+        wrapStack(this.stack.slice(offset), extractMatchers(fn))
+      }
 
       return router
     })
@@ -204,7 +205,7 @@ const visitedParams = new WeakSet()
 
 function wrapHandleRequest (original) {
   return function wrappedHandleRequest (req, res, next) {
-    if (routerParamStartCh.hasSubscribers && Object.keys(req.params).length && !visitedParams.has(req.params)) {
+    if (routerParamStartCh.hasSubscribers && !visitedParams.has(req.params) && Object.keys(req.params).length) {
       visitedParams.add(req.params)
 
       const abortController = new AbortController()

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

@@ -63,7 +63,6 @@ function getQueryOrProcedure (request) {
     return [request.parametersByName.statement.value, request.parametersByName.statement, 'value']
   } else if (request.parametersByName.stmt) {
     return [request.parametersByName.stmt.value, request.parametersByName.stmt, 'value']
-  } else {
-    return [request.sqlTextOrProcedure, request, 'sqlTextOrProcedure']
   }
+  return [request.sqlTextOrProcedure, request, 'sqlTextOrProcedure']
 }

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

@@ -1,4 +1,4 @@
-const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const { addHook, channel } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
 
@@ -38,7 +38,6 @@ const modifiedTasks = new WeakSet()
 let isRetryReasonEfd = false
 let isRetryReasonAttemptToFix = false
 const switchedStatuses = new WeakSet()
-const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
 const BREAKPOINT_HIT_GRACE_PERIOD_MS = 400
 
@@ -116,9 +115,7 @@ function isBaseSequencer (vitestPackage) {
 
 function getChannelPromise (channelToPublishTo) {
   return new Promise(resolve => {
-    sessionAsyncResource.runInAsyncScope(() => {
-      channelToPublishTo.publish({ onDone: resolve })
-    })
+    channelToPublishTo.publish({ onDone: resolve })
   })
 }
 
@@ -194,9 +191,6 @@ function getSortWrapper (sort) {
     let isImpactedTestsEnabled = false
     let testManagementAttemptToFixRetries = 0
     let isDiEnabled = false
-    let knownTests = {}
-    let testManagementTests = {}
-    let modifiedTests = {}
 
     try {
       const { err, libraryConfig } = await getChannelPromise(libraryConfigurationCh)
@@ -233,9 +227,8 @@ function getSortWrapper (sort) {
       const knownTestsResponse = await getChannelPromise(knownTestsCh)
       if (knownTestsResponse.err) {
         isEarlyFlakeDetectionEnabled = false
-        isKnownTestsEnabled = false
       } else {
-        knownTests = knownTestsResponse.knownTests
+        const knownTests = knownTestsResponse.knownTests
         const getFilePaths = this.ctx.getTestFilepaths || this.ctx._globTestFilepaths
 
         const testFilepaths = await getFilePaths.call(this.ctx)
@@ -249,7 +242,6 @@ function getSortWrapper (sort) {
         })
         if (isEarlyFlakeDetectionFaulty) {
           isEarlyFlakeDetectionEnabled = false
-          isKnownTestsEnabled = false
           log.warn('New test detection is disabled because the number of new tests is too high.')
         } else {
           // TODO: use this to pass session and module IDs to the worker, instead of polluting process.env
@@ -282,7 +274,7 @@ function getSortWrapper (sort) {
         isTestManagementTestsEnabled = false
         log.error('Could not get test management tests.')
       } else {
-        testManagementTests = receivedTestManagementTests
+        const testManagementTests = receivedTestManagementTests
         try {
           const workspaceProject = this.ctx.getCoreWorkspaceProject()
           workspaceProject._provided._ddIsTestManagementTestsEnabled = isTestManagementTestsEnabled
@@ -295,12 +287,10 @@ function getSortWrapper (sort) {
     }
 
     if (isImpactedTestsEnabled) {
-      const { err, modifiedTests: receivedModifiedTests } = await getChannelPromise(impactedTestsCh)
+      const { err, modifiedTests } = await getChannelPromise(impactedTestsCh)
       if (err) {
-        isImpactedTestsEnabled = false
         log.error('Could not get modified tests.')
       } else {
-        modifiedTests = receivedModifiedTests
         try {
           const workspaceProject = this.ctx.getCoreWorkspaceProject()
           workspaceProject._provided._ddIsImpactedTestsEnabled = isImpactedTestsEnabled
@@ -338,16 +328,14 @@ function getSortWrapper (sort) {
         error = new Error(`Test suites failed: ${failedSuites.length}.`)
       }
 
-      sessionAsyncResource.runInAsyncScope(() => {
-        testSessionFinishCh.publish({
-          status: getSessionStatus(this.state),
-          testCodeCoverageLinesTotal,
-          error,
-          isEarlyFlakeDetectionEnabled,
-          isEarlyFlakeDetectionFaulty,
-          isTestManagementTestsEnabled,
-          onFinish
-        })
+      testSessionFinishCh.publish({
+        status: getSessionStatus(this.state),
+        testCodeCoverageLinesTotal,
+        error,
+        isEarlyFlakeDetectionEnabled,
+        isEarlyFlakeDetectionFaulty,
+        isTestManagementTestsEnabled,
+        onFinish
       })
 
       await flushPromise
@@ -364,10 +352,8 @@ function getCreateCliWrapper (vitestPackage, frameworkVersion) {
     if (!testSessionStartCh.hasSubscribers) {
       return oldCreateCli.apply(this, arguments)
     }
-    sessionAsyncResource.runInAsyncScope(() => {
-      const processArgv = process.argv.slice(2).join(' ')
-      testSessionStartCh.publish({ command: `vitest ${processArgv}`, frameworkVersion })
-    })
+    const processArgv = process.argv.slice(2).join(' ')
+    testSessionStartCh.publish({ command: `vitest ${processArgv}`, frameworkVersion })
     return oldCreateCli.apply(this, arguments)
   })
 

package/packages/datadog-plugin-avsc/src/schema_iterator.js

@@ -104,21 +104,21 @@ class SchemaExtractor {
         }
       }
       return true
-    } else {
-      if (!builder.shouldExtractSchema(schemaName, depth)) {
-        return false
-      }
-      if (schema.fields?.[Symbol.iterator]) {
-        for (const field of schema.fields) {
-          if (!this.extractProperty(field, schemaName, field.name, builder, depth)) {
-            log.warn('DSM: Unable to extract field with name: %s from Avro schema with name: %s', field.name,
-              schemaName)
-          }
+    }
+    if (!builder.shouldExtractSchema(schemaName, depth)) {
+      return false
+    }
+    if (schema.fields?.[Symbol.iterator]) {
+      for (const field of schema.fields) {
+        if (!this.extractProperty(field, schemaName, field.name, builder, depth)) {
+          log.warn('DSM: Unable to extract field with name: %s from Avro schema with name: %s', field.name,
+            schemaName)
         }
-      } else {
-        log.warn('DSM: schema.fields is not iterable from Avro schema with name: %s', schemaName)
       }
+    } else {
+      log.warn('DSM: schema.fields is not iterable from Avro schema with name: %s', schemaName)
     }
+
     return true
   }
 

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

@@ -6,6 +6,7 @@ const { storage } = require('../../datadog-core')
 const { isTrue } = require('../../dd-trace/src/util')
 const coalesce = require('koalas')
 const { tagsFromRequest, tagsFromResponse } = require('../../dd-trace/src/payload-tagging')
+const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 
 class BaseAwsSdkPlugin extends ClientPlugin {
   static get id () { return 'aws' }
@@ -132,7 +133,7 @@ class BaseAwsSdkPlugin extends ClientPlugin {
 
   isEnabled (request) {
     const serviceId = this.serviceIdentifier.toUpperCase()
-    const envVarValue = process.env[`DD_TRACE_AWS_SDK_${serviceId}_ENABLED`]
+    const envVarValue = getEnvironmentVariable(`DD_TRACE_AWS_SDK_${serviceId}_ENABLED`)
     return envVarValue ? isTrue(envVarValue) : true
   }
 
@@ -142,11 +143,12 @@ class BaseAwsSdkPlugin extends ClientPlugin {
     const operation = response.request.operation
     const extraTags = this.generateTags(params, operation, response) || {}
 
-    const tags = Object.assign({
+    const tags = {
       'aws.response.request_id': response.requestId,
       'resource.name': operation,
-      'span.kind': 'client'
-    }, extraTags)
+      'span.kind': 'client',
+      ...extraTags
+    }
 
     span.addTags(tags)
 
@@ -211,19 +213,21 @@ function normalizeConfig (config, serviceIdentifier) {
   const batchPropagationEnabled = isTrue(
     coalesce(
       specificConfig.batchPropagationEnabled,
-      process.env[`DD_TRACE_AWS_SDK_${serviceId}_BATCH_PROPAGATION_ENABLED`],
+      getEnvironmentVariable(`DD_TRACE_AWS_SDK_${serviceId}_BATCH_PROPAGATION_ENABLED`),
       config.batchPropagationEnabled,
-      process.env.DD_TRACE_AWS_SDK_BATCH_PROPAGATION_ENABLED,
+      getEnvironmentVariable('DD_TRACE_AWS_SDK_BATCH_PROPAGATION_ENABLED'),
       false
     )
   )
 
   // Merge the specific config back into the main config
-  return Object.assign({}, config, specificConfig, {
+  return {
+    ...config,
+    ...specificConfig,
     splitByAwsService: config.splitByAwsService !== false,
     batchPropagationEnabled,
     hooks
-  })
+  }
 }
 
 const noop = () => {}

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

@@ -6,15 +6,13 @@ class CloudwatchLogs extends BaseAwsSdkPlugin {
   static get id () { return 'cloudwatchlogs' }
 
   generateTags (params, operation) {
-    const tags = {}
+    if (!params?.logGroupName) return {}
 
-    if (!params || !params.logGroupName) return tags
-
-    return Object.assign(tags, {
+    return {
       'resource.name': `${operation} ${params.logGroupName}`,
       'aws.cloudwatch.logs.log_group_name': params.logGroupName,
       loggroupname: params.logGroupName
-    })
+    }
   }
 }
 

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

@@ -14,40 +14,32 @@ class DynamoDb extends BaseAwsSdkPlugin {
     const tags = {}
 
     if (params) {
-      if (params.TableName) {
-        Object.assign(tags, {
-          'resource.name': `${operation} ${params.TableName}`,
-          'aws.dynamodb.table_name': params.TableName,
-          tablename: params.TableName
-        })
-      }
+      let tableName = params.TableName
 
-      // batch operations have different format, collect table name for batch
+      // Collect table name for batch operations which have different format
       // https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html#batchGetItem-property`
       // dynamoDB batch TableName
       if (params.RequestItems !== null && typeof params.RequestItems === 'object') {
         const requestItemsKeys = Object.keys(params.RequestItems)
         if (requestItemsKeys.length === 1) {
-          const tableName = requestItemsKeys[0]
-
-          // also add span type to match serverless convention
-          Object.assign(tags, {
-            'resource.name': `${operation} ${tableName}`,
-            'aws.dynamodb.table_name': tableName,
-            tablename: tableName
-          })
+          tableName = requestItemsKeys[0]
         }
       }
 
+      if (tableName) {
+        // Also add span type to match serverless convention
+        tags['resource.name'] = `${operation} ${tableName}`
+        tags['aws.dynamodb.table_name'] = tableName
+        tags.tablename = tableName
+      }
+
       // TODO: DynamoDB.DocumentClient does batches on multiple tables
       // https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#batchGet-property
       // it may be useful to have a different resource naming convention here to show all table names
     }
 
-    // also add span type to match serverless convention
-    Object.assign(tags, {
-      'span.type': 'dynamodb'
-    })
+    // Also add span type to match serverless convention
+    tags['span.type'] = 'dynamodb'
 
     return tags
   }

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

@@ -35,11 +35,10 @@ class Kinesis extends BaseAwsSdkPlugin {
           obj.needsFinish = true
           const options = {
             childOf: responseExtraction.maybeChildOf,
-            tags: Object.assign(
-              {},
-              this.requestTags.get(request) || {},
-              { 'span.kind': 'server' }
-            )
+            tags: {
+              ...this.requestTags.get(request),
+              'span.kind': 'server'
+            }
           }
           span = plugin.tracer.startSpan('aws.response', options)
           this.enter(span, store)

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

@@ -7,15 +7,13 @@ class Lambda extends BaseAwsSdkPlugin {
   static get id () { return 'lambda' }
 
   generateTags (params, operation, response) {
-    const tags = {}
+    if (!params?.FunctionName) return {}
 
-    if (!params || !params.FunctionName) return tags
-
-    return Object.assign(tags, {
+    return {
       'resource.name': `${operation} ${params.FunctionName}`,
       functionname: params.FunctionName,
       'aws.lambda': params.FunctionName
-    })
+    }
   }
 
   requestInject (span, request) {

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

@@ -6,15 +6,13 @@ class Redshift extends BaseAwsSdkPlugin {
   static get id () { return 'redshift' }
 
   generateTags (params, operation, response) {
-    const tags = {}
+    if (!params?.ClusterIdentifier) return {}
 
-    if (!params || !params.ClusterIdentifier) return tags
-
-    return Object.assign(tags, {
+    return {
       'resource.name': `${operation} ${params.ClusterIdentifier}`,
       'aws.redshift.cluster_identifier': params.ClusterIdentifier,
       clusteridentifier: params.ClusterIdentifier
-    })
+    }
   }
 }
 

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

@@ -11,15 +11,13 @@ class S3 extends BaseAwsSdkPlugin {
   static get isPayloadReporter () { return true }
 
   generateTags (params, operation, response) {
-    const tags = {}
+    if (!params?.Bucket) return {}
 
-    if (!params || !params.Bucket) return tags
-
-    return Object.assign(tags, {
+    return {
       'resource.name': `${operation} ${params.Bucket}`,
       'aws.s3.bucket_name': params.Bucket,
       bucketname: params.Bucket
-    })
+    }
   }
 
   addSpanPointers (span, response) {

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

@@ -74,8 +74,7 @@ class Sns extends BaseAwsSdkPlugin {
   injectToMessage (span, params, topicArn, injectTraceContext) {
     if (!params.MessageAttributes) {
       params.MessageAttributes = {}
-    }
-    if (Object.keys(params.MessageAttributes).length >= 10) { // SNS quota
+    } else if (Object.keys(params.MessageAttributes).length >= 10) { // SNS quota
       log.info('Message attributes full, skipping trace context injection')
       return
     }