feature(node): Add a Hono error handler

Author: Karibash

packages/node-core/src/utils/ensureIsWrapped.ts

@@ -9,7 +9,7 @@ import { createMissingInstrumentationContext } from './createMissingInstrumentat
  */
 export function ensureIsWrapped(
   maybeWrappedFunction: unknown,
-  name: 'express' | 'connect' | 'fastify' | 'hapi' | 'koa',
+  name: 'express' | 'connect' | 'fastify' | 'hapi' | 'koa' | 'hono',
 ): void {
   const clientOptions = getClient<NodeClient>()?.getOptions();
   if (

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

@@ -1,7 +1,22 @@
-import type { IntegrationFn } from '@sentry/core';
-import { defineIntegration } from '@sentry/core';
-import { generateInstrumentOnce } from '@sentry/node-core';
+import { ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_ROUTE } from '@opentelemetry/semantic-conventions';
+import type { IntegrationFn, Span } from '@sentry/core';
+import {
+  captureException,
+  debug,
+  defineIntegration,
+  getClient,
+  getDefaultIsolationScope,
+  getIsolationScope,
+  httpRequestToRequestData,
+  SEMANTIC_ATTRIBUTE_SENTRY_OP,
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+  spanToJSON,
+} from '@sentry/core';
+import { ensureIsWrapped, generateInstrumentOnce } from '@sentry/node-core';
+import { DEBUG_BUILD } from '../../../debug-build';
+import { AttributeNames } from './constants';
 import { HonoInstrumentation } from './instrumentation';
+import type { Context, MiddlewareHandler, MiddlewareHandlerInterface, Next } from './types';
 
 const INTEGRATION_NAME = 'Hono';
 
@@ -33,3 +48,104 @@ const _honoIntegration = (() => {
  * ```
  */
 export const honoIntegration = defineIntegration(_honoIntegration);
+
+interface HonoHandlerOptions {
+  /**
+   * Callback method deciding whether error should be captured and sent to Sentry
+   * @param error Captured Hono error
+   */
+  shouldHandleError: (context: Context) => boolean;
+}
+
+function honoRequestHandler(): MiddlewareHandler {
+  return async function sentryRequestMiddleware(context: Context, next: Next): Promise<void> {
+    const normalizedRequest = httpRequestToRequestData(context.req);
+    getIsolationScope().setSDKProcessingMetadata({ normalizedRequest });
+    await next();
+  };
+}
+
+function defaultShouldHandleError(context: Context): boolean {
+  const statusCode = context.res.status;
+  return statusCode >= 500;
+}
+
+function honoErrorHandler(options?: Partial<HonoHandlerOptions>): MiddlewareHandler {
+  return async function sentryErrorMiddleware(context: Context, next: Next): Promise<void> {
+    await next();
+
+    const shouldHandleError = options?.shouldHandleError || defaultShouldHandleError;
+    if (shouldHandleError(context)) {
+      (context.res as { sentry?: string }).sentry = captureException(context.error, {
+        mechanism: {
+          type: 'hono',
+          handled: false,
+        },
+      });
+    }
+  };
+}
+
+function addHonoSpanAttributes(span: Span): void {
+  const attributes = spanToJSON(span).data;
+  const type = attributes[AttributeNames.HONO_TYPE];
+  if (attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] || !type) {
+    return;
+  }
+
+  span.setAttributes({
+    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.otel.hono',
+    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `${type}.hono`,
+  });
+
+  const name = attributes[AttributeNames.HONO_NAME];
+  if (typeof name === 'string') {
+    span.updateName(name);
+  }
+
+  if (getIsolationScope() === getDefaultIsolationScope()) {
+    DEBUG_BUILD && debug.warn('Isolation scope is default isolation scope - skipping setting transactionName');
+    return;
+  }
+
+  const route = attributes[ATTR_HTTP_ROUTE];
+  const method = attributes[ATTR_HTTP_REQUEST_METHOD];
+  if (typeof route === 'string' && typeof method === 'string') {
+    getIsolationScope().setTransactionName(`${method} ${route}`);
+  }
+}
+
+/**
+ * Add a Hono error handler to capture errors to Sentry.
+ *
+ * @param app The Hono instances
+ * @param options Configuration options for the handler
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const { Hono } = require("hono");
+ *
+ * const app = new Hono();
+ *
+ * Sentry.setupHonoErrorHandler(app);
+ *
+ * // Add your routes, etc.
+ * ```
+ */
+export function setupHonoErrorHandler(
+  app: { use: MiddlewareHandlerInterface },
+  options?: Partial<HonoHandlerOptions>,
+): void {
+  app.use(honoRequestHandler());
+  app.use(honoErrorHandler(options));
+
+  const client = getClient();
+  if (client) {
+    client.on('spanStart', span => {
+      addHonoSpanAttributes(span);
+    });
+  }
+
+  ensureIsWrapped(app.use, 'hono');
+}

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

@@ -1,11 +1,14 @@
 // Vendored from: https://github.com/honojs/hono/blob/855e5b1adbf685bf4b3e6b76573aa7cb0a108d04/src/request.ts#L30
 export type HonoRequest = {
   path: string;
+  method: string;
 };
 
 // Vendored from: https://github.com/honojs/hono/blob/855e5b1adbf685bf4b3e6b76573aa7cb0a108d04/src/context.ts#L291
 export type Context = {
   req: HonoRequest;
+  res: Response;
+  error: Error | undefined;
 };
 
 // Vendored from: https://github.com/honojs/hono/blob/855e5b1adbf685bf4b3e6b76573aa7cb0a108d04/src/types.ts#L36C1-L36C39