dd-trace 4.18.0 → 5.6.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 = []
 
@@ -73,14 +74,88 @@ function getRootDir (playwrightRunner) {
   if (playwrightRunner._configDir) {
     return playwrightRunner._configDir
   }
-  if (playwrightRunner._config && playwrightRunner._config.config) {
-    return playwrightRunner._config.config.rootDir
+  if (playwrightRunner._config) {
+    return playwrightRunner._config.config?.rootDir || process.cwd()
   }
   return process.cwd()
 }
 
-function testBeginHandler (test) {
-  const { _requireFile: testSuiteAbsolutePath, title: testName, _type, location: { line: testSourceLine } } = test
+function getProjectsFromRunner (runner) {
+  const config = getPlaywrightConfig(runner)
+  return config.projects?.map((project) => {
+    if (project.project) {
+      return project.project
+    }
+    return project
+  })
+}
+
+function getProjectsFromDispatcher (dispatcher) {
+  const newConfig = dispatcher._config?.config?.projects
+  if (newConfig) {
+    return newConfig
+  }
+  // old
+  return dispatcher._loader?.fullConfig()?.projects
+}
+
+function getBrowserNameFromProjects (projects, test) {
+  if (!projects || !test) {
+    return null
+  }
+  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) {
+  const {
+    _requireFile: testSuiteAbsolutePath,
+    title: testName, _type,
+    location: { line: testSourceLine }
+  } = test
 
   if (_type === 'beforeAll' || _type === 'afterAll') {
     return
@@ -100,11 +175,11 @@ function testBeginHandler (test) {
   const testAsyncResource = new AsyncResource('bound-anonymous-fn')
   testToAr.set(test, testAsyncResource)
   testAsyncResource.runInAsyncScope(() => {
-    testStartCh.publish({ testName, testSuiteAbsolutePath, testSourceLine })
+    testStartCh.publish({ testName, testSuiteAbsolutePath, testSourceLine, browserName })
   })
 }
 
-function testEndHandler (test, annotations, testStatus, error) {
+function testEndHandler (test, annotations, testStatus, error, isTimeout) {
   let annotationTags
   if (annotations.length) {
     annotationTags = parseAnnotations(annotations)
@@ -112,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
   }
 
@@ -121,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)
 
@@ -140,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 })
     })
   }
 }
@@ -166,18 +252,20 @@ function dispatcherHook (dispatcherExport) {
   shimmer.wrap(dispatcherExport.Dispatcher.prototype, '_createWorker', createWorker => function () {
     const dispatcher = this
     const worker = createWorker.apply(this, arguments)
-
     worker.process.on('message', ({ method, params }) => {
       if (method === 'testBegin') {
         const { test } = dispatcher._testById.get(params.testId)
-        testBeginHandler(test)
+        const projects = getProjectsFromDispatcher(dispatcher)
+        const browser = getBrowserNameFromProjects(projects, test)
+        testBeginHandler(test, browser)
       } else if (method === 'testEnd') {
         const { test } = dispatcher._testById.get(params.testId)
 
         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)
       }
     })
 
@@ -203,12 +291,15 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
 
     worker.on('testBegin', ({ testId }) => {
       const test = getTestByTestId(dispatcher, testId)
-      testBeginHandler(test)
+      const projects = getProjectsFromDispatcher(dispatcher)
+      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
@@ -226,6 +317,7 @@ function runnerHook (runnerExport, playwrightVersion) {
     testSessionAsyncResource.runInAsyncScope(() => {
       testSessionStartCh.publish({ command, frameworkVersion: playwrightVersion, rootDir })
     })
+    const projects = getProjectsFromRunner(this)
 
     const runAllTestsReturn = await runAllTests.apply(this, arguments)
 
@@ -234,7 +326,8 @@ function runnerHook (runnerExport, playwrightVersion) {
       // there were tests that did not go through `testBegin` or `testEnd`,
       // because they were skipped
       tests.forEach(test => {
-        testBeginHandler(test)
+        const browser = getBrowserNameFromProjects(projects, test)
+        testBeginHandler(test, browser)
         testEndHandler(test, [], 'skip')
       })
     })
@@ -295,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-instrumentations/src/restify.js

@@ -50,7 +50,20 @@ function wrapFn (fn) {
     enterChannel.publish({ req, route })
 
     try {
-      return fn.apply(this, arguments)
+      const result = fn.apply(this, arguments)
+      if (result && typeof result === 'object' && typeof result.then === 'function') {
+        return result.then(function () {
+          nextChannel.publish({ req })
+          finishChannel.publish({ req })
+          return arguments[0]
+        }).catch(function (error) {
+          errorChannel.publish({ req, error })
+          nextChannel.publish({ req })
+          finishChannel.publish({ req })
+          throw error
+        })
+      }
+      return result
     } catch (error) {
       errorChannel.publish({ req, error })
       nextChannel.publish({ req })

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

@@ -22,7 +22,7 @@ const dispatchReceiveCh = channel('apm:rhea:receive:dispatch')
 const errorReceiveCh = channel('apm:rhea:receive:error')
 const finishReceiveCh = channel('apm:rhea:receive:finish')
 
-const contexts = new WeakMap()
+const contexts = new WeakMap() // key: delivery Fn, val: context
 
 addHook({ name: 'rhea', versions: ['>=1'] }, rhea => {
   shimmer.wrap(rhea.message, 'encode', encode => function (msg) {
@@ -52,7 +52,8 @@ addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/link.js' }, obj => {
       startSendCh.publish({ targetAddress, host, port, msg })
       const delivery = send.apply(this, arguments)
       const context = {
-        asyncResource
+        asyncResource,
+        connection: this.connection
       }
       contexts.set(delivery, context)
 
@@ -80,7 +81,8 @@ addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/link.js' }, obj => {
 
         if (msgObj.delivery) {
           const context = {
-            asyncResource
+            asyncResource,
+            connection: this.connection
           }
           contexts.set(msgObj.delivery, context)
           msgObj.delivery.update = wrapDeliveryUpdate(msgObj.delivery, msgObj.delivery.update)
@@ -114,7 +116,7 @@ addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/connection.js' }, Connecti
 
           asyncResource.runInAsyncScope(() => {
             errorReceiveCh.publish(error)
-            beforeFinish(delivery, null)
+            exports.beforeFinish(delivery, null)
             finishReceiveCh.publish()
           })
         })
@@ -187,7 +189,7 @@ function patchCircularBuffer (proto, Session) {
                 const state = remoteState && remoteState.constructor
                   ? entry.remote_state.constructor.composite_type : undefined
                 asyncResource.runInAsyncScope(() => {
-                  beforeFinish(entry, state)
+                  exports.beforeFinish(entry, state)
                   finishSendCh.publish()
                 })
               }
@@ -217,13 +219,13 @@ function addToInFlightDeliveries (connection, delivery) {
 }
 
 function beforeFinish (delivery, state) {
-  const obj = contexts.get(delivery)
-  if (obj) {
+  const context = contexts.get(delivery)
+  if (context) {
     if (state) {
       dispatchReceiveCh.publish({ state })
     }
-    if (obj.connection && obj.connection[inFlightDeliveries]) {
-      obj.connection[inFlightDeliveries].delete(delivery)
+    if (context.connection && context.connection[inFlightDeliveries]) {
+      context.connection[inFlightDeliveries].delete(delivery)
     }
   }
 }
@@ -238,3 +240,7 @@ function getStateFromData (stateData) {
     }
   }
 }
+
+module.exports.inFlightDeliveries = inFlightDeliveries
+module.exports.beforeFinish = beforeFinish
+module.exports.contexts = contexts

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

@@ -0,0 +1,113 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+
+const AEROSPIKE_PEER_SERVICE = 'aerospike.namespace'
+
+class AerospikePlugin extends DatabasePlugin {
+  static get id () { return 'aerospike' }
+  static get operation () { return 'command' }
+  static get system () { return 'aerospike' }
+  static get prefix () {
+    return 'tracing:apm:aerospike:command'
+  }
+
+  static get peerServicePrecursors () {
+    return [AEROSPIKE_PEER_SERVICE]
+  }
+
+  bindStart (ctx) {
+    const { commandName, commandArgs } = ctx
+    const resourceName = commandName.slice(0, commandName.indexOf('Command'))
+    const store = storage.getStore()
+    const childOf = store ? store.span : null
+    const meta = getMeta(resourceName, commandArgs)
+
+    const span = this.startSpan(this.operationName(), {
+      childOf,
+      service: this.serviceName({ pluginConfig: this.config }),
+      type: 'aerospike',
+      kind: 'client',
+      resource: resourceName,
+      meta
+    }, false)
+
+    ctx.parentStore = store
+    ctx.currentStore = { ...store, span }
+
+    return ctx.currentStore
+  }
+
+  bindAsyncStart (ctx) {
+    if (ctx.currentStore) {
+      // have to manually trigger peer service calculation when using tracing channel
+      this.tagPeerService(ctx.currentStore.span)
+      ctx.currentStore.span.finish()
+    }
+    return ctx.parentStore
+  }
+
+  end (ctx) {
+    if (ctx.result) {
+      // have to manually trigger peer service calculation when using tracing channel
+      this.tagPeerService(ctx.currentStore.span)
+      ctx.currentStore.span.finish()
+    }
+  }
+
+  error (ctx) {
+    if (ctx.error) {
+      const error = ctx.error
+      const span = ctx.currentStore.span
+      span.setTag('error', error)
+    }
+  }
+}
+
+function getMeta (resourceName, commandArgs) {
+  let meta = {}
+  if (resourceName.includes('Index')) {
+    const [ns, set, bin, index] = commandArgs
+    meta = getMetaForIndex(ns, set, bin, index)
+  } else if (resourceName === 'Query') {
+    const { ns, set } = commandArgs[2]
+    meta = getMetaForQuery({ ns, set })
+  } else if (isKeyObject(commandArgs[0])) {
+    const { ns, set, key } = commandArgs[0]
+    meta = getMetaForKey(ns, set, key)
+  }
+  return meta
+}
+
+function getMetaForIndex (ns, set, bin, index) {
+  return {
+    [AEROSPIKE_PEER_SERVICE]: ns,
+    'aerospike.setname': set,
+    'aerospike.bin': bin,
+    'aerospike.index': index
+  }
+}
+
+function getMetaForKey (ns, set, key) {
+  return {
+    'aerospike.key': `${ns}:${set}:${key}`,
+    [AEROSPIKE_PEER_SERVICE]: ns,
+    'aerospike.setname': set,
+    'aerospike.userkey': key
+  }
+}
+
+function getMetaForQuery (queryObj) {
+  const { ns, set } = queryObj
+  return {
+    [AEROSPIKE_PEER_SERVICE]: ns,
+    'aerospike.setname': set
+  }
+}
+
+function isKeyObject (obj) {
+  return obj && obj.ns !== undefined && obj.set !== undefined && obj.key !== undefined
+}
+
+module.exports = AerospikePlugin

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

@@ -2,6 +2,8 @@
 
 const { TEXT_MAP } = require('../../../ext/formats')
 const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
+const { getAmqpMessageSize } = require('../../dd-trace/src/datastreams/processor')
+const { DsmPathwayCodec } = require('../../dd-trace/src/datastreams/pathway')
 const { getResourceName } = require('./util')
 
 class AmqplibConsumerPlugin extends ConsumerPlugin {
@@ -13,7 +15,7 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
 
     const childOf = extract(this.tracer, message)
 
-    this.startSpan({
+    const span = this.startSpan({
       childOf,
       resource: getResourceName(method, fields),
       type: 'worker',
@@ -26,6 +28,17 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
         'amqp.destination': fields.destination
       }
     })
+
+    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.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,13 +3,15 @@
 const { TEXT_MAP } = require('../../../ext/formats')
 const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const { DsmPathwayCodec } = require('../../dd-trace/src/datastreams/pathway')
+const { getAmqpMessageSize } = require('../../dd-trace/src/datastreams/processor')
 const { getResourceName } = require('./util')
 
 class AmqplibProducerPlugin extends ProducerPlugin {
   static get id () { return 'amqplib' }
   static get operation () { return 'command' }
 
-  start ({ channel = {}, method, fields }) {
+  start ({ channel = {}, method, fields, message }) {
     if (method !== 'basic.publish') return
 
     const stream = (channel.connection && channel.connection.stream) || {}
@@ -30,6 +32,16 @@ class AmqplibProducerPlugin extends ProducerPlugin {
     fields.headers = fields.headers || {}
 
     this.tracer.inject(span, TEXT_MAP, fields.headers)
+
+    if (this.config.dsmEnabled) {
+      const hasRoutingKey = fields.routingKey != null
+      const payloadSize = getAmqpMessageSize({ content: message, headers: fields.headers })
+      const dataStreamsContext = this.tracer
+        .setCheckpoint(
+          ['direction:out', `exchange:${fields.exchange}`, `has_routing_key:${hasRoutingKey}`, 'type:rabbitmq']
+          , span, payloadSize)
+      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 })
       }
     }