@monocle.sh/adonisjs-agent 1.0.0-beta.13 → 1.0.0-beta.14

package/dist/helpers.d.mts

@@ -9,7 +9,6 @@ import { extractTraceContext, getCurrentSpan, injectTraceContext, otelLoggingPre
  * to extract source context lines from the stack trace.
  */
 declare function handleError(span: Span, error: Error): Promise<never>;
-type RecordCallback<T> = (span: Span) => T | Promise<T>;
 /**
  * Record a code section as a span in your traces.
  *
@@ -17,8 +16,9 @@ type RecordCallback<T> = (span: Span) => T | Promise<T>;
  * to capture exceptions with source context lines (pre/post context around
  * the error location).
  *
- * Always returns a Promise to ensure context lines are properly captured
- * even for synchronous errors.
+ * Preserves sync/async semantics: if the callback is synchronous, the return
+ * type is `T`. If the callback returns a Promise-like value, the return type
+ * is async-compatible.
  *
  * Automatically handles:
  * - Creating and closing the span
@@ -29,10 +29,10 @@ type RecordCallback<T> = (span: Span) => T | Promise<T>;
  * ```ts
  * import { record } from '@monocle.sh/adonisjs-agent'
  *
- * const result = await record('database.query', () => {
- *   return db.query('SELECT * FROM users')
- * })
+ * // Sync callback returns T directly
+ * const value = record('compute.hash', () => computeHash(data))
  *
+ * // Async callback returns Promise<T>
  * const user = await record('user.fetch', async () => {
  *   return await userService.findById(id)
  * })
@@ -44,6 +44,6 @@ type RecordCallback<T> = (span: Span) => T | Promise<T>;
  * })
  * ```
  */
-declare function record<T>(name: string, callback: RecordCallback<T>): Promise<T>;
+declare function record<T>(name: string, callback: (span: Span) => T): T;
 //#endregion
 export { extractTraceContext, getCurrentSpan, handleError, injectTraceContext, otelLoggingPreset, record, recordEvent, setAttributes };

package/dist/helpers.mjs

@@ -1,8 +1,31 @@
 import { ExceptionReporter } from "./src/exception_reporter.mjs";
-import { SpanStatusCode, trace } from "@opentelemetry/api";
+import { trace } from "@opentelemetry/api";
 import { extractTraceContext, getCurrentSpan, injectTraceContext, otelLoggingPreset, recordEvent, setAttributes } from "@adonisjs/otel/helpers";
 
 //#region src/helpers.ts
+function isPromiseLike(value) {
+	if (!value) return false;
+	if (typeof value !== "object" && typeof value !== "function") return false;
+	return typeof value.then === "function";
+}
+async function reportErrorAndEndSpan(span, error, endTime) {
+	const reporter = new ExceptionReporter();
+	try {
+		await reporter.report({
+			span,
+			error,
+			shouldReport: true
+		});
+	} catch {
+		reporter.reportSync({
+			span,
+			error,
+			shouldReport: true
+		});
+	} finally {
+		span.end(endTime);
+	}
+}
 /**
 * Handle an error by reporting it with context frames extraction.
 *
@@ -10,16 +33,7 @@ import { extractTraceContext, getCurrentSpan, injectTraceContext, otelLoggingPre
 * to extract source context lines from the stack trace.
 */
 async function handleError(span, error) {
-	await new ExceptionReporter().report({
-		span,
-		error,
-		shouldReport: true
-	});
-	span.setStatus({
-		code: SpanStatusCode.ERROR,
-		message: error?.message
-	});
-	span.end();
+	await reportErrorAndEndSpan(span, error, /* @__PURE__ */ new Date());
 	throw error;
 }
 /**
@@ -29,8 +43,9 @@ async function handleError(span, error) {
 * to capture exceptions with source context lines (pre/post context around
 * the error location).
 *
-* Always returns a Promise to ensure context lines are properly captured
-* even for synchronous errors.
+* Preserves sync/async semantics: if the callback is synchronous, the return
+* type is `T`. If the callback returns a Promise-like value, the return type
+* is async-compatible.
 *
 * Automatically handles:
 * - Creating and closing the span
@@ -41,10 +56,10 @@ async function handleError(span, error) {
 * ```ts
 * import { record } from '@monocle.sh/adonisjs-agent'
 *
-* const result = await record('database.query', () => {
-*   return db.query('SELECT * FROM users')
-* })
+* // Sync callback returns T directly
+* const value = record('compute.hash', () => computeHash(data))
 *
+* // Async callback returns Promise<T>
 * const user = await record('user.fetch', async () => {
 *   return await userService.findById(id)
 * })
@@ -56,14 +71,19 @@ async function handleError(span, error) {
 * })
 * ```
 */
-async function record(name, callback) {
-	return trace.getTracer("@monocle.sh/agent").startActiveSpan(name, async (span) => {
+function record(name, callback) {
+	return trace.getTracer("@monocle.sh/agent").startActiveSpan(name, (span) => {
 		try {
-			const result = await callback(span);
+			const result = callback(span);
+			if (isPromiseLike(result)) return Promise.resolve(result).then((value) => {
+				span.end();
+				return value;
+			}).catch((error) => handleError(span, error));
 			span.end();
 			return result;
 		} catch (error) {
-			return handleError(span, error);
+			reportErrorAndEndSpan(span, error, /* @__PURE__ */ new Date());
+			throw error;
 		}
 	});
 }

package/dist/src/exception_reporter.mjs

@@ -33,6 +33,23 @@ var ExceptionReporter = class {
 		const attributes = this.#buildAttributes(error, causeChain);
 		span.addEvent("exception", attributes);
 	}
+	/**
+	* Synchronous version of report. Uses buildCauseChain (no file I/O)
+	* so source context frames won't be available, but the full stack trace,
+	* cause chain, error status, and exception event are still recorded.
+	*/
+	reportSync(options) {
+		const { span, shouldReport } = options;
+		const error = toHttpError(options.error);
+		span.setStatus({
+			code: SpanStatusCode.ERROR,
+			message: error.message
+		});
+		span.setAttribute("monocle.exception.should_report", shouldReport);
+		const causeChain = buildCauseChain(error);
+		const attributes = this.#buildAttributes(error, causeChain);
+		span.addEvent("exception", attributes);
+	}
 	#buildAttributes(error, causeChain) {
 		const hasCauses = causeChain.length > 1;
 		const attributes = {

package/dist/src/instrumentations/cache/instrumentation.mjs

@@ -39,6 +39,15 @@ async function instrumentCache(config, appRoot) {
 		suppressInternalOperations: true
 	});
 	instrumentation.enable();
+	/**
+	* Eagerly import bentocache to trigger the ESM hook.
+	* If the hook didn't patch BentoCache (e.g. race condition),
+	* fall back to manual registration.
+	*/
+	try {
+		const bentocache = await import("bentocache");
+		if (bentocache.BentoCache.name !== "BentoCachePatched") instrumentation.manuallyRegister(bentocache);
+	} catch {}
 	return instrumentation;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monocle.sh/adonisjs-agent",
-  "version": "1.0.0-beta.13",
+  "version": "1.0.0-beta.14",
   "description": "Monocle agent for AdonisJS - sends telemetry to Monocle cloud",
   "keywords": [
     "adonisjs",