@agentuity/runtime 0.0.42 → 0.0.44

package/src/otel/exporters/jsonl-log-exporter.ts

@@ -0,0 +1,113 @@
+import { type ExportResult, ExportResultCode } from '@opentelemetry/core';
+import type { LogRecordExporter, ReadableLogRecord } from '@opentelemetry/sdk-logs';
+import { existsSync, appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+/**
+ * JSONL implementation of the LogRecordExporter interface
+ * Writes logs to a timestamped JSONL file
+ */
+export class JSONLLogExporter implements LogRecordExporter {
+	private currentFile: string | null = null;
+	private readonly basePath: string;
+	private readonly filePrefix: string;
+
+	/**
+	 * Creates a new JSONL log record exporter
+	 * @param basePath - Directory to store the JSONL files
+	 */
+	constructor(basePath: string) {
+		this.basePath = basePath;
+		this.filePrefix = 'otel-log';
+		this.ensureDirectory();
+	}
+
+	private ensureDirectory(): void {
+		if (!existsSync(this.basePath)) {
+			mkdirSync(this.basePath, { recursive: true });
+		}
+	}
+
+	private getOrCreateFile(): string {
+		// If current file exists, use it
+		if (this.currentFile && existsSync(this.currentFile)) {
+			return this.currentFile;
+		}
+
+		this.currentFile = join(
+			this.basePath,
+			`${this.filePrefix}-${Date.now()}.${randomUUID()}.jsonl`
+		);
+		return this.currentFile;
+	}
+
+	/**
+	 * Exports log records to a JSONL file
+	 *
+	 * @param logs - The log records to export
+	 * @param resultCallback - Callback function to report the export result
+	 */
+	export(logs: ReadableLogRecord[], resultCallback: (result: ExportResult) => void): void {
+		try {
+			if (logs.length === 0) {
+				resultCallback({ code: ExportResultCode.SUCCESS });
+				return;
+			}
+			const file = this.getOrCreateFile();
+			const lines: string[] = [];
+			for (const log of logs) {
+				const record = {
+					timestamp: log.hrTime,
+					observedTimestamp: log.hrTimeObserved,
+					severityNumber: log.severityNumber,
+					severityText: log.severityText,
+					body: log.body,
+					attributes: log.attributes,
+					resource: log.resource.attributes,
+					instrumentationScope: log.instrumentationScope,
+					spanContext: log.spanContext,
+				};
+
+				lines.push(JSON.stringify(record));
+			}
+			const payload = `${lines.join('\n')}\n`;
+			try {
+				appendFileSync(file, payload, 'utf-8');
+			} catch (err) {
+				// File may have been deleted, reset and retry once
+				const code = (err as NodeJS.ErrnoException).code;
+				if (code === 'ENOENT') {
+					this.currentFile = null;
+					const newFile = this.getOrCreateFile();
+					appendFileSync(newFile, payload, 'utf-8');
+				} else {
+					throw err;
+				}
+			}
+
+			resultCallback({ code: ExportResultCode.SUCCESS });
+		} catch (error) {
+			resultCallback({
+				code: ExportResultCode.FAILED,
+				error: error instanceof Error ? error : new Error(String(error)),
+			});
+		}
+	}
+
+	/**
+	 * Shuts down the exporter
+	 *
+	 * @returns A promise that resolves when shutdown is complete
+	 */
+	async shutdown(): Promise<void> {
+		this.currentFile = null;
+	}
+
+	/**
+	 * Forces a flush of any pending data
+	 */
+	async forceFlush(): Promise<void> {
+		// No-op for file-based exporter as writes are synchronous
+	}
+}

package/src/otel/exporters/jsonl-metric-exporter.ts

@@ -0,0 +1,120 @@
+import { type ExportResult, ExportResultCode } from '@opentelemetry/core';
+import {
+	type PushMetricExporter,
+	type ResourceMetrics,
+	AggregationTemporality,
+	InstrumentType,
+} from '@opentelemetry/sdk-metrics';
+import { existsSync, appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+/**
+ * JSONL implementation of the PushMetricExporter interface
+ * Writes metrics to a timestamped JSONL file
+ */
+export class JSONLMetricExporter implements PushMetricExporter {
+	private currentFile: string | null = null;
+	private readonly basePath: string;
+	private readonly filePrefix: string;
+
+	/**
+	 * Creates a new JSONL metric exporter
+	 * @param basePath - Directory to store the JSONL files
+	 */
+	constructor(basePath: string) {
+		this.basePath = basePath;
+		this.filePrefix = 'otel-metric';
+		this.ensureDirectory();
+	}
+
+	private ensureDirectory(): void {
+		if (!existsSync(this.basePath)) {
+			mkdirSync(this.basePath, { recursive: true });
+		}
+	}
+
+	private getOrCreateFile(): string {
+		// If current file exists, use it
+		if (this.currentFile && existsSync(this.currentFile)) {
+			return this.currentFile;
+		}
+
+		this.currentFile = join(
+			this.basePath,
+			`${this.filePrefix}-${Date.now()}.${randomUUID()}.jsonl`
+		);
+		return this.currentFile;
+	}
+
+	/**
+	 * Exports metrics to a JSONL file
+	 *
+	 * @param metrics - The resource metrics to export
+	 * @param resultCallback - Callback function to report the export result
+	 */
+	export(metrics: ResourceMetrics, resultCallback: (result: ExportResult) => void): void {
+		try {
+			const file = this.getOrCreateFile();
+
+			const record = {
+				resource: metrics.resource.attributes,
+				scopeMetrics: metrics.scopeMetrics.map((sm) => ({
+					scope: sm.scope,
+					metrics: sm.metrics.map((m) => ({
+						descriptor: m.descriptor,
+						dataPointType: m.dataPointType,
+						dataPoints: m.dataPoints,
+						aggregationTemporality: m.aggregationTemporality,
+					})),
+				})),
+			};
+
+			const line = JSON.stringify(record) + '\n';
+			try {
+				appendFileSync(file, line, 'utf-8');
+			} catch (err) {
+				// File may have been deleted, reset and retry once
+				const code = (err as NodeJS.ErrnoException).code;
+				if (code === 'ENOENT') {
+					this.currentFile = null;
+					const newFile = this.getOrCreateFile();
+					appendFileSync(newFile, line, 'utf-8');
+				} else {
+					throw err;
+				}
+			}
+
+			resultCallback({ code: ExportResultCode.SUCCESS });
+		} catch (error) {
+			resultCallback({
+				code: ExportResultCode.FAILED,
+				error: error instanceof Error ? error : new Error(String(error)),
+			});
+		}
+	}
+
+	/**
+	 * Shuts down the exporter
+	 *
+	 * @returns A promise that resolves when shutdown is complete
+	 */
+	async shutdown(): Promise<void> {
+		this.currentFile = null;
+	}
+
+	/**
+	 * Forces a flush of any pending data
+	 */
+	async forceFlush(): Promise<void> {
+		// No-op for file-based exporter as writes are synchronous
+	}
+
+	/**
+	 * Selects the aggregation temporality for the given instrument type
+	 */
+	selectAggregationTemporality?(_instrumentType: InstrumentType): AggregationTemporality {
+		// Default to cumulative temporality
+		return AggregationTemporality.CUMULATIVE;
+	}
+}

package/src/otel/exporters/jsonl-trace-exporter.ts

@@ -0,0 +1,121 @@
+import { type ExportResult, ExportResultCode } from '@opentelemetry/core';
+import type { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
+import { existsSync, appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+/**
+ * JSONL implementation of the SpanExporter interface
+ * Writes traces to a timestamped JSONL file
+ */
+export class JSONLTraceExporter implements SpanExporter {
+	private currentFile: string | null = null;
+	private readonly basePath: string;
+	private readonly filePrefix: string;
+
+	/**
+	 * Creates a new JSONL trace exporter
+	 * @param basePath - Directory to store the JSONL files
+	 */
+	constructor(basePath: string) {
+		this.basePath = basePath;
+		this.filePrefix = 'otel-trace';
+		this.ensureDirectory();
+	}
+
+	private ensureDirectory(): void {
+		if (!existsSync(this.basePath)) {
+			mkdirSync(this.basePath, { recursive: true });
+		}
+	}
+
+	private getOrCreateFile(): string {
+		// If current file exists, use it
+		if (this.currentFile && existsSync(this.currentFile)) {
+			return this.currentFile;
+		}
+
+		this.currentFile = join(
+			this.basePath,
+			`${this.filePrefix}-${Date.now()}.${randomUUID()}.jsonl`
+		);
+		return this.currentFile;
+	}
+
+	/**
+	 * Exports spans to a JSONL file
+	 *
+	 * @param spans - The spans to export
+	 * @param resultCallback - Callback function to report the export result
+	 */
+	export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void {
+		try {
+			if (spans.length === 0) {
+				resultCallback({ code: ExportResultCode.SUCCESS });
+				return;
+			}
+			const file = this.getOrCreateFile();
+			const lines: string[] = [];
+			for (const span of spans) {
+				const record = {
+					traceId: span.spanContext().traceId,
+					spanId: span.spanContext().spanId,
+					traceState: span.spanContext().traceState?.serialize(),
+					name: span.name,
+					kind: span.kind,
+					startTime: span.startTime,
+					endTime: span.endTime,
+					attributes: span.attributes,
+					status: span.status,
+					events: span.events,
+					links: span.links,
+					resource: span.resource.attributes,
+					droppedAttributesCount: span.droppedAttributesCount,
+					droppedEventsCount: span.droppedEventsCount,
+					droppedLinksCount: span.droppedLinksCount,
+					duration: span.duration,
+					ended: span.ended,
+				};
+
+				lines.push(JSON.stringify(record));
+			}
+			const payload = `${lines.join('\n')}\n`;
+			try {
+				appendFileSync(file, payload, 'utf-8');
+			} catch (err) {
+				// File may have been deleted, reset and retry once
+				const code = (err as NodeJS.ErrnoException).code;
+				if (code === 'ENOENT') {
+					this.currentFile = null;
+					const newFile = this.getOrCreateFile();
+					appendFileSync(newFile, payload, 'utf-8');
+				} else {
+					throw err;
+				}
+			}
+
+			resultCallback({ code: ExportResultCode.SUCCESS });
+		} catch (error) {
+			resultCallback({
+				code: ExportResultCode.FAILED,
+				error: error instanceof Error ? error : new Error(String(error)),
+			});
+		}
+	}
+
+	/**
+	 * Shuts down the exporter
+	 *
+	 * @returns A promise that resolves when shutdown is complete
+	 */
+	async shutdown(): Promise<void> {
+		this.currentFile = null;
+	}
+
+	/**
+	 * Forces a flush of any pending data
+	 */
+	async forceFlush(): Promise<void> {
+		// No-op for file-based exporter as writes are synchronous
+	}
+}

package/src/otel/http.ts

@@ -12,7 +12,9 @@ export function injectTraceContextToHeaders(
 	let _headers: Record<string, string>;
 	if (headers instanceof Headers) {
 		_headers = {};
-		headers.forEach((v, k) => (_headers[k] = v));
+		headers.forEach((v, k) => {
+			_headers[k] = v;
+		});
 	} else {
 		_headers = { ...headers };
 	}

package/src/otel/logger.ts

@@ -1,5 +1,5 @@
 import { format } from 'node:util';
-import { safeStringify } from '@agentuity/core';
+import { safeStringify, type LogLevel } from '@agentuity/core';
 import * as LogsAPI from '@opentelemetry/api-logs';
 import type { Logger } from '../logger';
 import ConsoleLogger from '../logger/console';
@@ -11,22 +11,21 @@ import { getAgentContext } from '../_context';
 export const __originalConsole = Object.create(console); // save the original console before we patch it
 
 export class OtelLogger implements Logger {
-	private readonly delegates: LogsAPI.Logger[];
+	private readonly delegate: LogsAPI.Logger;
 	private readonly context: Record<string, unknown> | undefined;
 	private readonly logger: ConsoleLogger | undefined;
+	private readonly logLevel: LogLevel;
 
 	constructor(
 		useConsole: boolean,
-		delegates: LogsAPI.Logger | LogsAPI.Logger[],
-		context?: Record<string, unknown> | undefined
+		delegate: LogsAPI.Logger,
+		context?: Record<string, unknown> | undefined,
+		logLevel?: LogLevel
 	) {
-		this.delegates = Array.isArray(delegates) ? delegates : [delegates];
+		this.delegate = delegate;
 		this.context = context;
-		this.logger = useConsole ? new ConsoleLogger(context, false) : undefined;
-	}
-
-	addDelegate(delegate: LogsAPI.Logger) {
-		this.delegates.push(delegate);
+		this.logLevel = logLevel ?? 'info';
+		this.logger = useConsole ? new ConsoleLogger(context, false, this.logLevel) : undefined;
 	}
 
 	private formatMessage(message: unknown) {
@@ -62,25 +61,65 @@ export class OtelLogger implements Logger {
 		return this.context;
 	}
 
-	private emitToAll(severityNumber: LogsAPI.SeverityNumber, severityText: string, body: string) {
+	private emit(severityNumber: LogsAPI.SeverityNumber, severityText: string, body: string) {
 		const attributes = this.getAttributes();
 
-		this.delegates.forEach((delegate) => {
-			try {
-				delegate.emit({
-					severityNumber,
-					severityText,
-					body,
-					attributes: attributes as LogsAPI.LogRecord['attributes'],
-				});
-			} catch (error) {
-				// Log error to console if available, but don't fail the entire operation
-				this.logger?.error('Failed to emit log to OTLP instance:', error);
-			}
-		});
+		try {
+			this.delegate.emit({
+				severityNumber,
+				severityText,
+				body,
+				attributes: attributes as LogsAPI.LogRecord['attributes'],
+			});
+		} catch (error) {
+			// Log error to console if available, but don't fail the entire operation
+			this.logger?.error('Failed to emit log to OTLP instance:', error);
+		}
 	}
 
-	debug(message: string, ...args: unknown[]) {
+	private shouldLog(level: LogsAPI.SeverityNumber): boolean {
+		switch (this.logLevel) {
+			case 'trace':
+				return true;
+			case 'debug':
+				return (
+					level === LogsAPI.SeverityNumber.DEBUG ||
+					level == LogsAPI.SeverityNumber.INFO ||
+					level == LogsAPI.SeverityNumber.WARN ||
+					level == LogsAPI.SeverityNumber.ERROR
+				);
+			case 'info':
+				return (
+					level == LogsAPI.SeverityNumber.INFO ||
+					level == LogsAPI.SeverityNumber.WARN ||
+					level == LogsAPI.SeverityNumber.ERROR
+				);
+			case 'warn':
+				return level == LogsAPI.SeverityNumber.WARN || level == LogsAPI.SeverityNumber.ERROR;
+			case 'error':
+				return level == LogsAPI.SeverityNumber.ERROR;
+		}
+		return false;
+	}
+
+	trace(message: unknown, ...args: unknown[]) {
+		if (!this.shouldLog(LogsAPI.SeverityNumber.TRACE)) {
+			return;
+		}
+		this.logger?.trace(message, ...args);
+		let body: string;
+		try {
+			body = format(this.formatMessage(message), ...args);
+		} catch {
+			// Fallback if format causes recursion
+			body = `${this.formatMessage(message)} ${args.map((arg) => String(arg)).join(' ')}`;
+		}
+		this.emit(LogsAPI.SeverityNumber.TRACE, 'TRACE', body);
+	}
+	debug(message: unknown, ...args: unknown[]) {
+		if (!this.shouldLog(LogsAPI.SeverityNumber.DEBUG)) {
+			return;
+		}
 		this.logger?.debug(message, ...args);
 		let body: string;
 		try {
@@ -89,9 +128,12 @@ export class OtelLogger implements Logger {
 			// Fallback if format causes recursion
 			body = `${this.formatMessage(message)} ${args.map((arg) => String(arg)).join(' ')}`;
 		}
-		this.emitToAll(LogsAPI.SeverityNumber.DEBUG, 'DEBUG', body);
+		this.emit(LogsAPI.SeverityNumber.DEBUG, 'DEBUG', body);
 	}
-	info(message: string, ...args: unknown[]) {
+	info(message: unknown, ...args: unknown[]) {
+		if (!this.shouldLog(LogsAPI.SeverityNumber.INFO)) {
+			return;
+		}
 		this.logger?.info(message, ...args);
 		let body: string;
 		try {
@@ -100,9 +142,12 @@ export class OtelLogger implements Logger {
 			// Fallback if format causes recursion
 			body = `${this.formatMessage(message)} ${args.map((arg) => String(arg)).join(' ')}`;
 		}
-		this.emitToAll(LogsAPI.SeverityNumber.INFO, 'INFO', body);
+		this.emit(LogsAPI.SeverityNumber.INFO, 'INFO', body);
 	}
-	warn(message: string, ...args: unknown[]) {
+	warn(message: unknown, ...args: unknown[]) {
+		if (!this.shouldLog(LogsAPI.SeverityNumber.WARN)) {
+			return;
+		}
 		this.logger?.warn(message, ...args);
 		let body: string;
 		try {
@@ -111,9 +156,12 @@ export class OtelLogger implements Logger {
 			// Fallback if format causes recursion
 			body = `${this.formatMessage(message)} ${args.map((arg) => String(arg)).join(' ')}`;
 		}
-		this.emitToAll(LogsAPI.SeverityNumber.WARN, 'WARN', body);
+		this.emit(LogsAPI.SeverityNumber.WARN, 'WARN', body);
 	}
-	error(message: string, ...args: unknown[]) {
+	error(message: unknown, ...args: unknown[]) {
+		if (!this.shouldLog(LogsAPI.SeverityNumber.ERROR)) {
+			return;
+		}
 		this.logger?.error(message, ...args);
 		let body: string;
 		try {
@@ -122,13 +170,22 @@ export class OtelLogger implements Logger {
 			// Fallback if format causes recursion
 			body = `${this.formatMessage(message)} ${args.map((arg) => String(arg)).join(' ')}`;
 		}
-		this.emitToAll(LogsAPI.SeverityNumber.ERROR, 'ERROR', body);
+		this.emit(LogsAPI.SeverityNumber.ERROR, 'ERROR', body);
+	}
+	fatal(message: unknown, ...args: unknown[]): never {
+		this.error(message, ...args);
+		process.exit(1);
 	}
-	child(opts: Record<string, unknown>) {
-		return new OtelLogger(!!this.logger, this.delegates, {
-			...(this.context ?? {}),
-			...opts,
-		});
+	child(opts: Record<string, unknown>): Logger {
+		return new OtelLogger(
+			!!this.logger,
+			this.delegate,
+			{
+				...(this.context ?? {}),
+				...opts,
+			},
+			this.logLevel
+		);
 	}
 }
 
@@ -139,11 +196,15 @@ export class OtelLogger implements Logger {
  * @param context - Additional context to include with log records
  * @returns A logger instance
  */
-export function createLogger(useConsole: boolean, context?: Record<string, unknown>): Logger {
+export function createLogger(
+	useConsole: boolean,
+	context?: Record<string, unknown>,
+	logLevel?: LogLevel
+): Logger {
 	const delegate = LogsAPI.logs.getLogger('default', undefined, {
 		scopeAttributes: context as LogsAPI.LoggerOptions['scopeAttributes'],
 	});
-	return new OtelLogger(useConsole, [delegate], context);
+	return new OtelLogger(useConsole, delegate, context, logLevel);
 }
 
 /**
@@ -151,12 +212,16 @@ export function createLogger(useConsole: boolean, context?: Record<string, unkno
  *
  * @param attributes - Attributes to include with all console log records
  */
-export function patchConsole(enabled: boolean, attributes: Record<string, unknown>) {
+export function patchConsole(
+	enabled: boolean,
+	attributes: Record<string, unknown>,
+	logLevel: LogLevel
+) {
 	if (!enabled) {
 		return;
 	}
 	const _patch = { ...__originalConsole };
-	const delegate = createLogger(true, attributes);
+	const delegate = createLogger(true, attributes, logLevel);
 
 	// Patch individual console methods instead of reassigning the whole object
 	_patch.log = (...args: unknown[]) => {