@glasstrace/sdk 0.1.0 → 0.2.0

package/dist/index.js

@@ -68,17 +68,18 @@ function isAnonymousMode(config) {
 import { createHash } from "crypto";
 import { SessionIdSchema } from "@glasstrace/protocol";
 var FOUR_HOURS_MS = 4 * 60 * 60 * 1e3;
+var cachedGlasstraceEnv = process.env.GLASSTRACE_ENV;
+var cachedPort = process.env.PORT ?? "3000";
 function deriveSessionId(apiKey, origin, date, windowIndex) {
   const input = JSON.stringify([apiKey, origin, date, windowIndex]);
   const hash = createHash("sha256").update(input).digest("hex").slice(0, 16);
   return SessionIdSchema.parse(hash);
 }
 function getOrigin() {
-  if (process.env.GLASSTRACE_ENV) {
-    return process.env.GLASSTRACE_ENV;
+  if (cachedGlasstraceEnv) {
+    return cachedGlasstraceEnv;
   }
-  const port = process.env.PORT ?? "3000";
-  return `localhost:${port}`;
+  return `localhost:${cachedPort}`;
 }
 function getDateString() {
   const now = /* @__PURE__ */ new Date();
@@ -132,6 +133,7 @@ var SessionManager = class {
 };
 
 // src/fetch-classifier.ts
+var cachedPort2 = process.env.PORT ?? "3000";
 function classifyFetchTarget(url) {
   let parsed;
   try {
@@ -146,8 +148,7 @@ function classifyFetchTarget(url) {
   if (hostname === "stripe.com" || hostname.endsWith(".stripe.com")) {
     return "stripe";
   }
-  const port = process.env.PORT ?? "3000";
-  const internalOrigin = `localhost:${port}`;
+  const internalOrigin = `localhost:${cachedPort2}`;
   const parsedPort = parsed.port || (parsed.protocol === "https:" ? "443" : "80");
   const urlOrigin = `${hostname}:${parsedPort}`;
   if (urlOrigin === internalOrigin) {
@@ -296,6 +297,10 @@ async function sendInitRequest(config, anonKey, sdkVersion, importGraph, healthR
     signal
   });
   if (!response.ok) {
+    try {
+      await response.text();
+    } catch {
+    }
     const error = new Error(`Init request failed with status ${response.status}`);
     error.status = response.status;
     throw error;
@@ -418,6 +423,7 @@ var GlasstraceExporter = class {
   endpointUrl;
   createDelegateFn;
   delegate = null;
+  delegateKey = null;
   pendingBatches = [];
   pendingSpanCount = 0;
   overflowLogged = false;
@@ -430,12 +436,12 @@ var GlasstraceExporter = class {
     this.createDelegateFn = options.createDelegate;
   }
   export(spans, resultCallback) {
-    const enrichedSpans = spans.map((span) => this.enrichSpan(span));
     const currentKey = this.getApiKey();
     if (currentKey === API_KEY_PENDING) {
-      this.bufferSpans(enrichedSpans, resultCallback);
+      this.bufferSpans(spans, resultCallback);
       return;
     }
+    const enrichedSpans = spans.map((span) => this.enrichSpan(span));
     const exporter = this.ensureDelegate();
     if (exporter) {
       exporter.export(enrichedSpans, resultCallback);
@@ -477,58 +483,43 @@ var GlasstraceExporter = class {
   /**
    * Enriches a ReadableSpan with all glasstrace.* attributes.
    * Returns a new ReadableSpan wrapper; the original span is not mutated.
-   * Each attribute derivation is wrapped in its own try-catch for partial
-   * enrichment resilience.
+   *
+   * External function calls (getSessionId, deriveErrorCategory,
+   * deriveOrmProvider, classifyFetchTarget) are individually guarded so a
+   * failure in one does not prevent the remaining attributes from being set.
+   * On total failure, returns the original span unchanged.
    */
   enrichSpan(span) {
-    const attrs = span.attributes ?? {};
-    const name = span.name ?? "";
-    const extra = {};
     try {
+      const attrs = span.attributes ?? {};
+      const name = span.name ?? "";
+      const extra = {};
       extra[ATTR.TRACE_TYPE] = "server";
-    } catch {
-    }
-    try {
-      const sessionId = this.sessionManager.getSessionId(this.getApiKey());
-      extra[ATTR.SESSION_ID] = sessionId;
-    } catch {
-    }
-    try {
+      try {
+        const sessionId = this.sessionManager.getSessionId(this.getApiKey());
+        extra[ATTR.SESSION_ID] = sessionId;
+      } catch {
+      }
       const env = this.environment ?? process.env.GLASSTRACE_ENV;
       if (env) {
         extra[ATTR.ENVIRONMENT] = env;
       }
-    } catch {
-    }
-    try {
       const existingCid = attrs["glasstrace.correlation.id"];
       if (typeof existingCid === "string") {
         extra[ATTR.CORRELATION_ID] = existingCid;
       }
-    } catch {
-    }
-    try {
       const route = attrs["http.route"] ?? name;
       if (route) {
         extra[ATTR.ROUTE] = route;
       }
-    } catch {
-    }
-    try {
       const method = attrs["http.method"] ?? attrs["http.request.method"];
       if (method) {
         extra[ATTR.HTTP_METHOD] = method;
       }
-    } catch {
-    }
-    try {
       const statusCode = attrs["http.status_code"] ?? attrs["http.response.status_code"];
       if (statusCode !== void 0) {
         extra[ATTR.HTTP_STATUS_CODE] = statusCode;
       }
-    } catch {
-    }
-    try {
       if (span.startTime && span.endTime) {
         const [startSec, startNano] = span.startTime;
         const [endSec, endNano] = span.endTime;
@@ -537,72 +528,78 @@ var GlasstraceExporter = class {
           extra[ATTR.HTTP_DURATION_MS] = durationMs;
         }
       }
-    } catch {
-    }
-    try {
       const errorMessage = attrs["exception.message"];
       if (errorMessage) {
         extra[ATTR.ERROR_MESSAGE] = errorMessage;
       }
-    } catch {
-    }
-    try {
-      const errorType = attrs["exception.type"];
-      if (errorType) {
-        extra[ATTR.ERROR_CODE] = errorType;
-        extra[ATTR.ERROR_CATEGORY] = deriveErrorCategory(errorType);
+      try {
+        const errorType = attrs["exception.type"];
+        if (errorType) {
+          extra[ATTR.ERROR_CODE] = errorType;
+          extra[ATTR.ERROR_CATEGORY] = deriveErrorCategory(errorType);
+        }
+      } catch {
       }
-    } catch {
-    }
-    try {
       const errorField = attrs["error.field"];
       if (errorField) {
         extra[ATTR.ERROR_FIELD] = errorField;
       }
-    } catch {
-    }
-    try {
-      const spanAny = span;
-      const instrumentationName = spanAny.instrumentationScope?.name ?? spanAny.instrumentationLibrary?.name ?? "";
-      const ormProvider = deriveOrmProvider(instrumentationName);
-      if (ormProvider) {
-        extra[ATTR.ORM_PROVIDER] = ormProvider;
-        const model = attrs["db.sql.table"] ?? attrs["db.prisma.model"];
-        if (model) {
-          extra[ATTR.ORM_MODEL] = model;
-        }
-        const operation = attrs["db.operation"];
-        if (operation) {
-          extra[ATTR.ORM_OPERATION] = operation;
+      try {
+        const spanAny = span;
+        const instrumentationName = spanAny.instrumentationScope?.name ?? spanAny.instrumentationLibrary?.name ?? "";
+        const ormProvider = deriveOrmProvider(instrumentationName);
+        if (ormProvider) {
+          extra[ATTR.ORM_PROVIDER] = ormProvider;
+          const model = attrs["db.sql.table"] ?? attrs["db.prisma.model"];
+          if (model) {
+            extra[ATTR.ORM_MODEL] = model;
+          }
+          const operation = attrs["db.operation"];
+          if (operation) {
+            extra[ATTR.ORM_OPERATION] = operation;
+          }
         }
+      } catch {
       }
-    } catch {
-    }
-    try {
-      const url = attrs["http.url"] ?? attrs["url.full"];
-      if (url && span.kind === SpanKind.CLIENT) {
-        extra[ATTR.FETCH_TARGET] = classifyFetchTarget(url);
+      try {
+        const url = attrs["http.url"] ?? attrs["url.full"];
+        if (url && span.kind === SpanKind.CLIENT) {
+          extra[ATTR.FETCH_TARGET] = classifyFetchTarget(url);
+        }
+      } catch {
       }
+      return createEnrichedSpan(span, extra);
     } catch {
+      return span;
     }
-    return createEnrichedSpan(span, extra);
   }
   /**
    * Lazily creates the delegate OTLP exporter once the API key is resolved.
+   * Recreates the delegate if the key has changed (e.g., after key rotation)
+   * so the Authorization header stays current.
    */
   ensureDelegate() {
     if (!this.createDelegateFn) return null;
-    if (this.delegate) return this.delegate;
     const currentKey = this.getApiKey();
     if (currentKey === API_KEY_PENDING) return null;
+    if (this.delegate && this.delegateKey === currentKey) {
+      return this.delegate;
+    }
+    if (this.delegate) {
+      void this.delegate.shutdown?.().catch(() => {
+      });
+    }
     this.delegate = this.createDelegateFn(this.endpointUrl, {
       Authorization: `Bearer ${currentKey}`
     });
+    this.delegateKey = currentKey;
     return this.delegate;
   }
   /**
-   * Buffers enriched spans while the API key is pending.
+   * Buffers raw (unenriched) spans while the API key is pending.
    * Evicts oldest batches if the buffer exceeds MAX_PENDING_SPANS.
+   * Re-checks the key after buffering to close the race window where
+   * the key resolves between the caller's check and this buffer call.
    */
   bufferSpans(spans, resultCallback) {
     this.pendingBatches.push({ spans, resultCallback });
@@ -618,10 +615,14 @@ var GlasstraceExporter = class {
         );
       }
     }
+    if (this.getApiKey() !== API_KEY_PENDING) {
+      this.flushPending();
+    }
   }
   /**
    * Flushes all buffered spans through the delegate exporter.
-   * Called when the API key resolves.
+   * Enriches spans at flush time (not buffer time) so that session IDs
+   * are computed with the resolved API key instead of the "pending" sentinel.
    */
   flushPending() {
     if (this.pendingBatches.length === 0) return;
@@ -638,7 +639,8 @@ var GlasstraceExporter = class {
     this.pendingBatches = [];
     this.pendingSpanCount = 0;
     for (const batch of batches) {
-      exporter.export(batch.spans, batch.resultCallback);
+      const enriched = batch.spans.map((span) => this.enrichSpan(span));
+      exporter.export(enriched, batch.resultCallback);
     }
   }
 };
@@ -762,6 +764,7 @@ function createDiscoveryHandler(getAnonKey, getSessionId) {
 // src/otel-config.ts
 var _resolvedApiKey = API_KEY_PENDING;
 var _activeExporter = null;
+var _shutdownHandler = null;
 function setResolvedApiKey(key) {
   _resolvedApiKey = key;
 }
@@ -778,6 +781,33 @@ async function tryImport(moduleId) {
     return null;
   }
 }
+function registerShutdownHooks(provider) {
+  if (typeof process === "undefined" || typeof process.once !== "function") {
+    return;
+  }
+  if (_shutdownHandler) {
+    process.removeListener("SIGTERM", _shutdownHandler);
+    process.removeListener("SIGINT", _shutdownHandler);
+  }
+  let shutdownCalled = false;
+  const shutdown = (signal) => {
+    if (shutdownCalled) return;
+    shutdownCalled = true;
+    void provider.shutdown().catch((err) => {
+      console.warn(
+        `[glasstrace] Error during OTel shutdown: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }).finally(() => {
+      process.removeListener("SIGTERM", _shutdownHandler);
+      process.removeListener("SIGINT", _shutdownHandler);
+      process.kill(process.pid, signal);
+    });
+  };
+  const handler = (signal) => shutdown(signal);
+  _shutdownHandler = handler;
+  process.once("SIGTERM", handler);
+  process.once("SIGINT", handler);
+}
 async function configureOtel(config, sessionManager) {
   const exporterUrl = `${config.endpoint}/v1/traces`;
   let createOtlpExporter = null;
@@ -818,7 +848,16 @@ async function configureOtel(config, sessionManager) {
   }
   try {
     const otelSdk = await import("@opentelemetry/sdk-trace-base");
-    const otelApi = await import("@opentelemetry/api");
+    const otelApi3 = await import("@opentelemetry/api");
+    const existingProvider = otelApi3.trace.getTracerProvider();
+    const probeTracer = existingProvider.getTracer("glasstrace-probe");
+    if (probeTracer.constructor.name !== "ProxyTracer") {
+      console.warn(
+        "[glasstrace] An existing OpenTelemetry TracerProvider is already registered. Glasstrace will not overwrite it. To use Glasstrace alongside another tracing tool, add GlasstraceExporter as an additional span processor on your existing provider."
+      );
+      _activeExporter = null;
+      return;
+    }
     if (!createOtlpExporter) {
       const consoleExporter = new otelSdk.ConsoleSpanExporter();
       const consoleGlasstraceExporter = new GlasstraceExporter({
@@ -837,20 +876,16 @@ async function configureOtel(config, sessionManager) {
       const provider2 = new otelSdk.BasicTracerProvider({
         spanProcessors: [processor2]
       });
-      otelApi.trace.setGlobalTracerProvider(provider2);
+      otelApi3.trace.setGlobalTracerProvider(provider2);
+      registerShutdownHooks(provider2);
       return;
     }
-    const processor = new otelSdk.SimpleSpanProcessor(glasstraceExporter);
+    const processor = new otelSdk.BatchSpanProcessor(glasstraceExporter);
     const provider = new otelSdk.BasicTracerProvider({
       spanProcessors: [processor]
     });
-    const existingProvider = otelApi.trace.getTracerProvider();
-    if (existingProvider && existingProvider.constructor.name !== "ProxyTracerProvider") {
-      console.warn(
-        "[glasstrace] An existing OpenTelemetry TracerProvider was detected and will be replaced. If you use another tracing tool, configure Glasstrace as an additional exporter instead."
-      );
-    }
-    otelApi.trace.setGlobalTracerProvider(provider);
+    otelApi3.trace.setGlobalTracerProvider(provider);
+    registerShutdownHooks(provider);
   } catch {
     console.warn(
       "[glasstrace] Neither @vercel/otel nor @opentelemetry/sdk-trace-base available. Tracing disabled."
@@ -858,7 +893,108 @@ async function configureOtel(config, sessionManager) {
   }
 }
 
+// src/console-capture.ts
+var isGlasstraceLog = false;
+var originalError = null;
+var originalWarn = null;
+var installed = false;
+var otelApi = null;
+function formatArgs(args) {
+  return args.map((arg) => {
+    if (typeof arg === "string") return arg;
+    if (arg instanceof Error) return arg.stack ?? arg.message;
+    try {
+      return JSON.stringify(arg);
+    } catch {
+      return String(arg);
+    }
+  }).join(" ");
+}
+function isSdkMessage(args) {
+  return typeof args[0] === "string" && args[0].startsWith("[glasstrace]");
+}
+async function installConsoleCapture() {
+  if (installed) return;
+  try {
+    otelApi = await import("@opentelemetry/api");
+  } catch {
+    otelApi = null;
+  }
+  originalError = console.error;
+  originalWarn = console.warn;
+  installed = true;
+  console.error = (...args) => {
+    originalError.apply(console, args);
+    if (isGlasstraceLog || isSdkMessage(args)) return;
+    if (otelApi) {
+      const span = otelApi.trace.getSpan(otelApi.context.active());
+      if (span) {
+        span.addEvent("console.error", {
+          "console.message": formatArgs(args)
+        });
+      }
+    }
+  };
+  console.warn = (...args) => {
+    originalWarn.apply(console, args);
+    if (isGlasstraceLog || isSdkMessage(args)) return;
+    if (otelApi) {
+      const span = otelApi.trace.getSpan(otelApi.context.active());
+      if (span) {
+        span.addEvent("console.warn", {
+          "console.message": formatArgs(args)
+        });
+      }
+    }
+  };
+}
+
+// src/capture-error.ts
+var otelApi2 = null;
+var otelLoadAttempted = false;
+var otelLoadPromise = null;
+async function _preloadOtelApi() {
+  if (otelLoadAttempted) return;
+  otelLoadAttempted = true;
+  try {
+    otelApi2 = await import("@opentelemetry/api");
+  } catch {
+    otelApi2 = null;
+  }
+}
+function captureError(error) {
+  if (otelApi2) {
+    recordError(otelApi2, error);
+    return;
+  }
+  if (!otelLoadAttempted) {
+    otelLoadPromise ??= _preloadOtelApi();
+  }
+  if (otelLoadPromise) {
+    void otelLoadPromise.then(() => {
+      if (otelApi2) {
+        recordError(otelApi2, error);
+      }
+    });
+  }
+}
+function recordError(api, error) {
+  try {
+    const span = api.trace.getSpan(api.context.active());
+    if (!span) return;
+    const attributes = {
+      "error.message": String(error)
+    };
+    if (error instanceof Error) {
+      attributes["error.type"] = error.constructor.name;
+    }
+    span.addEvent("glasstrace.error", attributes);
+  } catch {
+  }
+}
+
 // src/register.ts
+var consoleCaptureInstalled = false;
 var discoveryHandler = null;
 var isRegistered = false;
 var registrationGeneration = 0;
@@ -869,7 +1005,7 @@ function registerGlasstrace(options) {
     }
     const config = resolveConfig(options);
     if (config.verbose) {
-      console.info("[glasstrace] Step 1: Config resolved.");
+      console.info("[glasstrace] Config resolved.");
     }
     if (isProductionDisabled(config)) {
       console.warn(
@@ -878,7 +1014,7 @@ function registerGlasstrace(options) {
       return;
     }
     if (config.verbose) {
-      console.info("[glasstrace] Step 2: Not production-disabled.");
+      console.info("[glasstrace] Not production-disabled.");
     }
     const anonymous = isAnonymousMode(config);
     let effectiveKey = config.apiKey;
@@ -887,7 +1023,7 @@ function registerGlasstrace(options) {
     }
     if (config.verbose) {
       console.info(
-        `[glasstrace] Step 3: Auth mode = ${anonymous ? "anonymous" : "dev-key"}.`
+        `[glasstrace] Auth mode = ${anonymous ? "anonymous" : "dev-key"}.`
       );
     }
     const cachedInitResponse = loadCachedConfig();
@@ -896,19 +1032,21 @@ function registerGlasstrace(options) {
     }
     if (config.verbose) {
       console.info(
-        `[glasstrace] Step 4: Cached config ${cachedInitResponse ? "loaded and applied" : "not found"}.`
+        `[glasstrace] Cached config ${cachedInitResponse ? "loaded and applied" : "not found"}.`
       );
     }
     const sessionManager = new SessionManager();
     if (config.verbose) {
-      console.info("[glasstrace] Step 5: SessionManager created.");
+      console.info("[glasstrace] SessionManager created.");
     }
     isRegistered = true;
     const currentGeneration = registrationGeneration;
     void configureOtel(config, sessionManager).then(
       () => {
+        void _preloadOtelApi();
+        maybeInstallConsoleCapture();
         if (config.verbose) {
-          console.info("[glasstrace] Step 6: OTel configured.");
+          console.info("[glasstrace] OTel configured.");
         }
       },
       (err) => {
@@ -926,7 +1064,7 @@ function registerGlasstrace(options) {
           () => sessionManager.getSessionId(getResolvedApiKey())
         );
         if (config.verbose) {
-          console.info("[glasstrace] Step 8: Discovery endpoint registered (key pending).");
+          console.info("[glasstrace] Discovery endpoint registered (key pending).");
         }
         void (async () => {
           try {
@@ -942,9 +1080,10 @@ function registerGlasstrace(options) {
               () => sessionManager.getSessionId(getResolvedApiKey())
             );
             if (config.verbose) {
-              console.info("[glasstrace] Step 7: Background init firing.");
+              console.info("[glasstrace] Background init firing.");
             }
-            await performInit(config, anonKey, "0.1.0");
+            await performInit(config, anonKey, "0.2.0");
+            maybeInstallConsoleCapture();
           } catch (err) {
             console.warn(
               `[glasstrace] Background init failed: ${err instanceof Error ? err.message : String(err)}`
@@ -961,9 +1100,10 @@ function registerGlasstrace(options) {
             effectiveKey = anonKey;
             if (currentGeneration !== registrationGeneration) return;
             if (config.verbose) {
-              console.info("[glasstrace] Step 7: Background init firing.");
+              console.info("[glasstrace] Background init firing.");
             }
-            await performInit(config, anonKey, "0.1.0");
+            await performInit(config, anonKey, "0.2.0");
+            maybeInstallConsoleCapture();
           } catch (err) {
             console.warn(
               `[glasstrace] Background init failed: ${err instanceof Error ? err.message : String(err)}`
@@ -982,9 +1122,10 @@ function registerGlasstrace(options) {
           }
           if (currentGeneration !== registrationGeneration) return;
           if (config.verbose) {
-            console.info("[glasstrace] Step 7: Background init firing.");
+            console.info("[glasstrace] Background init firing.");
           }
-          await performInit(config, anonKeyForInit, "0.1.0");
+          await performInit(config, anonKeyForInit, "0.2.0");
+          maybeInstallConsoleCapture();
         } catch (err) {
           console.warn(
             `[glasstrace] Background init failed: ${err instanceof Error ? err.message : String(err)}`
@@ -993,7 +1134,7 @@ function registerGlasstrace(options) {
       })();
     }
     if (config.coverageMapEnabled && config.verbose) {
-      console.info("[glasstrace] Step 9: Import graph building skipped.");
+      console.info("[glasstrace] Import graph building skipped.");
     }
   } catch (err) {
     console.warn(
@@ -1004,6 +1145,13 @@ function registerGlasstrace(options) {
 function getDiscoveryHandler() {
   return discoveryHandler;
 }
+function maybeInstallConsoleCapture() {
+  if (consoleCaptureInstalled) return;
+  if (getActiveConfig().consoleErrors) {
+    consoleCaptureInstalled = true;
+    void installConsoleCapture();
+  }
+}
 function isDiscoveryEnabled(config) {
   if (process.env.GLASSTRACE_DISCOVERY_ENABLED === "true") return true;
   if (process.env.GLASSTRACE_DISCOVERY_ENABLED === "false") return false;
@@ -1088,6 +1236,10 @@ async function uploadSourceMaps(apiKey, endpoint, buildHash, maps) {
     body: JSON.stringify(body)
   });
   if (!response.ok) {
+    try {
+      await response.text();
+    } catch {
+    }
     throw new Error(
       `Source map upload failed: ${String(response.status)} ${response.statusText}`
     );
@@ -1163,6 +1315,7 @@ export {
   SdkError,
   SessionManager,
   buildImportGraph,
+  captureError,
   classifyFetchTarget,
   collectSourceMaps,
   computeBuildHash,