dd-trace 2.9.0 → 2.11.0

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

@@ -5,101 +5,132 @@ const testStartCh = channel('ci:mocha:test:start')
 const errorCh = channel('ci:mocha:test:error')
 const skipCh = channel('ci:mocha:test:skip')
 const testFinishCh = channel('ci:mocha:test:finish')
-const suiteFinishCh = channel('ci:mocha:suite:finish')
-const hookErrorCh = channel('ci:mocha:hook:error')
 const parameterizedTestCh = channel('ci:mocha:test:parameterize')
 const testRunFinishCh = channel('ci:mocha:run:finish')
 
-// TODO: remove when root hooks and fixtures are implemented
-const patched = new WeakSet()
-
 function isRetry (test) {
   return test._currentRetry !== undefined && test._currentRetry !== 0
 }
 
-function getAllTestsInSuite (root) {
-  const tests = []
-  function getTests (suiteOrTest) {
-    suiteOrTest.tests.forEach(test => {
-      tests.push(test)
-    })
-    suiteOrTest.suites.forEach(suite => {
-      getTests(suite)
-    })
+function getTestAsyncResource (test) {
+  if (!test.fn) {
+    return testToAr.get(test)
   }
-  getTests(root)
-  return tests
+  if (!test.fn.asyncResource) {
+    return testToAr.get(test.fn)
+  }
+  const originalFn = originalFns.get(test.fn)
+  return testToAr.get(originalFn)
 }
 
+// TODO: remove when root hooks and fixtures are implemented
+const patched = new WeakSet()
+
+const testToAr = new WeakMap()
+const originalFns = new WeakMap()
+
 function mochaHook (Runner) {
   if (patched.has(Runner)) return Runner
 
   patched.add(Runner)
 
-  shimmer.wrap(Runner.prototype, 'runTest', runTest => function () {
-    if (!testStartCh.hasSubscribers || isRetry(this.test)) {
-      return runTest.apply(this, arguments)
+  shimmer.wrap(Runner.prototype, 'run', run => function () {
+    if (!testStartCh.hasSubscribers) {
+      return run.apply(this, arguments)
     }
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return asyncResource.runInAsyncScope(() => {
-      testStartCh.publish(this.test)
-
-      this.once('test end', AsyncResource.bind(() => {
-        let status
+    this.on('test', (test) => {
+      if (isRetry(test)) {
+        return
+      }
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
+      testToAr.set(test.fn, asyncResource)
+      asyncResource.runInAsyncScope(() => {
+        testStartCh.publish(test)
+      })
+    })
 
-        if (this.test.pending) {
-          status = 'skipped'
-        } else if (this.test.state !== 'failed' && !this.test.timedOut) {
-          status = 'pass'
-        } else {
-          status = 'fail'
-        }
+    this.on('test end', (test) => {
+      const asyncResource = getTestAsyncResource(test)
+      let status
+      if (test.pending) {
+        status = 'skip'
+      } else if (test.state !== 'failed' && !test.timedOut) {
+        status = 'pass'
+      } else {
+        status = 'fail'
+      }
 
-        testFinishCh.publish(status)
-      }))
+      // if there are afterEach to be run, we don't finish the test yet
+      if (!test.parent._afterEach.length) {
+        asyncResource.runInAsyncScope(() => {
+          testFinishCh.publish(status)
+        })
+      }
+    })
 
-      this.once('fail', AsyncResource.bind((test, err) => {
-        errorCh.publish(err)
-      }))
+    // If the hook passes, 'hook end' will be emitted. Otherwise, 'fail' will be emitted
+    this.on('hook end', (hook) => {
+      const test = hook.ctx.currentTest
+      if (test && hook.parent._afterEach.includes(hook)) { // only if it's an afterEach
+        const isLastAfterEach = hook.parent._afterEach.indexOf(hook) === hook.parent._afterEach.length - 1
+        if (isLastAfterEach) {
+          const asyncResource = getTestAsyncResource(test)
+          asyncResource.runInAsyncScope(() => {
+            testFinishCh.publish('pass')
+          })
+        }
+      }
+    })
 
-      this.once('pending', AsyncResource.bind((test) => {
-        skipCh.publish(test)
-      }))
+    this.on('fail', (testOrHook, err) => {
+      let test = testOrHook
+      const isHook = testOrHook.type === 'hook'
+      if (isHook && testOrHook.ctx) {
+        test = testOrHook.ctx.currentTest
+      }
+      const asyncResource = getTestAsyncResource(test)
+      if (asyncResource) {
+        asyncResource.runInAsyncScope(() => {
+          if (isHook) {
+            err.message = `${testOrHook.title}: ${err.message}`
+            errorCh.publish(err)
+            // if it's a hook and it has failed, 'test end' will not be called
+            testFinishCh.publish('fail')
+          } else {
+            errorCh.publish(err)
+          }
+        })
+      }
+    })
 
-      try {
-        return runTest.apply(this, arguments)
-      } catch (err) {
-        errorCh.publish(err)
-        throw err
+    this.on('pending', (test) => {
+      const asyncResource = getTestAsyncResource(test)
+      if (asyncResource) {
+        asyncResource.runInAsyncScope(() => {
+          skipCh.publish(test)
+        })
+      } else {
+        // if there is no async resource, the test has been skipped through `test.skip``
+        const skippedTestAsyncResource = new AsyncResource('bound-anonymous-fn')
+        testToAr.set(test, skippedTestAsyncResource)
+        skippedTestAsyncResource.runInAsyncScope(() => {
+          skipCh.publish(test)
+        })
       }
     })
+
+    return run.apply(this, arguments)
   })
 
   shimmer.wrap(Runner.prototype, 'runTests', runTests => function () {
-    if (!suiteFinishCh.hasSubscribers) {
+    if (!testRunFinishCh.hasSubscribers) {
       return runTests.apply(this, arguments)
     }
     this.once('end', AsyncResource.bind(() => {
       testRunFinishCh.publish()
     }))
-    runTests.apply(this, arguments)
-    const suite = arguments[0]
-    // We call `getAllTestsInSuite` with the root suite so every skipped test
-    // should already have an associated test span.
-    const tests = getAllTestsInSuite(suite)
-    suiteFinishCh.publish(tests)
-  })
-
-  shimmer.wrap(Runner.prototype, 'fail', fail => function (hook, error) {
-    if (!hookErrorCh.hasSubscribers) {
-      return fail.apply(this, arguments)
-    }
-    if (error && hook.ctx && hook.ctx.currentTest) {
-      error.message = `${hook.title}: ${error.message}`
-      hookErrorCh.publish({ test: hook.ctx.currentTest, error })
-    }
-    return fail.apply(this, arguments)
+    return runTests.apply(this, arguments)
   })
 
   return Runner
@@ -129,6 +160,41 @@ addHook({
   file: 'lib/runner.js'
 }, mochaHook)
 
+addHook({
+  name: 'mocha',
+  versions: ['>=5.2.0'],
+  file: 'lib/runnable.js'
+}, (Runnable) => {
+  shimmer.wrap(Runnable.prototype, 'run', run => function () {
+    const isBeforeEach = this.parent._beforeEach.includes(this)
+    const isAfterEach = this.parent._afterEach.includes(this)
+
+    const isTestHook = isBeforeEach || isAfterEach
+
+    // we restore the original user defined function
+    if (this.fn.asyncResource) {
+      const originalFn = originalFns.get(this.fn)
+      this.fn = originalFn
+    }
+
+    if (isTestHook || this.type === 'test') {
+      const test = isTestHook ? this.ctx.currentTest : this
+      const asyncResource = getTestAsyncResource(test)
+
+      // we bind the test fn to the correct async resource
+      const newFn = asyncResource.bind(this.fn)
+
+      // we store the original function, not to lose it
+      originalFns.set(newFn, this.fn)
+
+      this.fn = newFn
+    }
+
+    return run.apply(this, arguments)
+  })
+  return Runnable
+})
+
 addHook({
   name: 'mocha-each',
   versions: ['>=2.0.1']

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

@@ -0,0 +1,140 @@
+'use strict'
+
+// TODO: either instrument all or none of the render functions
+
+const { channel, addHook, AsyncResource } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const startChannel = channel('apm:next:request:start')
+const finishChannel = channel('apm:next:request:finish')
+const errorChannel = channel('apm:next:request:error')
+const pageLoadChannel = channel('apm:next:page:load')
+
+const requestResources = new WeakMap()
+
+function wrapHandleRequest (handleRequest) {
+  return function (req, res, pathname, query) {
+    return instrument(req, res, () => handleRequest.apply(this, arguments))
+  }
+}
+
+function wrapHandleApiRequest (handleApiRequest) {
+  return function (req, res, pathname, query) {
+    return instrument(req, res, () => {
+      const promise = handleApiRequest.apply(this, arguments)
+
+      return promise.then(handled => {
+        if (!handled) return handled
+
+        const page = getPageFromPath(pathname, this.dynamicRoutes)
+
+        pageLoadChannel.publish({ page })
+
+        return handled
+      })
+    })
+  }
+}
+
+function wrapRenderToResponse (renderToResponse) {
+  return function (ctx) {
+    return instrument(ctx.req, ctx.res, () => renderToResponse.apply(this, arguments))
+  }
+}
+
+function wrapRenderErrorToResponse (renderErrorToResponse) {
+  return function (ctx) {
+    return instrument(ctx.req, ctx.res, () => renderErrorToResponse.apply(this, arguments))
+  }
+}
+
+function wrapRenderToHTML (renderToHTML) {
+  return function (req, res, pathname, query, parsedUrl) {
+    return instrument(req, res, () => renderToHTML.apply(this, arguments))
+  }
+}
+
+function wrapRenderErrorToHTML (renderErrorToHTML) {
+  return function (err, req, res, pathname, query) {
+    return instrument(req, res, () => renderErrorToHTML.apply(this, arguments))
+  }
+}
+
+function wrapFindPageComponents (findPageComponents) {
+  return function (pathname, query) {
+    const result = findPageComponents.apply(this, arguments)
+
+    if (result) {
+      pageLoadChannel.publish({ page: pathname })
+    }
+
+    return result
+  }
+}
+
+function getPageFromPath (page, dynamicRoutes = []) {
+  for (const dynamicRoute of dynamicRoutes) {
+    if (dynamicRoute.page.startsWith('/api') && dynamicRoute.match(page)) {
+      return dynamicRoute.page
+    }
+  }
+
+  return page
+}
+
+function instrument (req, res, handler) {
+  if (requestResources.has(req)) return handler()
+
+  const requestResource = new AsyncResource('bound-anonymous-fn')
+
+  requestResources.set(req, requestResource)
+
+  return requestResource.runInAsyncScope(() => {
+    startChannel.publish({ req, res })
+
+    try {
+      const promise = handler()
+
+      return promise.then(
+        result => finish(req, res, result),
+        err => finish(req, res, null, err)
+      )
+    } catch (e) {
+      finish(req, res, null, e)
+    }
+  })
+}
+
+function finish (req, res, result, err) {
+  if (err) {
+    errorChannel.publish(err)
+  }
+
+  finishChannel.publish({ req, res })
+
+  return result || err
+}
+
+addHook({ name: 'next', versions: ['>=11.1'], file: 'dist/server/next-server.js' }, nextServer => {
+  const Server = nextServer.default
+
+  shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)
+  shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequest)
+  shimmer.wrap(Server.prototype, 'renderToResponse', wrapRenderToResponse)
+  shimmer.wrap(Server.prototype, 'renderErrorToResponse', wrapRenderErrorToResponse)
+  shimmer.wrap(Server.prototype, 'findPageComponents', wrapFindPageComponents)
+
+  return nextServer
+})
+
+addHook({ name: 'next', versions: ['>=9.5 <11.1'], file: 'dist/next-server/server/next-server.js' }, nextServer => {
+  const Server = nextServer.default
+
+  shimmer.wrap(Server.prototype, 'handleRequest', wrapHandleRequest)
+  shimmer.wrap(Server.prototype, 'handleApiRequest', wrapHandleApiRequest)
+  shimmer.wrap(Server.prototype, 'renderToHTML', wrapRenderToHTML)
+  shimmer.wrap(Server.prototype, 'renderErrorToHTML', wrapRenderErrorToHTML)
+  shimmer.wrap(Server.prototype, 'findPageComponents', wrapFindPageComponents)
+
+  return nextServer
+})

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

@@ -7,6 +7,7 @@ const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 
 function createWrapRouterMethod (name) {
   const enterChannel = channel(`apm:${name}:middleware:enter`)
+  const exitChannel = channel(`apm:${name}:middleware:exit`)
   const errorChannel = channel(`apm:${name}:middleware:error`)
   const nextChannel = channel(`apm:${name}:middleware:next`)
 
@@ -51,6 +52,7 @@ function createWrapRouterMethod (name) {
         } catch (e) {
           errorChannel.publish(e)
           nextChannel.publish({ req })
+          exitChannel.publish({ req })
 
           throw e
         }
@@ -93,6 +95,7 @@ function createWrapRouterMethod (name) {
       }
 
       nextChannel.publish({ req })
+      exitChannel.publish({ req })
 
       next.apply(null, arguments)
     }

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

@@ -13,7 +13,7 @@ addHook({ name: 'tedious', versions: [ '>=1.0.0' ] }, tedious => {
   const errorCh = channel('apm:tedious:request:error')
   shimmer.wrap(tedious.Connection.prototype, 'makeRequest', makeRequest => function (request) {
     if (!startCh.hasSubscribers) {
-      return request.apply(this, arguments)
+      return makeRequest.apply(this, arguments)
     }
 
     const queryOrProcedure = getQueryOrProcedure(request)