instrumentation: add hono support (#6061)

The instrumentation does not yet handle middlewares, while
the basic functionality should work just fine.

---------

Co-authored-by: Luke Dunscombe <dunscombe1@gmail.com>

Author: 2 people

.github/workflows/apm-integrations.yml

@@ -438,6 +438,14 @@ jobs:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       - uses: ./.github/actions/plugins/test
 
+  hono:
+    runs-on: ubuntu-latest
+    env:
+      PLUGINS: hono
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: ./.github/actions/plugins/test
+
   http:
     strategy:
       matrix:

docs/test.ts

@@ -339,6 +339,8 @@ tracer.use('grpc', { client: { metadata: [] } });
 tracer.use('grpc', { server: { metadata: [] } });
 tracer.use('hapi');
 tracer.use('hapi', httpServerOptions);
+tracer.use('hono');
+tracer.use('hono', httpServerOptions);
 tracer.use('http');
 tracer.use('http', {
   server: httpServerOptions

index.d.ts

@@ -186,6 +186,7 @@ interface Plugins {
   "graphql": tracer.plugins.graphql;
   "grpc": tracer.plugins.grpc;
   "hapi": tracer.plugins.hapi;
+  "hono": tracer.plugins.hono;
   "http": tracer.plugins.http;
   "http2": tracer.plugins.http2;
   "ioredis": tracer.plugins.ioredis;
@@ -1603,6 +1604,12 @@ declare namespace tracer {
      */
     interface hapi extends HttpServer {}
 
+    /**
+     * This plugin automatically instruments the
+     * [hono](https://hono.dev/) module.
+     */
+    interface hono extends HttpServer {}
+
     /**
      * This plugin automatically instruments the
      * [http](https://nodejs.org/api/http.html) module.

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

@@ -58,6 +58,7 @@ module.exports = {
   grpc: () => require('../grpc'),
   handlebars: () => require('../handlebars'),
   hapi: () => require('../hapi'),
+  hono: { esmFirst: true, fn: () => require('../hono') },
   http: () => require('../http'),
   http2: () => require('../http2'),
   https: () => require('../http'),

packages/datadog-instrumentations/src/helpers/register.js

@@ -207,7 +207,7 @@ function filename (name, file) {
 // This function captures the instrumentation file name for a given package by parsing the hook require
 // function given the module name. It is used to ensure that instrumentations such as redis
 // that have several different modules being hooked, ie: 'redis' main package, and @redis/client submodule
-// return a consistent instrumentation name. This is used later to ensure that atleast some portion of
+// return a consistent instrumentation name. This is used later to ensure that at least some portion of
 // the integration was successfully instrumented. Prevents incorrect `Found incompatible integration version: ` messages
 // Example:
 //                  redis -> "() => require('../redis')" -> redis

packages/datadog-instrumentations/src/hono.js

@@ -0,0 +1,102 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  addHook,
+  channel
+} = require('./helpers/instrument')
+
+const routeChannel = channel('apm:hono:request:route')
+const handleChannel = channel('apm:hono:request:handle')
+const errorChannel = channel('apm:hono:request:error')
+
+function wrapFetch (fetch) {
+  return function (request, env, executionCtx) {
+    handleChannel.publish({ req: env.incoming })
+    return fetch.apply(this, arguments)
+  }
+}
+
+function wrapCompose (compose) {
+  return function (middleware, onError, onNotFound) {
+    const instrumentedOnError = (...args) => {
+      const [error, context] = args
+      const req = context.env.incoming
+      errorChannel.publish({ req, error })
+      return onError(...args)
+    }
+
+    const instrumentedMiddlewares = middleware.map(h => {
+      const [[fn, meta], params] = h
+
+      // TODO: handle middleware instrumentation
+      const instrumentedFn = (...args) => {
+        const context = args[0]
+        const req = context.env.incoming
+        const route = meta.path
+        routeChannel.publish({
+          req,
+          route
+        })
+        return fn(...args)
+      }
+      return [[instrumentedFn, meta], params]
+    })
+    return compose.apply(this, [instrumentedMiddlewares, instrumentedOnError, onNotFound])
+  }
+}
+
+addHook({
+  name: 'hono',
+  versions: ['>=4'],
+  file: 'dist/hono.js'
+}, hono => {
+  class Hono extends hono.Hono {
+    constructor (...args) {
+      super(...args)
+      shimmer.wrap(this, 'fetch', wrapFetch)
+    }
+  }
+
+  hono.Hono = Hono
+
+  return hono
+})
+
+addHook({
+  name: 'hono',
+  versions: ['>=4'],
+  file: 'dist/cjs/hono.js'
+}, hono => {
+  class Hono extends hono.Hono {
+    constructor (...args) {
+      super(...args)
+      shimmer.wrap(this, 'fetch', wrapFetch)
+    }
+  }
+
+  return Object.create(hono, {
+    Hono: {
+      get () {
+        return Hono
+      },
+      enumerable: true,
+    }
+  })
+})
+
+addHook({
+  name: 'hono',
+  versions: ['>=4'],
+  file: 'dist/cjs/compose.js'
+}, Compose => {
+  return shimmer.wrap(Compose, 'compose', wrapCompose, { replaceGetter: true })
+})
+
+addHook({
+  name: 'hono',
+  versions: ['>=4'],
+  file: 'dist/compose.js'
+}, Compose => {
+  return shimmer.wrap(Compose, 'compose', wrapCompose)
+})

packages/datadog-plugin-hono/src/index.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const RouterPlugin = require('../../datadog-plugin-router/src')
+const web = require('../../dd-trace/src/plugins/util/web')
+
+class HonoPlugin extends RouterPlugin {
+  static get id () {
+    return 'hono'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:hono:request:handle', ({ req }) => {
+      this.setFramework(req, 'hono', this.config)
+    })
+
+    this.addSub('apm:hono:request:route', ({ req, route }) => {
+      web.setRoute(req, route)
+    })
+
+    this.addSub('apm:hono:request:error', ({ req, error }) => {
+      web.addError(req, error)
+    })
+  }
+}
+
+module.exports = HonoPlugin