dd-trace 3.3.1 → 3.5.0

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

@@ -1,71 +1,35 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
-const { storage } = require('../../datadog-core')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-
-class ElasticsearchPlugin extends Plugin {
-  static get name () {
-    return 'elasticsearch'
-  }
-
-  constructor (...args) {
-    super(...args)
-
-    this.addSub('apm:elasticsearch:query:start', ({ params }) => {
-      const store = storage.getStore()
-      const childOf = store ? store.span : store
-      const body = getBody(params.body || params.bulkBody)
-      const span = this.tracer.startSpan('elasticsearch.query', {
-        childOf,
-        tags: {
-          'db.type': 'elasticsearch',
-          'span.kind': 'client',
-          'service.name': this.config.service || `${this.tracer._service}-elasticsearch`,
-          'resource.name': `${params.method} ${quantizePath(params.path)}`,
-          'span.type': 'elasticsearch',
-          'elasticsearch.url': params.path,
-          'elasticsearch.method': params.method,
-          'elasticsearch.body': body,
-          'elasticsearch.params': JSON.stringify(params.querystring || params.query)
-        }
-      })
-      analyticsSampler.sample(span, this.config.measured)
-      this.enter(span, store)
-    })
-
-    this.addSub('apm:elasticsearch:query:error', err => {
-      const span = storage.getStore().span
-      span.setTag('error', err)
-    })
-
-    this.addSub('apm:elasticsearch:query:finish', ({ params }) => {
-      const span = storage.getStore().span
-      this.config.hooks.query(span, params)
-      span.finish()
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+
+class ElasticsearchPlugin extends DatabasePlugin {
+  static get name () { return 'elasticsearch' }
+
+  start ({ params }) {
+    const body = getBody(params.body || params.bulkBody)
+
+    this.startSpan('elasticsearch.query', {
+      service: this.config.service,
+      resource: `${params.method} ${quantizePath(params.path)}`,
+      type: 'elasticsearch',
+      kind: 'client',
+      meta: {
+        'db.type': 'elasticsearch',
+        'elasticsearch.url': params.path,
+        'elasticsearch.method': params.method,
+        'elasticsearch.body': body,
+        'elasticsearch.params': JSON.stringify(params.querystring || params.query)
+      }
     })
   }
 
-  configure (config) {
-    return super.configure(normalizeConfig(config))
+  finish ({ params }) {
+    const span = this.activeSpan()
+    this.config.hooks.query(span, params)
+    super.finish({ params })
   }
 }
 
-function normalizeConfig (config) {
-  const hooks = getHooks(config)
-
-  return Object.assign({}, config, {
-    hooks
-  })
-}
-
-function getHooks (config) {
-  const noop = () => {}
-  const query = (config.hooks && config.hooks.query) || noop
-
-  return { query }
-}
-
 function getBody (body) {
   return body && JSON.stringify(body)
 }

package/packages/datadog-plugin-http2/src/server.js

@@ -3,11 +3,52 @@
 // Plugin temporarily disabled. See https://github.com/DataDog/dd-trace-js/issues/312
 
 const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
+const web = require('../../dd-trace/src/plugins/util/web')
+const { incomingHttpRequestStart } = require('../../dd-trace/src/appsec/gateway/channels')
 
 class Http2ServerPlugin extends Plugin {
   static get name () {
     return 'http2'
   }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:http2:server:request:start', ({ req, res }) => {
+      const store = storage.getStore()
+      const span = web.startSpan(this.tracer, this.config, req, res, 'web.request')
+
+      this.enter(span, { ...store, req })
+
+      const context = web.getContext(req)
+
+      if (!context.instrumented) {
+        context.res.writeHead = web.wrapWriteHead(context)
+        context.instrumented = true
+      }
+
+      if (incomingHttpRequestStart.hasSubscribers) {
+        incomingHttpRequestStart.publish({ req, res })
+      }
+    })
+
+    this.addSub('apm:http2:server:request:error', (error) => {
+      web.addError(error)
+    })
+
+    this.addSub('apm:http2:server:request:finish', ({ req }) => {
+      const context = web.getContext(req)
+
+      if (!context || !context.res) return // Not created by a http.Server instance.
+
+      web.finishAll(context)
+    })
+  }
+
+  configure (config) {
+    return super.configure(web.normalizeConfig(config))
+  }
 }
 
 module.exports = Http2ServerPlugin

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

@@ -1,3 +1,5 @@
+const { channel } = require('diagnostics_channel')
+
 const Plugin = require('../../dd-trace/src/plugins/plugin')
 const { storage } = require('../../datadog-core')
 
@@ -17,9 +19,16 @@ const {
   TEST_CODE_OWNERS,
   TEST_SESSION_ID,
   TEST_SUITE_ID,
-  TEST_COMMAND
+  TEST_COMMAND,
+  TEST_ITR_TESTS_SKIPPED,
+  TEST_CODE_COVERAGE_LINES_TOTAL
 } = require('../../dd-trace/src/plugins/util/test')
 
+const { getSkippableSuites } = require('../../dd-trace/src/ci-visibility/intelligent-test-runner/get-skippable-suites')
+const {
+  getItrConfiguration
+} = require('../../dd-trace/src/ci-visibility/intelligent-test-runner/get-itr-configuration')
+
 // https://github.com/facebook/jest/blob/d6ad15b0f88a05816c2fe034dd6900d28315d570/packages/jest-worker/src/types.ts#L38
 const CHILD_MESSAGE_END = 2
 
@@ -46,6 +55,16 @@ class JestPlugin extends Plugin {
   constructor (...args) {
     super(...args)
 
+    const gitMetadataUploadFinishCh = channel('ci:git-metadata-upload:finish')
+    // `gitMetadataPromise` is used to wait until git metadata is uploaded to
+    // proceed with calculating the suites to skip
+    // TODO: add timeout after which the promise is resolved
+    const gitMetadataPromise = new Promise(resolve => {
+      gitMetadataUploadFinishCh.subscribe(err => {
+        resolve(err)
+      })
+    })
+
     // Used to handle the end of a jest worker to be able to flush
     const handler = ([message]) => {
       if (message === CHILD_MESSAGE_END) {
@@ -63,6 +82,76 @@ class JestPlugin extends Plugin {
     this.testEnvironmentMetadata = getTestEnvironmentMetadata('jest', this.config)
     this.codeOwnersEntries = getCodeOwnersFileEntries()
 
+    const {
+      'git.repository_url': repositoryUrl,
+      'git.commit.sha': sha,
+      'os.version': osVersion,
+      'os.platform': osPlatform,
+      'os.architecture': osArchitecture,
+      'runtime.name': runtimeName,
+      'runtime.version': runtimeVersion,
+      'git.branch': gitBranch
+    } = this.testEnvironmentMetadata
+
+    this.addSub('ci:jest:configuration', ({ onResponse, onError }) => {
+      if (!this.config.isAgentlessEnabled || !this.config.isIntelligentTestRunnerEnabled) {
+        onResponse({})
+        return
+      }
+      const testConfiguration = {
+        site: this.config.site,
+        env: this.tracer._env,
+        service: this.config.service || this.tracer._service,
+        repositoryUrl,
+        sha,
+        osVersion,
+        osPlatform,
+        osArchitecture,
+        runtimeName,
+        runtimeVersion,
+        branch: gitBranch
+      }
+      getItrConfiguration(testConfiguration, (err, config) => {
+        if (err) {
+          onError(err)
+        } else {
+          onResponse(config)
+        }
+      })
+    })
+
+    this.addSub('ci:jest:test-suite:skippable', ({ onResponse, onError }) => {
+      if (!this.config.isAgentlessEnabled || !this.config.isIntelligentTestRunnerEnabled) {
+        return onResponse([])
+      }
+      // we only request after git upload has happened, if it didn't fail
+      gitMetadataPromise.then((gitUploadError) => {
+        if (gitUploadError) {
+          return onError(gitUploadError)
+        }
+        const testConfiguration = {
+          site: this.config.site,
+          env: this.tracer._env,
+          service: this.config.service || this.tracer._service,
+          repositoryUrl,
+          sha,
+          osVersion,
+          osPlatform,
+          osArchitecture,
+          runtimeName,
+          runtimeVersion,
+          branch: gitBranch
+        }
+        getSkippableSuites(testConfiguration, (err, skippableTests) => {
+          if (err) {
+            onError(err)
+          } else {
+            onResponse(skippableTests)
+          }
+        })
+      })
+    })
+
     this.addSub('ci:jest:session:start', (command) => {
       if (!this.config.isAgentlessEnabled) {
         return
@@ -81,12 +170,18 @@ class JestPlugin extends Plugin {
       this.enter(testSessionSpan, store)
     })
 
-    this.addSub('ci:jest:session:finish', (status) => {
+    this.addSub('ci:jest:session:finish', ({ status, isTestsSkipped, testCodeCoverageLinesTotal }) => {
       if (!this.config.isAgentlessEnabled) {
         return
       }
       const testSessionSpan = storage.getStore().span
       testSessionSpan.setTag(TEST_STATUS, status)
+      if (isTestsSkipped) {
+        testSessionSpan.setTag(TEST_ITR_TESTS_SKIPPED, 'true')
+      }
+      if (testCodeCoverageLinesTotal !== undefined) {
+        testSessionSpan.setTag(TEST_CODE_COVERAGE_LINES_TOTAL, testCodeCoverageLinesTotal)
+      }
       testSessionSpan.finish()
       finishAllTraceSpans(testSessionSpan)
       this.tracer._exporter._writer.flush()

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

@@ -0,0 +1,10 @@
+'use strict'
+
+const MySQLPlugin = require('../../datadog-plugin-mysql/src')
+
+class MariadbPlugin extends MySQLPlugin {
+  static get name () { return 'mariadb' }
+  static get system () { return 'mariadb' }
+}
+
+module.exports = MariadbPlugin

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

@@ -1,59 +1,24 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
-const { storage } = require('../../datadog-core')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-
-class MemcachedPlugin extends Plugin {
-  static get name () {
-    return 'memcached'
-  }
-
-  constructor (...args) {
-    super(...args)
-
-    this.addSub('apm:memcached:command:start', () => {
-      const store = storage.getStore()
-      const childOf = store ? store.span : store
-      const span = this.tracer.startSpan('memcached.command', {
-        childOf,
-        tags: {
-          'span.kind': 'client',
-          'span.type': 'memcached',
-          'service.name': this.config.service || `${this.tracer._service}-memcached`
-        }
-      })
-
-      analyticsSampler.sample(span, this.config.measured)
-      this.enter(span, store)
-    })
-
-    this.addSub('apm:memcached:command:start:with-args', ({ client, server, query }) => {
-      const span = storage.getStore().span
-      span.addTags({
-        'resource.name': query.type,
-        'memcached.command': query.command
-      })
-
-      const address = getAddress(client, server, query)
-
-      if (address) {
-        span.addTags({
-          'out.host': address[0],
-          'out.port': address[1]
-        })
+const CachePlugin = require('../../dd-trace/src/plugins/cache')
+
+class MemcachedPlugin extends CachePlugin {
+  static get name () { return 'memcached' }
+
+  start ({ client, server, query }) {
+    const address = getAddress(client, server, query)
+
+    this.startSpan('memcached.command', {
+      service: this.config.service,
+      resource: query.type,
+      type: 'memcached',
+      kind: 'client',
+      meta: {
+        'memcached.command': query.command,
+        'out.host': address[0],
+        'out.port': address[1]
       }
     })
-
-    this.addSub('apm:memcached:command:error', err => {
-      const span = storage.getStore().span
-      span.setTag('error', err)
-    })
-
-    this.addSub('apm:memcached:command:finish', () => {
-      const span = storage.getStore().span
-      span.finish()
-    })
   }
 }
 

package/packages/datadog-plugin-mongodb-core/src/index.js

@@ -1,54 +1,26 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
-const { storage } = require('../../datadog-core')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-
-class MongodbCorePlugin extends Plugin {
-  static get name () {
-    return 'mongodb-core'
-  }
-
-  constructor (...args) {
-    super(...args)
-
-    this.addSub(`apm:mongodb:query:start`, ({ ns, ops, options, name }) => {
-      const query = getQuery(ops)
-      const resource = truncate(getResource(ns, query, name))
-      const store = storage.getStore()
-      const childOf = store ? store.span : store
-      const span = this.tracer.startSpan('mongodb.query', {
-        childOf,
-        tags: {
-          'service.name': this.config.service || `${this.tracer._service}-mongodb`,
-          'resource.name': resource,
-          'span.type': 'mongodb',
-          'span.kind': 'client',
-          'db.name': ns
-        }
-      })
-
-      if (query) {
-        span.setTag('mongodb.query', query)
-      }
-
-      if (options && options.host && options.port) {
-        span.addTags({
-          'out.host': options.host,
-          'out.port': options.port
-        })
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+
+class MongodbCorePlugin extends DatabasePlugin {
+  static get name () { return 'mongodb-core' }
+  static get component () { return 'mongodb' }
+
+  start ({ ns, ops, options = {}, name }) {
+    const query = getQuery(ops)
+    const resource = truncate(getResource(ns, query, name))
+
+    this.startSpan('mongodb.query', {
+      service: this.config.service,
+      resource,
+      type: 'mongodb',
+      kind: 'client',
+      meta: {
+        'db.name': ns,
+        'mongodb.query': query,
+        'out.host': options.host,
+        'out.port': options.port
       }
-
-      analyticsSampler.sample(span, this.config.measured)
-      this.enter(span, store)
-    })
-
-    this.addSub(`apm:mongodb:query:error`, err => {
-      storage.getStore().span.setTag('error', err)
-    })
-
-    this.addSub(`apm:mongodb:query:finish`, () => {
-      storage.getStore().span.finish()
     })
   }
 }

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

@@ -1,65 +1,36 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
-const { storage } = require('../../datadog-core')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-
-class MySQLPlugin extends Plugin {
-  static get name () {
-    return 'mysql'
-  }
-
-  constructor (...args) {
-    super(...args)
-
-    this.addSub(`apm:${this.constructor.name}:query:start`, ({ sql, conf: dbConfig }) => {
-      const service = getServiceName(this.tracer, this.config, dbConfig)
-      const store = storage.getStore()
-      const childOf = store ? store.span : store
-      const span = this.tracer.startSpan('mysql.query', {
-        childOf,
-        tags: {
-          'service.name': service,
-          'span.type': 'sql',
-          'span.kind': 'client',
-          'db.type': 'mysql',
-          'db.user': dbConfig.user,
-          'out.host': dbConfig.host,
-          'out.port': dbConfig.port,
-          'resource.name': sql
-        }
-      })
-
-      if (dbConfig.database) {
-        span.setTag('db.name', dbConfig.database)
-      }
-
-      analyticsSampler.sample(span, this.config.measured)
-      this.enter(span, store)
-    })
-
-    this.addSub(`apm:${this.constructor.name}:query:error`, err => {
-      if (err) {
-        const span = storage.getStore().span
-        span.setTag('error', err)
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+
+class MySQLPlugin extends DatabasePlugin {
+  static get name () { return 'mysql' }
+  static get system () { return 'mysql' }
+
+  start ({ sql, conf: dbConfig }) {
+    const service = getServiceName(this.config, dbConfig)
+
+    this.startSpan(`${this.system}.query`, {
+      service,
+      resource: 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
       }
     })
-
-    this.addSub(`apm:${this.constructor.name}:query:finish`, () => {
-      const span = storage.getStore().span
-      span.finish()
-    })
   }
 }
 
-function getServiceName (tracer, config, dbConfig) {
+function getServiceName (config, dbConfig) {
   if (typeof config.service === 'function') {
     return config.service(dbConfig)
-  } else if (config.service) {
-    return config.service
-  } else {
-    return `${tracer._service}-mysql`
   }
+
+  return config.service
 }
 
 module.exports = MySQLPlugin

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

@@ -3,9 +3,7 @@
 const MySQLPlugin = require('../../datadog-plugin-mysql/src')
 
 class MySQL2Plugin extends MySQLPlugin {
-  static get name () {
-    return 'mysql2'
-  }
+  static get name () { return 'mysql2' }
 }
 
 module.exports = MySQL2Plugin

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

@@ -1,72 +1,47 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
-const { storage } = require('../../datadog-core')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
 const log = require('../../dd-trace/src/log')
 
-class OracledbPlugin extends Plugin {
-  static get name () {
-    return 'oracledb'
-  }
+class OracledbPlugin extends DatabasePlugin {
+  static get name () { return 'oracledb' }
+  static get system () { return 'oracle' }
 
-  constructor (...args) {
-    super(...args)
+  start ({ query, connAttrs }) {
+    const service = getServiceName(this.config, connAttrs)
+    const url = getUrl(connAttrs.connectString)
 
-    this.addSub('apm:oracledb:execute:start', ({ query, connAttrs }) => {
-      const service = getServiceName(this.tracer, this.config, connAttrs)
-      let connectStringObj
-      try {
-        connectStringObj = new URL(`http://${connAttrs.connectString}`)
-      } catch (e) {
-        log.error(e)
-      }
-      const tags = {
-        'span.kind': 'client',
-        'span.type': 'sql',
+    this.startSpan('oracle.query', {
+      service,
+      resource: query,
+      type: 'sql',
+      kind: 'client',
+      meta: {
         'sql.query': query,
         'db.user': this.config.user,
-        'resource.name': query,
-        'service.name': service
-      }
-      if (typeof connectStringObj !== 'undefined') {
-        tags['db.instance'] = connectStringObj.pathname.substring(1)
-        tags['db.hostname'] = connectStringObj.hostname
-        tags['db.port'] = connectStringObj.port
-      }
-      const store = storage.getStore()
-      const childOf = store ? store.span : store
-      const span = this.tracer.startSpan('oracle.query', {
-        childOf,
-        tags
-      })
-      analyticsSampler.sample(span, this.config.measured)
-      this.enter(span, store)
-    })
-
-    this.addSub('apm:oracledb:execute:error', err => {
-      const store = storage.getStore()
-      if (store && store.span) {
-        store.span.setTag('error', err)
-      }
-    })
-
-    this.addSub('apm:oracledb:execute:finish', () => {
-      const store = storage.getStore()
-      if (store && store.span) {
-        store.span.finish()
+        'db.instance': url.pathname && url.pathname.substring(1),
+        'db.hostname': url.hostname,
+        'db.port': url.port
       }
     })
   }
 }
 
-function getServiceName (tracer, config, connAttrs) {
+function getServiceName (config, connAttrs) {
   if (typeof config.service === 'function') {
     return config.service(connAttrs)
-  } else if (config.service) {
-    return config.service
-  } else {
-    return `${tracer._service}-oracle`
+  }
+
+  return config.service
+}
+
+// TODO: Avoid creating an error since it's a heavy operation.
+function getUrl (connectString) {
+  try {
+    return new URL(`http://${connectString}`)
+  } catch (e) {
+    log.error(e)
+    return {}
   }
 }