@jaypie/express 1.2.4-rc6 → 1.2.4-rc8

package/dist/esm/index.js

@@ -1124,6 +1124,64 @@ function getCurrentInvokeUuid(req) {
     return getWebAdapterUuid();
 }
 
+//
+//
+// Helpers
+//
+/**
+ * Safely get a header value from response.
+ * Handles both Express Response and Lambda adapter responses.
+ * Defensive against dd-trace instrumentation issues.
+ */
+function safeGetHeader(res, name) {
+    try {
+        // Try direct _headers access first (Lambda adapter, avoids dd-trace)
+        if (res._headers instanceof Map) {
+            const value = res._headers.get(name.toLowerCase());
+            return value ? String(value) : undefined;
+        }
+        // Fall back to getHeader (more standard than get)
+        if (typeof res.getHeader === "function") {
+            const value = res.getHeader(name);
+            return value ? String(value) : undefined;
+        }
+        // Last resort: try get
+        if (typeof res.get === "function") {
+            const value = res.get(name);
+            return value ? String(value) : undefined;
+        }
+    }
+    catch {
+        // Silently fail - caller will handle missing value
+    }
+    return undefined;
+}
+/**
+ * Safely set a header value on response.
+ * Handles both Express Response and Lambda adapter responses.
+ * Defensive against dd-trace instrumentation issues.
+ */
+function safeSetHeader(res, name, value) {
+    try {
+        // Try direct _headers access first (Lambda adapter, avoids dd-trace)
+        if (res._headers instanceof Map) {
+            res._headers.set(name.toLowerCase(), value);
+            return;
+        }
+        // Fall back to setHeader (more standard than set)
+        if (typeof res.setHeader === "function") {
+            res.setHeader(name, value);
+            return;
+        }
+        // Last resort: try set
+        if (typeof res.set === "function") {
+            res.set(name, value);
+        }
+    }
+    catch {
+        // Silently fail - header just won't be set
+    }
+}
 //
 //
 // Main
@@ -1140,36 +1198,37 @@ const decorateResponse = (res, { handler = "", version = process.env.PROJECT_VER
         log$1.warn("decorateResponse called but response is not an object");
         return;
     }
+    const extRes = res;
     try {
         //
         //
         // Decorate Headers
         //
         // X-Powered-By, override "Express" but nothing else
-        if (!res.get(HTTP.HEADER.POWERED_BY) ||
-            res.get(HTTP.HEADER.POWERED_BY) === "Express") {
-            res.set(HTTP.HEADER.POWERED_BY, JAYPIE.LIB.EXPRESS);
+        const currentPoweredBy = safeGetHeader(extRes, HTTP.HEADER.POWERED_BY);
+        if (!currentPoweredBy || currentPoweredBy === "Express") {
+            safeSetHeader(extRes, HTTP.HEADER.POWERED_BY, JAYPIE.LIB.EXPRESS);
         }
         // X-Project-Environment
         if (process.env.PROJECT_ENV) {
-            res.set(HTTP.HEADER.PROJECT.ENVIRONMENT, process.env.PROJECT_ENV);
+            safeSetHeader(extRes, HTTP.HEADER.PROJECT.ENVIRONMENT, process.env.PROJECT_ENV);
         }
         // X-Project-Handler
         if (handler) {
-            res.set(HTTP.HEADER.PROJECT.HANDLER, handler);
+            safeSetHeader(extRes, HTTP.HEADER.PROJECT.HANDLER, handler);
         }
         // X-Project-Invocation
         const currentInvoke = getCurrentInvokeUuid();
         if (currentInvoke) {
-            res.set(HTTP.HEADER.PROJECT.INVOCATION, currentInvoke);
+            safeSetHeader(extRes, HTTP.HEADER.PROJECT.INVOCATION, currentInvoke);
         }
         // X-Project-Key
         if (process.env.PROJECT_KEY) {
-            res.set(HTTP.HEADER.PROJECT.KEY, process.env.PROJECT_KEY);
+            safeSetHeader(extRes, HTTP.HEADER.PROJECT.KEY, process.env.PROJECT_KEY);
         }
         // X-Project-Version
         if (version) {
-            res.set(HTTP.HEADER.PROJECT.VERSION, version);
+            safeSetHeader(extRes, HTTP.HEADER.PROJECT.VERSION, version);
         }
         //
         //
@@ -1229,6 +1288,55 @@ function summarizeResponse(res, extras) {
 
 // Cast logger to extended interface for runtime features not in type definitions
 const logger$1 = log;
+//
+//
+// Helpers - Safe response methods to bypass dd-trace interception
+//
+/**
+ * Check if response is a Lambda mock response with direct _headers access.
+ */
+function isLambdaMockResponse(res) {
+    return res._headers instanceof Map;
+}
+/**
+ * Safely send a JSON response, avoiding dd-trace interception.
+ * For Lambda mock responses, directly sets headers and writes to stream.
+ */
+function safeSendJson(res, statusCode, data) {
+    if (isLambdaMockResponse(res)) {
+        // Direct access for Lambda mock responses - bypasses dd-trace
+        res._headers.set("content-type", "application/json");
+        res.statusCode = statusCode;
+        res.end(JSON.stringify(data));
+        return;
+    }
+    // Fall back to standard Express methods for real responses
+    res.status(statusCode).json(data);
+}
+/**
+ * Safely send a response body, avoiding dd-trace interception.
+ * For Lambda mock responses, directly writes to stream.
+ */
+function safeSend(res, statusCode, body) {
+    if (isLambdaMockResponse(res)) {
+        // Direct access for Lambda mock responses - bypasses dd-trace
+        res.statusCode = statusCode;
+        if (body !== undefined) {
+            res.end(body);
+        }
+        else {
+            res.end();
+        }
+        return;
+    }
+    // Fall back to standard Express methods for real responses
+    if (body !== undefined) {
+        res.status(statusCode).send(body);
+    }
+    else {
+        res.status(statusCode).send();
+    }
+}
 function expressHandler(handlerOrOptions, optionsOrHandler) {
     /* eslint-enable no-redeclare */
     let handler;
@@ -1445,30 +1553,30 @@ function expressHandler(handlerOrOptions, optionsOrHandler) {
                     if (typeof response === "object") {
                         if (typeof response.json ===
                             "function") {
-                            res.json(response.json());
+                            safeSendJson(res, status, response.json());
                         }
                         else {
-                            res.status(status).json(response);
+                            safeSendJson(res, status, response);
                         }
                     }
                     else if (typeof response === "string") {
                         try {
-                            res.status(status).json(JSON.parse(response));
+                            safeSendJson(res, status, JSON.parse(response));
                         }
                         catch {
-                            res.status(status).send(response);
+                            safeSend(res, status, response);
                         }
                     }
                     else if (response === true) {
-                        res.status(HTTP.CODE.CREATED).send();
+                        safeSend(res, HTTP.CODE.CREATED);
                     }
                     else {
-                        res.status(status).send(response);
+                        safeSend(res, status, response);
                     }
                 }
                 else {
                     // No response
-                    res.status(HTTP.CODE.NO_CONTENT).send();
+                    safeSend(res, HTTP.CODE.NO_CONTENT);
                 }
             }
             else {