@mastra/auth-studio 1.3.4 → 1.3.5-alpha.1

package/dist/index.cjs

@@ -22,6 +22,46 @@ function getRequestHeader(request, name) {
 }
 //#endregion
 //#region ../../packages/_internal-core/dist/logger/index.js
+/**
+* Export a tracked exception through the adapter sink, mirroring the
+* DualLogger dual-write shape (`errorId`/`domain`/`category`/`details`/`cause`
+* when present on a MastraError-like value). Never throws into the caller.
+*/
+function exportTrackedException(ctx, error, metadata) {
+	if (!ctx?.options.export) return;
+	try {
+		const mastraError = error;
+		ctx.getLogSink()?.error(error.message, {
+			...mastraError.id !== void 0 ? { errorId: mastraError.id } : {},
+			...mastraError.domain !== void 0 ? { domain: mastraError.domain } : {},
+			...mastraError.category !== void 0 ? { category: mastraError.category } : {},
+			...mastraError.details !== void 0 ? { details: mastraError.details } : {},
+			...error.cause instanceof Error ? { cause: error.cause.message } : {},
+			...metadata
+		});
+	} catch {}
+}
+/**
+* Adapt IMastraLogger's variadic args into the structured `data` payload of
+* an exported log record. Extracts the first plain object as data,
+* serializes an Error arg, and collects remaining primitives under `args`
+* so the derived record preserves all context from the native call.
+*/
+function buildLogRecordData(args) {
+	const objectData = args.find((arg) => arg !== null && typeof arg === "object" && !Array.isArray(arg) && !(arg instanceof Error));
+	const errorArg = args.find((arg) => arg instanceof Error);
+	const extraArgs = args.filter((arg) => arg !== objectData && arg !== errorArg);
+	if (!objectData && !errorArg && extraArgs.length === 0) return void 0;
+	return {
+		...objectData ?? {},
+		...errorArg ? { error: {
+			name: errorArg.name,
+			message: errorArg.message,
+			stack: errorArg.stack
+		} } : {},
+		...extraArgs.length > 0 ? { args: extraArgs } : {}
+	};
+}
 const RegisteredLogger = {
 	AGENT: "AGENT",
 	OBSERVABILITY: "OBSERVABILITY",
@@ -108,19 +148,56 @@ var MastraLogger = class {
 var ConsoleLogger = class ConsoleLogger extends MastraLogger {
 	component;
 	filter;
+	#adapterContext;
 	constructor(options = {}) {
 		super(options);
 		this.component = options.component;
 		this.filter = options.filter;
 	}
+	/**
+	* Adapter hook (see `AdaptableLogger`): enables native trace correlation
+	* (trace_id/span_id appended to console output) and observability export
+	* derived from the same record. Called by Mastra during setup.
+	*/
+	__attachObservability(ctx) {
+		this.#adapterContext = ctx;
+	}
 	child(componentOrBindings) {
 		const component = typeof componentOrBindings === "string" ? componentOrBindings : componentOrBindings?.component ?? this.component;
-		return new ConsoleLogger({
+		const child = new ConsoleLogger({
 			name: this.name,
 			level: this.level,
 			component,
 			filter: this.filter
 		});
+		if (this.#adapterContext) child.__attachObservability(this.#adapterContext);
+		return child;
+	}
+	/**
+	* Native-record correlation: when a span is active, append the trace
+	* fields object to the console args so every destination sees them.
+	*/
+	#correlate(args) {
+		const ctx = this.#adapterContext;
+		if (!ctx?.options.correlation) return args;
+		try {
+			const fields = ctx.resolveTraceFields();
+			return fields ? [...args, fields] : args;
+		} catch {
+			return args;
+		}
+	}
+	/**
+	* Export the record derived from the same native call to observability.
+	* Mirrors DualLogger semantics: export is independent of the console
+	* level filter, and never throws into the caller.
+	*/
+	#export(level, message, args) {
+		const ctx = this.#adapterContext;
+		if (!ctx?.options.export) return;
+		try {
+			ctx.getLogSink()?.[level](message, buildLogRecordData(args));
+		} catch {}
 	}
 	shouldLog(level, message, args) {
 		if (!this.filter) return true;
@@ -140,16 +217,23 @@ var ConsoleLogger = class ConsoleLogger extends MastraLogger {
 		return this.component ? `[${this.component}] ` : "";
 	}
 	debug(message, ...args) {
-		if (this.level === LogLevel.DEBUG && this.shouldLog(LogLevel.DEBUG, message, args)) console.info(`${this.prefix()}${message}`, ...args);
+		if (this.level === LogLevel.DEBUG && this.shouldLog(LogLevel.DEBUG, message, args)) console.info(`${this.prefix()}${message}`, ...this.#correlate(args));
+		this.#export("debug", message, args);
 	}
 	info(message, ...args) {
-		if ((this.level === LogLevel.INFO || this.level === LogLevel.DEBUG) && this.shouldLog(LogLevel.INFO, message, args)) console.info(`${this.prefix()}${message}`, ...args);
+		if ((this.level === LogLevel.INFO || this.level === LogLevel.DEBUG) && this.shouldLog(LogLevel.INFO, message, args)) console.info(`${this.prefix()}${message}`, ...this.#correlate(args));
+		this.#export("info", message, args);
 	}
 	warn(message, ...args) {
-		if ((this.level === LogLevel.WARN || this.level === LogLevel.INFO || this.level === LogLevel.DEBUG) && this.shouldLog(LogLevel.WARN, message, args)) console.warn(`${this.prefix()}${message}`, ...args);
+		if ((this.level === LogLevel.WARN || this.level === LogLevel.INFO || this.level === LogLevel.DEBUG) && this.shouldLog(LogLevel.WARN, message, args)) console.warn(`${this.prefix()}${message}`, ...this.#correlate(args));
+		this.#export("warn", message, args);
 	}
 	error(message, ...args) {
-		if ((this.level === LogLevel.ERROR || this.level === LogLevel.WARN || this.level === LogLevel.INFO || this.level === LogLevel.DEBUG) && this.shouldLog(LogLevel.ERROR, message, args)) console.error(`${this.prefix()}${message}`, ...args);
+		if ((this.level === LogLevel.ERROR || this.level === LogLevel.WARN || this.level === LogLevel.INFO || this.level === LogLevel.DEBUG) && this.shouldLog(LogLevel.ERROR, message, args)) console.error(`${this.prefix()}${message}`, ...this.#correlate(args));
+		this.#export("error", message, args);
+	}
+	trackException(error, metadata) {
+		exportTrackedException(this.#adapterContext, error, metadata);
 	}
 	async listLogs(_transportId, _params) {
 		return {