dd-trace 2.4.2 → 2.7.0

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

@@ -1,272 +0,0 @@
-const { promisify } = require('util')
-
-const { RESOURCE_NAME } = require('../../../ext/tags')
-const {
-  TEST_NAME,
-  TEST_SUITE,
-  TEST_STATUS,
-  TEST_FRAMEWORK_VERSION,
-  JEST_TEST_RUNNER,
-  ERROR_MESSAGE,
-  ERROR_TYPE,
-  TEST_PARAMETERS,
-  CI_APP_ORIGIN,
-  getTestEnvironmentMetadata,
-  getTestParametersString,
-  finishAllTraceSpans,
-  getTestSuitePath
-} = require('../../dd-trace/src/plugins/util/test')
-const {
-  getFormattedJestTestParameters,
-  getTestSpanTags,
-  setSuppressedErrors
-} = require('./util')
-
-const originals = new WeakMap()
-
-function getVmContext (environment) {
-  if (typeof environment.getVmContext === 'function') {
-    return environment.getVmContext()
-  }
-  return null
-}
-
-function wrapEnvironment (BaseEnvironment) {
-  return class DatadogJestEnvironment extends BaseEnvironment {
-    constructor (config, context) {
-      super(config, context)
-      this.testSuite = getTestSuitePath(context.testPath, config.rootDir)
-      this.testSpansByTestName = {}
-      this.originalTestFnByTestName = {}
-    }
-  }
-}
-
-function createWrapTeardown (tracer, instrumenter) {
-  return function wrapTeardown (teardown) {
-    return async function teardownWithTrace () {
-      instrumenter.unwrap(this.global.test, 'each')
-      nameToParams = {}
-      // for jest-jasmine2
-      if (this.global.jasmine) {
-        instrumenter.unwrap(this.global.jasmine.Spec.prototype, 'onException')
-        instrumenter.unwrap(this.global, 'it')
-        instrumenter.unwrap(this.global, 'fit')
-        instrumenter.unwrap(this.global, 'xit')
-      }
-
-      instrumenter.unwrap(this.global.test, 'each')
-
-      return teardown.apply(this, arguments).finally(() => {
-        return new Promise(resolve => tracer._exporter._writer.flush(resolve))
-      })
-    }
-  }
-}
-
-let nameToParams = {}
-
-const isTimeout = (event) => {
-  return event.error &&
-  typeof event.error === 'string' &&
-  event.error.startsWith('Exceeded timeout')
-}
-
-function createHandleTestEvent (tracer, testEnvironmentMetadata, instrumenter) {
-  return async function handleTestEventWithTrace (event) {
-    if (event.name === 'test_retry') {
-      let testName = event.test && event.test.name
-      const context = getVmContext(this)
-      if (context) {
-        const { currentTestName } = context.expect.getState()
-        testName = currentTestName
-      }
-      // If it's a retry, we restore the original test function so that it is not wrapped again
-      if (this.originalTestFnByTestName[testName]) {
-        event.test.fn = this.originalTestFnByTestName[testName]
-      }
-      return
-    }
-    if (event.name === 'test_fn_failure') {
-      if (!isTimeout(event)) {
-        return
-      }
-      const context = getVmContext(this)
-      if (context) {
-        const { currentTestName } = context.expect.getState()
-        const testSpan = this.testSpansByTestName[`${currentTestName}_${event.test.invocations}`]
-        if (testSpan) {
-          testSpan.setTag(ERROR_TYPE, 'Timeout')
-          testSpan.setTag(ERROR_MESSAGE, event.error)
-          testSpan.setTag(TEST_STATUS, 'fail')
-        }
-      }
-      return
-    }
-    if (event.name === 'setup') {
-      instrumenter.wrap(this.global.test, 'each', function (original) {
-        return function () {
-          const testParameters = getFormattedJestTestParameters(arguments)
-          const eachBind = original.apply(this, arguments)
-          return function () {
-            const [testName] = arguments
-            nameToParams[testName] = testParameters
-            return eachBind.apply(this, arguments)
-          }
-        }
-      })
-      return
-    }
-
-    if (event.name !== 'test_skip' &&
-      event.name !== 'test_todo' &&
-      event.name !== 'test_start' &&
-      event.name !== 'hook_failure') {
-      return
-    }
-    // for hook_failure events the test entry might not be defined, because the hook
-    // is not necessarily associated to a test:
-    if (!event.test) {
-      return
-    }
-
-    const { childOf, commonSpanTags } = getTestSpanTags(tracer, testEnvironmentMetadata)
-
-    let testName = event.test.name
-    const context = getVmContext(this)
-
-    if (context) {
-      const { currentTestName } = context.expect.getState()
-      testName = currentTestName
-    }
-    const spanTags = {
-      ...commonSpanTags,
-      [TEST_NAME]: testName,
-      [TEST_SUITE]: this.testSuite,
-      [TEST_FRAMEWORK_VERSION]: tracer._version,
-      [JEST_TEST_RUNNER]: 'jest-circus'
-    }
-
-    const testParametersString = getTestParametersString(nameToParams, event.test.name)
-    if (testParametersString) {
-      spanTags[TEST_PARAMETERS] = testParametersString
-    }
-
-    const resource = `${this.testSuite}.${testName}`
-    if (event.name === 'test_skip' || event.name === 'test_todo') {
-      const testSpan = tracer.startSpan(
-        'jest.test',
-        {
-          childOf,
-          tags: {
-            ...spanTags,
-            [RESOURCE_NAME]: resource,
-            [TEST_STATUS]: 'skip'
-          }
-        }
-      )
-      testSpan.context()._trace.origin = CI_APP_ORIGIN
-      testSpan.finish()
-      return
-    }
-    if (event.name === 'hook_failure') {
-      const testSpan = tracer.startSpan(
-        'jest.test',
-        {
-          childOf,
-          tags: {
-            ...spanTags,
-            [RESOURCE_NAME]: resource,
-            [TEST_STATUS]: 'fail'
-          }
-        }
-      )
-      testSpan.context()._trace.origin = CI_APP_ORIGIN
-      if (event.test.errors && event.test.errors.length) {
-        const error = new Error(event.test.errors[0][0])
-        error.stack = event.test.errors[0][1].stack
-        testSpan.setTag('error', error)
-      }
-      testSpan.finish()
-      return
-    }
-    // event.name === test_start at this point
-    const environment = this
-    environment.originalTestFnByTestName[testName] = event.test.fn
-
-    let specFunction = event.test.fn
-    if (specFunction.length) {
-      specFunction = promisify(specFunction)
-    }
-    event.test.fn = tracer.wrap(
-      'jest.test',
-      {
-        type: 'test',
-        childOf,
-        resource,
-        tags: spanTags
-      },
-      async () => {
-        let result
-        const testSpan = tracer.scope().active()
-        environment.testSpansByTestName[`${testName}_${event.test.invocations}`] = testSpan
-        testSpan.context()._trace.origin = CI_APP_ORIGIN
-        try {
-          result = await specFunction()
-          // it may have been set already if the test timed out
-          let suppressedErrors = []
-          const context = getVmContext(environment)
-          if (context) {
-            suppressedErrors = context.expect.getState().suppressedErrors
-          }
-          setSuppressedErrors(suppressedErrors, testSpan)
-          if (!testSpan._spanContext._tags[TEST_STATUS]) {
-            testSpan.setTag(TEST_STATUS, 'pass')
-          }
-        } catch (error) {
-          testSpan.setTag(TEST_STATUS, 'fail')
-          testSpan.setTag('error', error)
-          throw error
-        } finally {
-          finishAllTraceSpans(testSpan)
-        }
-        return result
-      }
-    )
-  }
-}
-
-function patch (Environment, tracer, config) {
-  const testEnvironmentMetadata = getTestEnvironmentMetadata('jest', config)
-  const proto = Environment.prototype
-
-  this.wrap(proto, 'teardown', createWrapTeardown(tracer, this))
-
-  const newHandleTestEvent = createHandleTestEvent(tracer, testEnvironmentMetadata, this)
-  originals.set(newHandleTestEvent, proto.handleTestEvent)
-  proto.handleTestEvent = newHandleTestEvent
-
-  return wrapEnvironment(Environment)
-}
-
-function unpatch (Environment) {
-  const proto = Environment.prototype
-
-  this.unwrap(Environment.prototype, 'teardown')
-  proto.handleTestEvent = originals.get(proto.handleTestEvent)
-}
-
-module.exports = [
-  {
-    name: 'jest-environment-node',
-    versions: ['>=24.8.0'],
-    patch,
-    unpatch
-  },
-  {
-    name: 'jest-environment-jsdom',
-    versions: ['>=24.8.0'],
-    patch,
-    unpatch
-  }
-]

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

@@ -1,185 +0,0 @@
-const { promisify } = require('util')
-
-const { RESOURCE_NAME } = require('../../../ext/tags')
-const {
-  TEST_NAME,
-  TEST_SUITE,
-  TEST_STATUS,
-  TEST_FRAMEWORK_VERSION,
-  JEST_TEST_RUNNER,
-  CI_APP_ORIGIN,
-  getTestEnvironmentMetadata,
-  finishAllTraceSpans,
-  getTestSuitePath
-} = require('../../dd-trace/src/plugins/util/test')
-const { getTestSpanTags, setSuppressedErrors } = require('./util')
-
-function createWrapIt (tracer, globalConfig, globalInput, testEnvironmentMetadata) {
-  return function wrapIt (it) {
-    return function itWithTrace (description, specFunction, timeout) {
-      let oldSpecFunction = specFunction
-      if (specFunction.length) {
-        oldSpecFunction = promisify(oldSpecFunction)
-      }
-
-      const { childOf, commonSpanTags } = getTestSpanTags(tracer, testEnvironmentMetadata)
-
-      const testSuite = getTestSuitePath(globalInput.jasmine.testPath, globalConfig.rootDir)
-
-      const newSpecFunction = tracer.wrap(
-        'jest.test',
-        {
-          type: 'test',
-          childOf,
-          tags: {
-            ...commonSpanTags,
-            [TEST_SUITE]: testSuite,
-            [TEST_FRAMEWORK_VERSION]: tracer._version,
-            [JEST_TEST_RUNNER]: 'jest-jasmine2'
-          }
-        },
-        async (done) => {
-          const testSpan = tracer.scope().active()
-          const { currentTestName } = globalInput.expect.getState()
-          const resource = `${testSuite}.${currentTestName}`
-          testSpan.setTag(TEST_NAME, currentTestName)
-          testSpan.setTag(RESOURCE_NAME, resource)
-          testSpan.context()._trace.origin = CI_APP_ORIGIN
-          let result
-          globalInput.jasmine.testSpanByTestName[currentTestName] = testSpan
-
-          try {
-            result = await oldSpecFunction()
-            const suppressedErrors = globalInput.expect.getState().suppressedErrors
-            setSuppressedErrors(suppressedErrors, testSpan)
-            if (!testSpan._spanContext._tags[TEST_STATUS]) {
-              testSpan.setTag(TEST_STATUS, 'pass')
-            }
-          } catch (error) {
-            testSpan.setTag(TEST_STATUS, 'fail')
-            testSpan.setTag('error', error)
-            if (done) {
-              done(error)
-            }
-            throw error
-          } finally {
-            finishAllTraceSpans(testSpan)
-          }
-          if (done) {
-            done(result)
-          }
-        }
-      )
-      return it(description, newSpecFunction, timeout)
-    }
-  }
-}
-
-function createWrapOnException (tracer, globalInput) {
-  return function wrapOnException (onException) {
-    return function onExceptionWithTrace (err) {
-      let activeTestSpan = tracer.scope().active()
-      if (!activeTestSpan) {
-        activeTestSpan = globalInput.jasmine.testSpanByTestName[this.getFullName()]
-      }
-      if (!activeTestSpan) {
-        return onException.apply(this, arguments)
-      }
-      const {
-        [TEST_NAME]: testName,
-        [TEST_SUITE]: testSuite,
-        [TEST_STATUS]: testStatus
-      } = activeTestSpan._spanContext._tags
-
-      const isActiveSpanFailing = this.getFullName() === testName &&
-        this.result.testPath.endsWith(testSuite)
-
-      if (isActiveSpanFailing && !testStatus) {
-        activeTestSpan.setTag(TEST_STATUS, 'fail')
-        // If we don't do this, jest will show this file on its error message
-        if (err.stack) {
-          const stackFrames = err.stack.split('\n')
-          const filteredStackFrames = stackFrames.filter(frame => !frame.includes(__dirname)).join('\n')
-          err.stack = filteredStackFrames
-        }
-        activeTestSpan.setTag('error', err)
-        // need to manually finish, as it will not be caught in `itWithTrace`
-        activeTestSpan.finish()
-      }
-
-      return onException.apply(this, arguments)
-    }
-  }
-}
-
-function createWrapItSkip (tracer, globalConfig, globalInput, testEnvironmentMetadata) {
-  return function wrapItSkip (it) {
-    return function itSkipWithTrace () {
-      const { childOf, commonSpanTags } = getTestSpanTags(tracer, testEnvironmentMetadata)
-
-      const testSuite = getTestSuitePath(globalInput.jasmine.testPath, globalConfig.rootDir)
-
-      const spec = it.apply(this, arguments)
-
-      const testName = spec.getFullName()
-      const resource = `${testSuite}.${testName}`
-
-      const testSpan = tracer.startSpan(
-        'jest.test',
-        {
-          childOf,
-          tags: {
-            ...commonSpanTags,
-            [RESOURCE_NAME]: resource,
-            [TEST_NAME]: testName,
-            [TEST_SUITE]: testSuite,
-            [TEST_STATUS]: 'skip',
-            [TEST_FRAMEWORK_VERSION]: tracer._version,
-            [JEST_TEST_RUNNER]: 'jest-jasmine2'
-          }
-        }
-      )
-      testSpan.context()._trace.origin = CI_APP_ORIGIN
-      testSpan.finish()
-
-      return spec
-    }
-  }
-}
-
-function createWrapJasmineAsyncInstall (tracer, instrumenter, testEnvironmentMetadata) {
-  return function jasmineAsyncInstallWithTrace (jasmineAsyncInstall) {
-    return function (globalConfig, globalInput) {
-      globalInput.jasmine.testSpanByTestName = {}
-      instrumenter.wrap(globalInput.jasmine.Spec.prototype, 'onException', createWrapOnException(tracer, globalInput))
-      instrumenter.wrap(globalInput, 'it', createWrapIt(tracer, globalConfig, globalInput, testEnvironmentMetadata))
-      // instruments 'it.only'
-      instrumenter.wrap(globalInput, 'fit', createWrapIt(tracer, globalConfig, globalInput, testEnvironmentMetadata))
-      // instruments 'it.skip'
-      instrumenter.wrap(
-        globalInput,
-        'xit',
-        createWrapItSkip(tracer, globalConfig, globalInput, testEnvironmentMetadata)
-      )
-      return jasmineAsyncInstall(globalConfig, globalInput)
-    }
-  }
-}
-
-module.exports = [
-  {
-    name: 'jest-jasmine2',
-    versions: ['>=24.8.0'],
-    file: 'build/jasmineAsyncInstall.js',
-    patch: function (jasmineAsyncInstallExport, tracer, config) {
-      const testEnvironmentMetadata = getTestEnvironmentMetadata('jest', config)
-      return this.wrapExport(
-        jasmineAsyncInstallExport.default,
-        createWrapJasmineAsyncInstall(tracer, this, testEnvironmentMetadata)(jasmineAsyncInstallExport.default)
-      )
-    },
-    unpatch: function (jasmineAsyncInstallExport) {
-      this.unwrapExport(jasmineAsyncInstallExport.default)
-    }
-  }
-]

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

@@ -1,23 +0,0 @@
-'use strict'
-
-const { wrapThen } = require('../../datadog-instrumentations/src/helpers/promise')
-
-function createPatch (file) {
-  return {
-    name: 'knex',
-    versions: ['>=0.8.0'],
-    file,
-    patch (Builder) {
-      this.wrap(Builder.prototype, 'then', wrapThen)
-    },
-    unpatch (Builder) {
-      this.unwrap(Builder.prototype, 'then')
-    }
-  }
-}
-
-module.exports = [
-  createPatch('lib/query/builder.js'),
-  createPatch('lib/raw.js'),
-  createPatch('lib/schema/builder.js')
-]

package/packages/datadog-plugin-limitd-client/src/index.js

@@ -1,30 +0,0 @@
-'use strict'
-
-function createWrapRequest (tracer) {
-  const scope = tracer.scope()
-
-  return function wrapRequest (original) {
-    return function requestWithTrace (request, callback) {
-      const index = arguments.length - 1
-
-      arguments[index] = scope.bind(arguments[index])
-
-      return original.apply(this, arguments)
-    }
-  }
-}
-
-module.exports = [
-  {
-    name: 'limitd-client',
-    versions: ['>=2.8'],
-    patch (LimitdClient, tracer) {
-      this.wrap(LimitdClient.prototype, '_directRequest', createWrapRequest(tracer))
-      this.wrap(LimitdClient.prototype, '_retriedRequest', createWrapRequest(tracer))
-    },
-    unpatch (LimitdClient) {
-      this.unwrap(LimitdClient.prototype, '_directRequest')
-      this.unwrap(LimitdClient.prototype, '_retriedRequest')
-    }
-  }
-]

package/packages/dd-trace/src/exporters/agent/request.js

@@ -1,86 +0,0 @@
-'use strict'
-
-const http = require('http')
-const https = require('https')
-const docker = require('./docker')
-const log = require('../../log')
-const { storage } = require('../../../../datadog-core')
-
-const httpAgent = new http.Agent({ keepAlive: true })
-const httpsAgent = new https.Agent({ keepAlive: true })
-const containerId = docker.id()
-
-function retriableRequest (options, callback, client, data) {
-  const store = storage.getStore()
-
-  storage.enterWith({ noop: true })
-
-  const req = client.request(options, res => {
-    let data = ''
-
-    res.setTimeout(options.timeout)
-
-    res.on('data', chunk => { data += chunk })
-    res.on('end', () => {
-      if (res.statusCode >= 200 && res.statusCode <= 299) {
-        callback(null, data, res.statusCode)
-      } else {
-        const error = new Error(`Error from the agent: ${res.statusCode} ${http.STATUS_CODES[res.statusCode]}`)
-        error.status = res.statusCode
-
-        callback(error, null, res.statusCode)
-      }
-    })
-  })
-  req.setTimeout(options.timeout, req.abort)
-  data.forEach(buffer => req.write(buffer))
-
-  storage.enterWith(store)
-
-  return req
-}
-
-function request (options, callback) {
-  options = Object.assign({
-    headers: {},
-    data: [],
-    timeout: 2000
-  }, options)
-
-  const data = [].concat(options.data)
-  const isSecure = options.protocol === 'https:'
-  const client = isSecure ? https : http
-  const agent = isSecure ? httpsAgent : httpAgent
-
-  options.agent = agent
-  options.headers['Content-Length'] = byteLength(data)
-
-  if (containerId) {
-    options.headers['Datadog-Container-ID'] = containerId
-  }
-  const firstRequest = retriableRequest(options, callback, client, data)
-
-  // The first request will be retried if it fails due to a socket connection close
-  const firstRequestErrorHandler = error => {
-    if (firstRequest.reusedSocket && (error.code === 'ECONNRESET' || error.code === 'EPIPE')) {
-      log.debug('Retrying request due to socket connection error')
-      const retriedReq = retriableRequest(options, callback, client, data)
-      // The retried request will fail normally
-      retriedReq.on('error', e => callback(new Error(`Network error trying to reach the agent: ${e.message}`)))
-      retriedReq.end()
-    } else {
-      callback(new Error(`Network error trying to reach the agent: ${error.message}`))
-    }
-  }
-
-  firstRequest.on('error', firstRequestErrorHandler)
-  firstRequest.end()
-
-  return firstRequest
-}
-
-function byteLength (data) {
-  return data.length > 0 ? data.reduce((prev, next) => prev + next.length, 0) : 0
-}
-
-module.exports = request

package/scripts/postpublish.js

@@ -1,24 +0,0 @@
-'use strict'
-
-const exec = require('./helpers/exec')
-
-const pkg = require('../package.json')
-
-const betaExpr = /\d+\.\d+\.\d+-.*/
-const legacyExpr = /0\.\d+\.\d+/
-
-if (!betaExpr.test(pkg.version) && !legacyExpr.test(pkg.version)) {
-  const releaseBranches = exec.pipe('git fetch && git branch -a | grep -E "/v\\d+\\.x"')
-    .trim()
-    .split(/\s+/)
-  const releaseMajors = releaseBranches
-    .map(branch => parseInt(branch.replace(/[^0-9]/g, '')))
-    .sort()
-    .reverse()
-  const latestMajor = releaseMajors[0]
-  const currentMajor = parseInt(pkg.version.split('.')[0])
-
-  if (currentMajor === latestMajor) {
-    exec(`node scripts/publish_docs.js "v${pkg.version}"`)
-  }
-}