@sentienguard/apm 1.0.14 → 1.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentienguard/apm",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "SentienGuard APM SDK - Minimal, production-safe application performance monitoring",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/tracing.js

@@ -18,6 +18,54 @@ import { SentienGuardTraceSpanExporter } from './traceSpanExporter.js';
 let sdk = null;
 let tracingActive = false;
 
+function setAttr(span, key, value) {
+  try {
+    if (!span || typeof span.setAttribute !== 'function') return;
+    if (value == null) return;
+    const v = typeof value === 'string' ? value : String(value);
+    if (!v) return;
+    span.setAttribute(key, v);
+  } catch {
+    // ignore
+  }
+}
+
+function setAttrNumber(span, key, value) {
+  try {
+    if (!span || typeof span.setAttribute !== 'function') return;
+    const n = Number(value);
+    if (!Number.isFinite(n)) return;
+    span.setAttribute(key, n);
+  } catch {
+    // ignore
+  }
+}
+
+function safeUrlFromOutgoingRequest(requestOptions) {
+  try {
+    if (!requestOptions) return '';
+    if (typeof requestOptions === 'string') return requestOptions;
+    if (requestOptions instanceof URL) return requestOptions.toString();
+    const protocol = requestOptions.protocol || 'http:';
+    const hostRaw = requestOptions.hostname || requestOptions.host || '';
+    const host = String(hostRaw).trim();
+    const path = requestOptions.path || requestOptions.pathname || '/';
+    if (!host) return '';
+    return `${protocol}//${host}${path}`;
+  } catch {
+    return '';
+  }
+}
+
+function safeHostFromIncoming(req) {
+  try {
+    const h = req?.headers?.host;
+    return h ? String(h).split(',')[0].trim() : '';
+  } catch {
+    return '';
+  }
+}
+
 function shouldIgnoreOutgoingHost(hostname) {
   if (!hostname) return false;
   const host = hostname.split(':')[0];
@@ -64,6 +112,34 @@ export function startTracing() {
       ignoreOutgoingRequestHook: (requestOptions) => {
         const host = requestOptions.hostname || (requestOptions.host ? String(requestOptions.host).split(':')[0] : '');
         return shouldIgnoreOutgoingHost(host);
+      },
+      /**
+       * Ensure we always attach basic HTTP attributes.
+       * This protects us from cases where the underlying instrumentation
+       * doesn't populate attributes (common in some Node/Jest/undici combos).
+       */
+      requestHook: (span, request) => {
+        // Incoming request (SERVER)
+        if (request && typeof request === 'object' && 'headers' in request && 'method' in request) {
+          setAttr(span, 'http.method', request.method);
+          setAttr(span, 'http.target', request.url);
+          setAttr(span, 'http.host', safeHostFromIncoming(request));
+          return;
+        }
+
+        // Outgoing request (CLIENT) — requestOptions
+        setAttr(span, 'http.method', request?.method);
+        const url = safeUrlFromOutgoingRequest(request);
+        if (url) setAttr(span, 'http.url', url);
+        const host = request?.hostname || (request?.host ? String(request.host).split(':')[0] : '');
+        if (host) setAttr(span, 'net.peer.name', host);
+        if (request?.port) setAttrNumber(span, 'net.peer.port', request.port);
+      },
+      responseHook: (span, response) => {
+        // Incoming response (SERVER): ServerResponse
+        if (response && typeof response === 'object' && 'statusCode' in response) {
+          setAttrNumber(span, 'http.status_code', response.statusCode);
+        }
       }
     });