@blaxel/core 0.3.7-preview.229 → 0.3.7

package/dist/esm/common/lazyInit.js

@@ -13,8 +13,8 @@ let autoloaded = false;
  *     populates `BL_ENV` if the user has a dev workspace configured).
  *   - Re-apply the control-plane and sandbox clients' `baseUrl` so they
  *     target the now-env-aware endpoint.
- *   - Initialize the lightweight Sentry client (registers
- *     `uncaughtExceptionMonitor` and patches `console.error` in Node).
+ *   - Initialize the lightweight Sentry client (registers a composable
+ *     `uncaughtExceptionMonitor` handler in Node).
  *   - Pre-warm the edge H2 connection pool for `settings.region`.
  *
  * These used to run at module load, but that meant `import "@blaxel/core"`

package/dist/esm/common/sentry.js

@@ -1,37 +1,163 @@
 import { settings } from "./settings.js";
-// Lightweight Sentry client using fetch - only captures SDK errors
+const PACKAGE_LAYOUT_MARKERS = [
+    "/src/common/sentry.ts",
+    "/dist/cjs/common/sentry.js",
+    "/dist/esm/common/sentry.js",
+    "/dist/cjs-browser/common/sentry.js",
+    "/dist/esm-browser/common/sentry.js",
+];
+const OWNED_PACKAGE_DIRECTORIES = [
+    "/src/",
+    "/dist/cjs/",
+    "/dist/esm/",
+    "/dist/cjs-browser/",
+    "/dist/esm-browser/",
+];
+const SAFE_ERROR_NAMES = new Set([
+    "Error",
+    "EvalError",
+    "RangeError",
+    "ReferenceError",
+    "SyntaxError",
+    "TypeError",
+    "URIError",
+    "AggregateError",
+]);
+const MAX_IN_FLIGHT_EVENTS = 20;
+const DELIVERY_TIMEOUT_MS = 500;
+const SAFE_FILENAME_SEGMENT = /^[A-Za-z0-9._-]+$/;
 let sentryInitialized = false;
-const capturedExceptions = new Set();
 let handlersRegistered = false;
-// Parsed DSN components
 let sentryConfig = null;
-// SDK path patterns to identify errors originating from our SDK
-const SDK_PATTERNS = [
-    "@blaxel/",
-    "blaxel-sdk",
-    "/node_modules/@blaxel/",
-    "/@blaxel/core/",
-    "/@blaxel/telemetry/",
-];
+let flushPromise = null;
+const capturedExceptions = new WeakSet();
+const inFlightDeliveries = new Set();
+/**
+ * Normalize stack filenames without resolving or exposing host filesystem data.
+ */
+function normalizeFilename(filename) {
+    return filename.replace(/\\/g, "/").replace(/[?#].*$/, "");
+}
 /**
- * Check if an error originated from the SDK based on its stack trace.
- * Returns true if the stack trace contains any SDK-related paths.
+ * Parse V8/Node and browser stack-frame formats in call order (newest first).
  */
-function isFromSDK(error) {
-    const stack = error.stack || "";
-    return SDK_PATTERNS.some((pattern) => stack.includes(pattern));
+function parseStackTrace(stack) {
+    const frames = [];
+    // V8 starts with an error header (which does not match a frame), while
+    // Firefox-style stacks can start directly with the first frame.
+    for (const line of stack.split("\n")) {
+        const v8WithFunction = line.match(/^\s*at\s+(.+?)\s+\((.+):(\d+):(\d+)\)\s*$/);
+        const v8WithoutFunction = line.match(/^\s*at\s+(.+):(\d+):(\d+)\s*$/);
+        const browser = line.match(/^\s*(.*?)@(.+):(\d+):(\d+)\s*$/);
+        const match = v8WithFunction ?? v8WithoutFunction ?? browser;
+        if (!match)
+            continue;
+        if (match === v8WithFunction) {
+            frames.push({
+                function: match[1],
+                filename: normalizeFilename(match[2]),
+                lineno: Number.parseInt(match[3], 10),
+                colno: Number.parseInt(match[4], 10),
+            });
+            continue;
+        }
+        if (match === browser) {
+            frames.push({
+                function: match[1] || "<anonymous>",
+                filename: normalizeFilename(match[2]),
+                lineno: Number.parseInt(match[3], 10),
+                colno: Number.parseInt(match[4], 10),
+            });
+            continue;
+        }
+        frames.push({
+            function: "<anonymous>",
+            filename: normalizeFilename(match[1]),
+            lineno: Number.parseInt(match[2], 10),
+            colno: Number.parseInt(match[3], 10),
+        });
+    }
+    return frames;
 }
 /**
- * Parse a Sentry DSN into its components.
- * DSN format: https://{public_key}@{host}/{project_id}
+ * Discover this exact @blaxel/core package root from this module's own frame.
+ * This avoids trusting a generic "@blaxel" substring in an arbitrary stack.
+ */
+function discoverPackageRoot(stack) {
+    for (const frame of parseStackTrace(stack)) {
+        for (const marker of PACKAGE_LAYOUT_MARKERS) {
+            if (frame.filename.endsWith(marker)) {
+                return frame.filename.slice(0, -marker.length);
+            }
+        }
+    }
+    return null;
+}
+const sdkPackageRoot = discoverPackageRoot(new Error().stack ?? "");
+function isRuntimeFrame(filename) {
+    return filename.startsWith("node:") || filename.startsWith("internal/");
+}
+function ownedRelativeFilename(filename) {
+    if (!sdkPackageRoot)
+        return null;
+    for (const directory of OWNED_PACKAGE_DIRECTORIES) {
+        const prefix = `${sdkPackageRoot}${directory}`;
+        if (!filename.startsWith(prefix))
+            continue;
+        const relativeFilename = filename.slice(sdkPackageRoot.length).replace(/^\/+/, "");
+        const segments = relativeFilename.split("/");
+        if (segments.length > 0 &&
+            segments.every((segment) => segment !== "." && segment !== ".." && SAFE_FILENAME_SEGMENT.test(segment))) {
+            return relativeFilename;
+        }
+    }
+    return null;
+}
+function isOwnedFilename(filename) {
+    return ownedRelativeFilename(filename) !== null;
+}
+/**
+ * Attribute an exception only when its first non-runtime frame is inside the
+ * exact installed @blaxel/core package. Application and dependency frames are
+ * never included in the event.
+ */
+function getOwnedFrames(error) {
+    const frames = parseStackTrace(error.stack ?? "");
+    const firstRelevantFrame = frames.find((frame) => !isRuntimeFrame(frame.filename));
+    if (!firstRelevantFrame || !isOwnedFilename(firstRelevantFrame.filename)) {
+        return [];
+    }
+    return frames.filter((frame) => isOwnedFilename(frame.filename));
+}
+function sanitizeFunctionName(name) {
+    const normalized = name.trim();
+    if (!normalized || normalized.length > 120 || !/^[\w.$<> /-]+$/u.test(normalized)) {
+        return "<sdk>";
+    }
+    return normalized;
+}
+function sanitizeOwnedFrame(frame) {
+    const relativeFilename = ownedRelativeFilename(frame.filename) ?? "unknown";
+    return {
+        function: sanitizeFunctionName(frame.function),
+        filename: `@blaxel/core/${relativeFilename}`,
+        lineno: frame.lineno,
+        colno: frame.colno,
+    };
+}
+function sanitizeErrorName(name) {
+    return SAFE_ERROR_NAMES.has(name) ? name : "Error";
+}
+/**
+ * Parse a Sentry DSN into the public transport components used by envelopes.
  */
 function parseDsn(dsn) {
     try {
         const url = new URL(dsn);
         const publicKey = url.username;
         const host = url.host;
-        const projectId = url.pathname.slice(1); // Remove leading slash
-        if (!publicKey || !host || !projectId) {
+        const projectId = url.pathname.slice(1);
+        if (!publicKey || !host || !projectId || !["http:", "https:"].includes(url.protocol)) {
             return null;
         }
         return { publicKey, host, projectId };
@@ -40,21 +166,18 @@ function parseDsn(dsn) {
         return null;
     }
 }
-/**
- * Generate a UUID v4
- */
 function generateEventId() {
-    return "xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-        const r = (Math.random() * 16) | 0;
-        const v = c === "x" ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
+    return "xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx".replace(/[xy]/g, (character) => {
+        const random = (Math.random() * 16) | 0;
+        const value = character === "x" ? random : (random & 0x3) | 0x8;
+        return value.toString(16);
     });
 }
 /**
- * Convert an Error to a Sentry event payload.
+ * Build an allowlisted event. Raw messages, response bodies, workspace/resource
+ * context, and absolute host paths are deliberately excluded.
  */
-function errorToSentryEvent(error) {
-    const frames = parseStackTrace(error.stack || "");
+function errorToSentryEvent(error, ownedFrames) {
     return {
         event_id: generateEventId(),
         timestamp: Date.now() / 1000,
@@ -63,64 +186,43 @@ function errorToSentryEvent(error) {
         environment: settings.env,
         release: `sdk-typescript@${settings.version}`,
         tags: {
-            "blaxel.workspace": settings.workspace,
             "blaxel.version": settings.version,
             "blaxel.commit": settings.commit,
+            "blaxel.error_source": "unhandled-sdk-exception",
         },
         exception: {
             values: [
                 {
-                    type: error.name,
-                    value: error.message,
+                    type: sanitizeErrorName(error.name),
+                    value: "Unhandled SDK exception",
                     stacktrace: {
-                        frames,
+                        // Sentry expects oldest-to-newest frame order.
+                        frames: ownedFrames.map(sanitizeOwnedFrame).reverse(),
                     },
                 },
             ],
         },
     };
 }
-/**
- * Parse a stack trace string into Sentry-compatible frames.
- */
-function parseStackTrace(stack) {
-    const lines = stack.split("\n").slice(1); // Skip first line (error message)
-    const frames = [];
-    for (const line of lines) {
-        // Match patterns like "at functionName (filename:line:col)" or "at filename:line:col"
-        const match = line.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/);
-        if (match) {
-            frames.unshift({
-                function: match[1] || "<anonymous>",
-                filename: match[2],
-                lineno: parseInt(match[3], 10),
-                colno: parseInt(match[4], 10),
-            });
-        }
-    }
-    return frames;
-}
-/**
- * Send an event to Sentry using fetch.
- */
 async function sendToSentry(event) {
     if (!sentryConfig)
         return;
     const { publicKey, host, projectId } = sentryConfig;
     const envelopeUrl = `https://${host}/api/${projectId}/envelope/`;
-    // Create envelope header
     const envelopeHeader = JSON.stringify({
         event_id: event.event_id,
         sent_at: new Date().toISOString(),
         dsn: `https://${publicKey}@${host}/${projectId}`,
     });
-    // Create item header
     const itemHeader = JSON.stringify({
         type: "event",
         content_type: "application/json",
     });
-    // Create envelope body
     const envelope = `${envelopeHeader}\n${itemHeader}\n${JSON.stringify(event)}`;
+    const controller = typeof AbortController === "function" ? new AbortController() : null;
+    const abortTimer = controller
+        ? setTimeout(() => controller.abort(), DELIVERY_TIMEOUT_MS)
+        : null;
     try {
         await fetch(envelopeUrl, {
             method: "POST",
@@ -129,170 +231,114 @@ async function sendToSentry(event) {
                 "X-Sentry-Auth": `Sentry sentry_version=7, sentry_client=blaxel-sdk/${settings.version}, sentry_key=${publicKey}`,
             },
             body: envelope,
+            keepalive: true,
+            signal: controller?.signal,
         });
     }
     catch {
-        // Silently fail - error reporting should never break the SDK
+        // Error reporting must never affect the host application.
     }
-}
-// Queue for pending events
-const pendingEvents = [];
-let flushPromise = null;
-/**
- * Register browser/edge environment error handlers.
- * Separated to isolate dynamic globalThis access.
- */
-function registerBrowserHandlers() {
-    const g = globalThis;
-    if (g && typeof g.addEventListener === "function") {
-        g.addEventListener("error", (event) => {
-            const e = event;
-            if (e.error instanceof Error && isFromSDK(e.error)) {
-                captureException(e.error);
-            }
-        });
-        g.addEventListener("unhandledrejection", (event) => {
-            const e = event;
-            const error = e.reason instanceof Error ? e.reason : new Error(String(e.reason));
-            if (isFromSDK(error)) {
-                captureException(error);
-            }
-        });
+    finally {
+        if (abortTimer)
+            clearTimeout(abortTimer);
     }
 }
-/**
- * Initialize the lightweight Sentry client for SDK error tracking.
- */
-export function initSentry() {
+function scheduleDelivery(event) {
+    if (inFlightDeliveries.size >= MAX_IN_FLIGHT_EVENTS)
+        return;
+    // Contain rejections from setup that occurs before sendToSentry's internal
+    // fetch guard (for example, a host-provided AbortController implementation).
+    const delivery = sendToSentry(event).catch(() => undefined);
+    inFlightDeliveries.add(delivery);
+    void delivery.then(() => inFlightDeliveries.delete(delivery));
+}
+function captureException(error) {
+    if (!sentryInitialized || !sentryConfig || capturedExceptions.has(error)) {
+        return;
+    }
     try {
-        // Check if tracking is disabled
-        if (!settings.tracking) {
-            return;
-        }
-        const dsn = settings.sentryDsn;
-        if (!dsn) {
-            return;
-        }
-        // Parse DSN
-        sentryConfig = parseDsn(dsn);
-        if (!sentryConfig) {
+        const ownedFrames = getOwnedFrames(error);
+        if (ownedFrames.length === 0)
             return;
-        }
-        // Only allow dev/prod environments
-        if (settings.env !== "dev" && settings.env !== "prod") {
-            return;
-        }
-        sentryInitialized = true;
-        // Register error handlers only once
-        if (!handlersRegistered) {
-            handlersRegistered = true;
-            // Node.js specific handlers
-            if (typeof process !== "undefined" && typeof process.on === "function") {
-                // Monitor uncaught exceptions to capture SDK errors without
-                // preventing Node.js default crash behavior (print + exit).
-                const uncaughtExceptionMonitorHandler = (error) => {
-                    if (isFromSDK(error)) {
-                        captureException(error);
-                    }
-                };
-                process.on("uncaughtExceptionMonitor", uncaughtExceptionMonitorHandler);
-                // Intercept console.error to capture SDK errors that are caught and logged
-                const originalConsoleError = console.error;
-                console.error = function (...args) {
-                    originalConsoleError.apply(console, args);
-                    for (const arg of args) {
-                        if (arg instanceof Error && isFromSDK(arg)) {
-                            captureException(arg);
-                            break;
-                        }
-                    }
-                };
-            }
-            else {
-                // Browser/Edge environment handlers
-                registerBrowserHandlers();
-            }
-        }
+        capturedExceptions.add(error);
+        scheduleDelivery(errorToSentryEvent(error, ownedFrames));
     }
-    catch (error) {
-        // Silently fail - Sentry initialization should never break the SDK
-        if (settings.env !== "production") {
-            console.error("[Blaxel SDK] Error initializing Sentry:", error);
-        }
+    catch {
+        // Error reporting must never affect the host application.
     }
 }
+function registerBrowserHandlers() {
+    const host = globalThis;
+    if (typeof host.addEventListener !== "function")
+        return;
+    host.addEventListener.call(host, "error", (event) => {
+        const error = event.error;
+        if (error instanceof Error)
+            captureException(error);
+    });
+    host.addEventListener.call(host, "unhandledrejection", (event) => {
+        const reason = event.reason;
+        // A primitive rejection carries no attributable stack, so do not guess.
+        if (reason instanceof Error)
+            captureException(reason);
+    });
+}
 /**
- * Capture an exception to Sentry.
- * Only errors originating from SDK code will be captured.
- *
- * @param error - The error to capture
+ * Initialize opt-in SDK error tracking. Registration composes with host global
+ * handlers and never replaces console, process, or browser callbacks.
  */
-function captureException(error) {
-    if (!sentryInitialized || !sentryConfig) {
-        return;
-    }
-    // Double-check that error is from SDK (defense in depth)
-    if (!isFromSDK(error)) {
-        return;
-    }
+export function initSentry() {
     try {
-        // Create a unique identifier for this exception to avoid duplicates
-        const errorKey = `${error.name}:${error.message}:${error.stack?.slice(0, 200)}`;
-        if (capturedExceptions.has(errorKey)) {
+        if (!settings.tracking || !settings.sentryDsn || !sdkPackageRoot)
+            return;
+        const config = parseDsn(settings.sentryDsn);
+        if (!config || (settings.env !== "dev" && settings.env !== "prod"))
+            return;
+        sentryConfig = config;
+        sentryInitialized = true;
+        if (handlersRegistered)
+            return;
+        handlersRegistered = true;
+        if (typeof process !== "undefined" &&
+            process.versions?.node &&
+            typeof process.on === "function") {
+            process.on("uncaughtExceptionMonitor", (error) => {
+                captureException(error);
+            });
             return;
         }
-        capturedExceptions.add(errorKey);
-        // Clean up old exception keys to prevent memory leak
-        if (capturedExceptions.size > 1000) {
-            capturedExceptions.clear();
-        }
-        // Convert error to Sentry event and queue it
-        const event = errorToSentryEvent(error);
-        pendingEvents.push(event);
-        // Send immediately (fire and forget)
-        sendToSentry(event).catch(() => {
-            // Silently fail
-        });
+        registerBrowserHandlers();
     }
     catch {
-        // Silently fail - error capturing should never break the SDK
+        // Initialization is intentionally silent and cannot break the SDK.
     }
 }
 /**
- * Flush pending Sentry events.
- * This should be called before the process exits to ensure all events are sent.
- *
- * @param timeout - Maximum time in milliseconds to wait for flush (default: 2000)
+ * Await only deliveries already in flight, bounded by the supplied timeout.
+ * Events are sent exactly once; flush never re-enqueues them.
  */
-export async function flushSentry(timeout = 2000) {
-    if (!sentryInitialized || pendingEvents.length === 0) {
+export async function flushSentry(timeout = DELIVERY_TIMEOUT_MS) {
+    if (!sentryInitialized || inFlightDeliveries.size === 0)
         return;
-    }
-    // If already flushing, wait for it
     if (flushPromise) {
         await flushPromise;
         return;
     }
+    let timeoutHandle;
     try {
-        // Send all pending events
-        const eventsToSend = [...pendingEvents];
-        pendingEvents.length = 0;
-        flushPromise = Promise.race([
-            Promise.all(eventsToSend.map((event) => sendToSentry(event))).then(() => { }),
-            new Promise((resolve) => setTimeout(resolve, timeout)),
-        ]);
+        const deliveries = Promise.allSettled([...inFlightDeliveries]).then(() => undefined);
+        const timeoutPromise = new Promise((resolve) => {
+            timeoutHandle = setTimeout(resolve, Math.max(0, timeout));
+        });
+        flushPromise = Promise.race([deliveries, timeoutPromise]);
         await flushPromise;
     }
-    catch {
-        // Silently fail
-    }
     finally {
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
         flushPromise = null;
     }
 }
-/**
- * Check if Sentry is initialized and available.
- */
 export function isSentryInitialized() {
     return sentryInitialized;
 }