@flareapp/core 2.2.0 → 2.2.1

package/dist/index.mjs

@@ -0,0 +1,760 @@
+import ErrorStackParser from "error-stack-parser";
+
+//#region src/env/index.ts
+const CLIENT_VERSION = typeof process !== "undefined" && true ? "2.2.1" : "?";
+const KEY = typeof FLARE_JS_KEY === "undefined" ? "" : FLARE_JS_KEY;
+const SOURCEMAP_VERSION = typeof FLARE_SOURCEMAP_VERSION === "undefined" ? "" : FLARE_SOURCEMAP_VERSION;
+
+//#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;
+}
+
+//#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);
+}
+
+//#endregion
+//#region src/util/convertToError.ts
+function convertToError(error) {
+	if (error instanceof Error) return error;
+	if (typeof error === "string") return new Error(error);
+	if (typeof error === "object" && error !== null) {
+		const obj = error;
+		const message = typeof obj.message === "string" ? obj.message : String(error);
+		const converted = new Error(message);
+		if (typeof obj.stack === "string") converted.stack = obj.stack;
+		if (typeof obj.name === "string") converted.name = obj.name;
+		return converted;
+	}
+	return new Error(String(error));
+}
+
+//#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);
+}
+
+//#endregion
+//#region src/util/flatJsonStringify.ts
+function flatJsonStringify(json) {
+	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);
+}
+
+//#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 ?? {}
+		}
+	}));
+}
+
+//#endregion
+//#region src/util/now.ts
+function now() {
+	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 redactUrlQuery(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;
+	}
+}
+
+//#endregion
+//#region src/api/Api.ts
+var Api = class {
+	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);
+		});
+	}
+};
+
+//#endregion
+//#region src/Scope.ts
+/**
+* Holds the per-call mutable state that used to live on the `Flare` instance:
+* breadcrumbs (`glows`), custom attributes (`pendingAttributes`), and the
+* current entry-point handler.
+*
+* Why this exists as its own class: in the browser there is one `Flare` per
+* page and one user at a time, so a single shared bag of state is fine. In
+* Node, a single `Flare` instance serves many concurrent requests, and each
+* request wants its own breadcrumbs and its own custom context that do NOT
+* leak into other requests. Splitting this state out of `Flare` lets the
+* consumer choose: one global `Scope` (browser) or one `Scope` per request
+* via AsyncLocalStorage (Node).
+*
+* `Flare` reads and writes this through `scopeProvider.active()` instead of
+* holding the state directly, so the per-request behavior comes from the
+* provider, not from the class itself.
+*
+* `NodeScope` (in `@flareapp/node`) extends this with two more buckets:
+* `request` (HTTP method, path, headers) and `user` (id, email, ...). Browser
+* does not need those.
+*/
+var Scope = class {
+	glows = [];
+	pendingAttributes = {};
+	entryPoint = null;
+	/**
+	* Append a breadcrumb. Caps the list at `maxGlowsPerReport` by dropping the
+	* OLDEST entries when the limit is exceeded; this keeps reports below a
+	* payload-size threshold while preserving the most recent events leading
+	* up to an error.
+	*
+	* `slice(length - max)` returns the trailing `max` items, which is the
+	* shortest way to drop from the front and keep insertion order.
+	*/
+	addGlow(glow, maxGlowsPerReport) {
+		this.glows.push(glow);
+		if (this.glows.length > maxGlowsPerReport) this.glows = this.glows.slice(this.glows.length - maxGlowsPerReport);
+	}
+	clearGlows() {
+		this.glows = [];
+	}
+	/**
+	* Set a single attribute on this scope. Called from `Flare.addContext` and
+	* `Flare.addContextGroup`. Last write wins.
+	*/
+	setAttribute(key, value) {
+		this.pendingAttributes[key] = value;
+	}
+	/**
+	* Shallow-merge a bag of attributes into this scope. Used by Node's
+	* AsyncLocalStorage provider when patching the live request context via
+	* `flare.mergeContext({ ... })`. Last write wins per key; nested objects
+	* are NOT deep-merged.
+	*/
+	mergeAttributes(partial) {
+		Object.assign(this.pendingAttributes, partial);
+	}
+};
+/**
+* The simplest provider: one `Scope` for the lifetime of the provider, shared
+* by every caller. This is the right default for environments with a single
+* logical context (browser tab, CLI script, etc.) and is the default that
+* `Flare`'s constructor falls back to when no provider is supplied.
+*/
+var GlobalScopeProvider = class {
+	scope = new Scope();
+	active() {
+		return this.scope;
+	}
+};
+
+//#endregion
+//#region src/stacktrace/fileReader.ts
+const cachedFiles = {};
+function getCodeSnippet(fileReader, 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(fileReader, 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 readFile(fileReader, url) {
+	if (cachedFiles[url] !== void 0) return Promise.resolve(cachedFiles[url]);
+	return fileReader.read(url).then((text) => {
+		if (text !== null) cachedFiles[url] = text;
+		return text;
+	});
+}
+function readLinesFromFile(fileText, lineNumber, columnNumber, maxSnippetLineLength = 1e3, maxSnippetLines = 40) {
+	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
+	};
+}
+
+//#endregion
+//#region src/stacktrace/createStackTrace.ts
+function createStackTrace(error, debug, fileReader) {
+	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(fileReader, 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) {
+	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;
+}
+
+//#endregion
+//#region src/stacktrace/NullFileReader.ts
+/**
+* No-op `FileReader` that returns `null` for every URL it is asked to read.
+*
+* Used as the default for `Flare`'s `fileReader` constructor parameter so the
+* class is usable without picking a side: instantiated bare (`new Flare()`),
+* reports still build, but stack frames omit source-code snippets — which is
+* the correct, safe behavior in an environment we know nothing about.
+*
+* The two real implementations live in the consumer packages and take their
+* place once the right environment is established:
+*
+* - `@flareapp/js` injects `FetchFileReader`, which `fetch()`s source maps
+*   and original files over HTTP for browser stack frames.
+* - `@flareapp/node` injects `DiskFileReader`, which reads files from disk
+*   via `node:fs/promises` for server stack frames.
+*
+* The interface (`read(url) -> Promise<string | null>`) lets the stack-trace
+* builder treat all three the same way: ask for a URL, render the snippet
+* when text comes back, gracefully skip it when `null` does. No environment
+* checks anywhere in core.
+*/
+var NullFileReader = class {
+	read(_url) {
+		return Promise.resolve(null);
+	}
+};
+
+//#endregion
+//#region src/Flare.ts
+const DEFAULT_SDK_NAME = "@flareapp/core";
+var Flare = class {
+	inflight = /* @__PURE__ */ new Set();
+	_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
+	};
+	sdkInfo = {
+		name: DEFAULT_SDK_NAME,
+		version: CLIENT_VERSION
+	};
+	framework = null;
+	/**
+	* @param api              sends the report over HTTP.
+	* @param contextCollector returns per-report attributes (browser DOM info, Node
+	*                         process info, etc). Default is a no-op.
+	* @param fileReader       reads source files for stack-trace snippets. Default
+	*                         returns null (no snippets); `@flareapp/js` injects a
+	*                         fetch-based reader, `@flareapp/node` injects a disk reader.
+	* @param scopeProvider    returns the current `Scope` (per-call mutable state:
+	*                         glows, pendingAttributes, entryPoint). Browser uses a
+	*                         single global scope; Node uses an AsyncLocalStorage-
+	*                         backed provider so each request gets its own.
+	*/
+	constructor(api = new Api(), contextCollector = () => ({}), fileReader = new NullFileReader(), scopeProvider = new GlobalScopeProvider()) {
+		this.api = api;
+		this.contextCollector = contextCollector;
+		this.fileReader = fileReader;
+		this.scopeProvider = scopeProvider;
+	}
+	/**
+	* Register an in-flight report so `flush()` can wait for it. Called by
+	* every public report entry point (`report`, `reportSilently`,
+	* `reportMessage`, `reportUnhandledRejection`, `test`); each wraps its
+	* full async pipeline (beforeEvaluate -> stack trace + source snippets ->
+	* beforeSubmit -> `api.report()`) so the entire roundtrip is what's
+	* tracked, not just the HTTP send at the end.
+	*
+	* Two problems this method solves at once.
+	*
+	* Problem 1: hold a reference to the work without leaking rejections.
+	*
+	*   `p` is the real report pipeline; it can reject (network failure,
+	*   `beforeSubmit` throws, etc). If we stored `p` directly in `inflight`
+	*   and no caller attached a `.catch` (the global error listeners use
+	*   `reportSilently` which DOES catch, but the path is still subtle), an
+	*   eventual rejection would surface as an unhandled-rejection warning
+	*   on Node and a console error in the browser. Bad citizen.
+	*
+	*   So we build a SHADOW promise that mirrors `p`'s timing but cannot
+	*   reject:
+	*
+	*     p.then(
+	*         () => undefined,   // on fulfilment, value is undefined
+	*         () => undefined,   // on rejection, ALSO resolve with undefined
+	*     )
+	*
+	*   Providing the second argument means we have "handled" any rejection
+	*   from `p`. The shadow always resolves with `undefined`, and `p`'s
+	*   rejection is consumed at the boundary. From the runtime's point of
+	*   view, the shadow is well-behaved.
+	*
+	* Problem 2: self-cleaning entry.
+	*
+	*   `tracked.finally(() => this.inflight.delete(tracked))`. `finally`
+	*   fires whether the shadow resolves or rejects, but the shadow can no
+	*   longer reject (problem 1 normalized it), so this is effectively
+	*   "when the underlying report has settled, remove me from the Set."
+	*   No GC magic, no external cleanup, no race window.
+	*
+	*   Note that `.finally` itself returns a new promise that we drop on
+	*   the floor. If the cleanup callback ever throws, that would surface
+	*   as an unhandled rejection on the dropped promise; `delete` does not
+	*   throw so we are safe today, but anything more elaborate added here
+	*   should be wrapped in try/catch.
+	*
+	* The return value is the ORIGINAL `p`. The caller awaits real success
+	* or failure; the tracking is completely invisible to them. This is why
+	* `await flare.report(err)` inside a fatal handler observes network
+	* errors the same as before tracking was added.
+	*/
+	track(p) {
+		const tracked = p.then(() => void 0, () => void 0);
+		this.inflight.add(tracked);
+		tracked.finally(() => this.inflight.delete(tracked));
+		return p;
+	}
+	/**
+	* Wait until every in-flight report settles, or until `timeoutMs`
+	* elapses, whichever comes first. Always resolves; never rejects.
+	*
+	* The main consumer is `@flareapp/node`'s fatal handler:
+	*
+	*     process.on('uncaughtException', async (err) => {
+	*         process.exitCode = 1;
+	*         try { await flare.report(err); } catch {}
+	*         await flare.flush(shutdownTimeoutMs);
+	*         process.exit(1);
+	*     });
+	*
+	* The fatal `report` is awaited explicitly; `flush` then drains any
+	* OTHER reports that were already in flight (a request handler that
+	* fired `flare.report(...)` concurrently with the crash). The timeout
+	* caps the wait so a hung HTTP request cannot indefinitely block
+	* shutdown.
+	*
+	* Walking the implementation:
+	*
+	*   const pending = [...this.inflight];
+	*
+	*     Spread takes a SNAPSHOT of the Set at this instant. Reports that
+	*     start AFTER this line are not included in `pending`, so they are
+	*     not awaited by THIS flush call. This is intentional: it bounds
+	*     the wait. Without the snapshot, a handler that kept emitting
+	*     reports during shutdown could keep flush alive forever and block
+	*     the process from exiting.
+	*
+	*   if (pending.length === 0) return Promise.resolve();
+	*
+	*     Fast path. No timer scheduled, no promise constructor needed.
+	*     Resolves on the microtask queue. Cheap.
+	*
+	*   return new Promise<void>((resolve) => {
+	*       const timer = setTimeout(resolve, timeoutMs);
+	*       Promise.allSettled(pending).then(() => {
+	*           clearTimeout(timer);
+	*           resolve();
+	*       });
+	*   });
+	*
+	*     The race between two outcomes, both calling the same `resolve`:
+	*
+	*     1. `setTimeout(resolve, timeoutMs)` schedules a "give up" call.
+	*        After `timeoutMs` it fires, calling `resolve()` from the
+	*        timer-queue side. The outer promise resolves immediately,
+	*        even if reports are still pending. Those reports are abandoned
+	*        (they continue running but the process is about to die).
+	*
+	*     2. `Promise.allSettled(pending)` returns a promise that resolves
+	*        when every promise in `pending` has either fulfilled or
+	*        rejected. It NEVER rejects on its own. We use `allSettled`
+	*        rather than `Promise.all` because `all` short-circuits on the
+	*        first rejection -- we want to wait for everyone regardless of
+	*        whether their HTTP calls succeed or fail. (Our shadows cannot
+	*        reject anyway because `track` normalized them, but using
+	*        `allSettled` documents the intent and survives future changes
+	*        to shadow construction.) When it resolves, we call
+	*        `clearTimeout(timer)` to cancel the pending timer (so it does
+	*        not fire later and call `resolve` a second time -- a no-op,
+	*        but wasted work) and then `resolve()` ourselves.
+	*
+	*   Resolve can only meaningfully fire once. Subsequent calls to the
+	*   same `resolve` are silently ignored by the Promise spec, so the
+	*   race is safe even if for some reason both branches fired together.
+	*
+	* Things flush() deliberately does NOT do:
+	*
+	*   - It does not reject. Even if every report failed, allSettled
+	*     resolves. Callers do not need a `.catch`.
+	*   - It does not retry. One pipeline attempt per report, then move on.
+	*   - It does not stop new reports from starting. The Flare instance
+	*     is still usable after flush resolves. flush is "wait for what is
+	*     in flight," not "freeze the SDK."
+	*   - It does not drain reports started after the snapshot. Call flush
+	*     again if you need to wait for those too.
+	*/
+	flush(timeoutMs = 2e3) {
+		const pending = [...this.inflight];
+		if (pending.length === 0) return Promise.resolve();
+		return new Promise((resolve) => {
+			const timer = setTimeout(resolve, timeoutMs);
+			Promise.allSettled(pending).then(() => {
+				clearTimeout(timer);
+				resolve();
+			});
+		});
+	}
+	get config() {
+		return this._config;
+	}
+	get glows() {
+		return this.scopeProvider.active().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;
+	}
+	test() {
+		return this.track(this.testInternal());
+	}
+	async testInternal() {
+		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.scopeProvider.active().addGlow({
+			name,
+			messageLevel: level,
+			metaData: data,
+			time,
+			microtime: time
+		}, this._config.maxGlowsPerReport);
+		return this;
+	}
+	clearGlows() {
+		this.scopeProvider.active().clearGlows();
+		return this;
+	}
+	addContext(name, value) {
+		const scope = this.scopeProvider.active();
+		const existing = scope.pendingAttributes["context.custom"] ?? {};
+		scope.setAttribute("context.custom", {
+			...existing,
+			[name]: value
+		});
+		return this;
+	}
+	addContextGroup(groupName, value) {
+		this.scopeProvider.active().setAttribute(`context.${groupName}`, value);
+		return this;
+	}
+	setEntryPoint(handler) {
+		this.scopeProvider.active().entryPoint = handler;
+		return this;
+	}
+	setSdkInfo(info) {
+		this.sdkInfo = info;
+		return this;
+	}
+	setFramework(framework) {
+		this.framework = framework;
+		return this;
+	}
+	report(error, attributes = {}) {
+		return this.track(this.reportInternal(error, attributes));
+	}
+	async reportInternal(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);
+	}
+	reportSilently(error, attributes = {}) {
+		this.track(this.reportInternal(error, attributes).catch(() => {}));
+	}
+	reportUnhandledRejection(message, attributes = {}) {
+		return this.track(this.reportUnhandledRejectionInternal(message, attributes));
+	}
+	async reportUnhandledRejectionInternal(message, attributes = {}) {
+		if (this._config.sampleRate < 1 && 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);
+	}
+	reportMessage(message, level, attributes = {}) {
+		return this.track(this.reportMessageInternal(message, level, attributes));
+	}
+	async reportMessageInternal(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, this.fileReader);
+		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, this.fileReader);
+		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 activeScope = this.scopeProvider.active();
+		const baseAttributes = {
+			"telemetry.sdk.language": "javascript",
+			"telemetry.sdk.name": this.sdkInfo.name,
+			"telemetry.sdk.version": this.sdkInfo.version,
+			"flare.language.name": "javascript"
+		};
+		if (this._config.stage) baseAttributes["service.stage"] = this._config.stage;
+		if (this._config.version) baseAttributes["service.version"] = this._config.version;
+		if (this.framework?.name) baseAttributes["flare.framework.name"] = this.framework.name;
+		if (this.framework?.version) baseAttributes["flare.framework.version"] = this.framework.version;
+		const entryPoint = activeScope.entryPoint;
+		const entryPointOverrides = {};
+		if (entryPoint?.identifier !== void 0) entryPointOverrides["flare.entry_point.handler.identifier"] = entryPoint.identifier;
+		if (entryPoint?.type !== void 0) entryPointOverrides["flare.entry_point.handler.type"] = entryPoint.type;
+		if (entryPoint?.name !== void 0) entryPointOverrides["flare.entry_point.handler.name"] = entryPoint.name;
+		const attributes = {
+			...baseAttributes,
+			...this.contextCollector(this._config),
+			...entryPointOverrides,
+			...activeScope.pendingAttributes,
+			...input.extraAttributes
+		};
+		const pendingCustom = activeScope.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
+		};
+		if (this.framework?.name) attributes["context.custom"] = {
+			...attributes["context.custom"] ?? {},
+			framework: this.framework.name.toLowerCase()
+		};
+		const report = {
+			exceptionClass: input.exceptionClass,
+			message: input.message,
+			seenAtUnixNano: input.seenAtUnixNano,
+			stacktrace: input.stacktrace,
+			events: glowsToEvents(activeScope.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);
+	}
+};
+
+//#endregion
+export { Api, DEFAULT_URL_DENYLIST, Flare, GlobalScopeProvider, NullFileReader, Scope, assert, assertKey, convertToError, createStackTrace, extractCode, flatJsonStringify, getCodeSnippet, glowsToEvents, now, readLinesFromFile, redactUrlQuery, resolveDenylist };