@agentuity/runtime 2.0.11 → 3.0.0-alpha.0

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

@@ -1,121 +0,0 @@
-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/fetch.ts

@@ -1,105 +0,0 @@
-import { context, propagation, SpanStatusCode, trace } from '@opentelemetry/api';
-
-/**
- * Reference to the original fetch function before instrumentation
- */
-export const __originalFetch = fetch; // save the original fetch before we patch it
-
-/**
- * Instruments the global fetch function with OpenTelemetry tracing
- *
- * Replaces the global fetch with an instrumented version that creates spans
- * for each HTTP request and propagates trace context in headers
- */
-export function instrumentFetch() {
-	const patch = async (
-		input: string | Request | URL,
-		init: RequestInit | undefined
-	): Promise<Response> => {
-		const url =
-			typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
-
-		const method =
-			init?.method ||
-			(typeof input !== 'string' && !(input instanceof URL) ? input.method || 'GET' : 'GET');
-
-		// Get the active span if it exists
-		const activeSpan = trace.getActiveSpan();
-
-		// If there's no active span, just call the original fetch
-		if (!activeSpan) {
-			return __originalFetch(input, init);
-		}
-
-		// Get the current active context
-		const currentContext = context.active();
-		const _url = new URL(url);
-
-		// Create a child span using the current context
-		const childSpan = trace.getTracer('fetch').startSpan(
-			`${method} ${_url.pathname}`,
-			{
-				attributes: {
-					'http.url': url,
-					'http.path': _url.pathname,
-					'http.method': method,
-					host: _url.host,
-				},
-			},
-			currentContext
-		);
-
-		try {
-			// Prepare trace context injection
-			const carrier: Record<string, string> = {};
-
-			// Create a new context with the child span
-			const newContext = trace.setSpan(currentContext, childSpan);
-
-			// Use the new context for propagation
-			propagation.inject(newContext, carrier);
-
-			// Preserve original headers and add trace context
-			// Handle headers from both Request input and init parameter
-			const baseHeaders =
-				typeof input !== 'string' && !(input instanceof URL) && input instanceof Request
-					? input.headers
-					: undefined;
-			const headers = new Headers(baseHeaders ?? init?.headers ?? {});
-
-			// Add trace context headers (overwriting any already present)
-			for (const [key, value] of Object.entries(carrier)) {
-				headers.set(key, value);
-			}
-
-			// Create new init object with updated headers
-			const newInit = {
-				...init,
-				headers,
-			};
-
-			const response = await __originalFetch(input, newInit);
-
-			// Add response attributes to span
-			childSpan.setAttributes({
-				'http.status_code': response.status,
-				'http.user_agent': response.headers.get('user-agent') || '',
-			});
-
-			if (!response.ok) {
-				childSpan.setStatus({ code: SpanStatusCode.ERROR });
-			} else {
-				childSpan.setStatus({ code: SpanStatusCode.OK });
-			}
-
-			return response;
-		} catch (error) {
-			childSpan.recordException(error as Error);
-			childSpan.setStatus({ code: SpanStatusCode.ERROR });
-			throw error;
-		} finally {
-			childSpan.end();
-		}
-	};
-	globalThis.fetch = patch as typeof fetch;
-}

package/src/otel/http.ts

@@ -1,53 +0,0 @@
-import { context, propagation } from '@opentelemetry/api';
-
-/**
- * Injects trace context into response headers using the OpenTelemetry propagation API
- *
- * @param headers - Optional existing headers to include
- * @returns A record of headers with trace context injected
- */
-export function injectTraceContextToHeaders(
-	headers: Record<string, string> | Headers = {}
-): Record<string, string> {
-	let _headers: Record<string, string>;
-	if (headers instanceof Headers) {
-		_headers = {};
-		headers.forEach((v, k) => {
-			_headers[k] = v;
-		});
-	} else {
-		_headers = { ...headers };
-	}
-	// Create a carrier object for the headers
-	const carrier: Record<string, string> = { ..._headers } as Record<string, string>;
-
-	// Get the current context
-	const currentContext = context.active();
-
-	// Inject trace context into the carrier
-	propagation.inject(currentContext, carrier);
-
-	return carrier;
-}
-
-/**
- * Extracts trace context from Bun Request headers
- *
- * @param req - The Bun Request object
- * @returns The context with trace information
- */
-export function extractTraceContextFromRequest(
-	req: Request
-): ReturnType<typeof propagation.extract> {
-	// Create a carrier object from the headers
-	const carrier: Record<string, string> = {};
-
-	// Convert headers to the format expected by the propagator
-	req.headers.forEach((value, key) => {
-		carrier[key.toLowerCase()] = value;
-	});
-
-	// Extract the context using the global propagator
-	const activeContext = context.active();
-	return propagation.extract(activeContext, carrier);
-}

package/src/otel/logger.ts

@@ -1,293 +0,0 @@
-import { format } from 'node:util';
-import { safeStringify, type LogLevel } from '@agentuity/core';
-import * as LogsAPI from '@opentelemetry/api-logs';
-import type { Logger } from '../logger';
-import ConsoleLogger from '../logger/console';
-
-import { originalConsole as originalConsoleGlobal } from '../_globals';
-
-/**
- * Reference to the original console object before patching.
- * Stored in a Symbol.for() global to survive hot reloads.
- */
-const existingOriginal = originalConsoleGlobal.get();
-export const __originalConsole: Console = existingOriginal ?? Object.create(console);
-
-if (!existingOriginal) {
-	originalConsoleGlobal.set(__originalConsole);
-}
-
-export class OtelLogger implements 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,
-		delegate: LogsAPI.Logger,
-		context?: Record<string, unknown> | undefined,
-		logLevel?: LogLevel
-	) {
-		this.delegate = delegate;
-		this.context = context;
-		this.logLevel = logLevel ?? 'info';
-		this.logger = useConsole ? new ConsoleLogger(context, false, this.logLevel) : undefined;
-	}
-
-	private formatMessage(message: unknown) {
-		if (typeof message === 'string') {
-			return message;
-		}
-		try {
-			return safeStringify(message);
-		} catch {
-			// Handle circular references or other unknown stringification errors
-			return String(message);
-		}
-	}
-
-	private getAttributes(): Record<string, unknown> | undefined {
-		return this.context;
-	}
-
-	private emit(severityNumber: LogsAPI.SeverityNumber, severityText: string, body: string) {
-		const attributes = this.getAttributes();
-
-		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);
-		}
-	}
-
-	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 {
-			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.DEBUG, 'DEBUG', body);
-	}
-	info(message: unknown, ...args: unknown[]) {
-		if (!this.shouldLog(LogsAPI.SeverityNumber.INFO)) {
-			return;
-		}
-		this.logger?.info(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.INFO, 'INFO', body);
-	}
-	warn(message: unknown, ...args: unknown[]) {
-		if (!this.shouldLog(LogsAPI.SeverityNumber.WARN)) {
-			return;
-		}
-		this.logger?.warn(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.WARN, 'WARN', body);
-	}
-	error(message: unknown, ...args: unknown[]) {
-		if (!this.shouldLog(LogsAPI.SeverityNumber.ERROR)) {
-			return;
-		}
-		this.logger?.error(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.ERROR, 'ERROR', body);
-	}
-	fatal(message: unknown, ...args: unknown[]): never {
-		this.error(message, ...args);
-		process.exit(1);
-	}
-	child(opts: Record<string, unknown>): Logger {
-		return new OtelLogger(
-			!!this.logger,
-			this.delegate,
-			{
-				...(this.context ?? {}),
-				...opts,
-			},
-			this.logLevel
-		);
-	}
-}
-
-/**
- * Creates a logger that integrates with OpenTelemetry
- *
- * @param useConsole - Whether to also log to the console
- * @param context - Additional context to include with log records
- * @returns A logger instance
- */
-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, logLevel);
-}
-
-/**
- * Patches the global console object to integrate with OpenTelemetry logging
- *
- * @param attributes - Attributes to include with all console log records
- */
-export function patchConsole(
-	enabled: boolean,
-	attributes: Record<string, unknown>,
-	logLevel: LogLevel
-) {
-	if (!enabled) {
-		return;
-	}
-	const _patch = { ...__originalConsole };
-	const delegate = createLogger(true, attributes, logLevel);
-
-	// Patch individual console methods instead of reassigning the whole object
-	_patch.log = (...args: unknown[]) => {
-		delegate.info(args[0] as string, ...args.slice(1));
-	};
-	_patch.error = (...args: unknown[]) => {
-		delegate.error(args[0] as string, ...args.slice(1));
-	};
-	_patch.warn = (...args: unknown[]) => {
-		delegate.warn(args[0] as string, ...args.slice(1));
-	};
-	_patch.debug = (...args: unknown[]) => {
-		delegate.debug(args[0] as string, ...args.slice(1));
-	};
-	_patch.info = (...args: unknown[]) => {
-		delegate.info(args[0] as string, ...args.slice(1));
-	};
-	_patch.dir = (...args: unknown[]) => {
-		let msg = '';
-		if (args.length === 1) {
-			msg = format(args[0]);
-		} else if (args.length >= 2) {
-			msg = format(args[0], args[1]);
-		} else {
-			msg = safeStringify(args);
-		}
-		delegate.debug(msg);
-	};
-	_patch.dirxml = (...args: unknown[]) => {
-		delegate.debug('dirxml:', ...args);
-	};
-	_patch.table = (...args: unknown[]) => {
-		delegate.debug('table:', ...args);
-	};
-	_patch.trace = (...args: unknown[]) => {
-		delegate.debug(args[0] as string, ...args.slice(1));
-	};
-	_patch.group = (...args: unknown[]) => {
-		delegate.debug('group:', ...args);
-	};
-	_patch.groupCollapsed = (...args: unknown[]) => {
-		delegate.debug('groupCollapsed:', ...args);
-	};
-	_patch.groupEnd = () => {
-		delegate.debug('groupEnd');
-	};
-	_patch.clear = () => {
-		/* no-op */
-	};
-	_patch.count = (...args: unknown[]) => {
-		delegate.debug('count:', ...args);
-	};
-	_patch.countReset = (...args: unknown[]) => {
-		delegate.debug('countReset:', ...args);
-	};
-	_patch.assert = (condition?: boolean, ...args: unknown[]) => {
-		if (!condition) {
-			delegate.error('assertion failed:', ...args);
-		}
-	};
-	_patch.time = (...args: unknown[]) => {
-		delegate.debug('time:', ...args);
-	};
-	_patch.timeLog = (...args: unknown[]) => {
-		delegate.debug('timeLog:', ...args);
-	};
-	_patch.timeEnd = (...args: unknown[]) => {
-		delegate.debug('timeEnd:', ...args);
-	};
-	_patch.profile = (...args: unknown[]) => {
-		delegate.debug('profile:', ...args);
-	};
-	_patch.profileEnd = (...args: unknown[]) => {
-		delegate.debug('profileEnd:', ...args);
-	};
-
-	// biome-ignore lint/suspicious/noGlobalAssign: intentionally replacing console with instrumented version
-	console = globalThis.console = _patch;
-}