feat: export log if configured to do so

Author: CarlosFdez

src/GameState.ts

@@ -128,6 +128,8 @@ export class MatchLogEntry {
 }
 
 export class GameState {
+	startTime: number;
+
 	playerCount: number;
 
 	gameOverCount: number;
@@ -155,6 +157,23 @@ export class GameState {
 		return this.players.length;
 	}
 
+	/**
+	 * Returns true if the game state is active for an ongoing game
+	 */
+	get active(): boolean {
+		return Boolean(this.startTime) && !this.complete;
+	}
+
+	/**
+	 * Returns true if the gamestate is representing a completed game.
+	 */
+	get complete(): boolean {
+		return this.gameOverCount === 2;
+	}
+
+	/**
+	 * Resets the game state to default conditions.
+	 */
 	reset(): void {
 		this.players = [];
 		this.matchLog = [];
@@ -163,6 +182,14 @@ export class GameState {
 		this.#missingEntityIds.clear();
 	}
 
+	/**
+	 * Resets the game state to default conditions and marks it as a game that has begun.
+	 */
+	start(): void {
+		this.reset();
+		this.startTime = Date.now();
+	}
+
 	addPlayer(player: Player): Player {
 		const existingPlayer = this.players.find(p => p.id === player.id);
 		if (existingPlayer) {

src/LogWatcher.ts

@@ -20,6 +20,11 @@ export interface Options {
 	logFile: string;
 	configFile: string;
 
+	/**
+	 * Path to save any log files
+	 */
+	logDirectory?: string;
+
 	/**
 	 * The number of lines in each parsing group.
 	 */
@@ -71,6 +76,9 @@ export class LogWatcher extends HspEventsEmitterClass {
 
 	private _updateDebouncer: (filePath: string, stats: fs.Stats) => void;
 
+	private _logStream: fs.WriteStream | null = null;
+	private _linesQueued = new Array<string>();
+
 	constructor(options?: Partial<Options>) {
 		super();
 
@@ -89,6 +97,11 @@ export class LogWatcher extends HspEventsEmitterClass {
 			throw new Error('Log file path does not exist.');
 		}
 
+		if (this.options.logDirectory) {
+			log('output log directory: %s', this.options.logDirectory);
+			fs.mkdirSync(this.options.logDirectory, {recursive: true});
+		}
+
 		// Copy local config file to the correct location.
 		// We're just gonna do this every time.
 		const localConfigFile = path.join(__dirname, '../log.config');
@@ -173,6 +186,8 @@ export class LogWatcher extends HspEventsEmitterClass {
 				this.emit('gamestate-changed', gameState);
 				updated = false;
 			}
+
+			this._handleLogging(line, gameState);
 		});
 
 		if (updated) {
@@ -182,6 +197,55 @@ export class LogWatcher extends HspEventsEmitterClass {
 		return gameState;
 	}
 
+	/**
+	 * Internal method to potentially write a line to the output log (if enabled).
+	 * @param line
+	 * @param gameState
+	 */
+	private _handleLogging(line: string, gameState: GameState) {
+		const activeOrComplete = gameState.active || gameState.complete;
+		if (!this.options.logDirectory || !activeOrComplete) {
+			return;
+		}
+
+		// If there's no file stream and we have enough info to create one, then create one.
+		if (!this._logStream && gameState.active && gameState.numPlayers === 2) {
+			const [player1, player2] = gameState.getAllPlayers();
+			const ext = path.extname(this.options.logFile);
+			const filename = `${gameState.startTime}_${player1?.name ?? 'unknown'}_vs_${player2?.name ?? 'unknown'}${ext}`;
+
+			// Convert the name to something safe to save
+			const specialChars = String.raw`<>:"/\|?*`.split('');
+			const filenameSlugged = filename.split('').map(c => specialChars.includes(c) ? '!' : c).join('');
+
+			// Create write stream
+			const filepath = path.join(this.options.logDirectory, filenameSlugged);
+			this._logStream = fs.createWriteStream(path.normalize(filepath));
+
+			// Flush our "buffer"
+			this._logStream.write(this._linesQueued.join(''));
+			this._linesQueued = [];
+		}
+
+		// Write to output log.
+		// If we are still waiting for players to load,write to a buffer beforehand.
+		// This is because the filename is decided AFTER the file has started.
+		if (gameState.active || (gameState.complete && this._logStream)) {
+			if (this._logStream) {
+				this._logStream.write(line + '\n');
+			} else {
+				// No file stream, so write to our "buffer"
+				this._linesQueued.push(line + '\n');
+			}
+		}
+
+		// If the game is complete, close the output stream
+		if (gameState.complete) {
+			this._logStream?.end();
+			this._logStream = null;
+		}
+	}
+
 	private _update(filePath: string, stats: fs.Stats): void {
 		// We're only going to read the portion of the file that we have not read so far.
 		const newFileSize = stats.size;

src/line-parsers/game-start.ts

@@ -8,7 +8,7 @@ export class GameStartLineParser extends AbstractLineParser {
 	eventName = 'game-start' as const;
 
 	lineMatched(_: string[], gameState: GameState): void {
-		gameState.reset();
+		gameState.start();
 	}
 
 	formatLogMessage(): string {

test/index.spec.ts

@@ -72,6 +72,7 @@ describe('hearthstone-log-watcher', () => {
 			// This is being tested elsewhere, so clear it out here
 			// Removed as a judgement call because this tests way too much.
 			gameState.matchLog = [];
+			delete gameState.startTime;
 
 			expect(gameState).deep.equal({
 				playerCount: 2,