@vigilon/browser 0.0.0-stage → 0.2.9-beta.pr-1.1

package/dist/index.mjs

@@ -0,0 +1,703 @@
+// src/core/limits.ts
+var LIMITS = {
+  eventsPerRequest: 20,
+  serviceNameLength: 100,
+  serviceVersionLength: 200,
+  exceptionTypeLength: 256,
+  exceptionMessageLength: 8 * 1024,
+  exceptionStackLength: 64 * 1024,
+  exceptionStackLines: 250,
+  componentStackLength: 16 * 1024,
+  causeDepth: 5,
+  debugIdEntries: 100,
+  debugIdKeyLength: 2 * 1024,
+  pageUrlLength: 2 * 1024,
+  pageRouteLength: 200,
+  identifierLength: 128,
+  tagEntries: 20,
+  tagKeyLength: 64,
+  tagValueLength: 256
+};
+var SERVICE_TOKEN_PATTERN = /^[A-Za-z0-9._:/-]+$/;
+var SCHEMA_ID = "vigilon.browser.event@1";
+
+// src/core/text.ts
+function truncate(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  const code = value.charCodeAt(maxLength - 1);
+  const end = code >= 55296 && code <= 56319 ? maxLength - 1 : maxLength;
+  return value.slice(0, end);
+}
+function truncateStack(stack) {
+  const lines = stack.split("\n");
+  const kept = lines.length > LIMITS.exceptionStackLines ? lines.slice(0, LIMITS.exceptionStackLines).join("\n") : stack;
+  return truncate(kept, LIMITS.exceptionStackLength);
+}
+var USERINFO = /^([a-z][a-z0-9+.-]*:\/\/)[^/?#@\s]*@/i;
+var URL_IN_TEXT = /\b[a-z][a-z0-9+.-]*:\/\/\S+/gi;
+var TRAILER = /(:\d+:\d+)?([)\]}>"',;.]*)$/;
+function scrubUrl(value) {
+  const url = value.replace(USERINFO, "$1");
+  const query = url.indexOf("?");
+  const fragment = url.indexOf("#");
+  const cut = query === -1 ? fragment : fragment === -1 ? query : Math.min(query, fragment);
+  return cut === -1 ? url : url.slice(0, cut);
+}
+function scrubUrlsInText(text) {
+  return text.replace(URL_IN_TEXT, (token) => {
+    var _a, _b;
+    const trailer = (_b = (_a = TRAILER.exec(token)) == null ? void 0 : _a[0]) != null ? _b : "";
+    return scrubUrl(token.slice(0, token.length - trailer.length)) + trailer;
+  });
+}
+
+// src/core/exception.ts
+function toException(error, mechanism, handled) {
+  const parts = toErrorParts(error);
+  const exception = { ...parts, mechanism, handled };
+  const cause = toCauseChain(error);
+  if (cause.length > 0) {
+    exception.cause = cause;
+  }
+  return exception;
+}
+function limitException(exception) {
+  const limited = {
+    ...exception,
+    ...limitParts(exception)
+  };
+  if (exception.cause) {
+    limited.cause = exception.cause.slice(0, LIMITS.causeDepth).map((cause) => limitParts(cause));
+  }
+  return limited;
+}
+function limitParts(parts) {
+  return {
+    type: truncate(String(parts.type), LIMITS.exceptionTypeLength),
+    message: truncate(String(parts.message), LIMITS.exceptionMessageLength),
+    stack: typeof parts.stack === "string" && parts.stack.length > 0 ? truncateStack(scrubUrlsInText(parts.stack)) : null
+  };
+}
+function toErrorParts(error) {
+  if (isErrorLike(error)) {
+    return {
+      type: typeof error.name === "string" && error.name ? error.name : "Error",
+      message: typeof error.message === "string" ? error.message : "",
+      stack: typeof error.stack === "string" ? error.stack : null
+    };
+  }
+  return { type: "Error", message: formatValue(error), stack: null };
+}
+function toCauseChain(error) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set([error]);
+  let cause = isErrorLike(error) ? error.cause : void 0;
+  while (cause !== void 0 && cause !== null && chain.length < LIMITS.causeDepth) {
+    if (seen.has(cause)) {
+      break;
+    }
+    seen.add(cause);
+    chain.push(toErrorParts(cause));
+    cause = isErrorLike(cause) ? cause.cause : void 0;
+  }
+  return chain;
+}
+function isErrorLike(value) {
+  return value instanceof Error || typeof value === "object" && value !== null && typeof value.message === "string" && typeof value.stack === "string";
+}
+function formatValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    const json = JSON.stringify(value);
+    return json === void 0 ? String(value) : json;
+  } catch {
+    return String(value);
+  }
+}
+
+// src/core/filters.ts
+var DEFAULT_IGNORE_ERRORS = [
+  /^Script error\.?$/,
+  /^(TypeError: )?Failed to fetch$/,
+  /^(TypeError: )?NetworkError when attempting to fetch resource\.?$/,
+  /^(TypeError: )?Load failed$/,
+  /^AbortError\b/,
+  /The (operation|user) aborted a request/,
+  /The operation was aborted/,
+  /^ResizeObserver loop/
+];
+var DEFAULT_DENY_URLS = [
+  /^(chrome|moz|safari|safari-web|ms-browser)-extension:\/\//,
+  /^webkit-masked-url:\/\//
+];
+var FIRST_URL = /\b[a-z][a-z0-9+.-]*:\/\/[^\s)]+/i;
+function matchesAny(value, patterns) {
+  return patterns.some(
+    (pattern) => typeof pattern === "string" ? value.includes(pattern) : pattern.test(value)
+  );
+}
+function isIgnoredError(event, patterns) {
+  const { type, message } = event.exception;
+  return matchesAny(message, patterns) || matchesAny(`${type}: ${message}`, patterns) || type === "AbortError" && matchesAny("AbortError", patterns);
+}
+function isDeniedUrl(event, sourceUrl, patterns) {
+  var _a, _b;
+  const url = sourceUrl || ((_b = FIRST_URL.exec((_a = event.exception.stack) != null ? _a : "")) == null ? void 0 : _b[0]);
+  return url !== void 0 && matchesAny(url, patterns);
+}
+
+// src/core/flood.ts
+var FloodGuard = class {
+  constructor(maxEventsPerPage, duplicateWindowMs) {
+    this.maxEventsPerPage = maxEventsPerPage;
+    this.duplicateWindowMs = duplicateWindowMs;
+    this.lastSeen = /* @__PURE__ */ new Map();
+    this.accepted = 0;
+  }
+  admit(event, now) {
+    if (this.accepted >= this.maxEventsPerPage) {
+      return false;
+    }
+    const { type, message, stack } = event.exception;
+    const key = `${type}
+${message}
+${(stack != null ? stack : "").split("\n", 3).join("\n")}`;
+    const previous = this.lastSeen.get(key);
+    if (previous !== void 0 && now - previous < this.duplicateWindowMs) {
+      return false;
+    }
+    this.lastSeen.set(key, now);
+    this.accepted += 1;
+    return true;
+  }
+};
+
+// src/core/privacy.ts
+var DENIED_TAG_KEY_FRAGMENTS = [
+  "password",
+  "passwd",
+  "secret",
+  "token",
+  "authorization",
+  "cookie",
+  "apikey",
+  "api_key",
+  "api-key",
+  "credential",
+  "private_key"
+];
+var EMAIL_LIKE = /[^\s@]+@[^\s@]+\.[^\s@]+/;
+function sanitizeTags(tags) {
+  const result = {};
+  let count = 0;
+  for (const key of Object.keys(tags)) {
+    if (count === LIMITS.tagEntries) {
+      break;
+    }
+    const lowered = key.toLowerCase();
+    if (key.length === 0 || key.length > LIMITS.tagKeyLength || DENIED_TAG_KEY_FRAGMENTS.some((fragment) => lowered.includes(fragment))) {
+      continue;
+    }
+    result[key] = truncate(String(tags[key]), LIMITS.tagValueLength);
+    count += 1;
+  }
+  return result;
+}
+function sanitizeIdentifier(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= LIMITS.identifierLength ? value : null;
+}
+function sanitizeUserId(value) {
+  const id = sanitizeIdentifier(value);
+  return id !== null && EMAIL_LIKE.test(id) ? null : id;
+}
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function sanitizeDebugIds(debugIds) {
+  const result = {};
+  let count = 0;
+  for (const [url, id] of Object.entries(debugIds)) {
+    const key = scrubUrl(url);
+    if (count === LIMITS.debugIdEntries) {
+      break;
+    }
+    if (key.length > 0 && key.length <= LIMITS.debugIdKeyLength && UUID.test(String(id))) {
+      result[key] = String(id);
+      count += 1;
+    }
+  }
+  return result;
+}
+
+// src/core/transport.ts
+var BATCH_DELAY_MS = 1e3;
+var MAX_BODY_BYTES = 240 * 1024;
+var KEEPALIVE_BUDGET_BYTES = 60 * 1024;
+var ENVELOPE_OVERHEAD_BYTES = 512;
+var MAX_QUEUE = 100;
+var MAX_ATTEMPTS = 5;
+var MAX_RETRY_AGE_MS = 30 * 60 * 1e3;
+var DEFAULT_RETRY_AFTER_MS = { 429: 6e4, 503: 1e4 };
+var MAX_BACKOFF_MS = 6e4;
+var Transport = class {
+  constructor(options) {
+    this.options = options;
+    this.queue = [];
+    this.pausedUntil = 0;
+    this.timer = null;
+    this.loop = null;
+    this.inFlight = /* @__PURE__ */ new Set();
+  }
+  enqueue(event) {
+    if (this.queue.length >= MAX_QUEUE) {
+      this.options.debug("queue full; event dropped");
+      return;
+    }
+    this.queue.push({
+      event,
+      bytes: byteLength(JSON.stringify(event)),
+      attempts: 0,
+      firstAttemptAt: null
+    });
+    this.schedule(BATCH_DELAY_MS);
+  }
+  /** Sends everything queued. Resolves true when nothing is left. */
+  async flush(timeoutMs = 2e3) {
+    this.cancelTimer();
+    let timeout;
+    await Promise.race([
+      this.drain().then(() => Promise.all(this.inFlight)),
+      new Promise((resolve) => {
+        timeout = setTimeout(resolve, timeoutMs);
+      })
+    ]);
+    clearTimeout(timeout);
+    return this.queue.length === 0 && this.inFlight.size === 0;
+  }
+  /**
+   * Called when the page is hidden or unloading: sends what fits in the
+   * keepalive budget synchronously, so the requests outlive the page.
+   */
+  flushOnUnload() {
+    this.cancelTimer();
+    if (this.options.now() < this.pausedUntil) {
+      return;
+    }
+    let budget = KEEPALIVE_BUDGET_BYTES;
+    while (this.queue.length > 0) {
+      const batch = this.takeBatch(budget);
+      if (batch.length === 0) {
+        break;
+      }
+      budget -= batchBytes(batch);
+      this.track(this.post(batch, true));
+    }
+  }
+  close() {
+    this.cancelTimer();
+    this.queue = [];
+  }
+  schedule(delayMs) {
+    if (this.timer !== null || this.queue.length === 0) {
+      return;
+    }
+    const wait = Math.max(delayMs, this.pausedUntil - this.options.now());
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.drain();
+    }, wait);
+  }
+  cancelTimer() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  drain() {
+    if (this.loop === null) {
+      this.loop = this.run().finally(() => {
+        this.loop = null;
+      });
+    }
+    return this.loop;
+  }
+  async run() {
+    while (this.queue.length > 0 && this.options.now() >= this.pausedUntil) {
+      const batch = this.takeBatch(MAX_BODY_BYTES);
+      if (batch.length === 0) {
+        break;
+      }
+      await this.track(this.post(batch, false));
+    }
+    this.schedule(0);
+  }
+  track(request) {
+    this.inFlight.add(request);
+    return request.finally(() => this.inFlight.delete(request));
+  }
+  /** Takes up to 20 events that fit maxBytes, dropping expired ones first. */
+  takeBatch(maxBytes) {
+    const now = this.options.now();
+    this.queue = this.queue.filter((pending) => {
+      const expired = pending.attempts >= MAX_ATTEMPTS || pending.firstAttemptAt !== null && now - pending.firstAttemptAt > MAX_RETRY_AGE_MS;
+      if (expired) {
+        this.options.debug(`event ${pending.event.eventId} dropped after retries`);
+      }
+      return !expired;
+    });
+    const batch = [];
+    let bytes = ENVELOPE_OVERHEAD_BYTES;
+    while (this.queue.length > 0 && batch.length < LIMITS.eventsPerRequest && bytes + this.queue[0].bytes <= maxBytes) {
+      const pending = this.queue.shift();
+      bytes += pending.bytes;
+      batch.push(pending);
+    }
+    if (batch.length === 0 && this.queue.length > 0 && maxBytes === MAX_BODY_BYTES) {
+      batch.push(this.queue.shift());
+    }
+    return batch;
+  }
+  async post(batch, keepalive) {
+    var _a, _b;
+    const now = this.options.now();
+    for (const pending of batch) {
+      pending.attempts += 1;
+      (_a = pending.firstAttemptAt) != null ? _a : pending.firstAttemptAt = now;
+    }
+    const envelope = {
+      ...this.options.envelope,
+      sentAt: new Date(now).toISOString(),
+      events: batch.map((pending) => pending.event)
+    };
+    let status;
+    let retryAfter = null;
+    try {
+      const response = await this.options.fetch(this.options.url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.options.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(envelope),
+        keepalive
+      });
+      status = response.status;
+      retryAfter = response.headers.get("Retry-After");
+    } catch {
+      this.requeue(batch);
+      const attempts = Math.max(...batch.map((pending) => pending.attempts));
+      this.pause(Math.min(1e3 * 2 ** attempts, MAX_BACKOFF_MS));
+      return;
+    }
+    if (status === 429 || status === 503) {
+      this.requeue(batch);
+      this.pause((_b = parseRetryAfter(retryAfter, this.options.now())) != null ? _b : DEFAULT_RETRY_AFTER_MS[status]);
+      return;
+    }
+    if (status < 200 || status >= 300) {
+      this.options.debug(`request rejected with ${status}; ${batch.length} events dropped`);
+    }
+  }
+  requeue(batch) {
+    this.queue.unshift(...batch);
+    this.queue.length = Math.min(this.queue.length, MAX_QUEUE);
+  }
+  pause(ms) {
+    this.pausedUntil = Math.max(this.pausedUntil, this.options.now() + ms);
+    this.cancelTimer();
+    this.schedule(0);
+  }
+};
+function parseRetryAfter(value, now) {
+  if (value === null || value.trim() === "") {
+    return null;
+  }
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) {
+    return Math.max(0, seconds * 1e3);
+  }
+  const date = Date.parse(value);
+  return Number.isNaN(date) ? null : Math.max(0, date - now);
+}
+function batchBytes(batch) {
+  return batch.reduce((total, pending) => total + pending.bytes, ENVELOPE_OVERHEAD_BYTES);
+}
+function byteLength(value) {
+  return typeof TextEncoder === "undefined" ? value.length * 3 : new TextEncoder().encode(value).length;
+}
+
+// src/core/uuid.ts
+function uuid() {
+  const bytes = new Uint8Array(16);
+  const crypto = globalThis.crypto;
+  if (crypto == null ? void 0 : crypto.getRandomValues) {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i += 1) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0"));
+  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10).join("")}`;
+}
+
+// src/browser/session.ts
+var SESSION_KEY = "vigilon.session";
+function sessionId() {
+  try {
+    const existing = window.sessionStorage.getItem(SESSION_KEY);
+    if (existing) {
+      return existing;
+    }
+    const created = uuid();
+    window.sessionStorage.setItem(SESSION_KEY, created);
+    return created;
+  } catch {
+    return null;
+  }
+}
+
+// src/browser/client.ts
+var SDK_NAME = "@vigilon/browser";
+var SDK_VERSION = "0.2.9-beta.pr-1.1";
+var DEFAULT_ENDPOINT = "https://ingest.vigilon.io";
+var EVENTS_PATH = "/v1/browser/events";
+var DUPLICATE_WINDOW_MS = 6e4;
+var BrowserClient = class {
+  constructor(options) {
+    this.options = options;
+    this.tags = {};
+    this.userId = null;
+    this.removeListeners = [];
+    var _a, _b, _c, _d;
+    const endpoint = ((_a = options.endpoint) != null ? _a : DEFAULT_ENDPOINT).replace(/\/+$/, "");
+    this.transport = new Transport({
+      url: `${endpoint}${EVENTS_PATH}`,
+      apiKey: options.apiKey,
+      envelope: {
+        schema: SCHEMA_ID,
+        sdk: { name: SDK_NAME, version: SDK_VERSION },
+        service: {
+          name: options.serviceName,
+          environment: options.environment,
+          ...options.serviceVersion ? { version: truncate(options.serviceVersion, LIMITS.serviceVersionLength) } : {}
+        }
+      },
+      fetch: (input, init2) => window.fetch(input, init2),
+      now: () => Date.now(),
+      debug: (message) => this.debug(message)
+    });
+    this.floodGuard = new FloodGuard(
+      (_b = options.maxEventsPerPage) != null ? _b : 100,
+      DUPLICATE_WINDOW_MS
+    );
+    this.ignoreErrors = [...DEFAULT_IGNORE_ERRORS, ...(_c = options.ignoreErrors) != null ? _c : []];
+    this.denyUrls = [...DEFAULT_DENY_URLS, ...(_d = options.denyUrls) != null ? _d : []];
+  }
+  install() {
+    this.listen(window, "error", (event) => {
+      const { error, message, filename } = event;
+      this.capture(error != null ? error : message, { mechanism: "onerror", handled: false }, filename);
+    });
+    this.listen(window, "unhandledrejection", (event) => {
+      this.capture(event.reason, {
+        mechanism: "unhandledrejection",
+        handled: false
+      });
+    });
+    this.listen(document, "visibilitychange", () => {
+      if (document.visibilityState === "hidden") {
+        this.transport.flushOnUnload();
+      }
+    });
+    this.listen(window, "pagehide", () => this.transport.flushOnUnload());
+  }
+  capture(error, context = {}, sourceUrl) {
+    try {
+      return this.captureUnsafe(error, context, sourceUrl);
+    } catch (failure) {
+      this.debug(`capture failed: ${String(failure)}`);
+      return null;
+    }
+  }
+  setUser(user) {
+    this.userId = user === null ? null : sanitizeUserId(user.id);
+    if (user !== null && this.userId === null) {
+      this.debug("user.id dropped: it must be an opaque ID of at most 128 characters, not an email address");
+    }
+  }
+  setTag(key, value) {
+    this.tags[key] = String(value);
+  }
+  flush(timeoutMs) {
+    return this.transport.flush(timeoutMs);
+  }
+  async close(timeoutMs) {
+    for (const remove of this.removeListeners.splice(0)) {
+      remove();
+    }
+    const flushed = await this.transport.flush(timeoutMs);
+    this.transport.close();
+    return flushed;
+  }
+  captureUnsafe(error, context, sourceUrl) {
+    var _a, _b, _c;
+    const sampleRate = (_a = this.options.sampleRate) != null ? _a : 1;
+    if (sampleRate < 1 && Math.random() >= sampleRate) {
+      return null;
+    }
+    const exception = toException(
+      error,
+      (_b = context.mechanism) != null ? _b : "manual",
+      (_c = context.handled) != null ? _c : true
+    );
+    if (context.componentStack) {
+      exception.componentStack = context.componentStack;
+    }
+    const session = sessionId();
+    let event = {
+      type: "exception",
+      eventId: uuid(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      exception,
+      page: {
+        url: window.location.href,
+        ...context.route ? { route: context.route } : {}
+      },
+      session: session === null ? null : { id: session },
+      user: this.userId === null ? null : { id: this.userId },
+      traceId: null,
+      tags: { ...this.tags }
+    };
+    if (isIgnoredError(event, this.ignoreErrors) || isDeniedUrl(event, sourceUrl, this.denyUrls)) {
+      return null;
+    }
+    if (this.options.beforeSend) {
+      try {
+        event = this.options.beforeSend(event);
+      } catch (failure) {
+        this.debug(`beforeSend threw; event dropped: ${String(failure)}`);
+        return null;
+      }
+      if (event === null) {
+        return null;
+      }
+    }
+    const limited = limitEvent(event);
+    if (!this.floodGuard.admit(limited, Date.now())) {
+      return null;
+    }
+    this.transport.enqueue(limited);
+    return limited.eventId;
+  }
+  listen(target, type, handler) {
+    target.addEventListener(type, handler);
+    this.removeListeners.push(() => target.removeEventListener(type, handler));
+  }
+  debug(message) {
+    if (this.options.debug) {
+      console.warn(`[Vigilon] ${message}`);
+    }
+  }
+};
+function limitEvent(event) {
+  var _a, _b, _c;
+  const limited = {
+    type: "exception",
+    eventId: event.eventId,
+    timestamp: event.timestamp,
+    exception: limitException(event.exception),
+    page: { url: truncate(scrubUrl(String(event.page.url)), LIMITS.pageUrlLength) }
+  };
+  if (event.exception.componentStack) {
+    limited.exception.componentStack = truncate(
+      event.exception.componentStack,
+      LIMITS.componentStackLength
+    );
+  }
+  if (event.page.route) {
+    limited.page.route = truncate(event.page.route, LIMITS.pageRouteLength);
+  }
+  const session = sanitizeIdentifier((_a = event.session) == null ? void 0 : _a.id);
+  limited.session = session === null ? null : { id: session };
+  const user = sanitizeUserId((_b = event.user) == null ? void 0 : _b.id);
+  limited.user = user === null ? null : { id: user };
+  limited.traceId = sanitizeIdentifier(event.traceId);
+  limited.tags = sanitizeTags((_c = event.tags) != null ? _c : {});
+  if (event.debugIds) {
+    limited.debugIds = sanitizeDebugIds(event.debugIds);
+  }
+  return limited;
+}
+function invalidOptions(options) {
+  if (!options || typeof options.apiKey !== "string" || options.apiKey.length === 0) {
+    return "apiKey is required";
+  }
+  for (const [name, value] of [
+    ["serviceName", options.serviceName],
+    ["environment", options.environment]
+  ]) {
+    if (typeof value !== "string" || value.length === 0 || value.length > LIMITS.serviceNameLength || !SERVICE_TOKEN_PATTERN.test(value)) {
+      return `${name} must be 1 to 100 characters of letters, digits, and . _ : / -`;
+    }
+  }
+  return null;
+}
+
+// src/index.ts
+var client = null;
+function init(options) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return false;
+  }
+  const problem = invalidOptions(options);
+  if (problem !== null) {
+    console.error(`[Vigilon] not started: ${problem}`);
+    return false;
+  }
+  if (!options.serviceVersion) {
+    console.warn(
+      "[Vigilon] serviceVersion is not set; errors will not be linked to a release"
+    );
+  }
+  if (client !== null) {
+    void client.close(0);
+  }
+  client = new BrowserClient(options);
+  client.install();
+  return true;
+}
+function captureException(error, context) {
+  return client === null ? null : client.capture(error, context);
+}
+function setUser(user) {
+  client == null ? void 0 : client.setUser(user);
+}
+function setTag(key, value) {
+  client == null ? void 0 : client.setTag(key, value);
+}
+function flush(timeoutMs) {
+  return client === null ? Promise.resolve(true) : client.flush(timeoutMs);
+}
+async function close(timeoutMs) {
+  if (client === null) {
+    return true;
+  }
+  const closing = client;
+  client = null;
+  return closing.close(timeoutMs);
+}
+export {
+  SDK_VERSION,
+  captureException,
+  close,
+  flush,
+  init,
+  setTag,
+  setUser
+};
+//# sourceMappingURL=index.mjs.map