@newtalaria/browser 0.1.18 → 0.1.19

package/dist/talaria.browser.iife.js

@@ -272,6 +272,250 @@
     return base;
   }
 
+  // src/utils/tags.ts
+  var MAX_TAGS_PER_EVENT = 20;
+  var MAX_TAG_KEY_LENGTH = 64;
+  var MAX_TAG_VALUE_LENGTH = 128;
+  var MAX_TAG_TOTAL_UTF8_BYTES = 2048;
+  var KEY_PATTERN = /^[a-z0-9_.-]+$/;
+  var HIGH_CARDINALITY_TAG_KEYS = /* @__PURE__ */ new Set([
+    "user_id",
+    "userid",
+    "request_id",
+    "requestid",
+    "business_id",
+    "order_id",
+    "email",
+    "url",
+    "uuid",
+    "session_id",
+    "trace_id",
+    "span_id"
+  ]);
+  var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  var EMAIL_RE = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;
+  var LONG_NUMERIC_RE = /^\d{8,}$/;
+  function utf8Bytes(s) {
+    if (typeof TextEncoder !== "undefined") {
+      return new TextEncoder().encode(s).length;
+    }
+    return unescape(encodeURIComponent(s)).length;
+  }
+  function normalizeKey(raw) {
+    const key = raw.trim().toLowerCase();
+    if (!key || key.length > MAX_TAG_KEY_LENGTH) return null;
+    if (!KEY_PATTERN.test(key)) return null;
+    return key;
+  }
+  function normalizeValue(raw) {
+    if (raw == null) return null;
+    const value = String(raw).trim();
+    if (!value) return null;
+    return value.length <= MAX_TAG_VALUE_LENGTH ? value : value.slice(0, MAX_TAG_VALUE_LENGTH);
+  }
+  function normalizeTags(tags) {
+    if (!tags) return {};
+    const result2 = {};
+    let totalBytes = 0;
+    for (const [rawKey, rawValue] of Object.entries(tags)) {
+      if (Object.keys(result2).length >= MAX_TAGS_PER_EVENT) break;
+      const key = normalizeKey(rawKey);
+      if (!key) continue;
+      const value = normalizeValue(rawValue);
+      if (value == null) continue;
+      if (result2[key] != null) {
+        totalBytes -= utf8Bytes(key) + utf8Bytes(result2[key]);
+      }
+      const entryBytes = utf8Bytes(key) + utf8Bytes(value);
+      if (totalBytes + entryBytes > MAX_TAG_TOTAL_UTF8_BYTES) continue;
+      result2[key] = value;
+      totalBytes += entryBytes;
+    }
+    return result2;
+  }
+  function mergeTags(...parts) {
+    const merged = {};
+    for (const part of parts) {
+      if (!part) continue;
+      Object.assign(merged, part);
+    }
+    return normalizeTags(merged);
+  }
+  function looksHighCardinalityValue(value) {
+    return UUID_RE.test(value) || EMAIL_RE.test(value) || LONG_NUMERIC_RE.test(value);
+  }
+  function warnSuspiciousTags(tags, environment) {
+    if (!environment || environment === "production") return;
+    if (typeof console === "undefined" || typeof console.warn !== "function") {
+      return;
+    }
+    for (const [key, value] of Object.entries(tags)) {
+      if (HIGH_CARDINALITY_TAG_KEYS.has(key)) {
+        console.warn(
+          `@newtalaria/browser: Tag "${key}" appears to have high cardinality. Consider moving it to context/extra.`
+        );
+        continue;
+      }
+      if (looksHighCardinalityValue(value)) {
+        console.warn(
+          `@newtalaria/browser: Tag "${key}" value looks high-cardinality. Consider moving it to context/extra.`
+        );
+      }
+    }
+  }
+
+  // src/utils/stacktrace.ts
+  var V8_FRAME = /^\s*at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?\s*$/;
+  var V8_FRAME_BARE = /^\s*at\s+(.+)\s*$/;
+  var EXTENSION_URL2 = /(?:chrome|moz|safari|safari-web|ms-browser)-extension:\/\//i;
+  function parseStackTrace(stack, inAppOptions) {
+    if (!stack || !stack.trim()) return void 0;
+    const parsed = [];
+    for (const line of stack.split("\n")) {
+      const frame = parseStackLine(line, inAppOptions);
+      if (frame) parsed.push(frame);
+    }
+    if (parsed.length === 0) return void 0;
+    parsed.reverse();
+    return { frames: parsed };
+  }
+  function parseStackLine(line, inAppOptions) {
+    if (!/^\s*at\s+/.test(line)) return null;
+    const v8 = V8_FRAME.exec(line);
+    if (v8) {
+      const functionName = cleanFunction(v8[1]);
+      const absPath = stripQuery(v8[2] ?? "");
+      const lineno = Number.parseInt(v8[3] ?? "", 10);
+      const colno = Number.parseInt(v8[4] ?? "", 10);
+      return {
+        functionName,
+        absPath: absPath || void 0,
+        filename: basename(absPath),
+        lineno: Number.isFinite(lineno) ? lineno : void 0,
+        colno: Number.isFinite(colno) ? colno : void 0,
+        inApp: isInAppFrame(absPath, inAppOptions),
+        platform: "javascript"
+      };
+    }
+    const bare = V8_FRAME_BARE.exec(line);
+    if (bare) {
+      const functionName = cleanFunction(bare[1]);
+      if (!functionName) return null;
+      return {
+        functionName,
+        inApp: false,
+        platform: "javascript"
+      };
+    }
+    return null;
+  }
+  function applySourceLocation(stacktrace, source, inAppOptions) {
+    if (!source) return stacktrace;
+    const filename = source.filename?.trim() || void 0;
+    const lineno = typeof source.lineno === "number" && source.lineno > 0 ? source.lineno : void 0;
+    const colno = typeof source.colno === "number" && source.colno >= 0 ? source.colno : void 0;
+    if (!filename && lineno == null && colno == null) return stacktrace;
+    if (!stacktrace || stacktrace.frames.length === 0) {
+      if (!filename && lineno == null) return stacktrace;
+      const absPath = filename;
+      return {
+        frames: [
+          {
+            filename: absPath ? basename(absPath) : void 0,
+            absPath,
+            lineno,
+            colno,
+            inApp: absPath ? isInAppFrame(absPath, inAppOptions) : true,
+            platform: "javascript"
+          }
+        ]
+      };
+    }
+    const frames = stacktrace.frames.slice();
+    const top = { ...frames[frames.length - 1] };
+    if (filename) {
+      top.absPath = filename;
+      top.filename = basename(filename);
+      top.inApp = isInAppFrame(filename, inAppOptions);
+    }
+    if (lineno != null) top.lineno = lineno;
+    if (colno != null) top.colno = colno;
+    frames[frames.length - 1] = top;
+    return { ...stacktrace, frames };
+  }
+  function isInAppFrame(path, options) {
+    const lower = path.toLowerCase();
+    if (!lower) return true;
+    if (lower.includes("node_modules")) return false;
+    if (EXTENSION_URL2.test(path) || lower.includes("webkit-masked-url://")) {
+      return false;
+    }
+    if (lower.includes("@newtalaria/browser")) return false;
+    if (matchesUrlList(path, options?.denyUrls)) return false;
+    if (matchesUrlList(path, options?.allowUrls)) return true;
+    const frameOrigin = tryParseOrigin(path);
+    if (frameOrigin != null) {
+      const pageOrigin = normalizeOrigin(options?.pageOrigin);
+      if (pageOrigin && frameOrigin === pageOrigin) return true;
+      const extra = options?.inAppOrigins ?? [];
+      for (const origin of extra) {
+        if (normalizeOrigin(origin) === frameOrigin) return true;
+      }
+      return false;
+    }
+    return true;
+  }
+  function matchesUrlList(path, patterns) {
+    if (!patterns || patterns.length === 0) return false;
+    for (const pattern of patterns) {
+      if (typeof pattern === "string") {
+        if (pattern && path.includes(pattern)) return true;
+      } else if (pattern.test(path)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function tryParseOrigin(path) {
+    if (!/^https?:\/\//i.test(path)) return null;
+    try {
+      return new URL(path).origin;
+    } catch {
+      return null;
+    }
+  }
+  function normalizeOrigin(origin) {
+    if (!origin || !origin.trim()) return null;
+    const trimmed = origin.trim();
+    try {
+      if (/^https?:\/\//i.test(trimmed)) {
+        return new URL(trimmed).origin;
+      }
+      return trimmed;
+    } catch {
+      return trimmed;
+    }
+  }
+  function resolvePageOrigin(originOrUrl) {
+    return normalizeOrigin(originOrUrl) ?? void 0;
+  }
+  function cleanFunction(raw) {
+    if (raw == null) return void 0;
+    const value = raw.trim();
+    return value.length === 0 ? void 0 : value;
+  }
+  function stripQuery(path) {
+    const q = path.indexOf("?");
+    return q >= 0 ? path.slice(0, q) : path;
+  }
+  function basename(path) {
+    if (!path) return void 0;
+    const normalized = stripQuery(path);
+    const parts = normalized.split(/[/\\]/);
+    const last = parts[parts.length - 1];
+    return last || normalized;
+  }
+
   // src/sdk_meta.ts
   var SDK_NAME = "@newtalaria/browser";
   var SDK_VERSION = "0.1.18";
@@ -332,6 +576,9 @@
     if (params.eventType) input2.eventType = params.eventType;
     if (params.title) input2.title = params.title;
     if (params.stackTrace) input2.stackTrace = params.stackTrace;
+    if (params.exception) input2.exception = serializeException(params.exception);
+    if (params.debugMeta) input2.debugMeta = serializeDebugMeta(params.debugMeta);
+    if (params.platform) input2.platform = params.platform;
     if (params.release) input2.release = params.release;
     if (params.userId) input2.userId = params.userId;
     if (params.sessionId) input2.sessionId = params.sessionId;
@@ -348,6 +595,89 @@
       { keepalive: params.keepalive }
     );
   }
+  function serializeException(data) {
+    return {
+      __className__: "ExceptionDataDto",
+      values: data.values.map(serializeExceptionValue)
+    };
+  }
+  function serializeExceptionValue(value) {
+    const out = {
+      __className__: "ExceptionValueDto"
+    };
+    if (value.type != null) out.type = value.type;
+    if (value.value != null) out.value = value.value;
+    if (value.module != null) out.module = value.module;
+    if (value.threadId != null) out.threadId = value.threadId;
+    if (value.code != null) out.code = value.code;
+    if (value.mechanism) out.mechanism = serializeMechanism(value.mechanism);
+    if (value.stacktrace) out.stacktrace = serializeStackTrace(value.stacktrace);
+    return out;
+  }
+  function serializeMechanism(mechanism) {
+    const out = {
+      __className__: "ExceptionMechanismDto",
+      type: mechanism.type
+    };
+    if (mechanism.handled != null) out.handled = mechanism.handled;
+    if (mechanism.synthetic != null) out.synthetic = mechanism.synthetic;
+    return out;
+  }
+  function serializeStackTrace(stack) {
+    const out = {
+      __className__: "StackTraceDto",
+      frames: stack.frames.map(serializeStackFrame)
+    };
+    if (stack.registers) out.registers = stack.registers;
+    return out;
+  }
+  function serializeStackFrame(frame) {
+    const out = {
+      __className__: "StackFrameDto"
+    };
+    if (frame.filename != null) out.filename = frame.filename;
+    if (frame.absPath != null) out.absPath = frame.absPath;
+    if (frame.functionName != null) out.functionName = frame.functionName;
+    if (frame.rawFunction != null) out.rawFunction = frame.rawFunction;
+    if (frame.module != null) out.module = frame.module;
+    if (frame.package != null) out.package = frame.package;
+    if (frame.platform != null) out.platform = frame.platform;
+    if (frame.lineno != null) out.lineno = frame.lineno;
+    if (frame.colno != null) out.colno = frame.colno;
+    if (frame.inApp != null) out.inApp = frame.inApp;
+    if (frame.instructionAddr != null) out.instructionAddr = frame.instructionAddr;
+    if (frame.symbolAddr != null) out.symbolAddr = frame.symbolAddr;
+    if (frame.imageAddr != null) out.imageAddr = frame.imageAddr;
+    if (frame.addrMode != null) out.addrMode = frame.addrMode;
+    if (frame.contextLine != null) out.contextLine = frame.contextLine;
+    if (frame.preContext != null) out.preContext = frame.preContext;
+    if (frame.postContext != null) out.postContext = frame.postContext;
+    if (frame.vars != null) out.vars = frame.vars;
+    if (frame.stackStart != null) out.stackStart = frame.stackStart;
+    return out;
+  }
+  function serializeDebugMeta(meta) {
+    const out = {
+      __className__: "DebugMetaDto"
+    };
+    if (meta.images) {
+      out.images = meta.images.map((image) => {
+        const img = {
+          __className__: "DebugImageDto"
+        };
+        if (image.type != null) img.type = image.type;
+        if (image.imageAddr != null) img.imageAddr = image.imageAddr;
+        if (image.imageSize != null) img.imageSize = image.imageSize;
+        if (image.debugId != null) img.debugId = image.debugId;
+        if (image.debugFile != null) img.debugFile = image.debugFile;
+        if (image.codeId != null) img.codeId = image.codeId;
+        if (image.codeFile != null) img.codeFile = image.codeFile;
+        if (image.arch != null) img.arch = image.arch;
+        return img;
+      });
+    }
+    return out;
+  }
 
   // src/utils/gzip.ts
   async function gzipBytes(data) {
@@ -13769,7 +14099,7 @@
       }
     }
   }
-  function resolvePageOrigin(pageOrigin) {
+  function resolvePageOrigin2(pageOrigin) {
     if (pageOrigin) {
       try {
         return new URL(pageOrigin).origin;
@@ -13794,12 +14124,12 @@
     if (!requestOrigin) return false;
     const allow = opts.networkErrorOrigins.map(normalizeNetworkOrigin);
     if (allow.includes("*")) return true;
-    const page = resolvePageOrigin(opts.pageOrigin);
+    const page = resolvePageOrigin2(opts.pageOrigin);
     if (page && requestOrigin === page) return true;
     return allow.includes(requestOrigin);
   }
   function classifyNetworkParty(requestOrigin, pageOrigin) {
-    const page = resolvePageOrigin(pageOrigin);
+    const page = resolvePageOrigin2(pageOrigin);
     if (page && requestOrigin && requestOrigin === page) return "first_party";
     return "third_party";
   }
@@ -14016,6 +14346,16 @@
   }
 
   // src/client.ts
+  var PLATFORM_JAVASCRIPT = "javascript";
+  var EXTRA_LOCATION_KEYS = /* @__PURE__ */ new Set([
+    "exception_class",
+    "file",
+    "line",
+    "code",
+    "filename",
+    "lineno",
+    "colno"
+  ]);
   function networkExceptionClass(failure) {
     if (failure.failureKind === "http") return "HttpError";
     if (failure.failureKind === "timeout") return "TimeoutError";
@@ -14058,14 +14398,59 @@
         aborted: failure.aborted ?? false,
         ok: failure.ok ?? false
       },
-      // Top-level for server fingerprint compatibility.
+      // Top-level for server fingerprint compatibility (status only —
+      // exception type lives on first-class `exception.values[0].type`).
       status_code: statusCode,
-      exception_class: networkExceptionClass(failure),
       durationMs: failure.durationMs,
       aborted: failure.aborted ?? false,
       ok: failure.ok ?? false
     };
   }
+  function networkExceptionData(failure, message) {
+    return {
+      values: [
+        {
+          type: networkExceptionClass(failure),
+          value: message,
+          mechanism: {
+            type: "http",
+            handled: true,
+            synthetic: true
+          }
+        }
+      ]
+    };
+  }
+  function scrubLegacyExceptionExtra(extra) {
+    if (!extra) return void 0;
+    const out = {};
+    for (const [key, value] of Object.entries(extra)) {
+      if (EXTRA_LOCATION_KEYS.has(key)) continue;
+      out[key] = value;
+    }
+    return Object.keys(out).length ? out : void 0;
+  }
+  function buildExceptionFromError(err, context, inAppOptions) {
+    const mechanism = context?.mechanism ?? {
+      type: "generic",
+      handled: true
+    };
+    const stacktrace = applySourceLocation(
+      parseStackTrace(err.stack, inAppOptions),
+      context?.source,
+      inAppOptions
+    );
+    return {
+      values: [
+        {
+          type: err.name || "Error",
+          value: err.message || err.name || "Error",
+          mechanism,
+          ...stacktrace ? { stacktrace } : {}
+        }
+      ]
+    };
+  }
   function mergeNetworkFailureContext(context, failure) {
     return {
       ...context,
@@ -14102,14 +14487,17 @@
       inlineStylesheet: options.inlineStylesheet ?? false,
       blockSelector: options.blockSelector ?? "",
       userId: options.userId,
-      tags: options.tags,
+      tags: mergeTags(options.tags),
       disableDefaultIntegrations: options.disableDefaultIntegrations ?? false,
       captureFailedRequests: options.captureFailedRequests ?? true,
       captureNetworkErrors: options.captureNetworkErrors ?? true,
       networkErrorOrigins: options.networkErrorOrigins ?? [],
       includeNetworkUrlQuery: options.captureRequestQueryParameters ?? options.includeNetworkUrlQuery ?? false,
       failedRequestStatusCodes: options.failedRequestStatusCodes ?? [[500, 599]],
-      failedRequestIgnoreUrls: options.failedRequestIgnoreUrls ?? []
+      failedRequestIgnoreUrls: options.failedRequestIgnoreUrls ?? [],
+      inAppAllowUrls: options.inAppAllowUrls ?? [],
+      inAppDenyUrls: options.inAppDenyUrls ?? [],
+      inAppOrigins: options.inAppOrigins ?? []
     };
   }
   var RECENT_NETWORK_FAILURE_MS = 5e3;
@@ -14256,17 +14644,21 @@
               failureKind: "http",
               aborted: false
             };
-            void this.captureMessage(
-              `HTTP ${status}: ${method} ${url}`,
-              status >= 500 ? "error" : "warning",
-              {
+            const message = `HTTP ${status}: ${method} ${url}`;
+            void this.capture({
+              message,
+              level: status >= 500 ? "error" : "warning",
+              title: networkExceptionClass(enriched),
+              exception: networkExceptionData(enriched, message),
+              platform: PLATFORM_JAVASCRIPT,
+              context: {
                 tags: {
                   ...networkFailureTags(enriched),
                   "http.status_code": String(status)
                 },
                 extra: networkFailureExtra(enriched)
               }
-            );
+            });
           },
           onNetworkError: (meta) => {
             this.rememberNetworkFailure(meta, { promoted: true });
@@ -14274,14 +14666,18 @@
             const url = meta.url || "(unknown url)";
             const errLabel = meta.errorName && meta.errorMessage ? `${meta.errorName}: ${meta.errorMessage}` : meta.errorMessage || meta.errorName || "Failed to fetch";
             const prefix = meta.failureKind === "timeout" ? "Timeout error" : "Network error";
-            void this.captureMessage(
-              `${prefix}: ${method} ${url} \u2014 ${errLabel}`,
-              "error",
-              {
+            const message = `${prefix}: ${method} ${url} \u2014 ${errLabel}`;
+            void this.capture({
+              message,
+              level: "error",
+              title: networkExceptionClass(meta),
+              exception: networkExceptionData(meta, message),
+              platform: PLATFORM_JAVASCRIPT,
+              context: {
                 tags: networkFailureTags(meta),
                 extra: networkFailureExtra(meta)
               }
-            );
+            });
           }
         }),
         installVisibilityResumeHook(() => this.onForegroundResume())
@@ -14318,7 +14714,7 @@
       if (this.capturing || this.ingestDisabled) return;
       const err = error instanceof Error ? error : new Error(typeof error === "string" ? error : "Unknown error");
       if (isAbortError(err)) return;
-      const filename = typeof context?.extra?.filename === "string" ? context.extra.filename : void 0;
+      const filename = context?.source?.filename;
       if (isBrowserExtensionNoise({
         message: err.message,
         stack: err.stack,
@@ -14340,6 +14736,12 @@
           level: "error",
           title: err.name || "Error",
           stackTrace: err.stack,
+          exception: buildExceptionFromError(
+            err,
+            mergedContext,
+            this.inAppFrameOptions()
+          ),
+          platform: PLATFORM_JAVASCRIPT,
           context: mergedContext
         });
       } finally {
@@ -14355,6 +14757,13 @@
         context
       });
     }
+    /**
+     * Returns a scoped capture facade that merges [tags] into every event.
+     * Nested `withTags` calls merge further (later keys win).
+     */
+    withTags(tags) {
+      return createScopedTalaria(this, mergeTags(tags));
+    }
     async flush(opts) {
       if (!this.options || !this.transport || this.closed) return;
       const keepalive = opts?.keepalive ?? false;
@@ -14519,13 +14928,17 @@
       }
       const queuedMs = Math.max(0, Date.now() - occurredAt.getTime());
       const tags = applyReplayCaptureTags(
-        {
-          ...this.browserContext ? browserContextTags(this.browserContext) : {},
-          ...this.options.tags ?? {},
-          ...args.context?.tags ?? {}
-        },
+        mergeTags(
+          this.browserContext ? browserContextTags(this.browserContext) : {},
+          this.options.tags,
+          args.context?.tags
+        ),
         errorClipOutcome
       );
+      warnSuspiciousTags(tags, this.options.environment);
+      const scrubbedContextExtra = scrubLegacyExceptionExtra(
+        args.context?.extra
+      );
       const extra = mergeReplayCaptureExtra(
         {
           ...this.browserContext ? {
@@ -14547,7 +14960,7 @@
             // Time spent in capture() before ingest (mostly replay flush).
             ...queuedMs >= 50 ? { queuedMs } : {}
           },
-          ...args.context?.extra
+          ...scrubbedContextExtra ?? {}
         },
         errorClipOutcome
       );
@@ -14559,6 +14972,8 @@
           eventType: levelToEventType(args.level),
           title: args.title ?? args.context?.title,
           stackTrace: args.stackTrace,
+          exception: args.exception,
+          platform: args.platform,
           release: this.options.release,
           userId: args.context?.userId ?? this.options.userId,
           sessionId: this.sessionId ?? void 0,
@@ -14808,6 +15223,23 @@
         this.resetToBufferMode();
       }
     }
+    inAppFrameOptions() {
+      const opts = this.options;
+      let pageOrigin;
+      try {
+        pageOrigin = resolvePageOrigin(
+          typeof window !== "undefined" ? window.location?.origin : void 0
+        );
+      } catch {
+        pageOrigin = void 0;
+      }
+      return {
+        pageOrigin,
+        allowUrls: opts?.inAppAllowUrls,
+        denyUrls: opts?.inAppDenyUrls,
+        inAppOrigins: opts?.inAppOrigins
+      };
+    }
     pruneRecentNetworkFailures(now = Date.now()) {
       this.recentNetworkFailures = this.recentNetworkFailures.filter(
         (f) => now - f.at <= RECENT_NETWORK_FAILURE_MS
@@ -14882,7 +15314,8 @@
           return;
         }
         void this.captureException(error, {
-          extra: {
+          mechanism: { type: "onerror", handled: false },
+          source: {
             filename: event.filename,
             lineno: event.lineno,
             colno: event.colno
@@ -14904,7 +15337,9 @@
         })) {
           return;
         }
-        void this.captureException(reason);
+        void this.captureException(reason, {
+          mechanism: { type: "unhandledrejection", handled: false }
+        });
       };
       window.addEventListener("error", onError);
       window.addEventListener("unhandledrejection", onRejection);
@@ -15166,6 +15601,23 @@
       }
     }
   };
+  function createScopedTalaria(client2, scopeTags) {
+    const mergeContext = (context) => ({
+      ...context,
+      tags: mergeTags(scopeTags, context?.tags)
+    });
+    return {
+      captureException(error, context) {
+        return client2.captureException(error, mergeContext(context));
+      },
+      captureMessage(message, level, context) {
+        return client2.captureMessage(message, level, mergeContext(context));
+      },
+      withTags(tags) {
+        return createScopedTalaria(client2, mergeTags(scopeTags, tags));
+      }
+    };
+  }
 
   // src/index.ts
   var client = new TalariaClient();
@@ -15179,6 +15631,9 @@
     captureMessage(message, level, context) {
       return client.captureMessage(message, level, context);
     },
+    withTags(tags) {
+      return client.withTags(tags);
+    },
     getReplayId() {
       return client.getReplayId();
     },