@senzops/apm-node 1.0.1 → 1.1.1

package/src/wrappers/next.ts

@@ -1,74 +1,65 @@
 import { client } from '../core/client';
 import { normalizePath } from '../core/normalizer';
 
-// --- App Router Wrapper (GET, POST, etc.) ---
+// --- App Router Wrapper (Route Handlers) ---
 export const wrapNextRoute = (handler: Function) => {
   return async (req: Request | any, context?: any) => {
-    const start = performance.now();
-    let status = 200;
+    // 1. Extract Info
+    const url = req.url ? new URL(req.url) : { pathname: '/' };
+    const method = req.method || 'GET';
+    const ua = req.headers.get ? req.headers.get('user-agent') : undefined;
+    const ip = req.headers.get ? req.headers.get('x-forwarded-for') : undefined;
 
-    try {
-      const response = await handler(req, context);
-      if (response && typeof response.status === 'number') {
-        status = response.status;
+    // 2. Run in Context
+    return client.startTrace({
+      method,
+      path: url.pathname,
+      userAgent: ua,
+      ip: ip
+    }, async () => {
+      try {
+        const response = await handler(req, context);
+        const status = response?.status || 200;
+        
+        client.endTrace(status, { route: normalizePath(url.pathname) });
+        return response;
+      } catch (err: any) {
+        client.endTrace(500, { route: normalizePath(url.pathname) });
+        throw err;
       }
-      return response;
-    } catch (err: any) {
-      status = 500;
-      throw err;
-    } finally {
-      const duration = performance.now() - start;
-
-      // App Router Request is a standard Web Request object
-      const url = req.url ? new URL(req.url) : { pathname: '/' };
-
-      // In App Router, we often rely on file-system path, but context.params helps
-      // For now, robust heuristic normalization is best
-      const route = normalizePath(url.pathname);
-
-      client.track({
-        method: req.method || 'GET',
-        route: route,
-        path: url.pathname,
-        status: status,
-        duration: duration,
-        userAgent: req.headers.get ? req.headers.get('user-agent') : undefined,
-        // IP extraction from Web Request is tricky without headers
-        ip: req.headers.get ? req.headers.get('x-forwarded-for') : undefined,
-      });
-
-      // Vercel/Serverless Flush Safety
-      // We purposefully do NOT await flush here to avoid latency.
-      // Ideally user configures transport to sync flush or uses waitUntil
-    }
+    });
   };
 };
 
-// --- Pages Router Wrapper (req, res) ---
+// --- Pages Router Wrapper (API Routes) ---
 export const wrapNextPages = (handler: Function) => {
   return async (req: any, res: any) => {
-    const start = performance.now();
+    const path = req.url ? req.url.split('?')[0] : '/';
+    
+    // 1. Run in Context
+    return client.startTrace({
+      method: req.method || 'GET',
+      path: path,
+      userAgent: req.headers['user-agent'],
+      ip: req.headers['x-forwarded-for'] || req.socket?.remoteAddress,
+    }, async () => {
+      
+      // 2. Hook Response
+      const done = () => {
+        client.endTrace(res.statusCode || 200, { route: normalizePath(path) });
+      };
+      
+      res.once('finish', done);
+      res.once('close', done); // Fallback if finish doesn't fire
 
-    // Hook into response finish
-    const done = () => {
-      const duration = performance.now() - start;
-      const path = req.url || '/';
-
-      client.track({
-        method: req.method || 'GET',
-        route: normalizePath(path.split('?')[0]),
-        path: path,
-        status: res.statusCode || 200,
-        duration: duration,
-        ip: req.headers['x-forwarded-for'] || req.socket?.remoteAddress,
-        userAgent: req.headers['user-agent']
-      });
-    };
-
-    res.once('finish', done);
-    // Handle error case if next/error isn't used
-    res.once('close', done);
-
-    return handler(req, res);
+      // 3. Execute
+      try {
+        return await handler(req, res);
+      } catch (e) {
+        // Next.js Pages router usually handles errors internally, 
+        // but we ensure we catch sync errors here
+        throw e;
+      }
+    });
   };
 };

package/wiki.md

@@ -94,4 +94,27 @@ import { Senzor } from '@senzops/apm-node';
 
 fastify.register(Senzor.fastifyPlugin, { apiKey: '...' });
 ```
-This approach provides **native robustness** for each framework. It captures errors (500s), 404s (Route not found), and correct timing without the user manually writing `track()` calls.
+This approach provides **native robustness** for each framework. It captures errors (500s), 404s (Route not found), and correct timing without the user manually writing `track()` calls.
+
+## How Users Add Spans (Waterfall)
+Now your users can do this in their Express/Next.js apps:
+
+```js
+app.get('/users', async (req, res) => {
+  // 1. Start a span
+  const dbSpan = Senzor.startSpan('fetch_users_db', 'db');
+  
+  const users = await db.query('SELECT * FROM users');
+  
+  // 2. End span (Duration calculated automatically)
+  dbSpan.end({ query: 'SELECT * FROM users' });
+
+  // 3. Start another span
+  const apiSpan = Senzor.startSpan('stripe_api', 'http');
+  await axios.get('...');
+  apiSpan.end({}, 200);
+
+  res.json(users);
+});
+```
+This will automatically appear in your **Waterfall Chart** on the dashboard, nested under the main request Trace.