@getlimelight/sdk 0.7.4 → 0.7.8

package/README.md

@@ -128,6 +128,15 @@ export default Limelight.withLimelight((req, res) => {
 
 Both methods automatically capture request/response headers, bodies, status codes, and timing — and propagate a trace ID (`x-limelight-trace-id`) for full-stack tracing.
 
+**Outbound HTTP interception** is automatic in Node.js environments. When `enableNetworkInspector` is `true` (the default), the SDK patches `http.request` and `https.request` to capture all outgoing calls your server makes — API calls to other services, auth servers, databases over HTTP, etc. Combined with the incoming middleware, this gives you full end-to-end tracing:
+
+```
+Client (fetch) → Your Server (middleware) → Downstream Service (http interceptor)
+       ↑ same trace ID propagated across all three ↑
+```
+
+No additional setup is required — just connect the SDK and add the middleware.
+
 ## Learn More
 
 - [Quick Start Guide](https://docs.getlimelight.io/quickstart)

package/dist/index.d.mts

@@ -5,7 +5,8 @@ declare enum NetworkType {
     FETCH = "fetch",
     XHR = "xhr",
     GRAPHQL = "graphql",
-    INCOMING = "incoming"
+    INCOMING = "incoming",
+    HTTP = "http"
 }
 declare enum NetworkPhase {
     CONNECT = "CONNECT",
@@ -572,6 +573,7 @@ declare class LimelightClient {
     private maxQueueSize;
     private networkInterceptor;
     private xhrInterceptor;
+    private httpInterceptor;
     private consoleInterceptor;
     private renderInterceptor;
     private stateInterceptor;

package/dist/index.d.ts

@@ -5,7 +5,8 @@ declare enum NetworkType {
     FETCH = "fetch",
     XHR = "xhr",
     GRAPHQL = "graphql",
-    INCOMING = "incoming"
+    INCOMING = "incoming",
+    HTTP = "http"
 }
 declare enum NetworkPhase {
     CONNECT = "CONNECT",
@@ -572,6 +573,7 @@ declare class LimelightClient {
     private maxQueueSize;
     private networkInterceptor;
     private xhrInterceptor;
+    private httpInterceptor;
     private consoleInterceptor;
     private renderInterceptor;
     private stateInterceptor;

package/dist/index.js

@@ -1,3 +1,7 @@
+// Bridge Node CJS require to globalThis so runtime dynamic requires work
+// in environments like ts-node where require is module-scoped only.
+// In ESM or browser contexts typeof require is 'undefined', so this is a no-op.
+if (typeof require === "function" && typeof globalThis !== "undefined" && typeof globalThis.require === "undefined" && typeof process !== "undefined" && process.versions && process.versions.node) { Object.defineProperty(globalThis, "require", { value: require, configurable: true, writable: true, enumerable: false }); }
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -67,6 +71,7 @@ var NetworkType = /* @__PURE__ */ ((NetworkType2) => {
   NetworkType2["XHR"] = "xhr";
   NetworkType2["GRAPHQL"] = "graphql";
   NetworkType2["INCOMING"] = "incoming";
+  NetworkType2["HTTP"] = "http";
   return NetworkType2;
 })(NetworkType || {});
 var NetworkPhase = /* @__PURE__ */ ((NetworkPhase2) => {
@@ -87,17 +92,17 @@ var BodyFormat = /* @__PURE__ */ ((BodyFormat2) => {
   BodyFormat2["UNSERIALIZABLE"] = "UNSERIALIZABLE";
   return BodyFormat2;
 })(BodyFormat || {});
-var HttpMethod = /* @__PURE__ */ ((HttpMethod6) => {
-  HttpMethod6["GET"] = "GET";
-  HttpMethod6["POST"] = "POST";
-  HttpMethod6["PUT"] = "PUT";
-  HttpMethod6["PATCH"] = "PATCH";
-  HttpMethod6["DELETE"] = "DELETE";
-  HttpMethod6["HEAD"] = "HEAD";
-  HttpMethod6["OPTIONS"] = "OPTIONS";
-  HttpMethod6["TRACE"] = "TRACE";
-  HttpMethod6["CONNECT"] = "CONNECT";
-  return HttpMethod6;
+var HttpMethod = /* @__PURE__ */ ((HttpMethod7) => {
+  HttpMethod7["GET"] = "GET";
+  HttpMethod7["POST"] = "POST";
+  HttpMethod7["PUT"] = "PUT";
+  HttpMethod7["PATCH"] = "PATCH";
+  HttpMethod7["DELETE"] = "DELETE";
+  HttpMethod7["HEAD"] = "HEAD";
+  HttpMethod7["OPTIONS"] = "OPTIONS";
+  HttpMethod7["TRACE"] = "TRACE";
+  HttpMethod7["CONNECT"] = "CONNECT";
+  return HttpMethod7;
 })(HttpMethod || {});
 var HttpStatusClass = /* @__PURE__ */ ((HttpStatusClass2) => {
   HttpStatusClass2[HttpStatusClass2["INFORMATIONAL"] = 100] = "INFORMATIONAL";
@@ -287,7 +292,7 @@ var LIMELIGHT_WEB_WSS_URL = "wss://api.getlimelight.io";
 var LIMELIGHT_DESKTOP_WSS_URL = "ws://localhost:8484";
 var LIMELIGHT_MCP_WS_URL = "ws://localhost:9229";
 var WS_PATH = "/limelight";
-var SDK_VERSION = true ? "0.7.4" : "test-version";
+var SDK_VERSION = true ? "0.7.8" : "test-version";
 var RENDER_THRESHOLDS = {
   HOT_VELOCITY: 5,
   HIGH_RENDER_COUNT: 50,
@@ -301,6 +306,16 @@ var RENDER_THRESHOLDS = {
   TOP_PROPS_TO_REPORT: 5
   // Only report top N changed props
 };
+var BINARY_CONTENT_TYPES = [
+  "image/",
+  "audio/",
+  "video/",
+  "application/octet-stream",
+  "application/pdf",
+  "application/zip",
+  "application/gzip"
+];
+var MAX_BODY_SIZE = 1024 * 1024;
 
 // src/helpers/safety/redactSensitiveHeaders.ts
 var redactSensitiveHeaders = (headers) => {
@@ -580,6 +595,21 @@ var getCurrentTransactionId = () => {
   return globalGetTransactionId?.() ?? null;
 };
 
+// src/helpers/http/resolveUrl.ts
+var resolveUrl = (protocol, options) => {
+  const host = options.hostname || options.host || "localhost";
+  const port = options.port ? `:${options.port}` : "";
+  const path = options.path || "/";
+  return `${protocol}//${host}${port}${path}`;
+};
+
+// src/helpers/http/isBinaryContentType.ts
+var isBinaryContentType = (contentType) => {
+  return BINARY_CONTENT_TYPES.some(
+    (type) => contentType.toLowerCase().includes(type)
+  );
+};
+
 // src/limelight/interceptors/ConsoleInterceptor.ts
 var ConsoleInterceptor = class {
   constructor(sendMessage, getSessionId) {
@@ -1205,6 +1235,360 @@ var XHRInterceptor = class {
   }
 };
 
+// src/limelight/interceptors/HttpInterceptor.ts
+var HttpInterceptor = class {
+  constructor(sendMessage, getSessionId) {
+    this.sendMessage = sendMessage;
+    this.getSessionId = getSessionId;
+    try {
+      const _require = globalThis["require"];
+      this.httpModule = _require("http");
+      this.httpsModule = _require("https");
+      this.originalHttpRequest = this.httpModule.request;
+      this.originalHttpGet = this.httpModule.get;
+      this.originalHttpsRequest = this.httpsModule.request;
+      this.originalHttpsGet = this.httpsModule.get;
+    } catch {
+    }
+  }
+  originalHttpRequest = null;
+  originalHttpGet = null;
+  originalHttpsRequest = null;
+  originalHttpsGet = null;
+  httpModule = null;
+  httpsModule = null;
+  config = null;
+  isSetup = false;
+  setup(config) {
+    if (this.isSetup) {
+      if (this.config?.enableInternalLogging) {
+        console.warn("[Limelight] HTTP interceptor already set up");
+      }
+      return;
+    }
+    if (!this.httpModule || !this.httpsModule) {
+      if (config?.enableInternalLogging) {
+        console.warn(
+          "[Limelight] Node http module not available, skipping HTTP interception"
+        );
+      }
+      return;
+    }
+    this.isSetup = true;
+    this.config = config;
+    const self2 = this;
+    const httpMod = this.httpModule;
+    const httpsMod = this.httpsModule;
+    httpMod.request = (...args) => {
+      return self2.interceptRequest(
+        "http:",
+        self2.originalHttpRequest,
+        httpMod,
+        args
+      );
+    };
+    httpMod.get = (...args) => {
+      const req = self2.interceptRequest(
+        "http:",
+        self2.originalHttpRequest,
+        httpMod,
+        args
+      );
+      req.end();
+      return req;
+    };
+    httpsMod.request = (...args) => {
+      return self2.interceptRequest(
+        "https:",
+        self2.originalHttpsRequest,
+        httpsMod,
+        args
+      );
+    };
+    httpsMod.get = (...args) => {
+      const req = self2.interceptRequest(
+        "https:",
+        self2.originalHttpsRequest,
+        httpsMod,
+        args
+      );
+      req.end();
+      return req;
+    };
+  }
+  interceptRequest(protocol, originalMethod, module2, args) {
+    let url;
+    let options;
+    let callback;
+    if (typeof args[0] === "string" || args[0] instanceof URL) {
+      url = args[0];
+      if (typeof args[1] === "function") {
+        options = {};
+        callback = args[1];
+      } else {
+        options = args[1] || {};
+        callback = args[2];
+      }
+    } else {
+      options = args[0] || {};
+      callback = args[1];
+    }
+    let resolvedUrl;
+    if (url) {
+      resolvedUrl = url.toString();
+    } else {
+      resolvedUrl = resolveUrl(protocol, options);
+    }
+    const limelightServerUrl = this.config?.serverUrl || "";
+    if (limelightServerUrl && resolvedUrl.includes(limelightServerUrl)) {
+      return originalMethod.apply(module2, args);
+    }
+    const self2 = this;
+    const requestId = generateRequestId();
+    const startTime = Date.now();
+    const initiator = getInitiator();
+    const traceHeaderName = this.config?.traceHeaderName ?? "x-limelight-trace-id";
+    const existingTraceId = getTraceContext()?.getStore()?.traceId;
+    const traceId = existingTraceId || generateRequestId();
+    if (!options.headers) {
+      options.headers = {};
+    }
+    options.headers[traceHeaderName] = traceId;
+    const method = (options.method || "GET").toUpperCase();
+    let patchedArgs;
+    if (url) {
+      patchedArgs = callback ? [url, options, callback] : [url, options];
+    } else {
+      patchedArgs = callback ? [options, callback] : [options];
+    }
+    const req = originalMethod.apply(
+      module2,
+      patchedArgs
+    );
+    const bodyChunks = [];
+    let totalBodySize = 0;
+    let requestEventSent = false;
+    const originalWrite = req.write.bind(req);
+    const originalEnd = req.end.bind(req);
+    req.write = (chunk, encodingOrCallback, callback2) => {
+      if (chunk && totalBodySize < MAX_BODY_SIZE) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bodyChunks.push(buf);
+        totalBodySize += buf.length;
+      }
+      return originalWrite(chunk, encodingOrCallback, callback2);
+    };
+    req.end = (chunk, encodingOrCallback, callback2) => {
+      if (chunk && typeof chunk !== "function" && totalBodySize < MAX_BODY_SIZE) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bodyChunks.push(buf);
+        totalBodySize += buf.length;
+      }
+      if (!requestEventSent) {
+        requestEventSent = true;
+        const fullBody = bodyChunks.length > 0 ? Buffer.concat(bodyChunks).toString("utf-8") : void 0;
+        const headers = {};
+        const rawHeaders = req.getHeaders();
+        for (const [key, value] of Object.entries(rawHeaders)) {
+          if (value !== void 0) {
+            headers[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : String(value);
+          }
+        }
+        const requestBody = serializeBody(
+          fullBody,
+          self2.config?.disableBodyCapture
+        );
+        let requestEvent = {
+          id: requestId,
+          traceId,
+          sessionId: self2.getSessionId(),
+          timestamp: startTime,
+          phase: "REQUEST" /* REQUEST */,
+          networkType: "http" /* HTTP */,
+          url: resolvedUrl,
+          method,
+          headers: redactSensitiveHeaders(headers),
+          body: requestBody,
+          name: formatRequestName(resolvedUrl),
+          initiator,
+          requestSize: requestBody?.size ?? 0
+        };
+        if (self2.config?.beforeSend) {
+          const modifiedEvent = self2.config.beforeSend(requestEvent);
+          if (!modifiedEvent) {
+            return originalEnd(
+              chunk,
+              encodingOrCallback,
+              callback2
+            );
+          }
+          if (modifiedEvent.phase !== "REQUEST" /* REQUEST */) {
+            console.error("[Limelight] beforeSend must return same event type");
+            return originalEnd(
+              chunk,
+              encodingOrCallback,
+              callback2
+            );
+          }
+          requestEvent = modifiedEvent;
+        }
+        self2.sendMessage(requestEvent);
+      }
+      return originalEnd(chunk, encodingOrCallback, callback2);
+    };
+    let responseSent = false;
+    req.on("response", (res) => {
+      const responseChunks = [];
+      let responseSize = 0;
+      res.on("data", (chunk) => {
+        if (responseSize < MAX_BODY_SIZE) {
+          responseChunks.push(chunk);
+          responseSize += chunk.length;
+        }
+      });
+      res.on("end", () => {
+        if (responseSent) return;
+        responseSent = true;
+        const endTime = Date.now();
+        const duration = endTime - startTime;
+        const responseHeaders = {};
+        if (res.headers) {
+          for (const [key, value] of Object.entries(res.headers)) {
+            if (value) {
+              responseHeaders[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+            }
+          }
+        }
+        const contentType = responseHeaders["content-type"] || "";
+        let responseBodyStr;
+        if (responseChunks.length > 0) {
+          if (isBinaryContentType(contentType)) {
+            responseBodyStr = `[Binary Data: ${contentType}]`;
+          } else {
+            const full = Buffer.concat(responseChunks);
+            responseBodyStr = full.length > MAX_BODY_SIZE ? full.toString("utf-8", 0, MAX_BODY_SIZE) + "...[truncated]" : full.toString("utf-8");
+          }
+        }
+        const responseBody = serializeBody(
+          responseBodyStr,
+          self2.config?.disableBodyCapture
+        );
+        const statusCode = res.statusCode ?? 0;
+        let responseEvent = {
+          id: requestId,
+          traceId,
+          sessionId: self2.getSessionId(),
+          timestamp: endTime,
+          phase: "RESPONSE" /* RESPONSE */,
+          networkType: "http" /* HTTP */,
+          status: statusCode,
+          statusText: res.statusMessage || "",
+          headers: redactSensitiveHeaders(responseHeaders),
+          body: responseBody,
+          duration,
+          responseSize: responseBody?.size ?? 0,
+          redirected: false,
+          ok: statusCode >= 200 && statusCode < 300
+        };
+        if (self2.config?.beforeSend) {
+          const modifiedEvent = self2.config.beforeSend(responseEvent);
+          if (!modifiedEvent) return;
+          if (modifiedEvent.phase !== "RESPONSE" /* RESPONSE */) {
+            console.error("[Limelight] beforeSend must return same event type");
+            return;
+          }
+          responseEvent = modifiedEvent;
+        }
+        self2.sendMessage(responseEvent);
+      });
+    });
+    req.on("error", (err) => {
+      if (responseSent) return;
+      responseSent = true;
+      let errorEvent = {
+        id: requestId,
+        traceId,
+        sessionId: self2.getSessionId(),
+        timestamp: Date.now(),
+        phase: "ERROR" /* ERROR */,
+        networkType: "http" /* HTTP */,
+        errorMessage: err.message || "Network request failed",
+        stack: err.stack
+      };
+      if (self2.config?.beforeSend) {
+        const modifiedEvent = self2.config.beforeSend(errorEvent);
+        if (modifiedEvent && (modifiedEvent.phase === "ERROR" /* ERROR */ || modifiedEvent.phase === "ABORT" /* ABORT */)) {
+          errorEvent = modifiedEvent;
+        }
+      }
+      self2.sendMessage(errorEvent);
+    });
+    req.on("timeout", () => {
+      if (responseSent) return;
+      responseSent = true;
+      let errorEvent = {
+        id: requestId,
+        traceId,
+        sessionId: self2.getSessionId(),
+        timestamp: Date.now(),
+        phase: "ERROR" /* ERROR */,
+        networkType: "http" /* HTTP */,
+        errorMessage: "Request timeout"
+      };
+      if (self2.config?.beforeSend) {
+        const modifiedEvent = self2.config.beforeSend(errorEvent);
+        if (modifiedEvent && (modifiedEvent.phase === "ERROR" /* ERROR */ || modifiedEvent.phase === "ABORT" /* ABORT */)) {
+          errorEvent = modifiedEvent;
+        }
+      }
+      self2.sendMessage(errorEvent);
+    });
+    req.on("close", () => {
+      if (responseSent) return;
+      if (!req.destroyed) return;
+      responseSent = true;
+      let errorEvent = {
+        id: requestId,
+        traceId,
+        sessionId: self2.getSessionId(),
+        timestamp: Date.now(),
+        phase: "ABORT" /* ABORT */,
+        networkType: "http" /* HTTP */,
+        errorMessage: "Request aborted"
+      };
+      if (self2.config?.beforeSend) {
+        const modifiedEvent = self2.config.beforeSend(errorEvent);
+        if (modifiedEvent && (modifiedEvent.phase === "ERROR" /* ERROR */ || modifiedEvent.phase === "ABORT" /* ABORT */)) {
+          errorEvent = modifiedEvent;
+        }
+      }
+      self2.sendMessage(errorEvent);
+    });
+    return req;
+  }
+  cleanup() {
+    if (!this.isSetup) {
+      if (this.config?.enableInternalLogging) {
+        console.warn("[Limelight] HTTP interceptor not set up");
+      }
+      return;
+    }
+    this.isSetup = false;
+    if (this.httpModule && this.originalHttpRequest) {
+      this.httpModule.request = this.originalHttpRequest;
+    }
+    if (this.httpModule && this.originalHttpGet) {
+      this.httpModule.get = this.originalHttpGet;
+    }
+    if (this.httpsModule && this.originalHttpsRequest) {
+      this.httpsModule.request = this.originalHttpsRequest;
+    }
+    if (this.httpsModule && this.originalHttpsGet) {
+      this.httpsModule.get = this.originalHttpsGet;
+    }
+  }
+};
+
 // src/limelight/interceptors/RenderInterceptor.ts
 var RenderInterceptor = class {
   sendMessage;
@@ -2574,6 +2958,7 @@ var LimelightClient = class {
   maxQueueSize = 100;
   networkInterceptor;
   xhrInterceptor;
+  httpInterceptor;
   consoleInterceptor;
   renderInterceptor;
   stateInterceptor;
@@ -2589,6 +2974,10 @@ var LimelightClient = class {
       this.sendMessage.bind(this),
       () => this.sessionId
     );
+    this.httpInterceptor = new HttpInterceptor(
+      this.sendMessage.bind(this),
+      () => this.sessionId
+    );
     this.consoleInterceptor = new ConsoleInterceptor(
       this.sendMessage.bind(this),
       () => this.sessionId
@@ -2649,6 +3038,9 @@ var LimelightClient = class {
         if (typeof XMLHttpRequest !== "undefined") {
           this.xhrInterceptor.setup(this.config);
         }
+        if (!hasDOM()) {
+          this.httpInterceptor.setup(this.config);
+        }
       }
       if (this.config.enableConsole) {
         this.consoleInterceptor.setup(this.config);
@@ -2874,6 +3266,7 @@ var LimelightClient = class {
     }
     this.networkInterceptor.cleanup();
     this.xhrInterceptor.cleanup();
+    this.httpInterceptor.cleanup();
     this.consoleInterceptor.cleanup();
     this.errorInterceptor.cleanup();
     this.renderInterceptor.cleanup();