dd-trace 2.3.1 → 2.4.2

package/packages/datadog-plugin-cassandra-driver/src/index.js

@@ -1,181 +1,75 @@
 'use strict'
 
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-const tx = require('../../dd-trace/src/plugins/util/tx')
 
-function createWrapInnerExecute (tracer, config) {
-  const isValid = (args) => {
-    return args.length === 4 || typeof args[3] === 'function'
+class CassandraDriverPlugin extends Plugin {
+  static get name () {
+    return 'cassandra-driver'
   }
+  constructor (...args) {
+    super(...args)
 
-  return function wrapInnerExecute (_innerExecute) {
-    return function _innerExecuteWithTrace (query, params, execOptions, callback) {
-      if (!isValid(arguments)) {
-        return _innerExecute.apply(this, arguments)
-      }
-
-      const scope = tracer.scope()
-      const span = start(tracer, config, this, query)
-
-      return scope.bind(_innerExecute, span).apply(this, tx.wrap(span, arguments))
-    }
-  }
-}
-
-function createWrapExecute (tracer, config) {
-  return function wrapExecute (_execute) {
-    return function _executeWithTrace (query, params, execOptions, callback) {
-      const span = start(tracer, config, this, query)
-      const promise = tracer.scope().bind(_execute, span).apply(this, arguments)
-
-      return tx.wrap(span, promise)
-    }
-  }
-}
+    this.addSub(`apm:cassandra:query:start`, ({ keyspace, query, connectionOptions }) => {
+      const store = storage.getStore()
+      const childOf = store ? store.span : store
 
-function createWrapExecutionStart (tracer, config) {
-  return function wrapExecutionStart (start) {
-    return function startWithTrace (getHostCallback) {
-      const span = tracer.scope().active()
-      const execution = this
-
-      if (!isRequestValid(this, arguments, 1, span)) {
-        return start.apply(this, arguments)
+      if (Array.isArray(query)) {
+        query = combine(query)
       }
 
-      arguments[0] = function () {
-        addHost(span, execution._connection)
-        return getHostCallback.apply(this, arguments)
+      const span = this.tracer.startSpan('cassandra.query', {
+        childOf,
+        tags: {
+          'service.name': this.config.service || `${this.tracer._service}-cassandra`,
+          'resource.name': trim(query, 5000),
+          'span.type': 'cassandra',
+          'span.kind': 'client',
+          'db.type': 'cassandra',
+          'cassandra.query': query,
+          'cassandra.keyspace': keyspace
+        }
+      })
+
+      if (connectionOptions) {
+        span.addTags({
+          'out.host': connectionOptions.host,
+          'out.port': connectionOptions.port
+        })
       }
 
-      return start.apply(this, arguments)
-    }
-  }
-}
-
-function createWrapSendOnConnection (tracer, config) {
-  return function wrapSendOnConnection (_sendOnConnection) {
-    return function _sendOnConnectionWithTrace () {
-      const span = tracer.scope().active()
-
-      addHost(span, this._connection)
-
-      return _sendOnConnection.apply(this, arguments)
-    }
-  }
-}
-
-function createWrapSend (tracer, config) {
-  return function wrapSend (send) {
-    return function sendWithTrace (request, options, callback) {
-      const span = tracer.scope().active()
-      const handler = this
-
-      if (!isRequestValid(this, arguments, 3, span)) {
-        return send.apply(this, arguments)
-      }
+      analyticsSampler.sample(span, this.config.measured)
+      this.enter(span, store)
+    })
 
-      arguments[2] = function () {
-        addHost(span, handler.connection)
-        return callback.apply(this, arguments)
-      }
+    this.addSub(`apm:cassandra:query:end`, () => {
+      this.exit()
+    })
 
-      return send.apply(this, arguments)
-    }
-  }
-}
+    this.addSub(`apm:cassandra:query:error`, err => {
+      storage.getStore().span.setTag('error', err)
+    })
 
-function createWrapBatch (tracer, config) {
-  return function wrapBatch (batch) {
-    return function batchWithTrace (queries, options, callback) {
-      const query = combine(queries)
-      const span = start(tracer, config, this, query)
-      const scope = tracer.scope()
-      const fn = scope.bind(batch, span)
+    this.addSub(`apm:cassandra:query:async-end`, () => {
+      storage.getStore().span.finish()
+    })
 
-      try {
-        return tx.wrap(span, fn.apply(this, tx.wrap(span, arguments)))
-      } catch (e) {
-        finish(span, e)
-        throw e
+    this.addSub(`apm:cassandra:query:addConnection`, connectionOptions => {
+      const store = storage.getStore()
+      if (!store) {
+        return
       }
-    }
-  }
-}
-
-function createWrapStream (tracer, config) {
-  return function wrapStream (stream) {
-    return function streamWithTrace (query, params, options, callback) {
-      return tracer.scope().bind(stream.apply(this, arguments))
-    }
-  }
-}
-
-function start (tracer, config, client = {}, query) {
-  const scope = tracer.scope()
-  const childOf = scope.active()
-  const span = tracer.startSpan('cassandra.query', {
-    childOf,
-    tags: {
-      'service.name': config.service || `${tracer._service}-cassandra`,
-      'resource.name': trim(query, 5000),
-      'span.type': 'cassandra',
-      'span.kind': 'client',
-      'db.type': 'cassandra',
-      'cassandra.query': query,
-      'cassandra.keyspace': client.keyspace
-    }
-  })
-
-  analyticsSampler.sample(span, config.measured)
-
-  return span
-}
-
-function finish (span, error) {
-  addError(span, error)
-
-  span.finish()
-
-  return error
-}
-
-function addTag (span, key, value) {
-  if (value) {
-    span.setTag(key, value)
-  }
-}
-
-function addHost (span, connection) {
-  if (span && connection) {
-    addTag(span, 'out.host', connection.address)
-    addTag(span, 'out.port', connection.port)
-  }
-}
-
-function addError (span, error) {
-  if (error && error instanceof Error) {
-    span.addTags({
-      'error.type': error.name,
-      'error.msg': error.message,
-      'error.stack': error.stack
+      const span = store.span
+      span.addTags({
+        'out.host': connectionOptions.address,
+        'out.port': connectionOptions.port
+      })
     })
   }
-
-  return error
-}
-
-function isRequestValid (exec, args, length, span) {
-  if (!exec) return false
-  if (args.length !== length || typeof args[length - 1] !== 'function') return false
-  if (!span || span.context()._name !== 'cassandra.query') return false
-
-  return true
 }
 
 function combine (queries) {
-  if (!Array.isArray(queries)) return []
-
   return queries
     .map(query => (query.query || query).replace(/;?$/, ';'))
     .join(' ')
@@ -187,70 +81,4 @@ function trim (str, size) {
   return `${str.substr(0, size - 3)}...`
 }
 
-module.exports = [
-  {
-    name: 'cassandra-driver',
-    versions: ['>=3.0.0'],
-    patch (cassandra, tracer, config) {
-      this.wrap(cassandra.Client.prototype, 'batch', createWrapBatch(tracer, config))
-      this.wrap(cassandra.Client.prototype, 'stream', createWrapStream(tracer, config))
-    },
-    unpatch (cassandra) {
-      this.unwrap(cassandra.Client.prototype, 'batch')
-      this.unwrap(cassandra.Client.prototype, 'stream')
-    }
-  },
-  {
-    name: 'cassandra-driver',
-    versions: ['>=4.4'],
-    patch (cassandra, tracer, config) {
-      this.wrap(cassandra.Client.prototype, '_execute', createWrapExecute(tracer, config))
-    },
-    unpatch (cassandra) {
-      this.unwrap(cassandra.Client.prototype, '_execute')
-    }
-  },
-  {
-    name: 'cassandra-driver',
-    versions: ['3 - 4.3'],
-    patch (cassandra, tracer, config) {
-      this.wrap(cassandra.Client.prototype, '_innerExecute', createWrapInnerExecute(tracer, config))
-    },
-    unpatch (cassandra) {
-      this.unwrap(cassandra.Client.prototype, '_innerExecute')
-    }
-  },
-  {
-    name: 'cassandra-driver',
-    versions: ['>=3.3'],
-    file: 'lib/request-execution.js',
-    patch (RequestExecution, tracer, config) {
-      this.wrap(RequestExecution.prototype, '_sendOnConnection', createWrapSendOnConnection(tracer, config))
-    },
-    unpatch (RequestExecution) {
-      this.unwrap(RequestExecution.prototype, '_sendOnConnection')
-    }
-  },
-  {
-    name: 'cassandra-driver',
-    versions: ['3.3 - 4.3'],
-    file: 'lib/request-execution.js',
-    patch (RequestExecution, tracer, config) {
-      this.wrap(RequestExecution.prototype, 'start', createWrapExecutionStart(tracer, config))
-    },
-    unpatch (RequestExecution) {
-      this.unwrap(RequestExecution.prototype, 'start')
-    }
-  },
-  {
-    name: 'cassandra-driver',
-    versions: ['3 - 3.2'],
-    file: 'lib/request-handler.js',
-    patch (RequestHandler, tracer, config) {
-      this.wrap(RequestHandler.prototype, 'send', createWrapSend(tracer, config))
-    },
-    unpatch (RequestHandler) {
-      this.unwrap(RequestHandler.prototype, 'send')
-    }
-  }
-]
+module.exports = CassandraDriverPlugin

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

@@ -16,8 +16,9 @@ const {
   getTestEnvironmentMetadata,
   getTestSuitePath
 } = require('../../dd-trace/src/plugins/util/test')
-const { SPAN_TYPE, RESOURCE_NAME } = require('../../../ext/tags')
+const { SPAN_TYPE, RESOURCE_NAME, SAMPLING_PRIORITY } = require('../../../ext/tags')
 const { SAMPLING_RULE_DECISION } = require('../../dd-trace/src/constants')
+const { AUTO_KEEP } = require('../../../ext/priority')
 
 class CucumberPlugin extends Plugin {
   static get name () {
@@ -44,6 +45,7 @@ class CucumberPlugin extends Plugin {
           [TEST_NAME]: pickleName,
           [TEST_SUITE]: testSuite,
           [SAMPLING_RULE_DECISION]: 1,
+          [SAMPLING_PRIORITY]: AUTO_KEEP,
           [TEST_FRAMEWORK_VERSION]: this.tracer._version,
           ...testEnvironmentMetadata
         }

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

@@ -13,8 +13,6 @@ class ElasticsearchPlugin extends Plugin {
     super(...args)
 
     this.addSub('apm:elasticsearch:query:start', ({ params }) => {
-      this.config = normalizeConfig(this.config)
-
       const store = storage.getStore()
       const childOf = store ? store.span : store
       const body = getBody(params.body || params.bulkBody)
@@ -51,6 +49,10 @@ class ElasticsearchPlugin extends Plugin {
       span.finish()
     })
   }
+
+  configure (config) {
+    return super.configure(normalizeConfig(config))
+  }
 }
 
 function normalizeConfig (config) {