@glasstrace/sdk 0.12.3 → 0.12.5

package/dist/index.cjs

@@ -17036,6 +17036,7 @@ function loadFsSyncOrNull() {
 var currentConfig = null;
 var configCacheChecked = false;
 var rateLimitBackoff = false;
+var lastInitSucceeded = false;
 function loadCachedConfig(projectRoot) {
   const modules = loadFsSyncOrNull();
   if (!modules) return null;
@@ -17205,6 +17206,7 @@ async function writeClaimedKey(newApiKey, projectRoot) {
   }
 }
 async function performInit(config2, anonKey, sdkVersion, healthReport) {
+  lastInitSucceeded = false;
   if (rateLimitBackoff) {
     rateLimitBackoff = false;
     return null;
@@ -17233,6 +17235,7 @@ async function performInit(config2, anonKey, sdkVersion, healthReport) {
       if (healthReport) {
         acknowledgeHealthReport(healthReport);
       }
+      lastInitSucceeded = true;
       await saveCachedConfig(result);
       if (result.claimResult) {
         try {
@@ -17279,7 +17282,6 @@ async function performInit(config2, anonKey, sdkVersion, healthReport) {
       return null;
     }
   } catch (err) {
-    recordInitFailure();
     console.warn(
       `[glasstrace] Unexpected init error: ${err instanceof Error ? err.message : String(err)}`
     );
@@ -17309,6 +17311,16 @@ function getClaimResult() {
 function _setCurrentConfig(config2) {
   currentConfig = config2;
 }
+function consumeRateLimitFlag() {
+  if (rateLimitBackoff) {
+    rateLimitBackoff = false;
+    return true;
+  }
+  return false;
+}
+function didLastInitSucceed() {
+  return lastInitSucceeded;
+}
 
 // src/span-processor.ts
 var GlasstraceSpanProcessor = class {
@@ -17345,6 +17357,7 @@ var GlasstraceExporter = class {
   environment;
   endpointUrl;
   createDelegateFn;
+  verbose;
   delegate = null;
   delegateKey = null;
   pendingBatches = [];
@@ -17357,6 +17370,7 @@ var GlasstraceExporter = class {
     this.environment = options.environment;
     this.endpointUrl = options.endpointUrl;
     this.createDelegateFn = options.createDelegate;
+    this.verbose = options.verbose ?? false;
   }
   export(spans, resultCallback) {
     const currentKey = this.getApiKey();
@@ -17365,11 +17379,16 @@ var GlasstraceExporter = class {
       return;
     }
     const enrichedSpans = spans.map((span) => this.enrichSpan(span));
+    if (this.verbose) {
+      sdkLog("info", `[glasstrace:diag] Export batch: ${enrichedSpans.length} spans`);
+    }
     const exporter = this.ensureDelegate();
     if (exporter) {
       exporter.export(enrichedSpans, (result) => {
         if (result.code !== 0) {
           sdkLog("warn", `[glasstrace] Span export failed: ${result.error?.message ?? "unknown error"}`);
+        } else if (this.verbose) {
+          sdkLog("info", `[glasstrace:diag] Export success: ${enrichedSpans.length} spans delivered`);
         }
         resultCallback(result);
       });
@@ -17462,6 +17481,21 @@ var GlasstraceExporter = class {
       if (statusCode !== void 0) {
         extra[ATTR.HTTP_STATUS_CODE] = statusCode;
       }
+      if (method && span.status?.code === SpanStatusCode.ERROR) {
+        if (statusCode === void 0 || statusCode === 0 || statusCode === 200) {
+          const httpErrorType = attrs["error.type"];
+          if (typeof httpErrorType === "string") {
+            const parsed = parseInt(httpErrorType, 10);
+            if (!isNaN(parsed) && parsed >= 400 && parsed <= 599) {
+              extra[ATTR.HTTP_STATUS_CODE] = parsed;
+            } else {
+              extra[ATTR.HTTP_STATUS_CODE] = 500;
+            }
+          } else {
+            extra[ATTR.HTTP_STATUS_CODE] = 500;
+          }
+        }
+      }
       if (span.startTime && span.endTime) {
         const [startSec, startNano] = span.startTime;
         const [endSec, endNano] = span.endTime;
@@ -17541,11 +17575,17 @@ var GlasstraceExporter = class {
   bufferSpans(spans, resultCallback) {
     this.pendingBatches.push({ spans, resultCallback });
     this.pendingSpanCount += spans.length;
+    if (this.verbose) {
+      sdkLog("info", `[glasstrace:diag] Buffering ${spans.length} spans (key pending, total: ${this.pendingSpanCount})`);
+    }
     while (this.pendingSpanCount > MAX_PENDING_SPANS && this.pendingBatches.length > 1) {
       const evicted = this.pendingBatches.shift();
       this.pendingSpanCount -= evicted.spans.length;
       recordSpansDropped(evicted.spans.length);
       evicted.resultCallback({ code: 0 });
+      if (this.verbose) {
+        sdkLog("info", `[glasstrace:diag] Buffer overflow: evicted ${evicted.spans.length} spans (total pending: ${this.pendingSpanCount})`);
+      }
       if (!this.overflowLogged) {
         this.overflowLogged = true;
         console.warn(
@@ -17584,6 +17624,8 @@ var GlasstraceExporter = class {
       exporter.export(enriched, (result) => {
         if (result.code !== 0) {
           sdkLog("warn", `[glasstrace] Span export failed: ${result.error?.message ?? "unknown error"}`);
+        } else if (this.verbose) {
+          sdkLog("info", `[glasstrace:diag] Flush export success: ${enriched.length} spans delivered`);
         }
         batch.resultCallback(result);
       });
@@ -20383,7 +20425,8 @@ async function configureOtel(config2, sessionManager) {
     getConfig: () => getActiveConfig(),
     environment: config2.environment,
     endpointUrl: exporterUrl,
-    createDelegate: createOtlpExporter
+    createDelegate: createOtlpExporter,
+    verbose: config2.verbose
   });
   _activeExporter = glasstraceExporter;
   const vercelOtel = await tryImport("@vercel/otel");
@@ -20426,6 +20469,9 @@ async function configureOtel(config2, sessionManager) {
   const processor = new BatchSpanProcessor(glasstraceExporter, {
     scheduledDelayMillis: 1e3
   });
+  if (config2.verbose) {
+    sdkLog("info", "[glasstrace:diag] BatchSpanProcessor configured: scheduledDelayMillis=1000");
+  }
   const provider = new BasicTracerProvider({
     spanProcessors: [processor]
   });
@@ -20435,6 +20481,112 @@ async function configureOtel(config2, sessionManager) {
 
 // src/register.ts
 init_console_capture();
+
+// src/heartbeat.ts
+init_console_capture();
+var HEARTBEAT_INTERVAL_MS = 5 * 60 * 1e3;
+var BACKOFF_BASE_MS = HEARTBEAT_INTERVAL_MS;
+var BACKOFF_MAX_MS = 30 * 60 * 1e3;
+var BACKOFF_JITTER = 0.2;
+var heartbeatTimer = null;
+var heartbeatGeneration = 0;
+var backoffAttempts = 0;
+var backoffUntil = 0;
+var tickInProgress = false;
+var _shutdownHandler2 = null;
+function startHeartbeat(config2, anonKey, sdkVersion, generation, onClaimTransition) {
+  if (heartbeatTimer !== null) return;
+  heartbeatGeneration = generation;
+  heartbeatTimer = setInterval(() => {
+    void heartbeatTick(config2, anonKey, sdkVersion, generation, onClaimTransition);
+  }, HEARTBEAT_INTERVAL_MS);
+  heartbeatTimer.unref();
+  registerShutdownHandlers(config2, anonKey, sdkVersion);
+  if (config2.verbose) {
+    sdkLog("info", "[glasstrace] Heartbeat started (5-minute interval).");
+  }
+}
+function stopHeartbeat() {
+  if (heartbeatTimer !== null) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  }
+  removeShutdownHandlers();
+}
+async function heartbeatTick(config2, anonKey, sdkVersion, generation, onClaimTransition) {
+  if (tickInProgress) return;
+  tickInProgress = true;
+  try {
+    if (generation !== heartbeatGeneration) {
+      stopHeartbeat();
+      return;
+    }
+    if (Date.now() < backoffUntil) {
+      if (config2.verbose) {
+        sdkLog("info", "[glasstrace] Heartbeat skipped (rate-limit backoff).");
+      }
+      return;
+    }
+    const healthReport = collectHealthReport(sdkVersion);
+    const initResult = await performInit(config2, anonKey, sdkVersion, healthReport);
+    if (generation !== heartbeatGeneration) return;
+    if (initResult === null && consumeRateLimitFlag()) {
+      backoffAttempts++;
+      const delay = Math.min(
+        BACKOFF_BASE_MS * Math.pow(2, backoffAttempts - 1),
+        BACKOFF_MAX_MS
+      );
+      const jitter = delay * BACKOFF_JITTER * (Math.random() * 2 - 1);
+      backoffUntil = Date.now() + delay + jitter;
+      if (config2.verbose) {
+        sdkLog("info", `[glasstrace] Heartbeat backing off for ${Math.round((delay + jitter) / 1e3)}s.`);
+      }
+    } else {
+      backoffAttempts = 0;
+      backoffUntil = 0;
+    }
+    if (initResult?.claimResult) {
+      onClaimTransition(initResult.claimResult.newApiKey);
+    }
+    if (config2.verbose) {
+      sdkLog("info", "[glasstrace] Heartbeat completed.");
+    }
+  } finally {
+    tickInProgress = false;
+  }
+}
+function registerShutdownHandlers(config2, anonKey, sdkVersion) {
+  if (typeof process === "undefined" || typeof process.once !== "function") {
+    return;
+  }
+  let shutdownFired = false;
+  const handler = (signal) => {
+    if (shutdownFired) return;
+    shutdownFired = true;
+    if (heartbeatTimer !== null) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    const healthReport = collectHealthReport(sdkVersion);
+    void performInit(config2, anonKey, sdkVersion, healthReport).catch(() => {
+    }).finally(() => {
+      removeShutdownHandlers();
+      process.kill(process.pid, signal);
+    });
+  };
+  _shutdownHandler2 = handler;
+  process.once("SIGTERM", _shutdownHandler2);
+  process.once("SIGINT", _shutdownHandler2);
+}
+function removeShutdownHandlers() {
+  if (_shutdownHandler2 && typeof process !== "undefined") {
+    process.removeListener("SIGTERM", _shutdownHandler2);
+    process.removeListener("SIGINT", _shutdownHandler2);
+    _shutdownHandler2 = null;
+  }
+}
+
+// src/register.ts
 var consoleCaptureInstalled = false;
 var discoveryHandler = null;
 var isRegistered = false;
@@ -20587,14 +20739,20 @@ async function backgroundInit(config2, anonKeyForInit, generation) {
   if (config2.verbose) {
     console.info("[glasstrace] Background init firing.");
   }
-  const healthReport = collectHealthReport("0.12.3");
-  const initResult = await performInit(config2, anonKeyForInit, "0.12.3", healthReport);
+  const healthReport = collectHealthReport("0.12.5");
+  const initResult = await performInit(config2, anonKeyForInit, "0.12.5", healthReport);
   if (generation !== registrationGeneration) return;
   if (initResult?.claimResult) {
     setResolvedApiKey(initResult.claimResult.newApiKey);
     notifyApiKeyResolved();
   }
   maybeInstallConsoleCapture();
+  if (didLastInitSucceed()) {
+    startHeartbeat(config2, anonKeyForInit, "0.12.5", generation, (newApiKey) => {
+      setResolvedApiKey(newApiKey);
+      notifyApiKeyResolved();
+    });
+  }
 }
 function getDiscoveryHandler() {
   return discoveryHandler;