dd-trace 2.1.0 → 2.2.1

package/packages/dd-trace/src/tracer.js

@@ -21,7 +21,7 @@ class DatadogTracer extends Tracer {
   }
 
   trace (name, options, fn) {
-    options = Object.assign({}, {
+    options = Object.assign({
       childOf: this.scope().active()
     }, options)
 

package/packages/datadog-plugin-generic-pool/src/index.js

@@ -1,52 +0,0 @@
-'use strict'
-
-function createWrapAcquire (tracer, config) {
-  return function wrapAcquire (acquire) {
-    return function acquireWithTrace (callback, priority) {
-      if (typeof callback === 'function') {
-        arguments[0] = tracer.scope().bind(callback)
-      }
-
-      return acquire.apply(this, arguments)
-    }
-  }
-}
-
-function createWrapPool (tracer, config, instrumenter) {
-  return function wrapPool (Pool) {
-    if (typeof Pool !== 'function') return Pool
-
-    return function PoolWithTrace (factory) {
-      const pool = Pool.apply(this, arguments)
-
-      if (pool && typeof pool.acquire === 'function') {
-        instrumenter.wrap(pool, 'acquire', createWrapAcquire(tracer, config))
-      }
-
-      return pool
-    }
-  }
-}
-
-module.exports = [
-  {
-    name: 'generic-pool',
-    versions: ['^2.4'],
-    patch (genericPool, tracer, config) {
-      this.wrap(genericPool.Pool.prototype, 'acquire', createWrapAcquire(tracer, config))
-    },
-    unpatch (genericPool) {
-      this.unwrap(genericPool.Pool.prototype, 'acquire')
-    }
-  },
-  {
-    name: 'generic-pool',
-    versions: ['2 - 2.3'],
-    patch (genericPool, tracer, config) {
-      this.wrap(genericPool, 'Pool', createWrapPool(tracer, config, this))
-    },
-    unpatch (genericPool) {
-      this.unwrap(genericPool, 'Pool')
-    }
-  }
-]

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

@@ -1,51 +0,0 @@
-'use strict'
-
-const { wrapThen } = require('../../datadog-instrumentations/src/helpers/promise')
-
-function createWrapCollectionAddQueue (tracer, config) {
-  return function wrapAddQueue (addQueue) {
-    return function addQueueWithTrace (name) {
-      const scope = tracer.scope()
-
-      if (typeof name === 'function') {
-        arguments[0] = scope.bind(name)
-      } else if (typeof this[name] === 'function') {
-        arguments[0] = scope.bind((...args) => this[name](...args))
-      }
-
-      return addQueue.apply(this, arguments)
-    }
-  }
-}
-
-function createWrapWrapCallback (tracer, config) {
-  return function wrapWrapCallback ($wrapCallback) {
-    return function $wrapCallbackWithTrace (cb) {
-      arguments[0] = tracer.scope().bind(cb)
-      return $wrapCallback.apply(this, arguments)
-    }
-  }
-}
-
-module.exports = [
-  {
-    name: 'mongoose',
-    versions: ['>=4.6.4'],
-    patch (mongoose, tracer, config) {
-      if (mongoose.Promise !== global.Promise) {
-        this.wrap(mongoose.Promise.prototype, 'then', wrapThen)
-      }
-
-      this.wrap(mongoose.Collection.prototype, 'addQueue', createWrapCollectionAddQueue(tracer, config))
-      this.wrap(mongoose.Model, '$wrapCallback', createWrapWrapCallback(tracer, config))
-    },
-    unpatch (mongoose) {
-      if (mongoose.Promise !== global.Promise) {
-        this.unwrap(mongoose.Promise.prototype, 'then')
-      }
-
-      this.unwrap(mongoose.Collection.prototype, 'addQueue')
-      this.unwrap(mongoose.Model, '$wrapCallback')
-    }
-  }
-]