@monocle.sh/adonisjs-agent 1.0.0-beta.10

package/dist/monocle_provider.d.mts

@@ -0,0 +1,19 @@
+import { ApplicationService } from "@adonisjs/core/types";
+
+//#region providers/monocle_provider.d.ts
+/**
+ * Stolen from @Adonisjs/otel to use another config filename. we need to expose this
+ * option from @adonis/otel so we can remove this file in the future.
+ */
+declare class OtelProvider {
+  #private;
+  protected app: ApplicationService;
+  constructor(app: ApplicationService);
+  register(): void;
+  /**
+   * Gracefully flush pending spans
+   */
+  shutdown(): Promise<void>;
+}
+//#endregion
+export { OtelProvider as default };

package/dist/monocle_provider.mjs

@@ -0,0 +1,66 @@
+import { ExceptionReporter, toHttpError } from "./src/exception_reporter.mjs";
+import { getCurrentSpan } from "@adonisjs/otel/helpers";
+import OtelMiddleware from "@adonisjs/otel/otel_middleware";
+import { OtelManager } from "@adonisjs/otel";
+import { ExceptionHandler } from "@adonisjs/core/http";
+import { configProvider } from "@adonisjs/core";
+
+//#region providers/monocle_provider.ts
+/**
+* Stolen from @Adonisjs/otel to use another config filename. we need to expose this
+* option from @adonis/otel so we can remove this file in the future.
+*/
+var OtelProvider = class {
+	constructor(app) {
+		this.app = app;
+	}
+	/**
+	* Hook into ExceptionHandler to record exceptions in spans.
+	*
+	* We always record the exception on the span (for trace visibility), but we also
+	* add an attribute `monocle.exception.should_report` to indicate whether this
+	* exception should appear in the Exceptions dashboard.
+	*
+	* This respects the AdonisJS `ignoreExceptions`, `ignoreStatuses`, and `ignoreCodes`
+	* configuration from the ExceptionHandler.
+	*/
+	#registerExceptionHandler() {
+		const originalReport = ExceptionHandler.prototype.report;
+		const reporter = new ExceptionReporter();
+		ExceptionHandler.macro("report", async function(error, ctx) {
+			const span = getCurrentSpan();
+			if (span) {
+				const httpError = toHttpError(error);
+				const shouldReport = this.shouldReport(httpError);
+				await reporter.report({
+					span,
+					error,
+					shouldReport
+				});
+			}
+			return originalReport.call(this, error, ctx);
+		});
+	}
+	register() {
+		this.#registerExceptionHandler();
+		this.#registerMiddleware();
+	}
+	/**
+	* Register the OtelMiddleware as a singleton in the container
+	*/
+	#registerMiddleware() {
+		this.app.container.singleton(OtelMiddleware, async () => {
+			const otelConfigProvider = this.app.config.get("monocle", {});
+			return new OtelMiddleware({ userContext: (await configProvider.resolve(this.app, otelConfigProvider))?.userContext });
+		});
+	}
+	/**
+	* Gracefully flush pending spans
+	*/
+	async shutdown() {
+		await OtelManager.getInstance()?.shutdown();
+	}
+};
+
+//#endregion
+export { OtelProvider as default };

package/dist/src/cli_instrumentation.mjs

@@ -0,0 +1,127 @@
+import { ExceptionReporter } from "./exception_reporter.mjs";
+import { createRequire } from "node:module";
+import { SpanKind, context, trace } from "@opentelemetry/api";
+
+//#region src/cli_instrumentation.ts
+/**
+* Default commands to exclude from tracing.
+* These are typically scaffolding commands or long-running workers.
+*/
+const DEFAULT_EXCLUDE = [
+	"make:*",
+	"generate:*",
+	"queue:work",
+	"queue:listen"
+];
+/**
+* Simple glob pattern matcher supporting only '*' wildcard
+*/
+function matchPattern(commandName, pattern) {
+	if (pattern === "*") return true;
+	if (!pattern.includes("*")) return commandName === pattern;
+	const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+	return new RegExp(`^${escaped.replace(/\*/g, ".*")}$`).test(commandName);
+}
+/**
+* Extract command arguments from the instance
+*/
+function extractArgs(command) {
+	const argsDef = command.constructor.args;
+	if (!argsDef || !Array.isArray(argsDef)) return {};
+	const result = {};
+	for (const arg of argsDef) {
+		const value = command[arg.name];
+		if (value !== void 0 && value !== null) result[arg.argumentName] = String(value);
+	}
+	return result;
+}
+/**
+* Extract command flags from the instance
+*/
+function extractFlags(command) {
+	const flagsDef = command.constructor.flags;
+	if (!flagsDef || !Array.isArray(flagsDef)) return {};
+	const result = {};
+	for (const flag of flagsDef) {
+		const value = command[flag.name];
+		if (value !== void 0 && value !== null && value !== false) result[flag.flagName] = String(value);
+	}
+	return result;
+}
+/**
+* Check if a command should be traced based on include/exclude patterns
+*/
+function shouldTraceCommand(commandName, config) {
+	if ((config.exclude ?? DEFAULT_EXCLUDE).some((pattern) => matchPattern(commandName, pattern))) return false;
+	if (config.include && config.include.length > 0) return config.include.some((pattern) => matchPattern(commandName, pattern));
+	return true;
+}
+/**
+* Instrument AdonisJS Ace CLI commands with OpenTelemetry tracing.
+*
+* Uses monkey-patching of BaseCommand.prototype.exec to wrap command
+* execution with an active OTEL span context. This ensures all child
+* spans created during command execution are properly linked to the
+* CLI command span.
+*
+* @param config - CLI tracing configuration
+* @param appRoot - Application root directory path
+*/
+async function instrumentCliCommands(config, appRoot) {
+	const tracer = trace.getTracer("@monocle.sh/adonisjs-agent", "1.0.0");
+	const BaseCommand = (await import(createRequire(appRoot ? `file://${appRoot}/package.json` : import.meta.url).resolve("@adonisjs/core/ace"))).BaseCommand;
+	const originalExec = BaseCommand.prototype.exec;
+	BaseCommand.prototype.exec = async function() {
+		const commandName = this.constructor.commandName;
+		const commandDescription = this.constructor.description;
+		if (!shouldTraceCommand(commandName, config)) return originalExec.call(this);
+		const args = extractArgs(this);
+		const flags = extractFlags(this);
+		const attributes = {
+			"entry_point.type": "cli",
+			"cli.command.name": commandName,
+			"cli.command.description": commandDescription || ""
+		};
+		for (const [key, value] of Object.entries(args)) attributes[`cli.args.${key}`] = value;
+		for (const [key, value] of Object.entries(flags)) attributes[`cli.flags.${key}`] = value;
+		const span = tracer.startSpan(`cli ${commandName}`, {
+			kind: SpanKind.INTERNAL,
+			attributes
+		});
+		const ctx = trace.setSpan(context.active(), span);
+		/**
+		* CRITICAL: Execute within context.with()
+		*
+		* This is what makes child spans work! Without this wrapper:
+		* - Child spans would have no parent
+		* - All spans would be root spans with different traceIds
+		* - The trace would be fragmented
+		*
+		* context.with() sets our span as the "active" span for all async
+		* operations within the callback, enabling proper trace propagation.
+		*/
+		return context.with(ctx, async () => {
+			try {
+				const result = await originalExec.call(this);
+				if (this.error) await new ExceptionReporter().report({
+					span,
+					error: this.error,
+					shouldReport: true
+				});
+				return result;
+			} catch (error) {
+				await new ExceptionReporter().report({
+					span,
+					error,
+					shouldReport: true
+				});
+				throw error;
+			} finally {
+				span.end();
+			}
+		});
+	};
+}
+
+//#endregion
+export { instrumentCliCommands };

package/dist/src/context_lines.mjs

@@ -0,0 +1,269 @@
+import { MAX_CAUSE_DEPTH, getErrorCause, isErrorLike } from "./error_serializer.mjs";
+import { createInterface } from "node:readline";
+import { createReadStream } from "node:fs";
+import { parseStack } from "error-stack-parser-es/lite";
+
+//#region src/context_lines.ts
+const DEFAULT_CONTEXT_LINES = 7;
+const MAX_LINENO = 1e4;
+const MAX_COLNO = 1e3;
+const MAX_LINE_LENGTH = 200;
+const FILE_CACHE_SIZE = 10;
+const FAILED_CACHE_SIZE = 20;
+/**
+* Simple LRU cache implementation.
+*/
+var LRUCache = class {
+	#maxSize;
+	#cache = /* @__PURE__ */ new Map();
+	constructor(maxSize) {
+		this.#maxSize = maxSize;
+	}
+	get(key) {
+		const value = this.#cache.get(key);
+		if (value === void 0) return void 0;
+		this.#cache.delete(key);
+		this.#cache.set(key, value);
+		return value;
+	}
+	set(key, value) {
+		this.#cache.delete(key);
+		if (this.#cache.size >= this.#maxSize) {
+			const oldestKey = this.#cache.keys().next().value;
+			if (oldestKey !== void 0) this.#cache.delete(oldestKey);
+		}
+		this.#cache.set(key, value);
+	}
+	has(key) {
+		return this.#cache.has(key);
+	}
+	clear() {
+		this.#cache.clear();
+	}
+};
+const fileCache = new LRUCache(FILE_CACHE_SIZE);
+const failedCache = new LRUCache(FAILED_CACHE_SIZE);
+/**
+* Normalize file path by stripping file:// protocol.
+*/
+function normalizeFilePath(path) {
+	if (path.startsWith("file://")) return path.slice(7);
+	return path;
+}
+/**
+* Check if a file should be skipped for context extraction.
+*/
+function shouldSkipFile(path) {
+	if (path.startsWith("node:")) return true;
+	if (path.startsWith("data:")) return true;
+	if (path.endsWith(".min.js")) return true;
+	if (path.endsWith(".min.cjs")) return true;
+	if (path.endsWith(".min.mjs")) return true;
+	if (path.includes("/node_modules/")) return true;
+	return false;
+}
+/**
+* Check if a frame should be skipped based on line/column numbers.
+*/
+function shouldSkipFrame(frame) {
+	if (frame.line === void 0) return true;
+	if (frame.line > MAX_LINENO) return true;
+	if (frame.col !== void 0 && frame.col > MAX_COLNO) return true;
+	return false;
+}
+/**
+* Check if a frame is from the application code (not node_modules).
+*/
+function isInApp(filename) {
+	return !filename.includes("/node_modules/");
+}
+/**
+* Truncate long lines to prevent huge payloads.
+*/
+function snipLine(line) {
+	if (line.length <= MAX_LINE_LENGTH) return line;
+	return line.slice(0, MAX_LINE_LENGTH) + "...";
+}
+/**
+* Create context range around a line number.
+*/
+function makeContextRange(lineno, contextLines) {
+	return [Math.max(1, lineno - contextLines), lineno + contextLines];
+}
+/**
+* Merge overlapping line ranges for efficient file reading.
+*/
+function mergeRanges(ranges) {
+	if (ranges.length === 0) return [];
+	const sorted = [...ranges].sort((a, b) => a[0] - b[0]);
+	const merged = [sorted[0]];
+	for (let i = 1; i < sorted.length; i++) {
+		const current = sorted[i];
+		const last = merged[merged.length - 1];
+		if (current[0] <= last[1] + 1) last[1] = Math.max(last[1], current[1]);
+		else merged.push(current);
+	}
+	return merged;
+}
+/**
+* Read specific line ranges from a file.
+* Follows Sentry's battle-tested patterns for stream handling.
+*/
+async function readFileLines(filepath, ranges) {
+	return new Promise((resolve) => {
+		const output = {};
+		let resolved = false;
+		const stream = createReadStream(filepath);
+		const lineReader = createInterface({ input: stream });
+		function destroyStreamAndResolve() {
+			if (resolved) return;
+			resolved = true;
+			stream.destroy();
+			resolve(output);
+		}
+		if (ranges.length === 0) {
+			destroyStreamAndResolve();
+			return;
+		}
+		let lineNumber = 0;
+		let currentRangeIndex = 0;
+		let rangeStart = ranges[0][0];
+		let rangeEnd = ranges[0][1];
+		function onStreamError() {
+			failedCache.set(filepath, true);
+			lineReader.close();
+			lineReader.removeAllListeners();
+			destroyStreamAndResolve();
+		}
+		stream.on("error", onStreamError);
+		lineReader.on("error", onStreamError);
+		lineReader.on("close", destroyStreamAndResolve);
+		lineReader.on("line", (line) => {
+			try {
+				lineNumber++;
+				if (lineNumber < rangeStart) return;
+				output[lineNumber] = snipLine(line);
+				if (lineNumber >= rangeEnd) {
+					if (currentRangeIndex === ranges.length - 1) {
+						lineReader.close();
+						lineReader.removeAllListeners();
+						return;
+					}
+					currentRangeIndex++;
+					const nextRange = ranges[currentRangeIndex];
+					rangeStart = nextRange[0];
+					rangeEnd = nextRange[1];
+				}
+			} catch {}
+		});
+	});
+}
+/**
+* Extract context lines for a stack trace.
+*/
+async function extractContextLines(stack, contextLines = DEFAULT_CONTEXT_LINES) {
+	const parsedFrames = parseStack(stack);
+	const framesToEnrich = [];
+	for (const frame of parsedFrames) {
+		if (!frame.file || !frame.line) continue;
+		const filepath = normalizeFilePath(frame.file);
+		if (shouldSkipFile(filepath)) continue;
+		if (shouldSkipFrame(frame)) continue;
+		const range = makeContextRange(frame.line, contextLines);
+		framesToEnrich.push({
+			frame,
+			filepath,
+			range
+		});
+	}
+	if (framesToEnrich.length === 0) return [];
+	const fileToRanges = /* @__PURE__ */ new Map();
+	for (const { filepath, range } of framesToEnrich) {
+		const existing = fileToRanges.get(filepath) || [];
+		existing.push(range);
+		fileToRanges.set(filepath, existing);
+	}
+	const readPromises = [];
+	for (const [filepath, ranges] of fileToRanges) {
+		if (failedCache.has(filepath)) continue;
+		const cachedContent = fileCache.get(filepath);
+		const mergedRanges = mergeRanges(ranges);
+		if (cachedContent && mergedRanges.every(([start, end]) => {
+			for (let i = start; i <= end; i++) if (cachedContent[i] === void 0) return false;
+			return true;
+		})) continue;
+		readPromises.push(readFileLines(filepath, mergedRanges).then((lines) => {
+			const existing = fileCache.get(filepath) || {};
+			fileCache.set(filepath, {
+				...existing,
+				...lines
+			});
+		}));
+	}
+	await Promise.all(readPromises).catch(() => {});
+	const enrichedFrames = [];
+	for (const { frame, filepath, range } of framesToEnrich) {
+		const fileContent = fileCache.get(filepath);
+		if (!fileContent) continue;
+		const [rangeStart, rangeEnd] = range;
+		const preContext = [];
+		const postContext = [];
+		for (let i = rangeStart; i < frame.line; i++) {
+			const line = fileContent[i];
+			if (line !== void 0) preContext.push(line);
+		}
+		const contextLine = fileContent[frame.line];
+		if (contextLine === void 0) continue;
+		for (let i = frame.line + 1; i <= rangeEnd; i++) {
+			const line = fileContent[i];
+			if (line !== void 0) postContext.push(line);
+		}
+		enrichedFrames.push({
+			filename: filepath,
+			lineno: frame.line,
+			colno: frame.col,
+			function: frame.function,
+			in_app: isInApp(filepath),
+			pre_context: preContext,
+			context_line: contextLine,
+			post_context: postContext
+		});
+	}
+	return enrichedFrames;
+}
+/**
+* Build a cause chain with context lines for each cause.
+* This extracts context lines from each error's stack trace.
+*/
+async function buildCauseChainWithContext(error, contextLines = DEFAULT_CONTEXT_LINES) {
+	return _buildCauseChainWithContext(error, /* @__PURE__ */ new Set(), 0, contextLines);
+}
+async function _buildCauseChainWithContext(err, seen, depth, contextLines) {
+	if (!isErrorLike(err)) return [];
+	if (depth >= MAX_CAUSE_DEPTH) return [{
+		type: "Error",
+		message: "(max cause depth reached)"
+	}];
+	if (seen.has(err)) return [{
+		type: "Error",
+		message: "(circular reference detected)"
+	}];
+	seen.add(err);
+	let frames;
+	if (err.stack) try {
+		const extracted = await extractContextLines(err.stack, contextLines);
+		if (extracted.length > 0) frames = extracted;
+	} catch {}
+	const current = {
+		type: err.name || "Error",
+		message: err.message || "",
+		stack: err.stack,
+		frames
+	};
+	const cause = getErrorCause(err);
+	if (cause) return [current, ...await _buildCauseChainWithContext(cause, seen, depth + 1, contextLines)];
+	return [current];
+}
+
+//#endregion
+export { buildCauseChainWithContext, extractContextLines };

package/dist/src/define_config.d.mts

@@ -0,0 +1,11 @@
+import { MonocleConfig } from "./types.mjs";
+
+//#region src/define_config.d.ts
+/**
+ * Define and validate Monocle agent configuration.
+ * Sets up environment variables for OTEL exporters to point to Monocle.
+ * Returns undefined if no API key is provided (telemetry will be disabled).
+ */
+declare function defineConfig(config: MonocleConfig): MonocleConfig | undefined;
+//#endregion
+export { defineConfig };

package/dist/src/define_config.mjs

@@ -0,0 +1,72 @@
+//#region src/define_config.ts
+/**
+* Extracts a header value from either ServerResponse (getHeader) or IncomingMessage (headers object).
+*/
+function getHeader(response, name) {
+	if ("getHeader" in response && typeof response.getHeader === "function") {
+		const value = response.getHeader(name);
+		if (typeof value === "string") return value;
+	}
+	if ("headers" in response && response.headers) {
+		const value = response.headers[name];
+		if (typeof value === "string") return value;
+	}
+}
+/**
+* Detects the connection type based on response headers.
+* Returns 'sse' for Server-Sent Events, 'websocket' for WebSocket upgrades,
+* or undefined for standard HTTP connections.
+*/
+function detectConnectionType(response) {
+	if (getHeader(response, "content-type")?.includes("text/event-stream")) return "sse";
+	if (getHeader(response, "upgrade")?.toLowerCase() === "websocket") return "websocket";
+}
+/**
+* Creates a response hook that detects long-running HTTP connections
+* (SSE and WebSocket) and adds the `http.connection_type` attribute.
+*/
+function createConnectionTypeHook(userHook) {
+	return (span, response) => {
+		const connectionType = detectConnectionType(response);
+		if (connectionType) span.setAttribute("http.connection_type", connectionType);
+		userHook?.(span, response);
+	};
+}
+/**
+* Extracts the user-defined response hook from HTTP instrumentation config.
+*/
+function extractUserResponseHook(httpConfig) {
+	if (typeof httpConfig !== "object" || httpConfig === null) return;
+	if (!("responseHook" in httpConfig)) return;
+	return httpConfig.responseHook;
+}
+/**
+* Define and validate Monocle agent configuration.
+* Sets up environment variables for OTEL exporters to point to Monocle.
+* Returns undefined if no API key is provided (telemetry will be disabled).
+*/
+function defineConfig(config) {
+	if (!config.apiKey) return;
+	const endpoint = config.endpoint || "https://ingest.monocle.sh";
+	const environment = config.environment || process.env.NODE_ENV || "development";
+	process.env.OTEL_EXPORTER_OTLP_ENDPOINT = endpoint;
+	process.env.OTEL_EXPORTER_OTLP_HEADERS = `x-api-key=${config.apiKey},x-monocle-env=${environment}`;
+	const httpConfig = config.instrumentations?.["@opentelemetry/instrumentation-http"];
+	const userResponseHook = extractUserResponseHook(httpConfig);
+	const instrumentations = {
+		...config.instrumentations,
+		"@opentelemetry/instrumentation-http": {
+			...typeof httpConfig === "object" && httpConfig !== null ? httpConfig : {},
+			responseHook: createConnectionTypeHook(userResponseHook)
+		}
+	};
+	return {
+		...config,
+		endpoint,
+		environment,
+		instrumentations
+	};
+}
+
+//#endregion
+export { defineConfig };

package/dist/src/error_serializer.mjs

@@ -0,0 +1,77 @@
+//#region src/error_serializer.ts
+/**
+* Maximum number of causes to capture (prevents infinite loops).
+*/
+const MAX_CAUSE_DEPTH = 5;
+/**
+* Check if a value is error-like (has a message property).
+*/
+function isErrorLike(err) {
+	return err != null && typeof err.message === "string";
+}
+/**
+* Safely extract the cause from an error.
+* Handles both standard Error.cause and VError-style cause() functions.
+*/
+function getErrorCause(err) {
+	if (!err) return void 0;
+	const cause = err.cause;
+	if (typeof cause === "function") {
+		const causeResult = cause();
+		return isErrorLike(causeResult) ? causeResult : void 0;
+	}
+	return isErrorLike(cause) ? cause : void 0;
+}
+/**
+* Build a combined stack trace from an error and all its causes.
+* Format:
+*   Error: Top-level message
+*       at file.js:10:5
+*   caused by: Error: Mid-level message
+*       at file.js:20:3
+*/
+function stackWithCauses(err) {
+	return _stackWithCauses(err, /* @__PURE__ */ new Set());
+}
+function _stackWithCauses(err, seen) {
+	if (!isErrorLike(err)) return "";
+	const stack = err.stack || "";
+	if (seen.has(err)) return stack + "\ncauses have become circular...";
+	const cause = getErrorCause(err);
+	if (cause) {
+		seen.add(err);
+		return stack + "\ncaused by: " + _stackWithCauses(cause, seen);
+	}
+	return stack;
+}
+/**
+* Build a structured cause chain from an error.
+* Returns an array of { type, message, stack } objects.
+* Limited to MAX_CAUSE_DEPTH to prevent infinite loops.
+*/
+function buildCauseChain(err) {
+	return _buildCauseChain(err, /* @__PURE__ */ new Set(), 0);
+}
+function _buildCauseChain(err, seen, depth) {
+	if (!isErrorLike(err)) return [];
+	if (depth >= MAX_CAUSE_DEPTH) return [{
+		type: "Error",
+		message: "(max cause depth reached)"
+	}];
+	if (seen.has(err)) return [{
+		type: "Error",
+		message: "(circular reference detected)"
+	}];
+	seen.add(err);
+	const current = {
+		type: err.name || "Error",
+		message: err.message || "",
+		stack: err.stack
+	};
+	const cause = getErrorCause(err);
+	if (cause) return [current, ..._buildCauseChain(cause, seen, depth + 1)];
+	return [current];
+}
+
+//#endregion
+export { MAX_CAUSE_DEPTH, buildCauseChain, getErrorCause, isErrorLike, stackWithCauses };

package/dist/src/exception_reporter.mjs

@@ -0,0 +1,52 @@
+import { buildCauseChain, stackWithCauses } from "./error_serializer.mjs";
+import { buildCauseChainWithContext } from "./context_lines.mjs";
+import { SpanStatusCode } from "@opentelemetry/api";
+import is from "@sindresorhus/is";
+
+//#region src/exception_reporter.ts
+const DEFAULT_CONTEXT_LINES = 7;
+/**
+* Convert any unknown error to an HttpError-like object.
+*/
+function toHttpError(error) {
+	const httpError = is.object(error) ? error : new Error(String(error));
+	if (!httpError.message) httpError.message = "Internal server error";
+	if (!httpError.status) httpError.status = 500;
+	return httpError;
+}
+/**
+* Reports exceptions to OpenTelemetry spans with context lines and cause chains.
+*/
+var ExceptionReporter = class {
+	/**
+	* Report an exception on the given span.
+	*/
+	async report(options) {
+		const { span, shouldReport, contextLines = DEFAULT_CONTEXT_LINES } = options;
+		const error = toHttpError(options.error);
+		span.setStatus({
+			code: SpanStatusCode.ERROR,
+			message: error.message
+		});
+		span.setAttribute("monocle.exception.should_report", shouldReport);
+		const causeChain = shouldReport ? await buildCauseChainWithContext(error, contextLines) : buildCauseChain(error);
+		const attributes = this.#buildAttributes(error, causeChain);
+		span.addEvent("exception", attributes);
+	}
+	#buildAttributes(error, causeChain) {
+		const hasCauses = causeChain.length > 1;
+		const attributes = {
+			"exception.type": error.name || "Error",
+			"exception.message": error.message || "",
+			"exception.stacktrace": hasCauses ? stackWithCauses(error) : error.stack || ""
+		};
+		const actualCauses = causeChain.slice(1);
+		if (actualCauses.length > 0) attributes["monocle.exception.cause_chain"] = JSON.stringify(actualCauses);
+		const mainFrames = causeChain[0]?.frames;
+		if (mainFrames && mainFrames.length > 0) attributes["monocle.exception.frames"] = JSON.stringify(mainFrames);
+		return attributes;
+	}
+};
+
+//#endregion
+export { ExceptionReporter, toHttpError };