@senzops/apm-node 1.1.18 → 1.2.1

package/src/instrumentation/undici.ts

@@ -0,0 +1,189 @@
+import { normalizePath } from '../core/normalizer';
+import { SenzorOptions } from '../core/types';
+import { SENZOR_INTERNAL_HEADER } from '../utils/internal';
+import { generateTraceparent } from '../utils/traceContext';
+import { hookRequire } from './hook';
+import { patchMethod } from './patch';
+import { runWithCapturedSpan, startCapturedSpan } from './span';
+
+const hasInternalHeader = (headers: any): boolean => {
+  if (!headers) return false;
+  if (Array.isArray(headers)) {
+    return headers.some(
+      ([key, value]) =>
+        String(key).toLowerCase() === SENZOR_INTERNAL_HEADER &&
+        String(value).toLowerCase() === 'true'
+    );
+  }
+
+  return Object.entries(headers).some(
+    ([key, value]) =>
+      key.toLowerCase() === SENZOR_INTERNAL_HEADER &&
+      String(value).toLowerCase() === 'true'
+  );
+};
+
+const setHeader = (headers: any, key: string, value: string) => {
+  if (Array.isArray(headers)) {
+    headers.push([key, value]);
+    return headers;
+  }
+
+  const nextHeaders = { ...(headers || {}) };
+  const existingKey = Object.keys(nextHeaders).find(
+    (header) => header.toLowerCase() === key.toLowerCase()
+  );
+  nextHeaders[existingKey || key] = value;
+  return nextHeaders;
+};
+
+const getUrlDetails = (input: any) => {
+  try {
+    const url = new URL(String(input));
+    return {
+      url: url.toString(),
+      hostname: url.hostname,
+      path: `${url.pathname}${url.search}`
+    };
+  } catch {
+    return {
+      url: String(input || ''),
+      hostname: 'unknown',
+      path: '/'
+    };
+  }
+};
+
+const patchRequestLike = (
+  target: any,
+  methodName: string,
+  patchKey: string,
+  options?: SenzorOptions
+) => {
+  patchMethod(
+    target,
+    methodName,
+    patchKey,
+    (original) =>
+      function patchedUndiciRequest(this: any, input: any, opts?: any, cb?: any) {
+        if (hasInternalHeader(opts?.headers)) {
+          return original.apply(this, arguments as any);
+        }
+
+        const details = getUrlDetails(input?.origin ? input.origin : input);
+        const method = String(opts?.method || 'GET').toUpperCase();
+        const span = startCapturedSpan(
+          `${method} ${details.hostname}`,
+          'http',
+          {
+            url: details.url,
+            method,
+            route: normalizePath(details.path),
+            library: 'undici',
+            'http.request.method': method,
+            'url.full': details.url,
+            'url.path': details.path,
+            'server.address': details.hostname
+          },
+          options
+        );
+
+        if (!span) return original.apply(this, arguments as any);
+
+        const nextOptions = { ...(opts || {}) };
+        nextOptions.headers = setHeader(
+          nextOptions.headers,
+          'traceparent',
+          generateTraceparent(span.trace!.id, span.spanId)
+        );
+        nextOptions.headers = setHeader(
+          nextOptions.headers,
+          'x-senzor-trace-id',
+          span.trace!.id
+        );
+        nextOptions.headers = setHeader(
+          nextOptions.headers,
+          'x-senzor-parent-span-id',
+          span.spanId
+        );
+
+        const wrappedCallback =
+          typeof cb === 'function'
+            ? function wrappedUndiciCallback(this: unknown, err: any, data: any) {
+              span.end(err ? 500 : data?.statusCode || 0, {
+                error: err?.message,
+                'error.type': err?.name,
+                'http.response.status_code': data?.statusCode
+              });
+              return cb.apply(this, arguments as any);
+            }
+            : cb;
+
+        return runWithCapturedSpan(span, () => {
+          try {
+            const result = original.call(
+              this,
+              input,
+              nextOptions,
+              wrappedCallback
+            );
+
+            if (result && typeof result.then === 'function') {
+              return result.then(
+                (value: any) => {
+                  span.end(value?.statusCode || value?.status || 0, {
+                    'http.response.status_code':
+                      value?.statusCode || value?.status
+                  });
+                  return value;
+                },
+                (error: any) => {
+                  span.end(500, {
+                    error: error?.message,
+                    'error.type': error?.name || 'Error'
+                  });
+                  throw error;
+                }
+              );
+            }
+
+            if (typeof wrappedCallback !== 'function') {
+              span.end(0);
+            }
+
+            return result;
+          } catch (error: any) {
+            span.end(500, {
+              error: error?.message,
+              'error.type': error?.name || 'Error'
+            });
+            throw error;
+          }
+        });
+      }
+  );
+};
+
+const patchUndici = (undici: any, options?: SenzorOptions) => {
+  patchRequestLike(undici, 'request', 'senzor.undici.request', options);
+  patchRequestLike(undici, 'stream', 'senzor.undici.stream', options);
+  patchRequestLike(undici, 'pipeline', 'senzor.undici.pipeline', options);
+
+  [
+    undici?.Client?.prototype,
+    undici?.Pool?.prototype,
+    undici?.Agent?.prototype,
+    undici?.ProxyAgent?.prototype
+  ].forEach((proto, index) => {
+    patchRequestLike(
+      proto,
+      'request',
+      `senzor.undici.dispatcher.${index}.request`,
+      options
+    );
+  });
+};
+
+export const instrumentUndici = (options?: SenzorOptions) => {
+  hookRequire('undici', (exports: any) => patchUndici(exports, options));
+};

package/src/register.ts

@@ -0,0 +1,58 @@
+import { client } from './core/client';
+
+const truthy = (value: string | undefined): boolean =>
+  value === '1' || value === 'true' || value === 'yes';
+
+const numberFromEnv = (value: string | undefined): number | undefined => {
+  if (!value) return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+};
+
+const apiKey =
+  process.env.SENZOR_API_KEY ||
+  process.env.SENZOR_APM_API_KEY ||
+  process.env.SENZOR_SERVICE_API_KEY;
+
+const endpoint =
+  process.env.SENZOR_ENDPOINT ||
+  process.env.SENZOR_APM_ENDPOINT;
+
+const options = {
+  apiKey: apiKey || '',
+  endpoint,
+  debug: truthy(process.env.SENZOR_DEBUG),
+  autoLogs: process.env.SENZOR_AUTO_LOGS === 'false' ? false : undefined,
+  batchSize: numberFromEnv(process.env.SENZOR_BATCH_SIZE),
+  flushInterval: numberFromEnv(process.env.SENZOR_FLUSH_INTERVAL),
+  flushTimeoutMs: numberFromEnv(process.env.SENZOR_FLUSH_TIMEOUT_MS),
+  maxQueueSize: numberFromEnv(process.env.SENZOR_MAX_QUEUE_SIZE),
+  maxSpansPerTrace: numberFromEnv(process.env.SENZOR_MAX_SPANS_PER_TRACE),
+  captureHeaders: truthy(process.env.SENZOR_CAPTURE_HEADERS),
+  captureDbStatement:
+    process.env.SENZOR_CAPTURE_DB_STATEMENT === 'false'
+      ? false
+      : undefined,
+  frameworkSpans:
+    process.env.SENZOR_FRAMEWORK_SPANS === 'false'
+      ? false
+      : undefined,
+  captureMiddlewareSpans:
+    process.env.SENZOR_CAPTURE_MIDDLEWARE_SPANS === 'false'
+      ? false
+      : undefined,
+  captureRouterSpans:
+    process.env.SENZOR_CAPTURE_ROUTER_SPANS === 'false'
+      ? false
+      : undefined,
+  captureLifecycleHookSpans:
+    process.env.SENZOR_CAPTURE_LIFECYCLE_HOOK_SPANS === 'false'
+      ? false
+      : undefined
+};
+
+if (apiKey) {
+  client.init(options);
+} else {
+  client.preload(options);
+}

package/src/utils/ids.ts

@@ -0,0 +1,7 @@
+import { randomUUID } from 'crypto';
+
+export const generateTraceId = (): string =>
+  randomUUID().replace(/-/g, '');
+
+export const generateSpanId = (): string =>
+  randomUUID().replace(/-/g, '').slice(0, 16);

package/src/utils/internal.ts

@@ -0,0 +1 @@
+export const SENZOR_INTERNAL_HEADER = 'x-senzor-sdk-internal';

package/src/wrappers/fastify.ts

@@ -1,11 +1,14 @@
-import { client } from '../core/client';
-import { SenzorOptions } from '../core/types';
-import { getClientIp } from '../utils/getClientIp';
+import { client } from '../core/client';
+import { SenzorOptions } from '../core/types';
+import { instrumentFastifyInstance } from '../instrumentation/fastify';
+import { getClientIp } from '../utils/getClientIp';
 
 export const senzorPlugin = (fastify: any, options: SenzorOptions, done: Function) => {
-  if (options && options.apiKey) {
-    client.init(options);
-  }
+  if (options && options.apiKey) {
+    client.init(options);
+  }
+
+  instrumentFastifyInstance(fastify, options);
 
   fastify.addHook('onRequest', (request: any, reply: any, next: Function) => {
     client.startTrace({
@@ -29,4 +32,4 @@ export const senzorPlugin = (fastify: any, options: SenzorOptions, done: Functio
   });
 
   done();
-};
+};

package/src/wrappers/h3.ts

@@ -1,6 +1,7 @@
-import { client } from '../core/client';
-import { getRoute } from '../core/normalizer';
-import { getClientIp } from '../utils/getClientIp';
+import { client } from '../core/client';
+import { getRoute } from '../core/normalizer';
+import { invokeWithFrameworkSpan } from '../instrumentation/framework';
+import { getClientIp } from '../utils/getClientIp';
 
 type EventHandler = (event: any) => any;
 
@@ -15,21 +16,44 @@ export const wrapH3 = (handler: EventHandler) => {
       ip: getClientIp(req),
       userAgent: req.headers['user-agent'],
       headers: req.headers // Pass headers
-    }, async () => {
-      try {
-        const response = await handler(event);
-        let status = 200;
-        if (event.node.res.statusCode) status = event.node.res.statusCode;
-        if (response && response.statusCode) status = response.statusCode;
-
-        client.endTrace(status, { route: getRoute(event, path) });
-        return response;
-      } catch (err: any) {
-        client.captureError(err);
-        const status = err.statusCode || err.status || 500;
+    }, async () => {
+      try {
+        const route = getRoute(event, path);
+        const response = await invokeWithFrameworkSpan(
+          handler,
+          undefined,
+          [event],
+          {
+            framework: 'h3',
+            type: 'event_handler',
+            name: `h3.event_handler ${req.method || 'GET'} ${route}`,
+            route,
+            method: req.method || 'GET',
+            request: req,
+            response: event.node.res,
+            attributes: {
+              'h3.type': 'event_handler',
+              'http.route': route
+            }
+          },
+          undefined,
+          {
+            callbackCompletesSpan: false,
+            responseEndsSpan: false
+          }
+        );
+        let status = 200;
+        if (event.node.res.statusCode) status = event.node.res.statusCode;
+        if (response && response.statusCode) status = response.statusCode;
+
+        client.endTrace(status, { route });
+        return response;
+      } catch (err: any) {
+        client.captureError(err);
+        const status = err.statusCode || err.status || 500;
         client.endTrace(status, { route: getRoute(event, path) });
         throw err;
       }
     });
   };
-};
+};

package/src/wrappers/next.ts

@@ -1,6 +1,7 @@
-import { client } from '../core/client';
-import { normalizePath } from '../core/normalizer';
-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) => {
@@ -37,16 +38,39 @@ export const wrapNextRoute = (handler: Function) => {
       userAgent: ua,
       ip: ip || getClientIp(req),
       headers: headers // Pass extracted headers
-    }, 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.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,
+            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;
       }
     });
@@ -71,14 +95,37 @@ export const wrapNextPages = (handler: Function) => {
       };
 
       res.once('finish', done);
-      res.once('close', done);
-
-      try {
-        return await handler(req, res);
-      } 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',
+            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/tsup.config.ts

@@ -1,11 +1,21 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  format: ['cjs', 'esm'],
-  dts: true,
-  clean: true,
-  minify: true,
-  sourcemap: true,
-  splitting: false,
-});
+import { defineConfig } from 'tsup';
+
+export default defineConfig([
+  {
+    entry: ['src/index.ts', 'src/register.ts'],
+    format: ['cjs', 'esm'],
+    dts: true,
+    clean: true,
+    minify: true,
+    sourcemap: true,
+    splitting: false,
+  },
+  {
+    entry: ['src/index.ts'],
+    format: ['iife'],
+    clean: false,
+    minify: true,
+    sourcemap: true,
+    splitting: false,
+  }
+]);