@shieldpress/tracker 1.0.0 → 1.1.0

package/dist/nextjs.mjs

@@ -5,6 +5,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/tracker.ts
+import http2 from "http";
+import https2 from "https";
+
 // src/config.ts
 var DEFAULT_API_URL = "https://api.shieldpress.net";
 function resolveConfig(config) {
@@ -81,8 +85,8 @@ function getPublicIpCached() {
   if (Date.now() - publicIpLastFetch > 6e5) {
     publicIpLastFetch = Date.now();
     try {
-      const http2 = __require("https");
-      const req = http2.get("https://api.ipify.org", { timeout: 3e3 }, (res) => {
+      const http3 = __require("https");
+      const req = http3.get("https://api.ipify.org", { timeout: 3e3 }, (res) => {
         let data = "";
         res.on("data", (chunk) => {
           data += chunk;
@@ -1118,23 +1122,49 @@ function sanitizePayload(payload) {
   }
   return p;
 }
-var Reporter = class {
+var _Reporter = class _Reporter {
   constructor(apiUrl, apiKey, logger) {
     this.queue = [];
     this.sending = false;
+    this.consecutiveFailures = 0;
+    this.backoffUntil = 0;
     this.apiUrl = apiUrl.replace(/\/$/, "");
     this.apiKey = apiKey;
     this.logger = logger;
   }
   async send(payload) {
     try {
+      if (this.queue.length >= _Reporter.MAX_QUEUE_SIZE) {
+        const dropped = this.queue.length - _Reporter.MAX_QUEUE_SIZE + 1;
+        this.queue.splice(0, dropped);
+        this.logger.warn(`Queue full, dropped ${dropped} oldest report(s)`);
+      }
       this.queue.push(payload);
       if (this.sending) return true;
+      const now = Date.now();
+      if (now < this.backoffUntil) {
+        this.logger.info(`Backoff active, will retry in ${Math.round((this.backoffUntil - now) / 1e3)}s`);
+        return true;
+      }
       this.sending = true;
       try {
         while (this.queue.length > 0) {
+          if (Date.now() < this.backoffUntil) break;
           const batch = this.queue.splice(0, 10);
-          await this.transmit(batch);
+          try {
+            await this.transmit(batch);
+            this.consecutiveFailures = 0;
+            this.backoffUntil = 0;
+          } catch (err) {
+            this.queue.unshift(...batch);
+            this.consecutiveFailures++;
+            const delay = Math.min(1e3 * Math.pow(2, this.consecutiveFailures - 1), _Reporter.MAX_BACKOFF_MS);
+            this.backoffUntil = Date.now() + delay;
+            this.logger.warn(
+              `Transmit failed (attempt ${this.consecutiveFailures}), backing off ${Math.round(delay / 1e3)}s: ${err instanceof Error ? err.message : err}`
+            );
+            break;
+          }
         }
         return true;
       } finally {
@@ -1157,6 +1187,8 @@ var Reporter = class {
         `Payload too large (${body.length} bytes), truncating arrays (key=${maskApiKey(this.apiKey)})`
       );
       for (const p of sanitized) {
+        p._truncated = true;
+        p._originalSize = body.length;
         if (p.security) {
           p.security.events = p.security.events.slice(0, 10);
         }
@@ -1224,6 +1256,11 @@ var Reporter = class {
     });
   }
 };
+/** Max queued reports before dropping oldest */
+_Reporter.MAX_QUEUE_SIZE = 100;
+/** Max backoff delay in ms (60 seconds) */
+_Reporter.MAX_BACKOFF_MS = 6e4;
+var Reporter = _Reporter;
 
 // src/tracker.ts
 var ShieldPressTracker = class {
@@ -1232,6 +1269,7 @@ var ShieldPressTracker = class {
     this.lagTimer = null;
     this.started = false;
     this.headersChecked = false;
+    this.autoHooked = false;
     this.config = resolveConfig(userConfig);
     this.logger = createLogger(this.config.debug);
     this.reporter = new Reporter(this.config.apiUrl, this.config.apiKey, this.logger);
@@ -1259,6 +1297,9 @@ var ShieldPressTracker = class {
         this.errorCollector.capture(err, { type: "unhandledRejection" });
       });
     }
+    if (this.config.httpTracking) {
+      this.autoHookHttpServers();
+    }
     if (this.config.systemMetrics) {
       collectSystemMetrics();
     }
@@ -1378,6 +1419,50 @@ var ShieldPressTracker = class {
     }
     return this.reporter.send(payload);
   }
+  /**
+   * Monkey-patch http.Server and https.Server so every incoming request
+   * is automatically tracked without requiring the user to install middleware.
+   * Safe to call multiple times — patches only once.
+   */
+  autoHookHttpServers() {
+    if (this.autoHooked) return;
+    this.autoHooked = true;
+    const tracker = this;
+    const patchEmit = (ServerProto) => {
+      const originalEmit = ServerProto.emit;
+      ServerProto.emit = function(event, ...args) {
+        if (event === "request") {
+          const req = args[0];
+          const res = args[1];
+          const start = process.hrtime.bigint();
+          const url = req.url || "/";
+          res.on("finish", () => {
+            try {
+              const durationMs = Number(process.hrtime.bigint() - start) / 1e6;
+              const parsedPath = url.split("?")[0] || "/";
+              tracker.recordRequest({
+                path: parsedPath,
+                method: req.method || "GET",
+                statusCode: res.statusCode,
+                durationMs: Math.round(durationMs * 100) / 100
+              });
+            } catch {
+            }
+          });
+        }
+        return originalEmit.apply(this, [event, ...args]);
+      };
+    };
+    try {
+      patchEmit(http2.Server.prototype);
+      patchEmit(https2.Server.prototype);
+      this.logger.info("Auto-hooked http/https servers for request tracking");
+    } catch (err) {
+      this.logger.warn(
+        `Failed to auto-hook HTTP servers: ${err instanceof Error ? err.message : err}`
+      );
+    }
+  }
   shouldIgnorePath(path) {
     return this.config.ignorePaths.some((pattern) => {
       if (pattern.endsWith("/*")) {