agent-telemetry 0.1.0 → 0.2.0

package/src/writer.ts

@@ -10,23 +10,32 @@
  */
 
 export interface WriterConfig {
-	logDir: string
-	filename: string
-	maxSize: number
-	maxBackups: number
-	prefix: string
+	logDir: string;
+	filename: string;
+	maxSize: number;
+	maxBackups: number;
+	prefix: string;
 }
 
 export interface Writer {
-	write: (line: string) => void
+	write: (line: string) => void;
 }
 
 const DEFAULTS: WriterConfig = {
-	logDir: 'logs',
-	filename: 'telemetry.jsonl',
+	logDir: "logs",
+	filename: "telemetry.jsonl",
 	maxSize: 5_000_000,
 	maxBackups: 3,
-	prefix: '[TEL]',
+	prefix: "[TEL]",
+};
+
+function hasErrnoCode(err: unknown, code: string): boolean {
+	return (
+		typeof err === "object" &&
+		err !== null &&
+		"code" in err &&
+		(err as { code?: unknown }).code === code
+	);
 }
 
 /**
@@ -40,92 +49,158 @@ export async function createWriter(config?: Partial<WriterConfig>): Promise<Writ
 		maxSize: config?.maxSize ?? DEFAULTS.maxSize,
 		maxBackups: config?.maxBackups ?? DEFAULTS.maxBackups,
 		prefix: config?.prefix ?? DEFAULTS.prefix,
-	}
+	};
 	const writeToConsole = (line: string): void => {
 		// biome-ignore lint/suspicious/noConsole: intentional fallback for runtimes without filesystem
-		console.log(`${cfg.prefix} ${line}`)
-	}
+		console.log(`${cfg.prefix} ${line}`);
+	};
 
 	try {
-		const fs = await import('node:fs')
-		const path = await import('node:path')
+		const fs = await import("node:fs");
+		const fsPromises = await import("node:fs/promises");
+		const path = await import("node:path");
 
-		const logDir = path.resolve(cfg.logDir)
-		const logFile = path.join(logDir, cfg.filename)
+		const logDir = path.resolve(cfg.logDir);
+		const logFile = path.join(logDir, cfg.filename);
 
 		// Probe: verify filesystem actually works
 		// (Cloudflare's nodejs_compat stubs succeed silently)
-		fs.mkdirSync(logDir, { recursive: true })
+		await fsPromises.mkdir(logDir, { recursive: true });
 		if (!fs.existsSync(logDir)) {
-			throw new Error('Filesystem probe failed')
+			throw new Error("Filesystem probe failed");
 		}
 
-		let useConsoleFallback = false
+		let useConsoleFallback = false;
+		let flushScheduled = false;
+		let flushInProgress = false;
+		let sizeCache: number | undefined;
+		let pending: string[] = [];
+
+		const unlinkIfExists = async (filePath: string): Promise<void> => {
+			try {
+				await fsPromises.unlink(filePath);
+			} catch (err) {
+				if (!hasErrnoCode(err, "ENOENT")) throw err;
+			}
+		};
+
+		const fileExists = async (filePath: string): Promise<boolean> => {
+			try {
+				await fsPromises.access(filePath);
+				return true;
+			} catch (err) {
+				if (hasErrnoCode(err, "ENOENT")) return false;
+				throw err;
+			}
+		};
+
+		const getCurrentSize = async (): Promise<number> => {
+			if (sizeCache !== undefined) return sizeCache;
+			try {
+				sizeCache = (await fsPromises.stat(logFile)).size;
+			} catch (err) {
+				if (!hasErrnoCode(err, "ENOENT")) throw err;
+				sizeCache = 0;
+			}
+			return sizeCache;
+		};
 
-		const rotate = (): void => {
-			if (!fs.existsSync(logFile)) return
+		const rotate = async (): Promise<void> => {
+			if (!(await fileExists(logFile))) {
+				sizeCache = 0;
+				return;
+			}
 
 			if (cfg.maxBackups <= 0) {
-				fs.unlinkSync(logFile)
-				return
+				await unlinkIfExists(logFile);
+				sizeCache = 0;
+				return;
 			}
 
-			const oldestBackup = `${logFile}.${cfg.maxBackups}`
-			if (fs.existsSync(oldestBackup)) {
-				fs.unlinkSync(oldestBackup)
-			}
+			const oldestBackup = `${logFile}.${cfg.maxBackups}`;
+			await unlinkIfExists(oldestBackup);
 
 			for (let i = cfg.maxBackups - 1; i >= 1; i--) {
-				const from = `${logFile}.${i}`
-				const to = `${logFile}.${i + 1}`
-				if (fs.existsSync(from)) {
-					fs.renameSync(from, to)
+				const from = `${logFile}.${i}`;
+				const to = `${logFile}.${i + 1}`;
+				if (await fileExists(from)) {
+					await fsPromises.rename(from, to);
 				}
 			}
 
-			fs.renameSync(logFile, `${logFile}.1`)
-		}
+			await fsPromises.rename(logFile, `${logFile}.1`);
+			sizeCache = 0;
+		};
 
-		return {
-			write(line: string) {
-				if (useConsoleFallback) {
-					writeToConsole(line)
-					return
-				}
+		const scheduleFlush = (): void => {
+			if (flushScheduled || flushInProgress || useConsoleFallback) return;
+			flushScheduled = true;
+			queueMicrotask(() => {
+				flushScheduled = false;
+				void flushPending();
+			});
+		};
 
-				try {
-					const lineWithNewline = `${line}\n`
-					const incomingSize = Buffer.byteLength(lineWithNewline)
-					let currentSize = 0
+		const flushPending = async (): Promise<void> => {
+			if (flushInProgress || useConsoleFallback) return;
+			flushInProgress = true;
+
+			try {
+				while (pending.length > 0 && !useConsoleFallback) {
+					const batch = pending;
+					pending = [];
+
+					const chunk = batch.map((line) => `${line}\n`).join("");
+					const incomingSize = Buffer.byteLength(chunk);
 
 					try {
-						currentSize = fs.statSync(logFile).size
-					} catch (err) {
-						const isEnoent =
-							typeof err === 'object' &&
-							err !== null &&
-							'code' in err &&
-							(err as { code?: unknown }).code === 'ENOENT'
-						if (!isEnoent) {
-							throw err
+						let currentSize = await getCurrentSize();
+						if (cfg.maxSize > 0 && currentSize + incomingSize > cfg.maxSize) {
+							await rotate();
+							currentSize = 0;
+						}
+
+						await fsPromises.appendFile(logFile, chunk);
+						sizeCache = currentSize + incomingSize;
+					} catch {
+						useConsoleFallback = true;
+						for (const line of batch) {
+							writeToConsole(line);
 						}
+						for (const line of pending) {
+							writeToConsole(line);
+						}
+						pending = [];
+						sizeCache = undefined;
 					}
+				}
+			} finally {
+				flushInProgress = false;
+				if (pending.length > 0 && !useConsoleFallback) {
+					scheduleFlush();
+				}
+			}
+		};
 
-					if (cfg.maxSize > 0 && currentSize + incomingSize > cfg.maxSize) {
-						rotate()
+		return {
+			write(line: string) {
+				try {
+					if (useConsoleFallback) {
+						writeToConsole(line);
+						return;
 					}
 
-					fs.appendFileSync(logFile, lineWithNewline)
+					pending.push(line);
+					scheduleFlush();
 				} catch {
-					useConsoleFallback = true
-					writeToConsole(line)
+					writeToConsole(line);
 				}
 			},
-		}
+		};
 	} catch {
 		// Import failed or filesystem probe failed — console fallback
 		return {
 			write: writeToConsole,
-		}
+		};
 	}
 }