@monocle.sh/adonisjs-agent 1.0.0-beta.6 → 1.0.0-beta.8

package/dist/monocle_provider.mjs

@@ -1,6 +1,5 @@
-import { recordExceptionWithContext } from "./src/context_lines.mjs";
+import { ExceptionReporter, toHttpError } from "./src/exception_reporter.mjs";
 import { getCurrentSpan } from "@adonisjs/otel/helpers";
-import is from "@sindresorhus/is";
 import OtelMiddleware from "@adonisjs/otel/otel_middleware";
 import { OtelManager } from "@adonisjs/otel";
 import { ExceptionHandler } from "@adonisjs/core/http";
@@ -16,15 +15,6 @@ var OtelProvider = class {
 		this.app = app;
 	}
 	/**
-	* Convert any error to an HttpError-like object
-	*/
-	#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;
-	}
-	/**
 	* Hook into ExceptionHandler to record exceptions in spans.
 	*
 	* We always record the exception on the span (for trace visibility), but we also
@@ -36,15 +26,15 @@ var OtelProvider = class {
 	*/
 	#registerExceptionHandler() {
 		const originalReport = ExceptionHandler.prototype.report;
-		const toHttpError = this.#toHttpError;
+		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 recordExceptionWithContext({
+				await reporter.report({
 					span,
-					error: is.error(error) ? error : new Error(String(error)),
+					error,
 					shouldReport
 				});
 			}

package/dist/src/cli_instrumentation.mjs

@@ -1,4 +1,4 @@
-import { recordExceptionWithContext } from "./context_lines.mjs";
+import { ExceptionReporter } from "./exception_reporter.mjs";
 import { createRequire } from "node:module";
 import { SpanKind, context, trace } from "@opentelemetry/api";
 
@@ -72,9 +72,10 @@ async function instrumentCliCommands(config, appRoot) {
 			try {
 				return await originalExec.call(this);
 			} catch (error) {
-				if (error instanceof Error) await recordExceptionWithContext({
+				await new ExceptionReporter().report({
 					span,
-					error
+					error,
+					shouldReport: true
 				});
 				throw error;
 			} finally {

package/dist/src/context_lines.mjs

@@ -1,5 +1,4 @@
-import { MAX_CAUSE_DEPTH, buildCauseChain, getErrorCause, isErrorLike, stackWithCauses } from "./error_serializer.mjs";
-import { SpanStatusCode } from "@opentelemetry/api";
+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";
@@ -265,30 +264,6 @@ async function _buildCauseChainWithContext(err, seen, depth, contextLines) {
 	if (cause) return [current, ...await _buildCauseChainWithContext(cause, seen, depth + 1, contextLines)];
 	return [current];
 }
-/**
-* Record an exception on a span with context lines.
-* This replaces `span.recordException()` with an enriched version.
-*/
-async function recordExceptionWithContext(options) {
-	const { span, error, shouldReport = true, contextLines = DEFAULT_CONTEXT_LINES } = options;
-	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 hasCauses = causeChain.length > 1;
-	const attributes = {
-		"exception.type": error.name,
-		"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);
-	span.addEvent("exception", attributes);
-}
 
 //#endregion
-export { recordExceptionWithContext };
+export { buildCauseChainWithContext };

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 };

package/dist/src/monocle.d.mts

@@ -1,7 +1,8 @@
 import { UserContextResult } from "@adonisjs/otel/types";
 
 //#region src/monocle.d.ts
-interface CaptureExceptionContext {
+type MessageLevel = 'debug' | 'info' | 'warning' | 'error' | 'fatal';
+interface CaptureContext {
   user?: {
     id: string;
     email?: string;
@@ -10,10 +11,15 @@ interface CaptureExceptionContext {
   tags?: Record<string, string>;
   extra?: Record<string, unknown>;
 }
+interface CaptureMessageContext extends CaptureContext {
+  level?: MessageLevel;
+}
+type CaptureExceptionContext = CaptureContext;
 /**
  * Monocle helper class for manual instrumentation.
  */
 declare class Monocle {
+  #private;
   /**
    * Capture an exception and record it on the current active span.
    * If no span is active, the exception is silently ignored.
@@ -21,7 +27,12 @@ declare class Monocle {
    * This method is async to allow for source context extraction.
    * You can choose to await it or fire-and-forget.
    */
-  static captureException(error: unknown, context?: CaptureExceptionContext): Promise<void>;
+  static captureException(error: unknown, ctx?: CaptureExceptionContext): Promise<void>;
+  /**
+   * Capture a message and record it on the current active span.
+   * If no span is active, the message is silently ignored.
+   */
+  static captureMessage(message: string, levelOrContext?: MessageLevel | CaptureMessageContext): void;
   /**
    * Set user information on the current active span.
    */

package/dist/src/monocle.mjs

@@ -1,4 +1,4 @@
-import { recordExceptionWithContext } from "./context_lines.mjs";
+import { ExceptionReporter } from "./exception_reporter.mjs";
 import { trace } from "@opentelemetry/api";
 import { setUser } from "@adonisjs/otel/helpers";
 
@@ -7,6 +7,18 @@ import { setUser } from "@adonisjs/otel/helpers";
 * Monocle helper class for manual instrumentation.
 */
 var Monocle = class {
+	static #applyUserToSpan(span, user) {
+		if (!user) return;
+		if (user.id) span.setAttribute("user.id", user.id);
+		if (user.email) span.setAttribute("user.email", user.email);
+		if (user.name) span.setAttribute("user.name", user.name);
+	}
+	static #buildContextAttributes(ctx) {
+		const attributes = {};
+		if (ctx?.tags) for (const [key, value] of Object.entries(ctx.tags)) attributes[`monocle.tag.${key}`] = value;
+		if (ctx?.extra) for (const [key, value] of Object.entries(ctx.extra)) attributes[`monocle.extra.${key}`] = JSON.stringify(value);
+		return attributes;
+	}
 	/**
 	* Capture an exception and record it on the current active span.
 	* If no span is active, the exception is silently ignored.
@@ -14,20 +26,34 @@ var Monocle = class {
 	* This method is async to allow for source context extraction.
 	* You can choose to await it or fire-and-forget.
 	*/
-	static async captureException(error, context$1) {
+	static async captureException(error, ctx) {
 		const span = trace.getActiveSpan();
 		if (!span) return;
-		await recordExceptionWithContext({
+		await new ExceptionReporter().report({
 			span,
-			error: error instanceof Error ? error : new Error(String(error))
+			error,
+			shouldReport: true
 		});
-		if (context$1?.user) {
-			if (context$1.user.id) span.setAttribute("user.id", context$1.user.id);
-			if (context$1.user.email) span.setAttribute("user.email", context$1.user.email);
-			if (context$1.user.name) span.setAttribute("user.name", context$1.user.name);
-		}
-		if (context$1?.tags) for (const [key, value] of Object.entries(context$1.tags)) span.setAttribute(`monocle.tag.${key}`, value);
-		if (context$1?.extra) for (const [key, value] of Object.entries(context$1.extra)) span.setAttribute(`monocle.extra.${key}`, JSON.stringify(value));
+		this.#applyUserToSpan(span, ctx?.user);
+		const contextAttrs = this.#buildContextAttributes(ctx);
+		for (const [key, value] of Object.entries(contextAttrs)) span.setAttribute(key, value);
+	}
+	/**
+	* Capture a message and record it on the current active span.
+	* If no span is active, the message is silently ignored.
+	*/
+	static captureMessage(message, levelOrContext) {
+		const span = trace.getActiveSpan();
+		if (!span) return;
+		const ctx = typeof levelOrContext === "string" ? { level: levelOrContext } : levelOrContext;
+		const level = ctx?.level ?? "info";
+		this.#applyUserToSpan(span, ctx?.user);
+		const attributes = {
+			"monocle.message.content": message,
+			"monocle.message.level": level,
+			...this.#buildContextAttributes(ctx)
+		};
+		span.addEvent("monocle.message", attributes);
 	}
 	/**
 	* Set user information on the current active span.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monocle.sh/adonisjs-agent",
-  "version": "1.0.0-beta.6",
+  "version": "1.0.0-beta.8",
   "description": "Monocle agent for AdonisJS - sends telemetry to Monocle cloud",
   "keywords": [
     "adonisjs",
@@ -58,7 +58,7 @@
     "prepublishOnly": "pnpm run build"
   },
   "dependencies": {
-    "@adonisjs/otel": "1.1.0",
+    "@adonisjs/otel": "^1.1.1",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/core": "^2.2.0",
     "@opentelemetry/exporter-metrics-otlp-http": "^0.208.0",
@@ -78,11 +78,11 @@
     "@japa/file-system": "^2.3.2",
     "@japa/runner": "^4.4.0",
     "@japa/snapshot": "^2.0.10",
-    "release-it": "^19.2.2",
-    "tsx": "^4.19.4"
+    "release-it": "^19.2.3",
+    "tsx": "^4.21.0"
   },
   "peerDependencies": {
     "@adonisjs/core": "^6.2.0 || ^7.0.0"
   },
-  "packageManager": "pnpm@10.26.2"
+  "packageManager": "pnpm@10.27.0"
 }