feat: add middleware enter/exit/finish instrumentations to hono (#7198)

Co-authored-by: Long Ho <longlho@users.noreply.github.com>

Author: BridgeAR

packages/datadog-instrumentations/src/hono.js

@@ -9,6 +9,10 @@ const {
 const routeChannel = channel('apm:hono:request:route')
 const handleChannel = channel('apm:hono:request:handle')
 const errorChannel = channel('apm:hono:request:error')
+const nextChannel = channel('apm:hono:middleware:next')
+const enterChannel = channel('apm:hono:middleware:enter')
+const exitChannel = channel('apm:hono:middleware:exit')
+const finishChannel = channel('apm:hono:middleware:finish')
 
 function wrapFetch (fetch) {
   return function (request, env, executionCtx) {
@@ -34,21 +38,62 @@ function wrapCompose (compose) {
 
     const instrumentedMiddlewares = middlewares.map(h => {
       const [[fn, meta], params] = h
-
-      const instrumentedFn = (...args) => {
-        const context = args[0]
-        routeChannel.publish({
-          req: context.env.incoming,
-          route: meta?.path
-        })
-        return fn(...args)
-      }
-      return [[instrumentedFn, meta], params]
+      return [[wrapMiddleware(fn, meta?.path), meta], params]
     })
     return compose.call(this, instrumentedMiddlewares, instrumentedOnError, onNotFound)
   }
 }
 
+function wrapNext (req, route, next) {
+  return shimmer.wrapFunction(
+    next,
+    (next) =>
+      function () {
+        nextChannel.publish({ req, route })
+
+        return next.apply(this, arguments)
+      }
+  )
+}
+
+function wrapMiddleware (middleware, route) {
+  const name = middleware.name
+  return shimmer.wrapFunction(
+    middleware,
+    (middleware) =>
+      function (context, next) {
+        const req = context.env.incoming
+        routeChannel.publish({ req, route })
+        enterChannel.publish({ req, name, route })
+        if (typeof next === 'function') {
+          arguments[1] = wrapNext(req, route, next)
+        }
+        try {
+          const result = middleware.apply(this, arguments)
+          if (result && typeof result.then === 'function') {
+            return result.then(
+              (result) => {
+                finishChannel.publish({ req })
+                return result
+              },
+              (error) => {
+                errorChannel.publish({ req, error })
+                throw error
+              }
+            )
+          }
+          finishChannel.publish({ req })
+          return result
+        } catch (error) {
+          errorChannel.publish({ req, error })
+          throw error
+        } finally {
+          exitChannel.publish({ req, route })
+        }
+      }
+  )
+}
+
 addHook({
   name: 'hono',
   versions: ['>=4'],

packages/datadog-instrumentations/test/hono.spec.js

@@ -0,0 +1,142 @@
+'use strict'
+
+const assert = require('assert/strict')
+
+const axios = require('axios')
+const dc = require('dc-polyfill')
+const { describe, it, beforeEach, before, after } = require('mocha')
+const sinon = require('sinon')
+
+const agent = require('../../dd-trace/test/plugins/agent')
+const { withVersions } = require('../../dd-trace/test/setup/mocha')
+
+withVersions('hono', 'hono', version => {
+  describe('hono instrumentation', () => {
+    let routeChannelCb, handleChannelCb, errorChannelCb, nextChannelCb
+    let enterChannelCb, exitChannelCb, finishChannelCb
+    let port, server, middlewareCalled
+
+    const routeChannel = dc.channel('apm:hono:request:route')
+    const handleChannel = dc.channel('apm:hono:request:handle')
+    const errorChannel = dc.channel('apm:hono:request:error')
+    const nextChannel = dc.channel('apm:hono:middleware:next')
+    const enterChannel = dc.channel('apm:hono:middleware:enter')
+    const exitChannel = dc.channel('apm:hono:middleware:exit')
+    const finishChannel = dc.channel('apm:hono:middleware:finish')
+
+    before(() => {
+      return agent.load('hono', { client: false })
+    })
+
+    before((done) => {
+      const { Hono } = require(`../../../versions/hono@${version}`).get()
+      const { serve } = require('../../../versions/@hono/node-server').get()
+      const app = new Hono()
+
+      // Add a middleware
+      app.use(async function named (_c, next) {
+        middlewareCalled()
+        await next()
+      })
+
+      // Add a route
+      app.get('/test', (c) => {
+        return c.text('OK')
+      })
+
+      // Add an error route
+      app.get('/error', (_c) => {
+        throw new Error('test error')
+      })
+
+      server = serve({ port: 0, fetch: app.fetch }, (info) => {
+        port = info.port
+        done()
+      })
+    })
+
+    beforeEach(() => {
+      routeChannelCb = sinon.stub()
+      handleChannelCb = sinon.stub()
+      errorChannelCb = sinon.stub()
+      nextChannelCb = sinon.stub()
+      enterChannelCb = sinon.stub()
+      exitChannelCb = sinon.stub()
+      finishChannelCb = sinon.stub()
+      middlewareCalled = sinon.stub()
+
+      routeChannel.subscribe(routeChannelCb)
+      handleChannel.subscribe(handleChannelCb)
+      errorChannel.subscribe(errorChannelCb)
+      nextChannel.subscribe(nextChannelCb)
+      enterChannel.subscribe(enterChannelCb)
+      exitChannel.subscribe(exitChannelCb)
+      finishChannel.subscribe(finishChannelCb)
+    })
+
+    afterEach(() => {
+      routeChannel.unsubscribe(routeChannelCb)
+      handleChannel.unsubscribe(handleChannelCb)
+      errorChannel.unsubscribe(errorChannelCb)
+      nextChannel.unsubscribe(nextChannelCb)
+      enterChannel.unsubscribe(enterChannelCb)
+      exitChannel.unsubscribe(exitChannelCb)
+      finishChannel.unsubscribe(finishChannelCb)
+    })
+
+    after(() => {
+      server.close()
+      return agent.close({ ritmReset: false })
+    })
+
+    it('should publish to handleChannel on request', async () => {
+      const res = await axios.get(`http://localhost:${port}/test`)
+
+      assert.strictEqual(res.data, 'OK')
+      sinon.assert.called(handleChannelCb)
+    })
+
+    it('should publish to middleware channels', async () => {
+      const res = await axios.get(`http://localhost:${port}/test`)
+
+      sinon.assert.called(routeChannelCb)
+      sinon.assert.calledOnce(middlewareCalled)
+
+      assert.strictEqual(res.data, 'OK')
+      sinon.assert.called(enterChannelCb)
+      let callArgs = enterChannelCb.firstCall.args[0]
+      assert.deepStrictEqual(Object.keys(callArgs), ['req', 'name', 'route'])
+      assert.strictEqual(callArgs.req.url, '/test')
+      assert.strictEqual(callArgs.name, 'named')
+
+      sinon.assert.called(nextChannelCb)
+      callArgs = nextChannelCb.firstCall.args[0]
+      assert.deepStrictEqual(Object.keys(callArgs), ['req', 'route'])
+      assert.strictEqual(callArgs.req.url, '/test')
+
+      sinon.assert.called(exitChannelCb)
+      callArgs = exitChannelCb.firstCall.args[0]
+      assert.deepStrictEqual(Object.keys(callArgs), ['req', 'route'])
+      assert.strictEqual(callArgs.req.url, '/test')
+
+      sinon.assert.called(finishChannelCb)
+      callArgs = finishChannelCb.firstCall.args[0]
+      assert.deepStrictEqual(Object.keys(callArgs), ['req'])
+      assert.strictEqual(callArgs.req.url, '/test')
+    })
+
+    it('should publish to errorChannel when middleware throws', async () => {
+      try {
+        await axios.get(`http://localhost:${port}/error`)
+      } catch (e) {
+        // Expected to fail
+      }
+
+      sinon.assert.called(errorChannelCb)
+      const callArgs = errorChannelCb.firstCall.args[0]
+      assert.deepStrictEqual(Object.keys(callArgs), ['req', 'error'])
+      assert.strictEqual(callArgs.req.url, '/error')
+      assert.strictEqual(callArgs.error.message, 'test error')
+    })
+  })
+})