dd-trace 3.12.1 → 3.13.0

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

@@ -0,0 +1,236 @@
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const testStartCh = channel('ci:playwright:test:start')
+const testFinishCh = channel('ci:playwright:test:finish')
+
+const testSessionStartCh = channel('ci:playwright:session:start')
+const testSessionFinishCh = channel('ci:playwright:session:finish')
+
+const testSuiteStartCh = channel('ci:playwright:test-suite:start')
+const testSuiteFinishCh = channel('ci:playwright:test-suite:finish')
+
+const testToAr = new WeakMap()
+const testSuiteToAr = new Map()
+const testSuiteToTestStatuses = new Map()
+
+let startedSuites = []
+
+const STATUS_TO_TEST_STATUS = {
+  passed: 'pass',
+  failed: 'fail',
+  timedOut: 'fail',
+  skipped: 'skip'
+}
+
+let remainingTestsByFile = {}
+
+function getTestsBySuiteFromTestsById (testsById) {
+  const testsByTestSuite = {}
+  for (const { test } of testsById.values()) {
+    const { _requireFile } = test
+    if (test._type === 'beforeAll' || test._type === 'afterAll') {
+      continue
+    }
+    if (testsByTestSuite[_requireFile]) {
+      testsByTestSuite[_requireFile].push(test)
+    } else {
+      testsByTestSuite[_requireFile] = [test]
+    }
+  }
+  return testsByTestSuite
+}
+
+function getPlaywrightConfig (playwrightRunner) {
+  try {
+    return playwrightRunner._configLoader.fullConfig()
+  } catch (e) {
+    try {
+      return playwrightRunner._loader.fullConfig()
+    } catch (e) {
+      return {}
+    }
+  }
+}
+
+function getRootDir (playwrightRunner) {
+  const config = getPlaywrightConfig(playwrightRunner)
+  if (config.rootDir) {
+    return config.rootDir
+  }
+  if (playwrightRunner._configDir) {
+    return playwrightRunner._configDir
+  }
+  return process.cwd()
+}
+
+function testBeginHandler (test) {
+  const { title: testName, location: { file: testSuiteAbsolutePath }, _type } = test
+
+  if (_type === 'beforeAll' || _type === 'afterAll') {
+    return
+  }
+
+  const isNewTestSuite = !startedSuites.includes(testSuiteAbsolutePath)
+
+  if (isNewTestSuite) {
+    startedSuites.push(testSuiteAbsolutePath)
+    const testSuiteAsyncResource = new AsyncResource('bound-anonymous-fn')
+    testSuiteToAr.set(testSuiteAbsolutePath, testSuiteAsyncResource)
+    testSuiteAsyncResource.runInAsyncScope(() => {
+      testSuiteStartCh.publish(testSuiteAbsolutePath)
+    })
+  }
+
+  const testAsyncResource = new AsyncResource('bound-anonymous-fn')
+  testToAr.set(test, testAsyncResource)
+  testAsyncResource.runInAsyncScope(() => {
+    testStartCh.publish({ testName, testSuiteAbsolutePath })
+  })
+}
+
+function testEndHandler (test, testStatus, error) {
+  const { location: { file: testSuiteAbsolutePath }, results, _type } = test
+
+  if (_type === 'beforeAll' || _type === 'afterAll') {
+    return
+  }
+
+  const testResult = results[results.length - 1]
+  const testAsyncResource = testToAr.get(test)
+  testAsyncResource.runInAsyncScope(() => {
+    testFinishCh.publish({ testStatus, steps: testResult.steps, error })
+  })
+
+  if (!testSuiteToTestStatuses.has(testSuiteAbsolutePath)) {
+    testSuiteToTestStatuses.set(testSuiteAbsolutePath, [testStatus])
+  } else {
+    testSuiteToTestStatuses.get(testSuiteAbsolutePath).push(testStatus)
+  }
+
+  remainingTestsByFile[testSuiteAbsolutePath] = remainingTestsByFile[testSuiteAbsolutePath]
+    .filter(currentTest => currentTest !== test)
+
+  if (!remainingTestsByFile[testSuiteAbsolutePath].length) {
+    const testStatuses = testSuiteToTestStatuses.get(testSuiteAbsolutePath)
+
+    let testSuiteStatus = 'pass'
+    if (testStatuses.some(status => status === 'fail')) {
+      testSuiteStatus = 'fail'
+    } else if (testStatuses.every(status => status === 'skip')) {
+      testSuiteStatus = 'skip'
+    }
+
+    const testSuiteAsyncResource = testSuiteToAr.get(testSuiteAbsolutePath)
+    testSuiteAsyncResource.runInAsyncScope(() => {
+      testSuiteFinishCh.publish(testSuiteStatus)
+    })
+  }
+}
+
+function dispatcherRunWrapper (run) {
+  return function () {
+    remainingTestsByFile = getTestsBySuiteFromTestsById(this._testById)
+    return run.apply(this, arguments)
+  }
+}
+
+function dispatcherHook (dispatcherExport) {
+  shimmer.wrap(dispatcherExport.Dispatcher.prototype, 'run', dispatcherRunWrapper)
+  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)
+      } else if (method === 'testEnd') {
+        const { test } = dispatcher._testById.get(params.testId)
+
+        const { results } = test
+        const testResult = results[results.length - 1]
+
+        testEndHandler(test, STATUS_TO_TEST_STATUS[testResult.status], testResult.error)
+      }
+    })
+
+    return worker
+  })
+  return dispatcherExport
+}
+
+function dispatcherHookNew (dispatcherExport) {
+  shimmer.wrap(dispatcherExport.Dispatcher.prototype, 'run', dispatcherRunWrapper)
+  shimmer.wrap(dispatcherExport.Dispatcher.prototype, '_createWorker', createWorker => function () {
+    const dispatcher = this
+    const worker = createWorker.apply(this, arguments)
+
+    worker.on('testBegin', ({ testId }) => {
+      const { test } = dispatcher._testById.get(testId)
+      testBeginHandler(test)
+    })
+    worker.on('testEnd', ({ testId, status, errors }) => {
+      const { test } = dispatcher._testById.get(testId)
+
+      testEndHandler(test, STATUS_TO_TEST_STATUS[status], errors && errors[0])
+    })
+
+    return worker
+  })
+  return dispatcherExport
+}
+
+function runnerHook (runnerExport) {
+  shimmer.wrap(runnerExport.Runner.prototype, 'runAllTests', runAllTests => async function () {
+    const testSessionAsyncResource = new AsyncResource('bound-anonymous-fn')
+    const { version: frameworkVersion } = getPlaywrightConfig(this)
+
+    const rootDir = getRootDir(this)
+
+    const processArgv = process.argv.slice(2).join(' ')
+    const command = `playwright ${processArgv}`
+    testSessionAsyncResource.runInAsyncScope(() => {
+      testSessionStartCh.publish({ command, frameworkVersion, rootDir })
+    })
+
+    const res = await runAllTests.apply(this, arguments)
+    const sessionStatus = STATUS_TO_TEST_STATUS[res.status]
+
+    let onDone
+
+    const flushWait = new Promise(resolve => {
+      onDone = resolve
+    })
+
+    testSessionAsyncResource.runInAsyncScope(() => {
+      testSessionFinishCh.publish({ status: sessionStatus, onDone })
+    })
+    await flushWait
+
+    startedSuites = []
+    remainingTestsByFile = {}
+
+    return res
+  })
+
+  return runnerExport
+}
+
+addHook({
+  name: '@playwright/test',
+  file: 'lib/runner.js',
+  versions: ['>=1.18.0']
+}, runnerHook)
+
+addHook({
+  name: '@playwright/test',
+  file: 'lib/dispatcher.js',
+  versions: ['>=1.18.0  <1.30.0']
+}, dispatcherHook)
+
+addHook({
+  name: '@playwright/test',
+  file: 'lib/dispatcher.js',
+  versions: ['>=1.30.0']
+}, dispatcherHookNew)

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

@@ -0,0 +1,45 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+
+class FsPlugin extends TracingPlugin {
+  static get name () { return 'fs' }
+  static get operation () { return 'operation' }
+
+  configure (...args) {
+    return super.configure(...args)
+  }
+
+  start ({ operation, ...params }) {
+    if (!this.activeSpan) return this.skip()
+
+    const lowerOp = operation.toLowerCase()
+    const flag = params.flag || params.flags || (params.options && (params.options.flag || params.options.flags))
+    const defaultFlag = ((lowerOp.includes('open') || lowerOp.includes('read')) && 'r') ||
+      (lowerOp.includes('write') && 'w') ||
+      (lowerOp.includes('append') && 'a')
+    const fd = params.fd || (typeof params.file === 'number' && params.file)
+    const path = params.path || params.prefix || params.filename || (typeof params.file === 'string' && params.file)
+    const uid = typeof params.uid === 'number' && params.uid.toString()
+    const gid = typeof params.gid === 'number' && params.gid.toString()
+    const mode = typeof params.mode === 'number' ? params.mode.toString(8) : params.mode
+
+    this.startSpan('fs.operation', {
+      service: this.config.service,
+      resource: operation,
+      kind: 'internal',
+      meta: {
+        'file.descriptor': (typeof fd === 'object' || typeof fd === 'number') ? fd.toString() : '',
+        'file.dest': params.dest || params.newPath || (params.target && params.path),
+        'file.flag': String(flag || defaultFlag || ''),
+        'file.gid': gid || '',
+        'file.mode': mode,
+        'file.path': path || '',
+        'file.src': params.src || params.oldPath || params.existingPath || params.target,
+        'file.uid': uid || ''
+      }
+    })
+  }
+}
+
+module.exports = FsPlugin

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

@@ -8,16 +8,19 @@ const {
   getTestEnvironmentMetadata,
   getTestParentSpan,
   getTestSessionCommonTags,
+  getTestModuleCommonTags,
   getTestSuiteCommonTags,
   TEST_PARAMETERS,
   getCodeOwnersFileEntries,
   TEST_SESSION_ID,
+  TEST_MODULE_ID,
   TEST_SUITE_ID,
   TEST_COMMAND,
   TEST_ITR_TESTS_SKIPPED,
   TEST_SESSION_CODE_COVERAGE_ENABLED,
   TEST_SESSION_ITR_SKIPPING_ENABLED,
-  TEST_CODE_COVERAGE_LINES_TOTAL
+  TEST_CODE_COVERAGE_LINES_TOTAL,
+  TEST_BUNDLE
 } = require('../../dd-trace/src/plugins/util/test')
 const { COMPONENT } = require('../../dd-trace/src/constants')
 
@@ -49,12 +52,12 @@ class JestPlugin extends CiPlugin {
     this.testEnvironmentMetadata = getTestEnvironmentMetadata('jest', this.config)
     this.codeOwnersEntries = getCodeOwnersFileEntries()
 
-    this.addSub('ci:jest:session:start', (command) => {
-      const store = storage.getStore()
+    this.addSub('ci:jest:session:start', ({ command, testFrameworkVersion }) => {
       const childOf = getTestParentSpan(this.tracer)
-      const testSessionSpanMetadata = getTestSessionCommonTags(command, this.tracer._version)
+      const testSessionSpanMetadata = getTestSessionCommonTags(command, testFrameworkVersion)
+      const testModuleSpanMetadata = getTestModuleCommonTags(command, testFrameworkVersion)
 
-      const testSessionSpan = this.tracer.startSpan('jest.test_session', {
+      this.testSessionSpan = this.tracer.startSpan('jest.test_session', {
         childOf,
         tags: {
           [COMPONENT]: this.constructor.name,
@@ -62,7 +65,14 @@ class JestPlugin extends CiPlugin {
           ...testSessionSpanMetadata
         }
       })
-      this.enter(testSessionSpan, store)
+      this.testModuleSpan = this.tracer.startSpan('jest.test_module', {
+        childOf: this.testSessionSpan,
+        tags: {
+          [COMPONENT]: this.constructor.name,
+          ...this.testEnvironmentMetadata,
+          ...testModuleSpanMetadata
+        }
+      })
     })
 
     this.addSub('ci:jest:session:finish', ({
@@ -72,18 +82,18 @@ class JestPlugin extends CiPlugin {
       isCodeCoverageEnabled,
       testCodeCoverageLinesTotal
     }) => {
-      const testSessionSpan = storage.getStore().span
-
-      testSessionSpan.setTag(TEST_STATUS, status)
-      testSessionSpan.setTag(TEST_ITR_TESTS_SKIPPED, isSuitesSkipped ? 'true' : 'false')
-      testSessionSpan.setTag(TEST_SESSION_ITR_SKIPPING_ENABLED, isSuitesSkippingEnabled ? 'true' : 'false')
-      testSessionSpan.setTag(TEST_SESSION_CODE_COVERAGE_ENABLED, isCodeCoverageEnabled ? 'true' : 'false')
+      this.testSessionSpan.setTag(TEST_STATUS, status)
+      this.testSessionSpan.setTag(TEST_ITR_TESTS_SKIPPED, isSuitesSkipped ? 'true' : 'false')
+      this.testSessionSpan.setTag(TEST_SESSION_ITR_SKIPPING_ENABLED, isSuitesSkippingEnabled ? 'true' : 'false')
+      this.testSessionSpan.setTag(TEST_SESSION_CODE_COVERAGE_ENABLED, isCodeCoverageEnabled ? 'true' : 'false')
 
       if (testCodeCoverageLinesTotal !== undefined) {
-        testSessionSpan.setTag(TEST_CODE_COVERAGE_LINES_TOTAL, testCodeCoverageLinesTotal)
+        this.testSessionSpan.setTag(TEST_CODE_COVERAGE_LINES_TOTAL, testCodeCoverageLinesTotal)
       }
-      testSessionSpan.finish()
-      finishAllTraceSpans(testSessionSpan)
+      this.testModuleSpan.setTag(TEST_STATUS, status)
+      this.testModuleSpan.finish()
+      this.testSessionSpan.finish()
+      finishAllTraceSpans(this.testSessionSpan)
       this.tracer._exporter.flush()
     })
 
@@ -91,21 +101,25 @@ class JestPlugin extends CiPlugin {
     // This subscriber changes the configuration objects from jest to inject the trace id
     // of the test session to the processes that run the test suites.
     this.addSub('ci:jest:session:configuration', configs => {
-      const testSessionSpan = storage.getStore().span
       configs.forEach(config => {
-        config._ddTestSessionId = testSessionSpan.context()._traceId.toString(10)
-        config._ddTestCommand = testSessionSpan.context()._tags[TEST_COMMAND]
+        config._ddTestSessionId = this.testSessionSpan.context().toTraceId()
+        config._ddTestModuleId = this.testModuleSpan.context().toSpanId()
+        config._ddTestCommand = this.testSessionSpan.context()._tags[TEST_COMMAND]
       })
     })
 
     this.addSub('ci:jest:test-suite:start', ({ testSuite, testEnvironmentOptions }) => {
-      const { _ddTestSessionId: testSessionId, _ddTestCommand: testCommand } = testEnvironmentOptions
+      const {
+        _ddTestSessionId: testSessionId,
+        _ddTestCommand: testCommand,
+        _ddTestModuleId: testModuleId
+      } = testEnvironmentOptions
 
       const store = storage.getStore()
 
       const testSessionSpanContext = this.tracer.extract('text_map', {
         'x-datadog-trace-id': testSessionId,
-        'x-datadog-parent-id': '0000000000000000'
+        'x-datadog-parent-id': testModuleId
       })
 
       const testSuiteMetadata = getTestSuiteCommonTags(testCommand, this.tracer._version, testSuite)
@@ -173,14 +187,22 @@ class JestPlugin extends CiPlugin {
   }
 
   startTestSpan (test) {
+    let childOf
     const suiteTags = {}
     const store = storage.getStore()
     const testSuiteSpan = store ? store.span : undefined
     if (testSuiteSpan) {
-      const testSuiteId = testSuiteSpan.context()._spanId.toString(10)
+      const testSuiteId = testSuiteSpan.context().toSpanId()
       suiteTags[TEST_SUITE_ID] = testSuiteId
-      suiteTags[TEST_SESSION_ID] = testSuiteSpan.context()._traceId.toString(10)
+      suiteTags[TEST_SESSION_ID] = testSuiteSpan.context().toTraceId()
+      suiteTags[TEST_MODULE_ID] = testSuiteSpan.context()._parentId.toString(10)
       suiteTags[TEST_COMMAND] = testSuiteSpan.context()._tags[TEST_COMMAND]
+      suiteTags[TEST_BUNDLE] = testSuiteSpan.context()._tags[TEST_COMMAND]
+      // This is a hack to get good time resolution on test events, while keeping
+      // the test event as the root span of its trace.
+      childOf = getTestParentSpan(this.tracer)
+      childOf._trace.startTime = testSuiteSpan.context()._trace.startTime
+      childOf._trace.ticks = testSuiteSpan.context()._trace.ticks
     }
 
     const { suite, name, runner, testParameters } = test
@@ -191,7 +213,7 @@ class JestPlugin extends CiPlugin {
       ...suiteTags
     }
 
-    return super.startTestSpan(name, suite, extraTags)
+    return super.startTestSpan(name, suite, extraTags, childOf)
   }
 }
 

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

@@ -11,9 +11,12 @@ const {
   getTestParentSpan,
   getTestParametersString,
   getTestSessionCommonTags,
+  getTestModuleCommonTags,
   getTestSuiteCommonTags,
   TEST_SUITE_ID,
   TEST_SESSION_ID,
+  TEST_MODULE_ID,
+  TEST_BUNDLE,
   TEST_COMMAND,
   TEST_ITR_TESTS_SKIPPED,
   TEST_SESSION_CODE_COVERAGE_ENABLED,
@@ -48,9 +51,9 @@ class MochaPlugin extends CiPlugin {
       })
     })
 
-    this.addSub('ci:mocha:session:start', (command) => {
+    this.addSub('ci:mocha:session:start', ({ command, frameworkVersion }) => {
       const childOf = getTestParentSpan(this.tracer)
-      const testSessionSpanMetadata = getTestSessionCommonTags(command, this.tracer._version)
+      const testSessionSpanMetadata = getTestSessionCommonTags(command, frameworkVersion)
 
       this.command = command
       this.testSessionSpan = this.tracer.startSpan('mocha.test_session', {
@@ -61,6 +64,16 @@ class MochaPlugin extends CiPlugin {
           ...testSessionSpanMetadata
         }
       })
+
+      const testModuleSpanMetadata = getTestModuleCommonTags(command, frameworkVersion)
+      this.testModuleSpan = this.tracer.startSpan('mocha.test_module', {
+        childOf: this.testSessionSpan,
+        tags: {
+          [COMPONENT]: this.constructor.name,
+          ...this.testEnvironmentMetadata,
+          ...testModuleSpanMetadata
+        }
+      })
     })
 
     this.addSub('ci:mocha:test-suite:start', (suite) => {
@@ -71,7 +84,7 @@ class MochaPlugin extends CiPlugin {
         getTestSuitePath(suite.file, this.sourceRoot)
       )
       const testSuiteSpan = this.tracer.startSpan('mocha.test_suite', {
-        childOf: this.testSessionSpan,
+        childOf: this.testModuleSpan,
         tags: {
           [COMPONENT]: this.constructor.name,
           ...this.testEnvironmentMetadata,
@@ -147,6 +160,8 @@ class MochaPlugin extends CiPlugin {
         this.testSessionSpan.setTag(TEST_SESSION_ITR_SKIPPING_ENABLED, isSuitesSkippingEnabled ? 'true' : 'false')
         this.testSessionSpan.setTag(TEST_SESSION_CODE_COVERAGE_ENABLED, isCodeCoverageEnabled ? 'true' : 'false')
 
+        this.testModuleSpan.setTag(TEST_STATUS, status)
+        this.testModuleSpan.finish()
         this.testSessionSpan.finish()
         finishAllTraceSpans(this.testSessionSpan)
       }
@@ -156,19 +171,32 @@ class MochaPlugin extends CiPlugin {
   }
 
   startTestSpan (test) {
+    const childOf = getTestParentSpan(this.tracer)
+    // This is a hack to get good time resolution on test events, while keeping
+    // the test event as the root span of its trace.
+    childOf._trace.startTime = this.testSessionSpan.context()._trace.startTime
+    childOf._trace.ticks = this.testSessionSpan.context()._trace.ticks
+
     const testSuiteTags = {}
     const testSuiteSpan = this._testSuites.get(test.parent.file)
     if (testSuiteSpan) {
-      const testSuiteId = testSuiteSpan.context()._spanId.toString(10)
+      const testSuiteId = testSuiteSpan.context().toSpanId()
       testSuiteTags[TEST_SUITE_ID] = testSuiteId
     }
 
     if (this.testSessionSpan) {
-      const testSessionId = this.testSessionSpan.context()._traceId.toString(10)
+      const testSessionId = this.testSessionSpan.context().toTraceId()
       testSuiteTags[TEST_SESSION_ID] = testSessionId
       testSuiteTags[TEST_COMMAND] = this.command
     }
 
+    if (this.testModuleSpan) {
+      const testModuleId = this.testModuleSpan.context().toSpanId()
+      testSuiteTags[TEST_MODULE_ID] = testModuleId
+      testSuiteTags[TEST_COMMAND] = this.command
+      testSuiteTags[TEST_BUNDLE] = this.command
+    }
+
     const { file: testSuiteAbsolutePath } = test
     const fullTestName = test.fullTitle()
     const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.sourceRoot)
@@ -182,7 +210,7 @@ class MochaPlugin extends CiPlugin {
       extraTags[TEST_PARAMETERS] = testParametersString
     }
 
-    return super.startTestSpan(fullTestName, testSuite, extraTags)
+    return super.startTestSpan(fullTestName, testSuite, extraTags, childOf)
   }
 }
 

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

@@ -6,22 +6,23 @@ class MySQLPlugin extends DatabasePlugin {
   static get name () { return 'mysql' }
   static get system () { return 'mysql' }
 
-  start ({ sql, conf: dbConfig }) {
-    const service = getServiceName(this.config, dbConfig)
+  start (payload) {
+    const service = getServiceName(this.config, payload.conf)
 
     this.startSpan(`${this.system}.query`, {
       service,
-      resource: sql,
+      resource: payload.sql,
       type: 'sql',
       kind: 'client',
       meta: {
         'db.type': this.system,
-        'db.user': dbConfig.user,
-        'db.name': dbConfig.database,
-        'out.host': dbConfig.host,
-        'out.port': dbConfig.port
+        'db.user': payload.conf.user,
+        'db.name': payload.conf.database,
+        'out.host': payload.conf.host,
+        'out.port': payload.conf.port
       }
     })
+    payload.sql = this.injectDbmQuery(payload.sql, service)
   }
 }