@flareapp/js 2.0.0-rc.1 → 2.0.0

package/dist/index.mjs

@@ -1,466 +1,570 @@
-// src/env/index.ts
-var CLIENT_VERSION = false ? "?" : '"2.0.0-rc.1"';
-var KEY = typeof FLARE_JS_KEY === "undefined" ? "" : FLARE_JS_KEY;
-var SOURCEMAP_VERSION = typeof FLARE_SOURCEMAP_VERSION === "undefined" ? "" : FLARE_SOURCEMAP_VERSION;
+import ErrorStackParser from "error-stack-parser";
+
+//#region src/browser/catchWindowErrors.ts
+function catchWindowErrors() {
+	if (typeof window === "undefined") return;
+	window.addEventListener("error", (event) => {
+		const flare = window.flare;
+		if (!flare) return;
+		if (event.error instanceof Error) Promise.resolve(flare.report(event.error)).catch(() => {});
+	});
+	window.addEventListener("unhandledrejection", (event) => {
+		const flare = window.flare;
+		if (!flare) return;
+		const reason = event.reason;
+		if (reason instanceof Error) {
+			Promise.resolve(flare.report(reason)).catch(() => {});
+			return;
+		}
+		if (hasStack$1(reason)) {
+			const error = new Error(describeRejectionReason(reason));
+			error.stack = reason.stack;
+			Promise.resolve(flare.report(error)).catch(() => {});
+			return;
+		}
+		Promise.resolve(flare.reportUnhandledRejection(describeRejectionReason(reason))).catch(() => {});
+	});
+}
+function describeRejectionReason(reason) {
+	if (typeof reason === "string") return reason;
+	if (reason && typeof reason === "object") {
+		const message = reason.message;
+		if (typeof message === "string") return message;
+		try {
+			return JSON.stringify(reason);
+		} catch {
+			return "Unhandled promise rejection (non-serializable reason)";
+		}
+	}
+	return String(reason);
+}
+function hasStack$1(value) {
+	return typeof value === "object" && value !== null && "stack" in value && typeof value.stack === "string";
+}
+
+//#endregion
+//#region src/env/index.ts
+const CLIENT_VERSION = typeof process !== "undefined" && true ? "2.0.0" : "?";
+const KEY = typeof FLARE_JS_KEY === "undefined" ? "" : FLARE_JS_KEY;
+const SOURCEMAP_VERSION = typeof FLARE_SOURCEMAP_VERSION === "undefined" ? "" : FLARE_SOURCEMAP_VERSION;
 
-// src/util/assert.ts
+//#endregion
+//#region src/util/assert.ts
 function assert(value, message, debug) {
-  if (debug && !value) {
-    console.error(`Flare JavaScript client v${CLIENT_VERSION}: ${message}`);
-  }
-  return !!value;
+	if (debug && !value) console.error(`Flare JavaScript client v${CLIENT_VERSION}: ${message}`);
+	return !!value;
 }
 
-// src/util/assertKey.ts
+//#endregion
+//#region src/util/assertKey.ts
 function assertKey(key, debug) {
-  return assert(
-    key,
-    "The client was not yet initialised with an API key. Run client.light('<flare-project-key>') when you initialise your app. If you are running in dev mode and didn't run the light command on purpose, you can ignore this error.",
-    debug
-  );
+	return assert(key, "The client was not yet initialised with an API key. Run client.light('<flare-project-key>') when you initialise your app. If you are running in dev mode and didn't run the light command on purpose, you can ignore this error.", debug);
 }
 
-// src/util/assertSolutionProvider.ts
-function assertSolutionProvider(solutionProvider, debug) {
-  return assert("canSolve" in solutionProvider, "A solution provider without a [canSolve] property was added.", debug) && assert(
-    "getSolutions" in solutionProvider,
-    "A solution provider without a [getSolutions] property was added.",
-    debug
-  );
+//#endregion
+//#region src/util/extractCode.ts
+const MAX_CODE_LENGTH = 64;
+function extractCode(error) {
+	const code = error.code;
+	if (typeof code !== "string" || code.length === 0) return;
+	return code.slice(0, MAX_CODE_LENGTH);
 }
 
-// src/util/flatJsonStringify.ts
+//#endregion
+//#region src/util/flatJsonStringify.ts
 function flatJsonStringify(json) {
-  let cache = [];
-  const flattenedStringifiedJson = JSON.stringify(json, function(_, value) {
-    if (typeof value === "object" && value !== null) {
-      if (cache.indexOf(value) !== -1) {
-        try {
-          return JSON.parse(JSON.stringify(value));
-        } catch (error) {
-          return;
-        }
-      }
-      cache.push(value);
-    }
-    return value;
-  });
-  cache = null;
-  return flattenedStringifiedJson;
+	return JSON.stringify(decycle(json));
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function decycle(root) {
+	const inPath = /* @__PURE__ */ new WeakSet();
+	function clone(node) {
+		if (Array.isArray(node)) {
+			if (inPath.has(node)) return "[Circular]";
+			inPath.add(node);
+			const result = node.map(clone);
+			inPath.delete(node);
+			return result;
+		}
+		if (isPlainObject(node)) {
+			if (inPath.has(node)) return "[Circular]";
+			inPath.add(node);
+			const result = {};
+			for (const [k, v] of Object.entries(node)) result[k] = clone(v);
+			inPath.delete(node);
+			return result;
+		}
+		return node;
+	}
+	return clone(root);
 }
 
-// src/util/flattenOnce.ts
-function flattenOnce(array) {
-  return array.reduce((flat, toFlatten) => {
-    return flat.concat(toFlatten);
-  }, []);
+//#endregion
+//#region src/util/glowsToEvents.ts
+function glowsToEvents(glows) {
+	return glows.map((glow) => ({
+		type: "php_glow",
+		startTimeUnixNano: Math.round(glow.microtime * 1e9),
+		endTimeUnixNano: null,
+		attributes: {
+			"glow.name": String(glow.name),
+			"glow.level": glow.messageLevel,
+			"glow.context": glow.metaData ?? {}
+		}
+	}));
 }
 
-// src/util/now.ts
+//#endregion
+//#region src/util/now.ts
 function now() {
-  return Math.round(Date.now() / 1e3);
+	return Math.round(Date.now() / 1e3);
+}
+
+//#endregion
+//#region src/util/redactUrl.ts
+const DEFAULT_URL_DENYLIST = /password|passwd|pwd|token|secret|authorization|\bauth\b|bearer|oauth|credentials?|cookie|api[-_]?key|private[-_]?key|session|csrf|xsrf|\bpin\b|\bssn\b|card[-_]?number|\bcvv\b/i;
+function resolveDenylist(custom, replaceDefault = false, defaultDenylist = DEFAULT_URL_DENYLIST) {
+	if (!custom) return defaultDenylist;
+	if (replaceDefault) {
+		const safeFlags = custom.flags.replace(/[gy]/g, "");
+		return new RegExp(custom.source, safeFlags);
+	}
+	const flags = unionFlags(defaultDenylist.flags, custom.flags);
+	return new RegExp(`(?:${defaultDenylist.source})|(?:${custom.source})`, flags);
+}
+function unionFlags(a, b) {
+	const merged = /* @__PURE__ */ new Set();
+	for (const flag of a + b) {
+		if (flag === "g" || flag === "y") continue;
+		merged.add(flag);
+	}
+	return [...merged].join("");
+}
+function redactFullPath(fullPath, denylist = DEFAULT_URL_DENYLIST) {
+	const queryStart = fullPath.indexOf("?");
+	if (queryStart === -1) return fullPath;
+	const hashStart = fullPath.indexOf("#", queryStart);
+	const queryEnd = hashStart === -1 ? fullPath.length : hashStart;
+	const prefix = fullPath.slice(0, queryStart + 1);
+	const queryString = fullPath.slice(queryStart + 1, queryEnd);
+	const suffix = fullPath.slice(queryEnd);
+	return `${prefix}${queryString.split("&").map((pair) => {
+		if (pair === "") return pair;
+		const eq = pair.indexOf("=");
+		const rawKey = eq === -1 ? pair : pair.slice(0, eq);
+		const decodedKey = safeDecode(rawKey);
+		if (!denylist.test(decodedKey)) return pair;
+		return eq === -1 ? rawKey : `${rawKey}=[redacted]`;
+	}).join("&")}${suffix}`;
+}
+function safeDecode(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
 }
 
-// src/api/Api.ts
+//#endregion
+//#region src/api/Api.ts
 var Api = class {
-  report(report, url, key, reportBrowserExtensionErrors) {
-    return fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-Api-Token": key,
-        "X-Requested-With": "XMLHttpRequest",
-        "X-Report-Browser-Extension-Errors": JSON.stringify(reportBrowserExtensionErrors)
-      },
-      body: flatJsonStringify({
-        ...report,
-        key
-      })
-    }).then(
-      (response) => {
-        if (response.status !== 204) {
-          console.error(`Received response with status ${response.status} from Flare`);
-        }
-      },
-      (error) => console.error(error)
-    );
-  }
+	report(report, url, key, reportBrowserExtensionErrors, debug = false) {
+		return fetch(url, {
+			method: "POST",
+			headers: {
+				"Accept": "application/json",
+				"Content-Type": "application/json",
+				"X-Api-Token": key ?? "",
+				"X-Report-Browser-Extension-Errors": JSON.stringify(reportBrowserExtensionErrors),
+				"X-Flare-Client-Version": "2"
+			},
+			body: flatJsonStringify(report)
+		}).then((response) => {
+			if (debug && response.status !== 201) console.error(`Received response with status ${response.status} from Flare`);
+		}, (error) => {
+			if (debug) console.error(error);
+		});
+	}
 };
 
-// src/context/cookie.ts
+//#endregion
+//#region src/context/cookie.ts
 function cookie() {
-  if (!window.document.cookie) {
-    return {};
-  }
-  return {
-    cookies: window.document.cookie.split("; ").reduce(
-      (cookies, cookie2) => {
-        const [cookieName, cookieValue] = cookie2.split(/=/);
-        cookies[cookieName] = cookieValue;
-        return cookies;
-      },
-      {}
-    )
-  };
-}
-
-// src/context/request.ts
-function request() {
-  return {
-    request: {
-      url: window.document.location.href,
-      useragent: window.navigator.userAgent,
-      referrer: window.document.referrer,
-      readyState: window.document.readyState
-    }
-  };
+	if (!window.document.cookie) return {};
+	const cookies = {};
+	window.document.cookie.split("; ").forEach((rawCookie) => {
+		const idx = rawCookie.indexOf("=");
+		if (idx === -1) {
+			cookies[rawCookie] = "";
+			return;
+		}
+		const name = rawCookie.slice(0, idx);
+		cookies[name] = rawCookie.slice(idx + 1);
+	});
+	return { "http.request.cookies": cookies };
 }
 
-// src/context/requestData.ts
-function requestData() {
-  if (!window.location.search) {
-    return {};
-  }
-  const queryString = {};
-  new URLSearchParams(window.location.search).forEach((value, key) => {
-    queryString[key] = value;
-  });
-  return { request_data: { queryString } };
+//#endregion
+//#region src/context/request.ts
+function request(urlDenylist) {
+	return {
+		"url.full": redactFullPath(window.location.href, urlDenylist),
+		"user_agent.original": window.navigator.userAgent,
+		"http.request.referrer": redactFullPath(window.document.referrer, urlDenylist),
+		"document.ready_state": window.document.readyState
+	};
 }
 
-// src/context/collectContext.ts
-function collectContext(additionalContext) {
-  if (typeof window === "undefined") {
-    return additionalContext;
-  }
-  return {
-    ...cookie(),
-    ...request(),
-    ...requestData(),
-    ...additionalContext
-  };
+//#endregion
+//#region src/context/requestData.ts
+function requestData(urlDenylist) {
+	if (!window.location.search) return {};
+	return { "url.query": redactFullPath(window.location.search, urlDenylist).replace(/^\?/, "") };
 }
 
-// src/solutions/getSolutions.ts
-function getSolutions(solutionProviders, error, extraSolutionParameters = {}) {
-  return new Promise((resolve) => {
-    const canSolves = solutionProviders.reduce(
-      (canSolves2, provider) => {
-        canSolves2.push(Promise.resolve(provider.canSolve(error, extraSolutionParameters)));
-        return canSolves2;
-      },
-      []
-    );
-    Promise.all(canSolves).then((resolvedCanSolves) => {
-      const solutionPromises = [];
-      resolvedCanSolves.forEach((canSolve, i) => {
-        if (canSolve) {
-          solutionPromises.push(
-            Promise.resolve(solutionProviders[i].getSolutions(error, extraSolutionParameters))
-          );
-        }
-      });
-      Promise.all(solutionPromises).then((solutions) => {
-        resolve(flattenOnce(solutions));
-      });
-    });
-  });
+//#endregion
+//#region src/context/collectAttributes.ts
+function collectAttributes(urlDenylist) {
+	if (typeof window === "undefined") return {};
+	return {
+		...request(urlDenylist),
+		...requestData(urlDenylist),
+		...cookie()
+	};
 }
 
-// src/stacktrace/createStackTrace.ts
-import ErrorStackParser from "error-stack-parser";
-
-// src/stacktrace/fileReader.ts
-var cachedFiles = {};
+//#endregion
+//#region src/stacktrace/fileReader.ts
+const cachedFiles = {};
 function getCodeSnippet(url, lineNumber, columnNumber) {
-  return new Promise((resolve) => {
-    if (!url || !lineNumber) {
-      return resolve({
-        codeSnippet: {
-          0: `Could not read from file: missing file URL or line number. URL: ${url} lineNumber: ${lineNumber}`
-        },
-        trimmedColumnNumber: null
-      });
-    }
-    readFile(url).then((fileText) => {
-      if (!fileText) {
-        return resolve({
-          codeSnippet: {
-            0: `Could not read from file: Error while opening file at URL ${url}`
-          },
-          trimmedColumnNumber: null
-        });
-      }
-      return resolve(readLinesFromFile(fileText, lineNumber, columnNumber));
-    });
-  });
+	return new Promise((resolve) => {
+		if (!url || !lineNumber) return resolve({
+			codeSnippet: { 0: `Could not read from file: missing file URL or line number. URL: ${url} lineNumber: ${lineNumber}` },
+			trimmedColumnNumber: null
+		});
+		if (!isFetchableUrl(url)) return resolve({
+			codeSnippet: { 0: `Could not read from file: unsupported URL scheme. URL: ${url}` },
+			trimmedColumnNumber: null
+		});
+		readFile(url).then((fileText) => {
+			if (!fileText) return resolve({
+				codeSnippet: { 0: `Could not read from file: Error while opening file at URL ${url}` },
+				trimmedColumnNumber: null
+			});
+			return resolve(readLinesFromFile(fileText, lineNumber, columnNumber));
+		});
+	});
+}
+function isFetchableUrl(url) {
+	return /^https?:\/\//i.test(url);
 }
 function readFile(url) {
-  if (cachedFiles[url]) {
-    return Promise.resolve(cachedFiles[url]);
-  }
-  return fetch(url).then((response) => {
-    if (response.status !== 200) {
-      return null;
-    }
-    return response.text();
-  }).catch(() => null);
+	if (cachedFiles[url] !== void 0) return Promise.resolve(cachedFiles[url]);
+	return fetch(url).then((response) => {
+		if (response.status !== 200) return null;
+		return response.text();
+	}).then((text) => {
+		if (text !== null) cachedFiles[url] = text;
+		return text;
+	}).catch(() => null);
 }
 function readLinesFromFile(fileText, lineNumber, columnNumber, maxSnippetLineLength = 1e3, maxSnippetLines = 40) {
-  const codeSnippet = {};
-  let trimmedColumnNumber = null;
-  const lines = fileText.split("\n");
-  for (let i = -maxSnippetLines / 2; i <= maxSnippetLines / 2; i++) {
-    const currentLineIndex = lineNumber + i;
-    if (currentLineIndex >= 0 && lines[currentLineIndex]) {
-      const displayLine = currentLineIndex + 1;
-      if (lines[currentLineIndex].length > maxSnippetLineLength) {
-        if (columnNumber && columnNumber + maxSnippetLineLength / 2 > maxSnippetLineLength) {
-          codeSnippet[displayLine] = lines[currentLineIndex].substr(
-            columnNumber - Math.round(maxSnippetLineLength / 2),
-            maxSnippetLineLength
-          );
-          if (displayLine === lineNumber) {
-            trimmedColumnNumber = Math.round(maxSnippetLineLength / 2);
-          }
-          continue;
-        }
-        codeSnippet[displayLine] = lines[currentLineIndex].substr(0, maxSnippetLineLength) + "\u2026";
-        continue;
-      }
-      codeSnippet[displayLine] = lines[currentLineIndex];
-    }
-  }
-  return { codeSnippet, trimmedColumnNumber };
+	const codeSnippet = {};
+	let trimmedColumnNumber = null;
+	const lines = fileText.split("\n");
+	const errorLineIndex = lineNumber - 1;
+	const half = Math.floor(maxSnippetLines / 2);
+	for (let i = -half; i <= half; i++) {
+		const currentLineIndex = errorLineIndex + i;
+		if (currentLineIndex < 0 || !lines[currentLineIndex]) continue;
+		const displayLine = currentLineIndex + 1;
+		const line = lines[currentLineIndex];
+		if (line.length > maxSnippetLineLength) {
+			if (columnNumber && columnNumber > maxSnippetLineLength / 2) {
+				const start = columnNumber - Math.round(maxSnippetLineLength / 2);
+				codeSnippet[displayLine] = line.slice(start, start + maxSnippetLineLength);
+				if (displayLine === lineNumber) trimmedColumnNumber = Math.round(maxSnippetLineLength / 2);
+				continue;
+			}
+			codeSnippet[displayLine] = line.slice(0, maxSnippetLineLength) + "…";
+			continue;
+		}
+		codeSnippet[displayLine] = line;
+	}
+	return {
+		codeSnippet,
+		trimmedColumnNumber
+	};
 }
 
-// src/stacktrace/createStackTrace.ts
+//#endregion
+//#region src/stacktrace/createStackTrace.ts
 function createStackTrace(error, debug) {
-  return new Promise((resolve) => {
-    if (!hasStack(error)) {
-      assert(false, "Couldn't generate stacktrace of below error:", debug);
-      if (debug) {
-        console.error(error);
-      }
-      return resolve([
-        {
-          line_number: 0,
-          column_number: 0,
-          method: "unknown",
-          file: "unknown",
-          code_snippet: {
-            0: "Could not read from file: stacktrace missing"
-          },
-          trimmed_column_number: null,
-          class: "unknown"
-        }
-      ]);
-    }
-    Promise.all(
-      ErrorStackParser.parse(error).map((frame) => {
-        return new Promise((resolve2) => {
-          getCodeSnippet(frame.fileName, frame.lineNumber, frame.columnNumber).then((snippet) => {
-            resolve2({
-              line_number: frame.lineNumber || 1,
-              column_number: frame.columnNumber || 1,
-              method: frame.functionName || "Anonymous or unknown function",
-              file: frame.fileName || "Unknown file",
-              code_snippet: snippet.codeSnippet,
-              trimmed_column_number: snippet.trimmedColumnNumber,
-              class: ""
-            });
-          });
-        });
-      })
-    ).then(resolve);
-  });
+	return new Promise((resolve) => {
+		if (!hasStack(error)) return resolve([fallbackFrame("stacktrace missing")]);
+		let parsedFrames;
+		try {
+			parsedFrames = ErrorStackParser.parse(error);
+		} catch (parseError) {
+			assert(false, "Couldn't parse stacktrace of below error:", debug);
+			if (debug) {
+				console.error(parseError);
+				console.error(error);
+			}
+			return resolve([fallbackFrame("stacktrace could not be parsed")]);
+		}
+		Promise.all(parsedFrames.map((frame) => {
+			return getCodeSnippet(frame.fileName, frame.lineNumber, frame.columnNumber).then((snippet) => ({
+				lineNumber: frame.lineNumber || 1,
+				columnNumber: frame.columnNumber || 1,
+				method: frame.functionName || "Anonymous or unknown function",
+				file: frame.fileName || "Unknown file",
+				codeSnippet: snippet.codeSnippet,
+				class: "",
+				isApplicationFrame: isApplicationFrame(frame.fileName)
+			}));
+		})).then(resolve);
+	});
+}
+function fallbackFrame(reason) {
+	return {
+		lineNumber: 0,
+		columnNumber: 0,
+		method: "unknown",
+		file: "unknown",
+		codeSnippet: { 0: `Could not read from file: ${reason}` },
+		class: "unknown"
+	};
 }
 function hasStack(err) {
-  return !!err && (!!err.stack || !!err.stacktrace || !!err["opera#sourceloc"]) && typeof (err.stack || err.stacktrace || err["opera#sourceloc"]) === "string" && err.stack !== `${err.name}: ${err.message}`;
+	if (!err || typeof err !== "object") return false;
+	const e = err;
+	const stack = e.stack ?? e.stacktrace ?? e["opera#sourceloc"];
+	return typeof stack === "string" && stack !== `${e.name}: ${e.message}`;
+}
+function isApplicationFrame(fileName) {
+	if (!fileName) return true;
+	if (/[/\\]node_modules[/\\]/.test(fileName)) return false;
+	if (/(^|[/\\])(vendor|vendors)[.~-][^/\\]*\.js/i.test(fileName)) return false;
+	return true;
 }
 
-// src/Flare.ts
+//#endregion
+//#region src/Flare.ts
+const DEFAULT_SDK_NAME = "@flareapp/js";
 var Flare = class {
-  constructor(http = new Api()) {
-    this.http = http;
-    this.config = {
-      key: KEY,
-      version: CLIENT_VERSION,
-      sourcemapVersion: SOURCEMAP_VERSION,
-      stage: "",
-      maxGlowsPerReport: 30,
-      reportingUrl: "https://reporting.flareapp.io/api/reports",
-      reportBrowserExtensionErrors: false,
-      debug: false,
-      beforeEvaluate: (error) => error,
-      beforeSubmit: (report) => report
-    };
-    this.glows = [];
-    this.context = { context: {} };
-    this.solutionProviders = [];
-  }
-  light(key = KEY, debug = false) {
-    this.config.key = key;
-    this.config.debug = debug;
-    return this;
-  }
-  configure(config) {
-    this.config = { ...this.config, ...config };
-    return this;
-  }
-  test() {
-    return this.report(new Error("The Flare client is set up correctly!"));
-  }
-  glow(name, level = "info", data = []) {
-    const time = now();
-    this.glows.push({
-      name,
-      message_level: level,
-      meta_data: data,
-      time,
-      microtime: time
-    });
-    if (this.glows.length > this.config.maxGlowsPerReport) {
-      this.glows = this.glows.slice(this.glows.length - this.config.maxGlowsPerReport);
-    }
-    return this;
-  }
-  clearGlows() {
-    this.glows = [];
-    return this;
-  }
-  addContext(name, value) {
-    this.context.context[name] = value;
-    return this;
-  }
-  addContextGroup(groupName, value) {
-    this.context[groupName] = value;
-    return this;
-  }
-  registerSolutionProvider(solutionProvider) {
-    if (!assertSolutionProvider(solutionProvider, this.config.debug)) {
-      return this;
-    }
-    this.solutionProviders.push(solutionProvider);
-    return this;
-  }
-  async report(error, context = {}, extraSolutionParameters = {}) {
-    const errorToReport = await this.config.beforeEvaluate(error);
-    if (!errorToReport) {
-      return;
-    }
-    const report = await this.createReportFromError(error, context, extraSolutionParameters);
-    if (!report) {
-      return;
-    }
-    return this.sendReport(report);
-  }
-  async reportMessage(message, context = {}, exceptionClass = "Log") {
-    const stackTrace = await createStackTrace(Error(), this.config.debug);
-    stackTrace.shift();
-    this.sendReport({
-      notifier: `Flare JavaScript client v${CLIENT_VERSION}`,
-      exception_class: exceptionClass,
-      seen_at: now(),
-      message,
-      language: "javascript",
-      glows: this.glows,
-      context: collectContext({ ...context, ...this.context }),
-      stacktrace: stackTrace,
-      sourcemap_version_id: this.config.sourcemapVersion,
-      solutions: [],
-      stage: this.config.stage
-    });
-  }
-  createReportFromError(error, context = {}, extraSolutionParameters = {}) {
-    if (!assert(error, "No error provided.", this.config.debug)) {
-      return Promise.resolve(false);
-    }
-    const seenAt = now();
-    return Promise.all([
-      getSolutions(this.solutionProviders, error, extraSolutionParameters),
-      createStackTrace(error, this.config.debug)
-    ]).then((result) => {
-      const [solutions, stacktrace] = result;
-      assert(stacktrace.length, "Couldn't generate stacktrace of this error: " + error, this.config.debug);
-      return {
-        notifier: `Flare JavaScript client v${CLIENT_VERSION}`,
-        exception_class: error.constructor && error.constructor.name ? error.constructor.name : "undefined",
-        seen_at: seenAt,
-        message: error.message,
-        language: "javascript",
-        glows: this.glows,
-        context: collectContext({ ...context, ...this.context }),
-        stacktrace,
-        sourcemap_version_id: this.config.sourcemapVersion,
-        solutions,
-        stage: this.config.stage
-      };
-    });
-  }
-  async sendReport(report) {
-    if (!assertKey(this.config.key, this.config.debug)) {
-      return;
-    }
-    const reportToSubmit = await this.config.beforeSubmit(report);
-    if (!reportToSubmit) {
-      return;
-    }
-    return this.http.report(
-      reportToSubmit,
-      this.config.reportingUrl,
-      this.config.key,
-      this.config.reportBrowserExtensionErrors
-    );
-  }
-  // Deprecated, the following methods exist for backwards compatibility.
-  set beforeEvaluate(beforeEvaluate) {
-    this.config.beforeEvaluate = beforeEvaluate ?? "";
-  }
-  set beforeSubmit(beforeSubmit) {
-    this.config.beforeSubmit = beforeSubmit ?? "";
-  }
-  set stage(stage) {
-    this.config.stage = stage ?? "";
-  }
+	_config = {
+		key: null,
+		version: "",
+		sourcemapVersionId: SOURCEMAP_VERSION,
+		stage: "",
+		maxGlowsPerReport: 30,
+		ingestUrl: "https://ingress.flareapp.io/v1/errors",
+		reportBrowserExtensionErrors: false,
+		debug: false,
+		urlDenylist: DEFAULT_URL_DENYLIST,
+		replaceDefaultUrlDenylist: false,
+		sampleRate: 1,
+		beforeEvaluate: (error) => error,
+		beforeSubmit: (report) => report
+	};
+	_glows = [];
+	pendingAttributes = {};
+	entryPoint = null;
+	sdkInfo = {
+		name: DEFAULT_SDK_NAME,
+		version: CLIENT_VERSION
+	};
+	framework = null;
+	constructor(api = new Api()) {
+		this.api = api;
+	}
+	get config() {
+		return this._config;
+	}
+	get glows() {
+		return this._glows;
+	}
+	light(key = KEY, debug) {
+		this._config.key = key;
+		if (debug !== void 0) this._config.debug = debug;
+		return this;
+	}
+	configure(config) {
+		this._config = {
+			...this._config,
+			...config
+		};
+		if (config.sampleRate !== void 0) this._config.sampleRate = Math.max(0, Math.min(1, config.sampleRate));
+		this._config.urlDenylist = resolveDenylist(config.urlDenylist, config.replaceDefaultUrlDenylist ?? this._config.replaceDefaultUrlDenylist);
+		return this;
+	}
+	async test() {
+		const report = await this.createReportFromError(/* @__PURE__ */ new Error("The Flare client is set up correctly!"));
+		if (!report) return;
+		return this.sendReport(report);
+	}
+	glow(name, level = "info", data = []) {
+		const time = now();
+		this._glows.push({
+			name,
+			messageLevel: level,
+			metaData: data,
+			time,
+			microtime: time
+		});
+		if (this._glows.length > this._config.maxGlowsPerReport) this._glows = this._glows.slice(this._glows.length - this._config.maxGlowsPerReport);
+		return this;
+	}
+	clearGlows() {
+		this._glows = [];
+		return this;
+	}
+	addContext(name, value) {
+		const existing = this.pendingAttributes["context.custom"] ?? {};
+		this.pendingAttributes["context.custom"] = {
+			...existing,
+			[name]: value
+		};
+		return this;
+	}
+	addContextGroup(groupName, value) {
+		this.pendingAttributes[`context.${groupName}`] = value;
+		return this;
+	}
+	setEntryPoint(handler) {
+		this.entryPoint = handler;
+		return this;
+	}
+	setSdkInfo(info) {
+		this.sdkInfo = info;
+		return this;
+	}
+	setFramework(framework) {
+		this.framework = framework;
+		return this;
+	}
+	async report(error, attributes = {}) {
+		if (this._config.sampleRate < 1 && Math.random() >= this._config.sampleRate) return;
+		const seenAtUnixNano = Date.now() * 1e6;
+		const coerced = error instanceof Error ? error : new Error(typeof error === "string" ? error : String(error));
+		const errorToReport = await this._config.beforeEvaluate(coerced);
+		if (!errorToReport) return;
+		const report = await this.createReportFromError(errorToReport, attributes, seenAtUnixNano);
+		if (!report) return;
+		return this.sendReport(report);
+	}
+	async reportUnhandledRejection(message, attributes = {}) {
+		if (Math.random() >= this._config.sampleRate) return;
+		const seenAtUnixNano = Date.now() * 1e6;
+		const report = this.buildReport({
+			exceptionClass: "UnhandledRejection",
+			message,
+			stacktrace: [],
+			isLog: false,
+			level: void 0,
+			extraAttributes: attributes,
+			code: void 0,
+			seenAtUnixNano
+		});
+		return this.sendReport(report);
+	}
+	async reportMessage(message, level, attributes = {}) {
+		if (this._config.sampleRate < 1 && Math.random() >= this._config.sampleRate) return;
+		const seenAtUnixNano = Date.now() * 1e6;
+		const stackTrace = await createStackTrace(/* @__PURE__ */ new Error(), this._config.debug);
+		stackTrace.shift();
+		const report = this.buildReport({
+			exceptionClass: "Log",
+			message,
+			stacktrace: stackTrace,
+			isLog: true,
+			level,
+			extraAttributes: attributes,
+			code: void 0,
+			seenAtUnixNano
+		});
+		return this.sendReport(report);
+	}
+	async createReportFromError(error, attributes = {}, seenAtUnixNano = Date.now() * 1e6) {
+		if (!assert(error, "No error provided.", this._config.debug)) return false;
+		const stacktrace = await createStackTrace(error, this._config.debug);
+		assert(stacktrace.length, "Couldn't generate stacktrace of this error: " + error, this._config.debug);
+		const exceptionClass = error.constructor && error.constructor.name ? error.constructor.name : "undefined";
+		return this.buildReport({
+			exceptionClass,
+			message: error.message,
+			stacktrace,
+			isLog: false,
+			level: void 0,
+			extraAttributes: attributes,
+			code: extractCode(error),
+			seenAtUnixNano
+		});
+	}
+	buildReport(input) {
+		const baseAttributes = {
+			"telemetry.sdk.language": "javascript",
+			"telemetry.sdk.name": this.sdkInfo.name,
+			"telemetry.sdk.version": this.sdkInfo.version,
+			"flare.language.name": "javascript",
+			"flare.entry_point.type": "web"
+		};
+		if (typeof window !== "undefined" && window?.location?.href) baseAttributes["flare.entry_point.value"] = redactFullPath(window.location.href, this._config.urlDenylist);
+		const handlerIdentifier = this.entryPoint?.identifier ?? (typeof window !== "undefined" && window?.location?.pathname ? window.location.pathname : void 0);
+		const handlerType = this.entryPoint?.type ?? (typeof window !== "undefined" && window ? "browser" : void 0);
+		if (handlerIdentifier !== void 0) baseAttributes["flare.entry_point.handler.identifier"] = handlerIdentifier;
+		if (handlerType !== void 0) baseAttributes["flare.entry_point.handler.type"] = handlerType;
+		if (this.entryPoint?.name !== void 0) baseAttributes["flare.entry_point.handler.name"] = this.entryPoint.name;
+		if (this.framework?.name) baseAttributes["flare.framework.name"] = this.framework.name;
+		if (this.framework?.version) baseAttributes["flare.framework.version"] = this.framework.version;
+		if (this._config.stage) baseAttributes["service.stage"] = this._config.stage;
+		if (this._config.version) baseAttributes["service.version"] = this._config.version;
+		const attributes = {
+			...baseAttributes,
+			...collectAttributes(this._config.urlDenylist),
+			...this.pendingAttributes,
+			...input.extraAttributes
+		};
+		const pendingCustom = this.pendingAttributes["context.custom"];
+		const extraCustom = input.extraAttributes["context.custom"];
+		if (pendingCustom && extraCustom && typeof pendingCustom === "object" && typeof extraCustom === "object" && !Array.isArray(pendingCustom) && !Array.isArray(extraCustom)) attributes["context.custom"] = {
+			...pendingCustom,
+			...extraCustom
+		};
+		const report = {
+			exceptionClass: input.exceptionClass,
+			message: input.message,
+			seenAtUnixNano: input.seenAtUnixNano,
+			stacktrace: input.stacktrace,
+			events: glowsToEvents(this._glows),
+			attributes
+		};
+		if (input.isLog) report.isLog = true;
+		if (input.level !== void 0) report.level = input.level;
+		if (this._config.sourcemapVersionId) report.sourcemapVersionId = this._config.sourcemapVersionId;
+		if (input.code !== void 0) report.code = input.code;
+		return report;
+	}
+	async sendReport(report) {
+		if (!assertKey(this._config.key, this._config.debug)) return;
+		const reportToSubmit = await this._config.beforeSubmit(report);
+		if (!reportToSubmit) return;
+		return this.api.report(reportToSubmit, this._config.ingestUrl, this._config.key, this._config.reportBrowserExtensionErrors, this._config.debug);
+	}
 };
 
-// src/browser/catchWindowErrors.ts
-function catchWindowErrors() {
-  if (typeof window === "undefined") {
-    return;
-  }
-  const flare2 = window.flare;
-  if (!window || !flare2) {
-    return;
-  }
-  const originalOnerrorHandler = window.onerror;
-  const originalOnunhandledrejectionHandler = window.onunhandledrejection;
-  window.onerror = (_1, _2, _3, _4, error) => {
-    if (error) {
-      flare2.report(error);
-    }
-    if (typeof originalOnerrorHandler === "function") {
-      originalOnerrorHandler(_1, _2, _3, _4, error);
-    }
-  };
-  window.onunhandledrejection = (error) => {
-    if (error.reason instanceof Error) {
-      flare2.report(error.reason);
-    }
-    if (typeof originalOnunhandledrejectionHandler === "function") {
-      originalOnunhandledrejectionHandler(error);
-    }
-  };
-}
-
-// src/index.ts
-var flare = new Flare();
+//#endregion
+//#region src/index.ts
+const flare = new Flare();
 if (typeof window !== "undefined" && window) {
-  window.flare = flare;
-  catchWindowErrors();
+	window.flare = flare;
+	catchWindowErrors();
 }
-export {
-  Flare,
-  flare
-};
+
+//#endregion
+export { DEFAULT_URL_DENYLIST, Flare, flare, redactFullPath, resolveDenylist };