feature(node): Add instrumentation to the handler in Hono

Author: Karibash

packages/node/src/integrations/tracing/hono/constants.ts

@@ -0,0 +1,13 @@
+export const AttributeNames = {
+  HONO_TYPE: 'hono.type',
+  HONO_NAME: 'hono.name',
+} as const;
+
+export type AttributeNames = (typeof AttributeNames)[keyof typeof AttributeNames];
+
+export const HonoTypes = {
+  MIDDLEWARE: 'middleware',
+  REQUEST_HANDLER: 'request_handler',
+} as const;
+
+export type HonoTypes = (typeof HonoTypes)[keyof typeof HonoTypes];

packages/node/src/integrations/tracing/hono/instrumentation.ts

@@ -1,5 +1,18 @@
+import type { Span } from '@opentelemetry/api';
+import { context, SpanStatusCode, trace } from '@opentelemetry/api';
 import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import type { HandlerInterface, Hono, HonoInstance, MiddlewareHandlerInterface, OnHandlerInterface } from './types';
+import { AttributeNames, HonoTypes } from './constants';
+import type {
+  Context,
+  Handler,
+  HandlerInterface,
+  Hono,
+  HonoInstance,
+  MiddlewareHandler,
+  MiddlewareHandlerInterface,
+  Next,
+  OnHandlerInterface,
+} from './types';
 
 const PACKAGE_NAME = '@sentry/instrumentation-hono';
 const PACKAGE_VERSION = '0.0.1';
@@ -50,10 +63,38 @@ export class HonoInstrumentation extends InstrumentationBase {
    * Patches the route handler to instrument it.
    */
   private _patchHandler(): (original: HandlerInterface) => HandlerInterface {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const instrumentation = this;
+
     return function (original: HandlerInterface) {
       return function wrappedHandler(this: HonoInstance, ...args: unknown[]) {
-        // TODO: Add OpenTelemetry tracing logic here
-        return original.apply(this, args);
+        if (typeof args[0] === 'string') {
+          const path = args[0];
+          if (args.length === 1) {
+            return original.apply(this, [path]);
+          }
+
+          const handlers = args.slice(1);
+          return original.apply(this, [
+            path,
+            ...handlers.map((handler, index) =>
+              instrumentation._wrapHandler(
+                index + 1 === handlers.length ? HonoTypes.REQUEST_HANDLER : HonoTypes.MIDDLEWARE,
+                handler as Handler | MiddlewareHandler,
+              ),
+            ),
+          ]);
+        }
+
+        return original.apply(
+          this,
+          args.map((handler, index) =>
+            instrumentation._wrapHandler(
+              index + 1 === args.length ? HonoTypes.REQUEST_HANDLER : HonoTypes.MIDDLEWARE,
+              handler as Handler | MiddlewareHandler,
+            ),
+          ),
+        );
       };
     };
   }
@@ -62,10 +103,21 @@ export class HonoInstrumentation extends InstrumentationBase {
    * Patches the 'on' handler to instrument it.
    */
   private _patchOnHandler(): (original: OnHandlerInterface) => OnHandlerInterface {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const instrumentation = this;
+
     return function (original: OnHandlerInterface) {
       return function wrappedHandler(this: HonoInstance, ...args: unknown[]) {
-        // TODO: Add OpenTelemetry tracing logic here
-        return original.apply(this, args);
+        const handlers = args.slice(2);
+        return original.apply(this, [
+          ...args.slice(0, 2),
+          ...handlers.map((handler, index) =>
+            instrumentation._wrapHandler(
+              index + 1 === handlers.length ? HonoTypes.REQUEST_HANDLER : HonoTypes.MIDDLEWARE,
+              handler as Handler | MiddlewareHandler,
+            ),
+          ),
+        ]);
       };
     };
   }
@@ -74,11 +126,107 @@ export class HonoInstrumentation extends InstrumentationBase {
    * Patches the middleware handler to instrument it.
    */
   private _patchMiddlewareHandler(): (original: MiddlewareHandlerInterface) => MiddlewareHandlerInterface {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const instrumentation = this;
+
     return function (original: MiddlewareHandlerInterface) {
       return function wrappedHandler(this: HonoInstance, ...args: unknown[]) {
-        // TODO: Add OpenTelemetry tracing logic here
-        return original.apply(this, args);
+        if (typeof args[0] === 'string') {
+          const path = args[0];
+          if (args.length === 1) {
+            return original.apply(this, [path]);
+          }
+
+          const handlers = args.slice(1);
+          return original.apply(this, [
+            path,
+            ...handlers.map(handler =>
+              instrumentation._wrapHandler(HonoTypes.MIDDLEWARE, handler as MiddlewareHandler),
+            ),
+          ]);
+        }
+
+        return original.apply(
+          this,
+          args.map(handler => instrumentation._wrapHandler(HonoTypes.MIDDLEWARE, handler as MiddlewareHandler)),
+        );
       };
     };
   }
+
+  /**
+   * Wraps a handler or middleware handler to apply instrumentation.
+   */
+  private _wrapHandler(type: HonoTypes, handler: Handler | MiddlewareHandler): Handler | MiddlewareHandler {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const instrumentation = this;
+
+    return function (this: unknown, c: Context, next: Next) {
+      if (!instrumentation.isEnabled()) {
+        return handler.apply(this, [c, next]);
+      }
+
+      const path = c.req.path;
+      const spanName = `${type.replace('_', ' ')} - ${path}`;
+      const span = instrumentation.tracer.startSpan(spanName, {
+        attributes: {
+          [AttributeNames.HONO_TYPE]: type,
+          [AttributeNames.HONO_NAME]: type === 'request_handler' ? path : handler.name || 'anonymous',
+        },
+      });
+
+      return context.with(trace.setSpan(context.active(), span), () => {
+        return instrumentation._safeExecute(
+          () => handler.apply(this, [c, next]),
+          () => span.end(),
+          error => {
+            instrumentation._handleError(span, error);
+            span.end();
+          },
+        );
+      });
+    };
+  }
+
+  /**
+   * Safely executes a function and handles errors.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private _safeExecute(execute: () => any, onSuccess: () => void, onFailure: (error: unknown) => void): () => any {
+    try {
+      const result = execute();
+
+      if (
+        result &&
+        typeof result === 'object' &&
+        typeof Object.getOwnPropertyDescriptor(result, 'then')?.value === 'function'
+      ) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        result.then(
+          () => onSuccess(),
+          (error: unknown) => onFailure(error),
+        );
+      } else {
+        onSuccess();
+      }
+
+      return result;
+    } catch (error: unknown) {
+      onFailure(error);
+      throw error;
+    }
+  }
+
+  /**
+   * Handles errors by setting the span status and recording the exception.
+   */
+  private _handleError(span: Span, error: unknown): void {
+    if (error instanceof Error) {
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error.message,
+      });
+      span.recordException(error);
+    }
+  }
 }