@senzops/apm-node 1.2.4 → 1.2.6

package/src/wrappers/next.ts

@@ -1,7 +1,7 @@
-import { client } from '../core/client';
-import { normalizePath } from '../core/normalizer';
-import { invokeWithFrameworkSpan } from '../instrumentation/framework';
-import { getClientIp } from '../utils/getClientIp';
+import { client } from '../core/client';
+import { normalizePath } from '../core/normalizer';
+import { invokeWithFrameworkSpan } from '../instrumentation/framework';
+import { getClientIp } from '../utils/getClientIp';
 
 // --- App Router Wrapper ---
 export const wrapNextRoute = (handler: Function) => {
@@ -38,39 +38,40 @@ export const wrapNextRoute = (handler: Function) => {
       userAgent: ua,
       ip: ip || getClientIp(req),
       headers: headers // Pass extracted headers
-    }, async () => {
-      try {
-        const route = normalizePath(url.pathname);
-        const response = await invokeWithFrameworkSpan(
-          handler,
-          undefined,
-          [req, context],
-          {
-            framework: 'next',
-            type: 'route_handler',
-            name: `next.app_route_handler ${method} ${route}`,
-            route,
-            method,
-            request: req,
-            attributes: {
-              'next.router': 'app',
-              'http.route': route,
-              'url.path': url.pathname
-            }
-          },
-          undefined,
-          {
-            callbackCompletesSpan: false,
-            responseEndsSpan: false
-          }
-        );
-        const status = response?.status || 200;
-
-        client.endTrace(status, { route });
-        return response;
-      } catch (err: any) {
-        client.captureError(err);
-        client.endTrace(500, { route: normalizePath(url.pathname) });
+    }, async () => {
+      try {
+        const route = normalizePath(url.pathname);
+        const response = await invokeWithFrameworkSpan(
+          handler,
+          undefined,
+          [req, context],
+          {
+            framework: 'next',
+            type: 'route_handler',
+            name: `next.app_route_handler ${method} ${route}`,
+            route,
+            method,
+            handlerName: (handler as any).name || 'handler',
+            request: req,
+            attributes: {
+              'next.router': 'app',
+              'http.route': route,
+              'url.path': url.pathname
+            }
+          },
+          undefined,
+          {
+            callbackCompletesSpan: false,
+            responseEndsSpan: false
+          }
+        );
+        const status = response?.status || 200;
+
+        client.endTrace(status, { route });
+        return response;
+      } catch (err: any) {
+        client.captureError(err);
+        client.endTrace(500, { route: normalizePath(url.pathname) });
         throw err;
       }
     });
@@ -95,37 +96,38 @@ export const wrapNextPages = (handler: Function) => {
       };
 
       res.once('finish', done);
-      res.once('close', done);
-
-      try {
-        const route = normalizePath(path);
-        return await invokeWithFrameworkSpan(
-          handler,
-          undefined,
-          [req, res],
-          {
-            framework: 'next',
-            type: 'route_handler',
-            name: `next.pages_api_handler ${req.method || 'GET'} ${route}`,
-            route,
-            method: req.method || 'GET',
-            request: req,
-            response: res,
-            attributes: {
-              'next.router': 'pages',
-              'http.route': route
-            }
-          },
-          undefined,
-          {
-            callbackCompletesSpan: false,
-            responseEndsSpan: true
-          }
-        );
-      } catch (e: any) {
-        client.captureError(e);
-        throw e;
+      res.once('close', done);
+
+      try {
+        const route = normalizePath(path);
+        return await invokeWithFrameworkSpan(
+          handler,
+          undefined,
+          [req, res],
+          {
+            framework: 'next',
+            type: 'route_handler',
+            name: `next.pages_api_handler ${req.method || 'GET'} ${route}`,
+            route,
+            method: req.method || 'GET',
+            handlerName: (handler as any).name || 'handler',
+            request: req,
+            response: res,
+            attributes: {
+              'next.router': 'pages',
+              'http.route': route
+            }
+          },
+          undefined,
+          {
+            callbackCompletesSpan: false,
+            responseEndsSpan: true
+          }
+        );
+      } catch (e: any) {
+        client.captureError(e);
+        throw e;
       }
     });
   };
-};
+};

package/src/wrappers/nitro.ts

@@ -0,0 +1,60 @@
+import { client } from '../core/client';
+import { getRoute, normalizePath } from '../core/normalizer';
+import { getClientIp } from '../utils/getClientIp';
+
+export interface NitroApp {
+  h3App: {
+    handler: (event: any) => Promise<any>;
+    stack: any[];
+  };
+  hooks: any;
+  [key: string]: any;
+}
+
+export const nitroPlugin = (nitroApp: NitroApp) => {
+  if (!nitroApp.h3App || !nitroApp.h3App.handler) return;
+
+  const originalHandler = nitroApp.h3App.handler;
+
+  nitroApp.h3App.handler = async (event: any) => {
+    const req = event.node?.req || event.req;
+    const path = req?.originalUrl || req?.url || (event.path as string) || '/';
+    const method = req?.method || (event.method as string) || 'GET';
+
+    const headers = req?.headers || {};
+
+    return client.startTrace({
+      method,
+      path,
+      route: normalizePath(path),
+      ip: getClientIp({ headers, socket: req?.socket }),
+      userAgent: headers['user-agent'],
+      headers
+    }, async () => {
+      let status = 200;
+      try {
+        const response = await originalHandler(event);
+
+        if (event.node?.res?.statusCode) status = event.node.res.statusCode;
+        if (response?.status) status = response.status;
+
+        client.endTrace(status, { route: getRoute(event, path) });
+        return response;
+      } catch (err: any) {
+        status = err.statusCode || err.status || 500;
+        client.captureError(err);
+        client.endTrace(status, { route: getRoute(event, path) });
+        throw err;
+      } finally {
+        const cfCtx = event.context?.cloudflare?.context || event.context?.cf || event.context;
+        const waitUntil = cfCtx?.waitUntil || event.waitUntil;
+
+        if (waitUntil && typeof waitUntil === 'function') {
+          waitUntil(client.flush());
+        } else {
+          client.flush().catch(() => {});
+        }
+      }
+    });
+  };
+};

package/src/wrappers/worker.ts

@@ -0,0 +1,45 @@
+import { client } from '../core/client';
+import { normalizePath } from '../core/normalizer';
+import { getClientIp } from '../utils/getClientIp';
+
+type WorkerHandler = (request: Request, env: any, ctx: any) => Promise<Response>;
+
+export const wrapWorker = (handler: WorkerHandler) => {
+  return async (request: Request, env: any, ctx: any) => {
+    const url = new URL(request.url);
+    const path = url.pathname;
+    const method = request.method || 'GET';
+
+    const headers: Record<string, string> = {};
+    request.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+
+    return client.startTrace({
+      method,
+      path,
+      route: normalizePath(path),
+      ip: getClientIp({ headers }),
+      userAgent: headers['user-agent'],
+      headers
+    }, async () => {
+      let status = 500;
+      try {
+        const response = await handler(request, env, ctx);
+        status = response.status;
+        return response;
+      } catch (err: any) {
+        client.captureError(err);
+        throw err;
+      } finally {
+        client.endTrace(status, { route: normalizePath(path) });
+
+        if (ctx && typeof ctx.waitUntil === 'function') {
+          ctx.waitUntil(client.flush());
+        } else {
+          await client.flush();
+        }
+      }
+    });
+  };
+};

package/tsup.config.ts

@@ -1,5 +1,11 @@
 import { defineConfig } from 'tsup';
 
+const NODE_BUILTINS = [
+  'http', 'https', 'url', 'net', 'module', 'crypto', 'async_hooks',
+  'node:http', 'node:https', 'node:url', 'node:net', 'node:module',
+  'node:crypto', 'node:async_hooks'
+];
+
 export default defineConfig([
   {
     entry: ['src/index.ts', 'src/register.ts'],
@@ -9,6 +15,8 @@ export default defineConfig([
     minify: true,
     sourcemap: true,
     splitting: false,
+    external: NODE_BUILTINS,
+    noExternal: [],
   },
   {
     entry: ['src/index.ts'],
@@ -17,5 +25,6 @@ export default defineConfig([
     minify: true,
     sourcemap: true,
     splitting: false,
+    external: NODE_BUILTINS,
   }
 ]);