@bugwatch/core 0.1.0 → 0.2.1

package/dist/index.js

@@ -4,6 +4,12 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -22,18 +28,33 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/transport.ts
-var DEFAULT_ENDPOINT; exports.HttpTransport = void 0; exports.NoopTransport = void 0; exports.ConsoleTransport = void 0; exports.BatchTransport = void 0;
+function safeJsonStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(value, (_key, val) => {
+    if (typeof val === "object" && val !== null) {
+      if (seen.has(val)) {
+        return "[Circular]";
+      }
+      seen.add(val);
+    }
+    return val;
+  });
+}
+var DEFAULT_ENDPOINT, DEFAULT_TIMEOUT_MS; exports.HttpTransport = void 0; exports.NoopTransport = void 0; exports.ConsoleTransport = void 0; exports.BatchTransport = void 0;
 var init_transport = __esm({
   "src/transport.ts"() {
     DEFAULT_ENDPOINT = "https://api.bugwatch.dev";
+    DEFAULT_TIMEOUT_MS = 1e4;
     exports.HttpTransport = class {
       endpoint;
       apiKey;
       debug;
+      timeoutMs;
       constructor(options) {
         this.endpoint = options.endpoint || DEFAULT_ENDPOINT;
         this.apiKey = options.apiKey;
         this.debug = options.debug || false;
+        this.timeoutMs = DEFAULT_TIMEOUT_MS;
       }
       async send(event) {
         const url = `${this.endpoint}/api/v1/events`;
@@ -41,35 +62,45 @@ var init_transport = __esm({
           console.log("[Bugwatch] Sending event:", event.event_id);
         }
         try {
-          const response = await this.fetch(url, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              "X-API-Key": this.apiKey,
-              "X-Bugwatch-SDK": event.sdk?.name || "bugwatch-core",
-              "X-Bugwatch-SDK-Version": event.sdk?.version || "0.1.0"
-            },
-            body: JSON.stringify(event)
-          });
-          if (!response.ok) {
-            const errorText = await response.text();
-            if (this.debug) {
-              console.error("[Bugwatch] Failed to send event:", response.status, errorText);
-            }
-            if (response.status === 429) {
-              const retryAfter = response.headers.get("Retry-After");
+          const controller = typeof AbortController !== "undefined" ? new AbortController() : null;
+          const timeoutId = controller ? setTimeout(() => controller.abort(), this.timeoutMs) : null;
+          try {
+            const response = await this.fetch(url, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${this.apiKey}`,
+                "X-Bugwatch-SDK": event.sdk?.name || "bugwatch-core",
+                "X-Bugwatch-SDK-Version": event.sdk?.version || "0.1.0"
+              },
+              body: safeJsonStringify(event),
+              ...controller && { signal: controller.signal }
+            });
+            if (!response.ok) {
+              const errorText = await response.text();
               if (this.debug) {
-                console.warn(`[Bugwatch] Rate limited. Retry after ${retryAfter}s`);
+                console.error("[Bugwatch] Failed to send event:", response.status, errorText);
+              }
+              if (response.status === 429) {
+                const retryAfter = response.headers.get("Retry-After");
+                if (this.debug) {
+                  console.warn(`[Bugwatch] Rate limited. Retry after ${retryAfter}s`);
+                }
               }
+              throw new Error(`Failed to send event: ${response.status}`);
+            }
+            if (this.debug) {
+              console.log("[Bugwatch] Event sent successfully:", event.event_id);
+            }
+          } finally {
+            if (timeoutId !== null) {
+              clearTimeout(timeoutId);
             }
-            throw new Error(`Failed to send event: ${response.status}`);
-          }
-          if (this.debug) {
-            console.log("[Bugwatch] Event sent successfully:", event.event_id);
           }
         } catch (error) {
           if (this.debug) {
-            console.error("[Bugwatch] Transport error:", error);
+            const message = error instanceof Error && error.name === "AbortError" ? `[Bugwatch] Request timed out after ${this.timeoutMs}ms` : "[Bugwatch] Transport error:";
+            console.error(message, error);
           }
         }
       }
@@ -89,7 +120,7 @@ var init_transport = __esm({
     };
     exports.ConsoleTransport = class {
       async send(event) {
-        console.log("[Bugwatch Event]", JSON.stringify(event, null, 2));
+        console.log("[Bugwatch Event]", safeJsonStringify(event));
       }
     };
     exports.BatchTransport = class {
@@ -115,7 +146,10 @@ var init_transport = __esm({
           return;
         }
         const events = this.queue.splice(0, this.maxBatchSize);
-        await Promise.all(events.map((event) => this.transport.send(event)));
+        const results = await Promise.allSettled(events.map((event) => this.transport.send(event)));
+        for (const result of results) {
+          if (result.status === "rejected") ;
+        }
       }
       startTimer() {
         if (typeof setInterval !== "undefined") {
@@ -134,6 +168,13 @@ var init_transport = __esm({
           this.timer = null;
         }
       }
+      /**
+       * Close the transport, flushing any remaining events and stopping the timer.
+       */
+      async close() {
+        await this.flush();
+        this.destroy();
+      }
     };
   }
 });
@@ -282,6 +323,126 @@ var init_fingerprint = __esm({
   }
 });
 
+// src/context.ts
+var context_exports = {};
+__export(context_exports, {
+  addRequestBreadcrumb: () => addRequestBreadcrumb,
+  createScopedContext: () => createScopedContext,
+  getMergedContext: () => getMergedContext,
+  getRequestContext: () => getRequestContext,
+  hasRequestContext: () => hasRequestContext,
+  runWithContext: () => runWithContext,
+  runWithContextAsync: () => runWithContextAsync,
+  setRequestExtra: () => setRequestExtra,
+  setRequestTag: () => setRequestTag,
+  setRequestUser: () => setRequestUser
+});
+function createScopedContext() {
+  return {
+    user: null,
+    tags: {},
+    extra: {},
+    breadcrumbs: []
+  };
+}
+function isNodeEnvironment() {
+  return typeof process !== "undefined" && process.versions?.node !== void 0 && typeof __require !== "undefined";
+}
+function getAsyncLocalStorage() {
+  if (asyncLocalStorage) {
+    return asyncLocalStorage;
+  }
+  if (!isNodeEnvironment()) {
+    return null;
+  }
+  try {
+    const asyncHooks = __require("async_hooks");
+    asyncLocalStorage = new asyncHooks.AsyncLocalStorage();
+    return asyncLocalStorage;
+  } catch {
+    return null;
+  }
+}
+function runWithContext(context, fn) {
+  const storage = getAsyncLocalStorage();
+  if (storage) {
+    return storage.run(context, fn);
+  }
+  return fn();
+}
+async function runWithContextAsync(context, fn) {
+  const storage = getAsyncLocalStorage();
+  if (storage) {
+    return storage.run(context, fn);
+  }
+  return fn();
+}
+function getRequestContext() {
+  const storage = getAsyncLocalStorage();
+  return storage?.getStore();
+}
+function hasRequestContext() {
+  return getRequestContext() !== void 0;
+}
+function setRequestUser(user) {
+  const ctx = getRequestContext();
+  if (ctx) {
+    ctx.user = user;
+    return true;
+  }
+  return false;
+}
+function setRequestTag(key, value) {
+  const ctx = getRequestContext();
+  if (ctx) {
+    ctx.tags[key] = value;
+    return true;
+  }
+  return false;
+}
+function setRequestExtra(key, value) {
+  const ctx = getRequestContext();
+  if (ctx) {
+    ctx.extra[key] = value;
+    return true;
+  }
+  return false;
+}
+function addRequestBreadcrumb(breadcrumb, maxBreadcrumbs = 100) {
+  const ctx = getRequestContext();
+  if (ctx) {
+    ctx.breadcrumbs.push(breadcrumb);
+    if (ctx.breadcrumbs.length > maxBreadcrumbs) {
+      ctx.breadcrumbs = ctx.breadcrumbs.slice(-maxBreadcrumbs);
+    }
+    return true;
+  }
+  return false;
+}
+function getMergedContext(globalUser, globalTags, globalExtra, globalBreadcrumbs) {
+  const reqCtx = getRequestContext();
+  if (!reqCtx) {
+    return {
+      user: globalUser,
+      tags: globalTags,
+      extra: globalExtra,
+      breadcrumbs: globalBreadcrumbs
+    };
+  }
+  return {
+    user: reqCtx.user || globalUser,
+    tags: { ...globalTags, ...reqCtx.tags },
+    extra: { ...globalExtra, ...reqCtx.extra },
+    breadcrumbs: [...globalBreadcrumbs, ...reqCtx.breadcrumbs]
+  };
+}
+var asyncLocalStorage;
+var init_context = __esm({
+  "src/context.ts"() {
+    asyncLocalStorage = null;
+  }
+});
+
 // src/client.ts
 var client_exports = {};
 __export(client_exports, {
@@ -292,12 +453,52 @@ function generateEventId() {
   const random = Math.random().toString(36).substring(2, 10);
   return `${timestamp}${random}`;
 }
-var SDK_NAME, SDK_VERSION, DEFAULT_OPTIONS; exports.Bugwatch = void 0;
+var RingBuffer, SDK_NAME, SDK_VERSION, DEFAULT_OPTIONS; exports.Bugwatch = void 0;
 var init_client = __esm({
   "src/client.ts"() {
     init_transport();
     init_stacktrace();
     init_fingerprint();
+    init_context();
+    RingBuffer = class {
+      constructor(maxSize) {
+        this.maxSize = maxSize;
+        this.buffer = new Array(maxSize);
+      }
+      buffer;
+      head = 0;
+      count = 0;
+      push(item) {
+        this.buffer[this.head] = item;
+        this.head = (this.head + 1) % this.maxSize;
+        if (this.count < this.maxSize) {
+          this.count++;
+        }
+      }
+      toArray() {
+        if (this.count === 0) {
+          return [];
+        }
+        const result = [];
+        const start = this.count < this.maxSize ? 0 : this.head;
+        for (let i = 0; i < this.count; i++) {
+          const index = (start + i) % this.maxSize;
+          const item = this.buffer[index];
+          if (item !== void 0) {
+            result.push(item);
+          }
+        }
+        return result;
+      }
+      clear() {
+        this.buffer = new Array(this.maxSize);
+        this.head = 0;
+        this.count = 0;
+      }
+      get length() {
+        return this.count;
+      }
+    };
     SDK_NAME = "@bugwatch/core";
     SDK_VERSION = "0.1.0";
     DEFAULT_OPTIONS = {
@@ -310,7 +511,7 @@ var init_client = __esm({
     exports.Bugwatch = class {
       options;
       transport;
-      breadcrumbs = [];
+      breadcrumbs;
       tags = {};
       extra = {};
       user = null;
@@ -319,6 +520,7 @@ var init_client = __esm({
       constructor(options) {
         this.options = { ...DEFAULT_OPTIONS, ...options };
         this.transport = this.createTransport();
+        this.breadcrumbs = new RingBuffer(this.options.maxBreadcrumbs || 100);
         if (options.tags) {
           this.tags = { ...options.tags };
         }
@@ -364,7 +566,17 @@ var init_client = __esm({
           return "";
         }
         const event = this.createEventFromError(error, context);
-        const processedEvent = this.options.beforeSend ? this.options.beforeSend(event) : event;
+        let processedEvent = event;
+        if (this.options.beforeSend) {
+          try {
+            processedEvent = this.options.beforeSend(event);
+          } catch (err) {
+            if (this.options.debug) {
+              console.error("[Bugwatch] beforeSend threw an error:", err);
+            }
+            processedEvent = event;
+          }
+        }
         if (!processedEvent) {
           if (this.options.debug) {
             console.log("[Bugwatch] Event dropped by beforeSend");
@@ -386,7 +598,17 @@ var init_client = __esm({
           message,
           level
         });
-        const processedEvent = this.options.beforeSend ? this.options.beforeSend(event) : event;
+        let processedEvent = event;
+        if (this.options.beforeSend) {
+          try {
+            processedEvent = this.options.beforeSend(event);
+          } catch (err) {
+            if (this.options.debug) {
+              console.error("[Bugwatch] beforeSend threw an error:", err);
+            }
+            processedEvent = event;
+          }
+        }
         if (!processedEvent) {
           return "";
         }
@@ -403,10 +625,6 @@ var init_client = __esm({
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
         this.breadcrumbs.push(crumb);
-        const max = this.options.maxBreadcrumbs || 100;
-        if (this.breadcrumbs.length > max) {
-          this.breadcrumbs = this.breadcrumbs.slice(-max);
-        }
       }
       /**
        * Set user context
@@ -430,7 +648,7 @@ var init_client = __esm({
        * Clear breadcrumbs
        */
       clearBreadcrumbs() {
-        this.breadcrumbs = [];
+        this.breadcrumbs.clear();
       }
       /**
        * Create an event from an Error object
@@ -454,6 +672,12 @@ var init_client = __esm({
        * Create a base event
        */
       createEvent(partial) {
+        const mergedContext = getMergedContext(
+          this.user,
+          this.tags,
+          this.extra,
+          this.breadcrumbs.toArray()
+        );
         const event = {
           event_id: generateEventId(),
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -462,17 +686,17 @@ var init_client = __esm({
           message: partial.message || "",
           environment: this.options.environment,
           release: this.options.release,
-          tags: { ...this.tags, ...partial.tags },
-          extra: { ...this.extra, ...partial.extra },
-          breadcrumbs: [...this.breadcrumbs],
+          tags: { ...mergedContext.tags, ...partial.tags },
+          extra: { ...mergedContext.extra, ...partial.extra },
+          breadcrumbs: mergedContext.breadcrumbs,
           sdk: {
             name: SDK_NAME,
             version: SDK_VERSION
           },
           ...partial
         };
-        if (this.user || partial.user) {
-          event.user = { ...this.user, ...partial.user };
+        if (mergedContext.user || partial.user) {
+          event.user = { ...mergedContext.user, ...partial.user };
         }
         if (event.exception) {
           const fingerprint = fingerprintFromException(event.exception);
@@ -516,6 +740,95 @@ var init_client = __esm({
         }
         return "javascript";
       }
+      /**
+       * Flush any pending events.
+       * Call this before process exit to ensure no events are lost.
+       */
+      async flush() {
+        if (this.transport.flush) {
+          await this.transport.flush();
+        }
+      }
+      /**
+       * Close the client and release any resources.
+       * This flushes any pending events and closes the transport.
+       * After calling this method, the client should not be used again.
+       */
+      async close() {
+        if (this.transport.close) {
+          await this.transport.close();
+        } else {
+          await this.flush();
+        }
+        this.initialized = false;
+      }
+    };
+  }
+});
+
+// src/env.ts
+var env_exports = {};
+__export(env_exports, {
+  ENV_VARS: () => exports.ENV_VARS,
+  getEnvConfig: () => getEnvConfig,
+  hasApiKey: () => hasApiKey,
+  validateApiKey: () => validateApiKey
+});
+function getEnvVar(name) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[name];
+  }
+  return void 0;
+}
+function getEnvConfig() {
+  const config = {};
+  const apiKey = getEnvVar(exports.ENV_VARS.API_KEY);
+  if (apiKey) {
+    config.apiKey = apiKey;
+  }
+  const environment = getEnvVar(exports.ENV_VARS.ENVIRONMENT);
+  if (environment) {
+    config.environment = environment;
+  }
+  const release = getEnvVar(exports.ENV_VARS.RELEASE);
+  if (release) {
+    config.release = release;
+  }
+  const debug = getEnvVar(exports.ENV_VARS.DEBUG);
+  if (debug === "true") {
+    config.debug = true;
+  }
+  const endpoint = getEnvVar(exports.ENV_VARS.ENDPOINT);
+  if (endpoint) {
+    config.endpoint = endpoint;
+  }
+  return config;
+}
+function validateApiKey(key) {
+  if (!key) {
+    throw new Error(
+      "Bugwatch: API key required. Set BUGWATCH_API_KEY environment variable or pass { apiKey: '...' }"
+    );
+  }
+  if (!key.startsWith("bw_")) {
+    const preview = key.length > 10 ? `${key.slice(0, 6)}...` : "[hidden]";
+    console.warn(
+      `Bugwatch: API key should start with 'bw_'. Got '${preview}'`
+    );
+  }
+}
+function hasApiKey(explicitKey) {
+  return Boolean(explicitKey || getEnvVar(exports.ENV_VARS.API_KEY));
+}
+exports.ENV_VARS = void 0;
+var init_env = __esm({
+  "src/env.ts"() {
+    exports.ENV_VARS = {
+      API_KEY: "BUGWATCH_API_KEY",
+      ENVIRONMENT: "BUGWATCH_ENVIRONMENT",
+      RELEASE: "BUGWATCH_RELEASE",
+      DEBUG: "BUGWATCH_DEBUG",
+      ENDPOINT: "BUGWATCH_ENDPOINT"
     };
   }
 });
@@ -525,26 +838,57 @@ init_client();
 init_transport();
 init_stacktrace();
 init_fingerprint();
+init_env();
+init_context();
 var globalClient = null;
+var lazyInitWarned = false;
 function init(options) {
   const { Bugwatch: Bugwatch2 } = (init_client(), __toCommonJS(client_exports));
-  const client = new Bugwatch2(options);
+  const { getEnvConfig: getEnvConfig2, validateApiKey: validateApiKey2 } = (init_env(), __toCommonJS(env_exports));
+  const envConfig = getEnvConfig2();
+  const mergedOptions = { ...envConfig, ...options };
+  validateApiKey2(mergedOptions.apiKey);
+  const client = new Bugwatch2(mergedOptions);
   globalClient = client;
+  lazyInitWarned = false;
   return client;
 }
 function getClient() {
   return globalClient;
 }
+function tryLazyInit() {
+  if (globalClient) return true;
+  const { getEnvConfig: getEnvConfig2, hasApiKey: hasApiKey2 } = (init_env(), __toCommonJS(env_exports));
+  if (!hasApiKey2()) {
+    return false;
+  }
+  try {
+    const { Bugwatch: Bugwatch2 } = (init_client(), __toCommonJS(client_exports));
+    const envConfig = getEnvConfig2();
+    if (!envConfig.apiKey) {
+      return false;
+    }
+    const client = new Bugwatch2(envConfig);
+    globalClient = client;
+    if (envConfig.debug && !lazyInitWarned) {
+      console.warn("[Bugwatch] Auto-initialized from BUGWATCH_API_KEY environment variable");
+      lazyInitWarned = true;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
 function captureException(error, context) {
-  if (!globalClient) {
-    console.warn("[Bugwatch] SDK not initialized. Call init() first.");
+  if (!globalClient && !tryLazyInit()) {
+    console.warn("[Bugwatch] SDK not initialized. Call init() first or set BUGWATCH_API_KEY environment variable.");
     return "";
   }
   return globalClient.captureException(error, context);
 }
 function captureMessage(message, level) {
-  if (!globalClient) {
-    console.warn("[Bugwatch] SDK not initialized. Call init() first.");
+  if (!globalClient && !tryLazyInit()) {
+    console.warn("[Bugwatch] SDK not initialized. Call init() first or set BUGWATCH_API_KEY environment variable.");
     return "";
   }
   return globalClient.captureMessage(message, level);
@@ -553,38 +897,93 @@ function addBreadcrumb(breadcrumb) {
   if (!globalClient) {
     return;
   }
+  const { addRequestBreadcrumb: addRequestBreadcrumb2 } = (init_context(), __toCommonJS(context_exports));
+  const crumb = {
+    ...breadcrumb,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (addRequestBreadcrumb2(crumb, globalClient.getOptions().maxBreadcrumbs || 100)) {
+    return;
+  }
   globalClient.addBreadcrumb(breadcrumb);
 }
 function setUser(user) {
   if (!globalClient) {
     return;
   }
+  const { setRequestUser: setRequestUser2 } = (init_context(), __toCommonJS(context_exports));
+  if (setRequestUser2(user)) {
+    return;
+  }
   globalClient.setUser(user);
 }
 function setTag(key, value) {
   if (!globalClient) {
     return;
   }
+  const { setRequestTag: setRequestTag2 } = (init_context(), __toCommonJS(context_exports));
+  if (setRequestTag2(key, value)) {
+    return;
+  }
   globalClient.setTag(key, value);
 }
 function setExtra(key, value) {
   if (!globalClient) {
     return;
   }
+  const { setRequestExtra: setRequestExtra2 } = (init_context(), __toCommonJS(context_exports));
+  if (setRequestExtra2(key, value)) {
+    return;
+  }
   globalClient.setExtra(key, value);
 }
+async function flush() {
+  if (!globalClient) {
+    console.warn("[Bugwatch] SDK not initialized. Call init() first.");
+    return;
+  }
+  await globalClient.flush();
+}
+async function close() {
+  if (!globalClient) {
+    console.warn("[Bugwatch] SDK not initialized. Call init() first.");
+    return;
+  }
+  await globalClient.close();
+  globalClient = null;
+}
+function reset() {
+  globalClient = null;
+  lazyInitWarned = false;
+}
 
 exports.addBreadcrumb = addBreadcrumb;
+exports.addRequestBreadcrumb = addRequestBreadcrumb;
 exports.captureException = captureException;
 exports.captureMessage = captureMessage;
+exports.close = close;
+exports.createScopedContext = createScopedContext;
 exports.extractErrorInfo = extractErrorInfo;
 exports.fingerprintFromException = fingerprintFromException;
+exports.flush = flush;
 exports.generateFingerprint = generateFingerprint;
 exports.getClient = getClient;
+exports.getEnvConfig = getEnvConfig;
+exports.getMergedContext = getMergedContext;
+exports.getRequestContext = getRequestContext;
+exports.hasApiKey = hasApiKey;
+exports.hasRequestContext = hasRequestContext;
 exports.init = init;
 exports.parseStackTrace = parseStackTrace;
+exports.reset = reset;
+exports.runWithContext = runWithContext;
+exports.runWithContextAsync = runWithContextAsync;
 exports.setExtra = setExtra;
+exports.setRequestExtra = setRequestExtra;
+exports.setRequestTag = setRequestTag;
+exports.setRequestUser = setRequestUser;
 exports.setTag = setTag;
 exports.setUser = setUser;
+exports.validateApiKey = validateApiKey;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map