dd-trace 3.3.1 → 3.4.0

package/LICENSE-3rdparty.csv

@@ -46,6 +46,8 @@ dev,int64-buffer,MIT,Copyright 2015-2016 Yusuke Kawasaki
 dev,jszip,MIT,Copyright 2015-2016 Stuart Knightley and contributors
 dev,mkdirp,MIT,Copyright 2010 James Halliday
 dev,mocha,MIT,Copyright 2011-2018 JS Foundation and contributors https://js.foundation
+dev,mocha-junit-reporter,MIT,Copyright (c) 2015 Michael Allen
+dev,mocha-multi-reporters,MIT,Copyright 2019 Yousaf Nabi and 2015 Stanley Ng
 dev,multer,MIT,Copyright 2014 Hage Yaapa
 dev,msgpack-lite,MIT,Copyright 2015 Yusuke Kawasaki
 dev,nock,MIT,Copyright 2017 Pedro Teixeira and other contributors

package/index.d.ts

@@ -587,6 +587,7 @@ interface Plugins {
   "kafkajs": plugins.kafkajs
   "knex": plugins.knex;
   "koa": plugins.koa;
+  "mariadb": plugins.mariadb;
   "memcached": plugins.memcached;
   "microgateway-core": plugins.microgateway_core;
   "mocha": plugins.mocha;
@@ -1164,6 +1165,12 @@ declare namespace plugins {
    */
   interface kafkajs extends Instrumentation {}
 
+  /**
+   * This plugin automatically instruments the
+   * [mariadb](https://github.com/mariadb-corporation/mariadb-connector-nodejs) module.
+   */
+   interface mariadb extends mysql {}
+
   /**
    * This plugin automatically instruments the
    * [memcached](https://github.com/3rd-Eden/memcached) module.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "3.3.1",
+  "version": "3.4.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -17,7 +17,7 @@
     "tdd": "node scripts/tdd.js",
     "test": "SERVICES=* yarn services && mocha --colors --exit --expose-gc 'packages/dd-trace/test/setup/node.js' 'packages/*/test/**/*.spec.js'",
     "test:trace:core": "mocha --colors --exit --expose-gc --file packages/dd-trace/test/setup/core.js --exclude \"packages/dd-trace/test/profiling/**/*.spec.js\" \"packages/dd-trace/test/**/*.spec.js\"",
-    "test:trace:core:ci": "nyc --no-clean --include \"packages/dd-trace/src/**/*.js\" --exclude \"packages/dd-trace/src/profiling/**/*.js\" -- npm run test:trace:core",
+    "test:trace:core:ci": "nyc --no-clean --include \"packages/dd-trace/src/**/*.js\" --exclude \"packages/dd-trace/src/profiling/**/*.js\" -- npm run test:trace:core -- --reporter mocha-multi-reporters --reporter-options configFile=mocha-reporter.json",
     "test:instrumentations": "mocha --colors --file 'packages/dd-trace/test/setup/core.js' 'packages/datadog-instrumentations/test/**/*.spec.js'",
     "test:instrumentations:ci": "nyc --no-clean --include 'packages/datadog-instrumentations/src/**/*.js' -- npm run test:instrumentations",
     "test:core": "mocha --colors --file packages/datadog-core/test/setup.js 'packages/datadog-core/test/**/*.spec.js'",
@@ -93,7 +93,7 @@
     "checksum": "^0.1.1",
     "cli-table3": "^0.5.1",
     "dotenv": "8.2.0",
-    "eslint": "^7.32.0",
+    "eslint": "^8.23.0",
     "eslint-config-standard": "^11.0.0-beta.0",
     "eslint-plugin-import": "^2.8.0",
     "eslint-plugin-node": "^5.2.1",
@@ -107,6 +107,8 @@
     "jszip": "^3.5.0",
     "mkdirp": "^0.5.1",
     "mocha": "8",
+    "mocha-junit-reporter": "^2.1.0",
+    "mocha-multi-reporters": "^1.5.1",
     "msgpack-lite": "^0.1.26",
     "multer": "^1.4.5-lts.1",
     "nock": "^11.3.3",

package/packages/datadog-instrumentations/src/cassandra-driver.js

@@ -7,10 +7,10 @@ const {
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
-const startCh = channel('apm:cassandra:query:start')
-const finishCh = channel('apm:cassandra:query:finish')
-const errorCh = channel('apm:cassandra:query:error')
-const addConnectionCh = channel(`apm:cassandra:query:addConnection`)
+const startCh = channel('apm:cassandra-driver:query:start')
+const finishCh = channel('apm:cassandra-driver:query:finish')
+const errorCh = channel('apm:cassandra-driver:query:error')
+const connectCh = channel(`apm:cassandra-driver:query:connect`)
 
 addHook({ name: 'cassandra-driver', versions: ['>=3.0.0'] }, cassandra => {
   shimmer.wrap(cassandra.Client.prototype, 'batch', batch => function (queries, options, callback) {
@@ -115,7 +115,7 @@ addHook({ name: 'cassandra-driver', versions: ['>=3.3'], file: 'lib/request-exec
     if (!startCh.hasSubscribers) {
       return _sendOnConnection.apply(this, arguments)
     }
-    addConnectionCh.publish({ address: this._connection.address, port: this._connection.port })
+    connectCh.publish({ hostname: this._connection.address, port: this._connection.port })
     return _sendOnConnection.apply(this, arguments)
   })
   return RequestExecution
@@ -136,7 +136,7 @@ addHook({ name: 'cassandra-driver', versions: ['3.3 - 4.3'], file: 'lib/request-
     getHostCallback = asyncResource.bind(getHostCallback)
 
     arguments[0] = AsyncResource.bind(function () {
-      addConnectionCh.publish({ address: execution._connection.address, port: execution._connection.port })
+      connectCh.publish({ hostname: execution._connection.address, port: execution._connection.port })
       return getHostCallback.apply(this, arguments)
     })
 
@@ -160,7 +160,7 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 3.2'], file: 'lib/request-ha
     callback = asyncResource.bind(callback)
 
     arguments[2] = AsyncResource.bind(function () {
-      addConnectionCh.publish({ address: handler.connection.address, port: handler.connection.port })
+      connectCh.publish({ hostname: handler.connection.address, port: handler.connection.port })
       return callback.apply(this, arguments)
     })
 

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -10,6 +10,7 @@ module.exports = {
   '@jest/core': () => require('../jest'),
   '@koa/router': () => require('../koa'),
   '@node-redis/client': () => require('../redis'),
+  '@redis/client': () => require('../redis'),
   'amqp10': () => require('../amqp10'),
   'amqplib': () => require('../amqplib'),
   'aws-sdk': () => require('../aws-sdk'),
@@ -41,6 +42,7 @@ module.exports = {
   'koa-router': () => require('../koa'),
   'kafkajs': () => require('../kafkajs'),
   'limitd-client': () => require('../limitd-client'),
+  'mariadb': () => require('../mariadb'),
   'memcached': () => require('../memcached'),
   'microgateway-core': () => require('../microgateway-core'),
   'mocha': () => require('../mocha'),

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

@@ -1,3 +1,69 @@
 'use strict'
 
-// Instrumentation temporarily disabled. See https://github.com/DataDog/dd-trace-js/issues/312
+// Old instrumentation temporarily replaced with compatibility mode only instrumentation.
+// See https://github.com/DataDog/dd-trace-js/issues/312
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('../helpers/instrument')
+const shimmer = require('../../../datadog-shimmer')
+
+const startServerCh = channel('apm:http2:server:request:start')
+const errorServerCh = channel('apm:http2:server:request:error')
+const finishServerCh = channel('apm:http2:server:request:finish')
+
+addHook({ name: 'http2' }, http2 => {
+  shimmer.wrap(http2, 'createSecureServer', wrapCreateServer)
+  shimmer.wrap(http2, 'createServer', wrapCreateServer)
+  return http2
+})
+
+function wrapCreateServer (createServer) {
+  return function (...args) {
+    const server = createServer.apply(this, args)
+    shimmer.wrap(server, 'emit', wrapEmit)
+    return server
+  }
+}
+
+function wrapResponseEmit (emit) {
+  const asyncResource = new AsyncResource('bound-anonymous-fn')
+  return function (eventName, event) {
+    return asyncResource.runInAsyncScope(() => {
+      if (eventName === 'close' && finishServerCh.hasSubscribers) {
+        finishServerCh.publish({ req: this.req })
+      }
+
+      return emit.apply(this, arguments)
+    })
+  }
+}
+function wrapEmit (emit) {
+  return function (eventName, req, res) {
+    if (!startServerCh.hasSubscribers) {
+      return emit.apply(this, arguments)
+    }
+
+    if (eventName === 'request') {
+      res.req = req
+
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
+      return asyncResource.runInAsyncScope(() => {
+        startServerCh.publish({ req, res })
+
+        shimmer.wrap(res, 'emit', wrapResponseEmit)
+
+        try {
+          return emit.apply(this, arguments)
+        } catch (err) {
+          errorServerCh.publish(err)
+
+          throw err
+        }
+      })
+    }
+    return emit.apply(this, arguments)
+  }
+}

package/packages/datadog-instrumentations/src/jest.js

@@ -2,6 +2,7 @@
 const istanbul = require('istanbul-lib-coverage')
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
+const log = require('../../dd-trace/src/log')
 
 const testSessionStartCh = channel('ci:jest:session:start')
 const testSessionFinishCh = channel('ci:jest:session:finish')
@@ -17,6 +18,12 @@ const testSkippedCh = channel('ci:jest:test:skip')
 const testRunFinishCh = channel('ci:jest:test:finish')
 const testErrCh = channel('ci:jest:test:err')
 
+const skippableSuitesCh = channel('ci:jest:test-suite:skippable')
+const jestConfigurationCh = channel('ci:jest:configuration')
+
+let skippableSuites = []
+let isCodeCoverageEnabled = false
+
 const {
   getTestSuitePath,
   getTestParametersString
@@ -179,17 +186,66 @@ addHook({
 
 function cliWrapper (cli) {
   const wrapped = shimmer.wrap(cli, 'runCLI', runCLI => async function () {
-    const processArgv = process.argv.slice(2).join(' ')
+    let onResponse, onError
+    const configurationPromise = new Promise((resolve, reject) => {
+      onResponse = resolve
+      onError = reject
+    })
+
     sessionAsyncResource.runInAsyncScope(() => {
-      testSessionStartCh.publish(`jest ${processArgv}`)
+      jestConfigurationCh.publish({ onResponse, onError })
     })
-    return runCLI.apply(this, arguments).then(result => {
-      const { results: { success } } = result
+
+    let isSuitesSkippingEnabled = false
+
+    try {
+      const config = await configurationPromise
+      isCodeCoverageEnabled = config.isCodeCoverageEnabled
+      isSuitesSkippingEnabled = config.isSuitesSkippingEnabled
+    } catch (e) {
+      // ignore error
+    }
+
+    if (isSuitesSkippingEnabled) {
+      const skippableSuitesPromise = new Promise((resolve, reject) => {
+        onResponse = resolve
+        onError = reject
+      })
+
       sessionAsyncResource.runInAsyncScope(() => {
-        testSessionFinishCh.publish(success ? 'pass' : 'fail')
+        skippableSuitesCh.publish({ onResponse, onError })
       })
-      return result
+
+      try {
+        skippableSuites = await skippableSuitesPromise
+      } catch (e) {
+        log.error(e)
+      }
+    }
+
+    const isTestsSkipped = !!skippableSuites.length
+
+    const processArgv = process.argv.slice(2).join(' ')
+    sessionAsyncResource.runInAsyncScope(() => {
+      testSessionStartCh.publish(`jest ${processArgv}`)
+    })
+
+    const result = await runCLI.apply(this, arguments)
+
+    const { results: { success, coverageMap } } = result
+
+    let testCodeCoverageLinesTotal
+    try {
+      testCodeCoverageLinesTotal = coverageMap.getCoverageSummary().lines.pct
+    } catch (e) {
+      // ignore errors
+    }
+
+    sessionAsyncResource.runInAsyncScope(() => {
+      testSessionFinishCh.publish({ status: success ? 'pass' : 'fail', isTestsSkipped, testCodeCoverageLinesTotal })
     })
+
+    return result
   })
 
   cli.runCLI = wrapped.runCLI
@@ -249,9 +305,23 @@ addHook({
 
 function configureTestEnvironment (readConfigsResult) {
   const { configs } = readConfigsResult
+  configs.forEach(config => {
+    skippableSuites.forEach((suite) => {
+      config.testMatch.push(`!**/${suite}`)
+    })
+    skippableSuites = []
+  })
   sessionAsyncResource.runInAsyncScope(() => {
     testSessionConfigurationCh.publish(configs.map(config => config.testEnvironmentOptions))
   })
+  if (isCodeCoverageEnabled) {
+    const globalConfig = {
+      ...readConfigsResult.globalConfig,
+      collectCoverage: true
+    }
+    readConfigsResult.globalConfig = globalConfig
+  }
+  return readConfigsResult
 }
 
 function jestConfigAsyncWrapper (jestConfig) {

package/packages/datadog-instrumentations/src/mariadb.js

@@ -0,0 +1,89 @@
+'use strict'
+
+const { channel, addHook, AsyncResource } = require('./helpers/instrument')
+
+const shimmer = require('../../datadog-shimmer')
+
+const startCh = channel('apm:mariadb:query:start')
+const finishCh = channel('apm:mariadb:query:finish')
+const errorCh = channel('apm:mariadb:query:error')
+
+function wrapConnectionAddCommand (addCommand) {
+  return function (cmd) {
+    if (!startCh.hasSubscribers) return addCommand.apply(this, arguments)
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const name = cmd && cmd.constructor && cmd.constructor.name
+    const isCommand = typeof cmd.start === 'function'
+    const isQuery = isCommand && (name === 'Execute' || name === 'Query')
+
+    // TODO: consider supporting all commands and not just queries
+    cmd.start = isQuery
+      ? wrapStart(cmd, cmd.start, asyncResource, this.opts)
+      : bindStart(cmd, cmd.start, asyncResource)
+
+    return asyncResource.bind(addCommand, this).apply(this, arguments)
+  }
+}
+
+function bindStart (cmd, start, asyncResource) {
+  return asyncResource.bind(function (packet, connection) {
+    if (this.resolve) {
+      this.resolve = asyncResource.bind(this.resolve)
+    }
+
+    if (this.reject) {
+      this.reject = asyncResource.bind(this.reject)
+    }
+
+    return start.apply(this, arguments)
+  }, cmd)
+}
+
+function wrapStart (cmd, start, asyncResource, config) {
+  const callbackResource = new AsyncResource('bound-anonymous-fn')
+
+  return asyncResource.bind(function (packet, connection) {
+    if (!this.resolve || !this.reject) return start.apply(this, arguments)
+
+    const sql = cmd.statement ? cmd.statement.query : cmd.sql
+
+    startCh.publish({ sql, conf: config })
+
+    const resolve = callbackResource.bind(this.resolve)
+    const reject = callbackResource.bind(this.reject)
+
+    this.resolve = asyncResource.bind(function () {
+      finishCh.publish(undefined)
+      resolve.apply(this, arguments)
+    }, 'bound-anonymous-fn', this)
+
+    this.reject = asyncResource.bind(function (error) {
+      errorCh.publish(error)
+      finishCh.publish(undefined)
+      reject.apply(this, arguments)
+    }, 'bound-anonymous-fn', this)
+
+    this.start = start
+
+    try {
+      return start.apply(this, arguments)
+    } catch (err) {
+      errorCh.publish(err)
+    }
+  }, cmd)
+}
+
+addHook(
+  {
+    name: 'mariadb',
+    file: 'lib/connection.js',
+    versions: ['>=3']
+  },
+  (Connection) => {
+    shimmer.wrap(Connection.prototype, 'addCommandEnable', wrapConnectionAddCommand)
+    shimmer.wrap(Connection.prototype, 'addCommandEnablePipeline', wrapConnectionAddCommand)
+
+    return Connection
+  }
+)

package/packages/datadog-instrumentations/src/memcached.js

@@ -9,7 +9,6 @@ const shimmer = require('../../datadog-shimmer')
 
 addHook({ name: 'memcached', versions: ['>=2.2'] }, Memcached => {
   const startCh = channel('apm:memcached:command:start')
-  const startWithArgsCh = channel('apm:memcached:command:start:with-args')
   const finishCh = channel('apm:memcached:command:finish')
   const errorCh = channel('apm:memcached:command:error')
 
@@ -35,14 +34,12 @@ addHook({ name: 'memcached', versions: ['>=2.2'] }, Memcached => {
 
         return callback.apply(this, arguments)
       })
-      startWithArgsCh.publish({ client, server, query })
+      startCh.publish({ client, server, query })
 
       return query
     })
 
     return asyncResource.runInAsyncScope(() => {
-      startCh.publish()
-
       arguments[0] = wrappedQueryCompiler
 
       const result = command.apply(this, arguments)

package/packages/datadog-instrumentations/src/next.js

@@ -99,12 +99,16 @@ function instrument (req, res, handler) {
     try {
       const promise = handler()
 
+      // promise should only reject when propagateError is true:
+      // https://github.com/vercel/next.js/blob/cee656238a/packages/next/server/api-utils/node.ts#L547
       return promise.then(
         result => finish(req, res, result),
         err => finish(req, res, null, err)
       )
     } catch (e) {
-      finish(req, res, null, e)
+      // this will probably never happen as the handler caller is an async function:
+      // https://github.com/vercel/next.js/blob/cee656238a/packages/next/server/api-utils/node.ts#L420
+      return finish(req, res, null, e)
     }
   })
 }
@@ -116,7 +120,11 @@ function finish (req, res, result, err) {
 
   finishChannel.publish({ req, res })
 
-  return result || err
+  if (err) {
+    throw err
+  }
+
+  return result
 }
 
 addHook({ name: 'next', versions: ['>=11.1'], file: 'dist/server/next-server.js' }, nextServer => {

package/packages/datadog-instrumentations/src/oracledb.js

@@ -10,21 +10,21 @@ const shimmer = require('../../datadog-shimmer')
 const connectionAttributes = new WeakMap()
 const poolAttributes = new WeakMap()
 
-const executeStartChannel = channel('apm:oracledb:execute:start')
-const executeErrorChannel = channel('apm:oracledb:execute:error')
-const executeFinishChannel = channel('apm:oracledb:execute:finish')
+const startChannel = channel('apm:oracledb:query:start')
+const errorChannel = channel('apm:oracledb:query:error')
+const finishChannel = channel('apm:oracledb:query:finish')
 
 function finish (err) {
   if (err) {
-    executeErrorChannel.publish(err)
+    errorChannel.publish(err)
   }
-  executeFinishChannel.publish(undefined)
+  finishChannel.publish(undefined)
 }
 
 addHook({ name: 'oracledb', versions: ['5'] }, oracledb => {
   shimmer.wrap(oracledb.Connection.prototype, 'execute', execute => {
     return function wrappedExecute (dbQuery, ...args) {
-      if (!executeStartChannel.hasSubscribers) {
+      if (!startChannel.hasSubscribers) {
         return execute.apply(this, arguments)
       }
 
@@ -39,7 +39,7 @@ addHook({ name: 'oracledb', versions: ['5'] }, oracledb => {
 
       return new AsyncResource('apm:oracledb:inner-scope').runInAsyncScope(() => {
         const connAttrs = connectionAttributes.get(this)
-        executeStartChannel.publish({ query: dbQuery, connAttrs })
+        startChannel.publish({ query: dbQuery, connAttrs })
         try {
           let result = execute.apply(this, arguments)
 
@@ -58,7 +58,7 @@ addHook({ name: 'oracledb', versions: ['5'] }, oracledb => {
 
           return result
         } catch (err) {
-          executeErrorChannel.publish(err)
+          errorChannel.publish(err)
           throw err
         }
       })

package/packages/datadog-instrumentations/src/redis.js

@@ -11,8 +11,8 @@ const startCh = channel('apm:redis:command:start')
 const finishCh = channel('apm:redis:command:finish')
 const errorCh = channel('apm:redis:command:error')
 
-addHook({ name: '@node-redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1'] }, redis => {
-  shimmer.wrap(redis.default.prototype, 'addCommand', addCommand => function (command) {
+function wrapAddCommand (addCommand) {
+  return function (command) {
     if (!startCh.hasSubscribers) {
       return addCommand.apply(this, arguments)
     }
@@ -32,7 +32,16 @@ addHook({ name: '@node-redis/client', file: 'dist/lib/client/commands-queue.js',
 
       return res
     })
-  })
+  }
+}
+
+addHook({ name: '@redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1.1'] }, redis => {
+  shimmer.wrap(redis.default.prototype, 'addCommand', wrapAddCommand)
+  return redis
+})
+
+addHook({ name: '@node-redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1'] }, redis => {
+  shimmer.wrap(redis.default.prototype, 'addCommand', wrapAddCommand)
   return redis
 })
 

package/packages/datadog-instrumentations/src/rhea.js

@@ -15,8 +15,19 @@ const dispatchCh = channel('apm:rhea:dispatch')
 const errorCh = channel('apm:rhea:error')
 const finishCh = channel('apm:rhea:finish')
 
+const encodeCh = channel('apm:rhea:encode')
+
 const contexts = new WeakMap()
 
+addHook({ name: 'rhea', versions: ['>=1'] }, rhea => {
+  shimmer.wrap(rhea.message, 'encode', encode => function (msg) {
+    encodeCh.publish(msg)
+    return encode.apply(this, arguments)
+  })
+
+  return rhea
+})
+
 addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/link.js' }, obj => {
   const startSendCh = channel('apm:rhea:send:start')
   const startReceiveCh = channel('apm:rhea:receive:start')

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

@@ -1,66 +1,28 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
-const { storage } = require('../../datadog-core')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-
-class CassandraDriverPlugin extends Plugin {
-  static get name () {
-    return 'cassandra-driver'
-  }
-  constructor (...args) {
-    super(...args)
-
-    this.addSub(`apm:cassandra:query:start`, ({ keyspace, query, connectionOptions }) => {
-      const store = storage.getStore()
-      const childOf = store ? store.span : store
-
-      if (Array.isArray(query)) {
-        query = combine(query)
-      }
-
-      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
-        })
-      }
-
-      analyticsSampler.sample(span, this.config.measured)
-      this.enter(span, store)
-    })
-
-    this.addSub(`apm:cassandra:query:error`, err => {
-      storage.getStore().span.setTag('error', err)
-    })
-
-    this.addSub(`apm:cassandra:query:finish`, () => {
-      storage.getStore().span.finish()
-    })
-
-    this.addSub(`apm:cassandra:query:addConnection`, connectionOptions => {
-      const store = storage.getStore()
-      if (!store) {
-        return
-      }
-      const span = store.span
-      span.addTags({
-        'out.host': connectionOptions.address,
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+
+class CassandraDriverPlugin extends DatabasePlugin {
+  static get name () { return 'cassandra-driver' }
+  static get system () { return 'cassandra' }
+
+  start ({ keyspace, query, connectionOptions = {} }) {
+    if (Array.isArray(query)) {
+      query = combine(query)
+    }
+
+    this.startSpan('cassandra.query', {
+      service: this.config.service,
+      resource: trim(query, 5000),
+      type: 'cassandra',
+      kind: 'client',
+      meta: {
+        'db.type': 'cassandra',
+        'cassandra.query': query,
+        'cassandra.keyspace': keyspace,
+        'out.host': connectionOptions.host,
         'out.port': connectionOptions.port
-      })
+      }
     })
   }
 }