dd-trace 2.3.1 → 2.4.2

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

@@ -1,59 +0,0 @@
-'use strict'
-
-const { instrument } = require('./util')
-
-function createWrapCommand (tracer, config, name) {
-  return function wrapCommand (command) {
-    return function commandWithTrace (ns, ops) {
-      return instrument(command, this, arguments, this, ns, ops, tracer, config, { name })
-    }
-  }
-}
-
-function createWrapQuery (tracer, config) {
-  return function wrapQuery (query) {
-    return function queryWithTrace () {
-      const pool = this.server.s.pool
-      const ns = this.ns
-      const ops = this.cmd
-
-      return instrument(query, this, arguments, pool, ns, ops, tracer, config)
-    }
-  }
-}
-
-function createWrapCursor (tracer, config, name) {
-  return function wrapCursor (cursor) {
-    return function cursorWithTrace () {
-      const pool = this.server.s.pool
-      const ns = this.ns
-
-      return instrument(cursor, this, arguments, pool, ns, {}, tracer, config, { name })
-    }
-  }
-}
-
-module.exports = [
-  {
-    name: 'mongodb-core',
-    versions: ['2 - 3.1.9'],
-    patch ({ Cursor, Server }, tracer, config) {
-      this.wrap(Server.prototype, 'command', createWrapCommand(tracer, config))
-      this.wrap(Server.prototype, 'insert', createWrapCommand(tracer, config, 'insert'))
-      this.wrap(Server.prototype, 'update', createWrapCommand(tracer, config, 'update'))
-      this.wrap(Server.prototype, 'remove', createWrapCommand(tracer, config, 'remove'))
-      this.wrap(Cursor.prototype, '_getmore', createWrapCursor(tracer, config, 'getMore'))
-      this.wrap(Cursor.prototype, '_find', createWrapQuery(tracer, config))
-      this.wrap(Cursor.prototype, 'kill', createWrapCursor(tracer, config, 'killCursors'))
-    },
-    unpatch ({ Cursor, Server }) {
-      this.unwrap(Server.prototype, 'command')
-      this.unwrap(Server.prototype, 'insert')
-      this.unwrap(Server.prototype, 'update')
-      this.unwrap(Server.prototype, 'remove')
-      this.unwrap(Cursor.prototype, '_getmore')
-      this.unwrap(Cursor.prototype, '_find')
-      this.unwrap(Cursor.prototype, 'kill')
-    }
-  }
-]

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

@@ -1,138 +0,0 @@
-'use strict'
-
-const { instrument } = require('./util')
-
-function createWrapConnectionCommand (tracer, config, name) {
-  return function wrapCommand (command) {
-    return function commandWithTrace (ns, ops) {
-      const hostParts = typeof this.address === 'string' ? this.address.split(':') : ''
-      const options = hostParts.length === 2
-        ? { host: hostParts[0], port: hostParts[1] }
-        : {} // no port means the address is a random UUID so no host either
-      const topology = { s: { options } }
-
-      ns = `${ns.db}.${ns.collection}`
-
-      return instrument(command, this, arguments, topology, ns, ops, tracer, config, { name })
-    }
-  }
-}
-
-function createWrapCommand (tracer, config, name) {
-  return function wrapCommand (command) {
-    return function commandWithTrace (server, ns, ops) {
-      return instrument(command, this, arguments, server, ns, ops, tracer, config, { name })
-    }
-  }
-}
-
-function createWrapMaybePromise (tracer, config) {
-  return function wrapMaybePromise (maybePromise) {
-    return function maybePromiseWithTrace (parent, callback, fn) {
-      const callbackIndex = arguments.length - 2
-
-      callback = arguments[callbackIndex]
-
-      if (typeof callback === 'function') {
-        arguments[callbackIndex] = tracer.scope().bind(callback)
-      }
-
-      return maybePromise.apply(this, arguments)
-    }
-  }
-}
-
-function patch (wp, tracer, config) {
-  this.wrap(wp, 'command', createWrapCommand(tracer, config))
-  this.wrap(wp, 'insert', createWrapCommand(tracer, config, 'insert'))
-  this.wrap(wp, 'update', createWrapCommand(tracer, config, 'update'))
-  this.wrap(wp, 'remove', createWrapCommand(tracer, config, 'remove'))
-  this.wrap(wp, 'query', createWrapCommand(tracer, config))
-  this.wrap(wp, 'getMore', createWrapCommand(tracer, config, 'getMore'))
-  this.wrap(wp, 'killCursors', createWrapCommand(tracer, config, 'killCursors'))
-}
-
-function unpatch (wp) {
-  this.unwrap(wp, 'command')
-  this.unwrap(wp, 'insert')
-  this.unwrap(wp, 'update')
-  this.unwrap(wp, 'remove')
-  this.unwrap(wp, 'query')
-  this.unwrap(wp, 'getMore')
-  this.unwrap(wp, 'killCursors')
-}
-
-function patchConnection ({ Connection }, tracer, config) {
-  const proto = Connection.prototype
-
-  this.wrap(proto, 'command', createWrapConnectionCommand(tracer, config))
-  this.wrap(proto, 'query', createWrapConnectionCommand(tracer, config))
-  this.wrap(proto, 'getMore', createWrapConnectionCommand(tracer, config, 'getMore'))
-  this.wrap(proto, 'killCursors', createWrapConnectionCommand(tracer, config, 'killCursors'))
-}
-
-function unpatchConnection ({ Connection }) {
-  const proto = Connection.prototype
-
-  this.unwrap(proto, 'command')
-  this.unwrap(proto, 'query')
-  this.unwrap(proto, 'getMore')
-  this.unwrap(proto, 'killCursors')
-}
-
-function patchClass (WireProtocol, tracer, config) {
-  this.wrap(WireProtocol.prototype, 'command', createWrapCommand(tracer, config))
-}
-
-function unpatchClass (WireProtocol) {
-  this.unwrap(WireProtocol.prototype, 'command')
-}
-
-module.exports = [
-  {
-    name: 'mongodb',
-    versions: ['>=4'],
-    file: 'lib/cmap/connection.js',
-    patch: patchConnection,
-    unpatch: unpatchConnection
-  },
-  {
-    name: 'mongodb',
-    versions: ['>=3.5.4'],
-    file: 'lib/utils.js',
-    patch (util, tracer, config) {
-      this.wrap(util, 'maybePromise', createWrapMaybePromise(tracer, config))
-    },
-    unpatch (util) {
-      this.unwrap(util, 'maybePromise')
-    }
-  },
-  {
-    name: 'mongodb',
-    versions: ['>=3.3 <4'],
-    file: 'lib/core/wireprotocol/index.js',
-    patch,
-    unpatch
-  },
-  {
-    name: 'mongodb-core',
-    versions: ['>=3.2'],
-    file: 'lib/wireprotocol/index.js',
-    patch,
-    unpatch
-  },
-  {
-    name: 'mongodb-core',
-    versions: ['~3.1.10'],
-    file: 'lib/wireprotocol/3_2_support.js',
-    patch: patchClass,
-    unpatch: unpatchClass
-  },
-  {
-    name: 'mongodb-core',
-    versions: ['~3.1.10'],
-    file: 'lib/wireprotocol/2_6_support.js',
-    patch: patchClass,
-    unpatch: unpatchClass
-  }
-]

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

@@ -1,143 +0,0 @@
-'use strict'
-
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-
-function instrument (command, ctx, args, server, ns, ops, tracer, config, options = {}) {
-  const name = options.name || (ops && Object.keys(ops)[0])
-  const index = args.length - 1
-  const callback = args[index]
-
-  if (typeof callback !== 'function') return command.apply(ctx, args)
-
-  const span = startSpan(tracer, config, ns, ops, server, name)
-
-  if (name !== 'getMore' && name !== 'killCursors') {
-    analyticsSampler.sample(span, config.measured)
-  }
-
-  args[index] = wrapCallback(tracer, span, callback)
-
-  return tracer.scope().bind(command, span).apply(ctx, args)
-}
-
-function startSpan (tracer, config, ns, ops, server, name) {
-  const scope = tracer.scope()
-  const childOf = scope.active()
-  const span = tracer.startSpan('mongodb.query', { childOf })
-
-  addTags(span, tracer, config, ns, ops, server, name)
-
-  return span
-}
-
-function wrapCallback (tracer, span, done) {
-  return tracer.scope().bind((err, res) => {
-    if (err) {
-      span.addTags({
-        'error.type': err.name,
-        'error.msg': err.message,
-        'error.stack': err.stack
-      })
-    }
-
-    span.finish()
-
-    if (done) {
-      done(err, res)
-    }
-  })
-}
-
-function addTags (span, tracer, config, ns, cmd, topology, operationName) {
-  const query = getQuery(cmd)
-  const resource = getResource(ns, query, operationName)
-
-  span.addTags({
-    'service.name': config.service || `${tracer._service}-mongodb`,
-    'resource.name': resource,
-    'span.type': 'mongodb',
-    'span.kind': 'client',
-    'db.name': ns
-  })
-
-  if (query) {
-    span.setTag('mongodb.query', query)
-  }
-
-  addHost(span, topology)
-}
-
-function addHost (span, topology) {
-  const options = topology && topology.s && topology.s.options
-
-  if (options && options.host && options.port) {
-    span.addTags({
-      'out.host': topology.s.options.host,
-      'out.port': topology.s.options.port
-    })
-  }
-}
-
-function getQuery (cmd) {
-  if (!cmd || typeof cmd !== 'object' || Array.isArray(cmd)) return
-  if (cmd.query) return JSON.stringify(sanitize(cmd.query))
-  if (cmd.filter) return JSON.stringify(sanitize(cmd.filter))
-}
-
-function getResource (ns, query, operationName) {
-  const parts = [operationName, ns]
-
-  if (query) {
-    parts.push(query)
-  }
-
-  return parts.join(' ')
-}
-
-function shouldHide (input) {
-  return !isObject(input) || Buffer.isBuffer(input) || isBSON(input)
-}
-
-function sanitize (input) {
-  if (shouldHide(input)) return '?'
-
-  const output = {}
-  const queue = [{
-    input,
-    output,
-    depth: 0
-  }]
-
-  while (queue.length) {
-    const {
-      input, output, depth
-    } = queue.pop()
-    const nextDepth = depth + 1
-    for (const key in input) {
-      if (typeof input[key] === 'function') continue
-
-      const child = input[key]
-      if (depth >= 20 || shouldHide(child)) {
-        output[key] = '?'
-      } else {
-        queue.push({
-          input: child,
-          output: output[key] = {},
-          depth: nextDepth
-        })
-      }
-    }
-  }
-
-  return output
-}
-
-function isObject (val) {
-  return typeof val === 'object' && val !== null && !(val instanceof Array)
-}
-
-function isBSON (val) {
-  return val && val._bsontype
-}
-
-module.exports = { instrument }