dd-trace 2.4.2 → 2.6.0

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/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