@masuidrive/procman 0.1.2 → 0.2.0

package/dist/src/services/log-manager.js

@@ -5,883 +5,23 @@
  * リアルタイムログストリーミング機能とファイル管理を提供する。
  * ログストリーミングはEventEmitterパターンで実装し、new-log イベントを発行する。
  */
-/* global NodeJS */
 import { EventEmitter } from 'events';
-import * as fs from 'fs';
-import { promises as fsPromises } from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { DEFAULT_LOG_MANAGER_CONFIG, } from './log-manager-config.js';
 import { LogPathValidator, SecureLogPathBuilder, } from './log-path-validator.js';
 import { LOG_STREAM_EVENTS } from '../shared/constants-streaming.js';
 import { EventCleanupHelper } from '../utils/event-cleanup.js';
-// =============================================================================
-// Constants
-// =============================================================================
-/** 特殊文字のエスケープ対象 */
-// eslint-disable-next-line no-control-regex
-const ESCAPE_CHARS = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g;
-// =============================================================================
-// FileManager Class
-// =============================================================================
-/**
- * FileManager - ファイル操作の専門クラス（単一責任原則）
- */
-class FileManager {
-    config;
-    constructor(config = DEFAULT_LOG_MANAGER_CONFIG) {
-        this.config = config;
-    }
-    /**
-     * ファイルの存在確認・作成
-     */
-    ensureFileExists(filePath) {
-        try {
-            // ディレクトリの確認・作成
-            const dir = path.dirname(filePath);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, {
-                    recursive: true,
-                    mode: this.config.file.directoryMode,
-                });
-            }
-            // ファイルが存在しない場合は空ファイルを作成
-            if (!fs.existsSync(filePath)) {
-                fs.writeFileSync(filePath, '', { mode: this.config.file.fileMode });
-            }
-        }
-        catch (error) {
-            console.warn(`[FileManager] Failed to ensure file exists ${filePath}: ${error.message}`);
-        }
-    }
-    /**
-     * ログディレクトリの確認・作成
-     */
-    ensureLogDirectory(logDir) {
-        if (!fs.existsSync(logDir)) {
-            fs.mkdirSync(logDir, {
-                recursive: true,
-                mode: this.config.file.directoryMode,
-            });
-        }
-    }
-    /**
-     * ファイルの末尾から指定行数を効率的に読み込み
-     */
-    async readTailLines(filePath, maxLines) {
-        const stat = fs.statSync(filePath);
-        const fileSize = stat.size;
-        if (fileSize === 0) {
-            return [];
-        }
-        // 小さなファイルの場合は全体を読み込み
-        if (fileSize < this.config.performance.smallFileThreshold) {
-            const content = fs.readFileSync(filePath, 'utf8');
-            return content
-                .split('\n')
-                .filter((line) => line.trim())
-                .slice(-maxLines);
-        }
-        // 大きなファイルの場合は末尾から効率的に読み込み
-        return this.readTailLinesFromLargeFile(filePath, maxLines, fileSize);
-    }
-    /**
-     * 大きなファイルから末尾行数を読み込み（関数分割）
-     */
-    readTailLinesFromLargeFile(filePath, maxLines, fileSize) {
-        const fd = fs.openSync(filePath, 'r');
-        try {
-            return this.readLinesBackward(fd, fileSize, maxLines);
-        }
-        finally {
-            fs.closeSync(fd);
-        }
-    }
-    /**
-     * ファイルを後方から読み込んで行を取得（10行以下に分割）
-     */
-    readLinesBackward(fd, fileSize, maxLines) {
-        let position = fileSize;
-        let lines = [];
-        let buffer = '';
-        while (position > 0 && lines.length < maxLines) {
-            const chunkResult = this.readChunkBackward(fd, position);
-            position = chunkResult.newPosition;
-            buffer = chunkResult.chunk + buffer;
-            lines = this.processBufferLines(buffer, lines, maxLines);
-            buffer = this.extractPartialLine(buffer);
-        }
-        return lines.slice(-maxLines);
-    }
-    /**
-     * 後方からチャンクを読み込み（10行以下）
-     */
-    readChunkBackward(fd, position) {
-        const chunkSize = this.config.file.chunkSize;
-        const readSize = Math.min(chunkSize, position);
-        const newPosition = position - readSize;
-        const chunk = Buffer.alloc(readSize);
-        fs.readSync(fd, chunk, 0, readSize, newPosition);
-        return {
-            chunk: chunk.toString('utf8'),
-            newPosition,
-        };
-    }
-    /**
-     * バッファの行を処理（10行以下）
-     */
-    processBufferLines(buffer, currentLines, maxLines) {
-        const lineArray = buffer.split('\n');
-        const lines = [...currentLines];
-        // 完全な行を先頭に追加（逆順）
-        for (let i = lineArray.length - 2; i >= 0; i--) {
-            const line = lineArray[i].trim();
-            if (line && lines.length < maxLines) {
-                lines.unshift(line);
-            }
-        }
-        return lines;
-    }
-    /**
-     * 部分的な行を抽出（10行以下）
-     */
-    extractPartialLine(buffer) {
-        const lineArray = buffer.split('\n');
-        return lineArray.shift() || '';
-    }
-    /**
-     * リトライ機能付きファイル書き込み
-     */
-    async writeToFileWithRetry(filePath, content, maxRetries) {
-        let lastError = null;
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                await fsPromises.appendFile(filePath, content, { encoding: 'utf8' });
-                return; // 成功した場合はリターン
-            }
-            catch (error) {
-                lastError = error;
-                if (attempt === maxRetries) {
-                    // 最後の試行で失敗した場合はエラーログを出力
-                    console.error(`[FileManager] Failed to write to log file ${filePath} after ${maxRetries} attempts: ${lastError.message}`);
-                    // エラーを伝播（上位でハンドリング可能にする）
-                    throw lastError;
-                }
-                else {
-                    // リトライ前の短い待機（設定値 * 試行回数）
-                    await new Promise((resolve) => setTimeout(resolve, this.config.file.retryBaseDelay * attempt));
-                }
-            }
-        }
-    }
-}
-// =============================================================================
-// LogPreprocessor Class
-// =============================================================================
-/**
- * LogPreprocessor - ログ前処理の専門クラス（単一責任原則）
- */
-class LogPreprocessor {
-    config;
-    constructor(config = DEFAULT_LOG_MANAGER_CONFIG) {
-        this.config = config;
-    }
-    /**
-     * ログメッセージの前処理
-     */
-    preprocessMessage(message) {
-        let processed = message;
-        // サイズ制限の適用
-        processed = this.applySizeLimit(processed);
-        // 特殊文字のエスケープ
-        processed = this.escapeSpecialChars(processed);
-        // エンコーディング問題の修正
-        processed = this.fixEncodingIssues(processed);
-        // 改行文字の正規化とトリム
-        processed = this.normalizeAndTrim(processed);
-        return processed;
-    }
-    /**
-     * サイズ制限の適用
-     */
-    applySizeLimit(message) {
-        if (message.length > this.config.maxLogMessageSize) {
-            return message.substring(0, this.config.maxLogMessageSize - 3) + '...';
-        }
-        return message;
-    }
-    /**
-     * 特殊文字のエスケープ（制御文字の削除）
-     */
-    escapeSpecialChars(message) {
-        return message.replace(ESCAPE_CHARS, '');
-    }
-    /**
-     * エンコーディング問題の修正
-     */
-    fixEncodingIssues(message) {
-        try {
-            // Buffer経由でUTF-8として解釈し直す
-            const buffer = Buffer.from(message, 'utf8');
-            return buffer.toString('utf8');
-        }
-        catch {
-            // エラーが発生した場合はASCII文字のみを保持
-            return message.replace(/[^\x20-\x7E]/g, '?');
-        }
-    }
-    /**
-     * 改行文字の正規化とトリム
-     */
-    normalizeAndTrim(message) {
-        // 改行文字の正規化
-        const normalized = message.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-        // トリム（前後の空白を削除）
-        return normalized.trim();
-    }
-}
-// =============================================================================
-// LogLevelStrategy Classes
-// =============================================================================
-/**
- * DefaultLogLevelStrategy - デフォルトのログレベル判定戦略（Strategy パターン）
- */
-class DefaultLogLevelStrategy {
-    /**
-     * ログレベルの判定
-     */
-    determineLevel(type, message) {
-        // stderr は基本的に warn 以上
-        if (type === 'stderr') {
-            return this.determineStderrLevel(message);
-        }
-        // stdout でもエラー関連のキーワードがあればエラー扱い
-        return this.determineStdoutLevel(message);
-    }
-    /**
-     * stderr のログレベル判定
-     */
-    determineStderrLevel(message) {
-        const lowerMessage = message.toLowerCase();
-        if (lowerMessage.includes('error') || lowerMessage.includes('fatal')) {
-            return 'error';
-        }
-        return 'warn';
-    }
-    /**
-     * stdout のログレベル判定
-     */
-    determineStdoutLevel(message) {
-        const lowerMessage = message.toLowerCase();
-        if (lowerMessage.includes('error') || lowerMessage.includes('fatal')) {
-            return 'error';
-        }
-        if (lowerMessage.includes('warn') || lowerMessage.includes('warning')) {
-            return 'warn';
-        }
-        return 'info';
-    }
-}
-// =============================================================================
-// EventManager Class
-// =============================================================================
-/**
- * EventManager - イベント発行の専門クラス（単一責任原則）
- */
-class EventManager {
-    eventEmitter;
-    constructor(eventEmitter) {
-        this.eventEmitter = eventEmitter;
-    }
-    /**
-     * ログイベントの発行
-     */
-    emitLogEvent(logEntry) {
-        this.eventEmitter.emit('log', logEntry);
-        // ストリーミング用の新しいログイベントも発行
-        this.eventEmitter.emit(LOG_STREAM_EVENTS.NEW_LOG, logEntry);
-    }
-    /**
-     * ファイル変更イベントの発行
-     */
-    emitFileChangeEvent(data) {
-        this.eventEmitter.emit('fileChange', data);
-    }
-    /**
-     * ディスク容量エラーイベントの発行
-     */
-    emitDiskSpaceErrorEvent(data) {
-        this.eventEmitter.emit('diskSpaceError', data);
-    }
-}
-// =============================================================================
-// LogBuffer Class
-// =============================================================================
-/**
- * LogBuffer - 高頻度書き込み時のバッファリング管理
- */
-class LogBuffer {
-    onFlush;
-    config;
-    buffer = [];
-    bufferSize = 0;
-    flushTimer = null;
-    isBackpressured = false;
-    constructor(onFlush, config = DEFAULT_LOG_MANAGER_CONFIG) {
-        this.onFlush = onFlush;
-        this.config = config;
-    }
-    /**
-     * ログエントリをバッファに追加
-     */
-    addEntry(entry) {
-        // バックプレッシャー制御
-        if (this.isBackpressured) {
-            return false;
-        }
-        const entrySize = JSON.stringify(entry.logEntry).length;
-        // バッファサイズ制限チェック
-        if (this.bufferSize + entrySize > this.config.buffer.maxSize) {
-            this.flush();
-        }
-        this.buffer.push(entry);
-        this.bufferSize += entrySize;
-        // バックプレッシャー制御
-        if (this.bufferSize > this.config.buffer.backpressureThreshold) {
-            this.isBackpressured = true;
-        }
-        // 定期フラッシュタイマー設定
-        if (!this.flushTimer) {
-            this.flushTimer = setTimeout(async () => {
-                await this.flush();
-            }, this.config.buffer.flushInterval);
-        }
-        return true;
-    }
-    /**
-     * バッファを強制フラッシュ
-     */
-    async flush() {
-        if (this.buffer.length === 0) {
-            return;
-        }
-        const entriesToFlush = [...this.buffer];
-        this.buffer = [];
-        this.bufferSize = 0;
-        this.isBackpressured = false;
-        if (this.flushTimer) {
-            clearTimeout(this.flushTimer);
-            this.flushTimer = null;
-        }
-        try {
-            await this.onFlush(entriesToFlush);
-        }
-        catch (error) {
-            console.error(`[LogBuffer] Failed to flush entries: ${error.message}`);
-            // 重要：失敗したエントリは失われるが、バッファが詰まるのを防ぐ
-        }
-    }
-    /**
-     * バッファクリーンアップ
-     */
-    async cleanup() {
-        await this.flush();
-        if (this.flushTimer) {
-            clearTimeout(this.flushTimer);
-            this.flushTimer = null;
-        }
-    }
-    /**
-     * バッファ統計情報
-     */
-    getStats() {
-        return {
-            entryCount: this.buffer.length,
-            bufferSize: this.bufferSize,
-            isBackpressured: this.isBackpressured,
-        };
-    }
-}
-/**
- * AppLogger - 個別アプリケーションのログ管理（リファクタリング後）
- */
-class AppLogger {
-    logDir;
-    eventEmitter;
-    managerConfig;
-    logInfo;
-    watchers = [];
-    logBuffer;
-    partialLines = new Map();
-    // 依存性注入されたサービスクラス
-    fileManager;
-    logPreprocessor;
-    logLevelStrategy;
-    eventManager;
-    constructor(appName, config, logDir, eventEmitter, managerConfig = DEFAULT_LOG_MANAGER_CONFIG, 
-    // 依存性注入（テスト時にはモックを注入可能）
-    fileManager, logPreprocessor, logLevelStrategy, eventManager) {
-        this.logDir = logDir;
-        this.eventEmitter = eventEmitter;
-        this.managerConfig = managerConfig;
-        this.logInfo = this.initializeLogInfo(appName, config);
-        // 依存性注入の実装（DI コンテナパターン）
-        this.fileManager = fileManager || new FileManager(this.managerConfig);
-        this.logPreprocessor =
-            logPreprocessor || new LogPreprocessor(this.managerConfig);
-        this.logLevelStrategy = logLevelStrategy || new DefaultLogLevelStrategy();
-        this.eventManager = eventManager || new EventManager(this.eventEmitter);
-        this.ensureLogFiles();
-        this.logBuffer = new LogBuffer(async (entries) => await this.flushBufferedEntries(entries), this.managerConfig);
-    }
-    /**
-     * ログ情報の初期化
-     */
-    initializeLogInfo(appName, config) {
-        const namespace = config.namespace || 'default';
-        // ログファイルパスの決定（仕様に従った優先順位）
-        let logFile = null;
-        let outFile = null;
-        let errorFile = null;
-        if (config.outFile && config.errorFile) {
-            // 1. out_file + error_file が指定時 → これらを使用、log_fileは無視
-            outFile = config.outFile;
-            errorFile = config.errorFile;
-        }
-        else if (config.logFile) {
-            // 2. log_file のみ指定時 → stdout/stderrを同一ファイルに出力
-            logFile = config.logFile;
-        }
-        else {
-            // 3. 未指定時 → デフォルトパス
-            logFile = path.join(this.logDir, `${appName}.jsonl`);
-        }
-        return {
-            appName,
-            namespace,
-            logFile,
-            outFile,
-            errorFile,
-            streams: {},
-        };
-    }
-    /**
-     * ログファイルの事前作成（FileManagerに委譲）
-     */
-    ensureLogFiles() {
-        // 統合ログファイル
-        if (this.logInfo.logFile) {
-            this.fileManager.ensureFileExists(this.logInfo.logFile);
-        }
-        // stdout専用ファイル
-        if (this.logInfo.outFile) {
-            this.fileManager.ensureFileExists(this.logInfo.outFile);
-        }
-        // stderr専用ファイル
-        if (this.logInfo.errorFile) {
-            this.fileManager.ensureFileExists(this.logInfo.errorFile);
-        }
-    }
-    /**
-     * プロセス出力のキャプチャとログ記録
-     * ProcessLifecycleManagerからの stdout/stderr データを処理
-     */
-    captureProcessOutput(type, data) {
-        // 既存の部分的な行を取得
-        const existingPartial = this.partialLines.get(type) || '';
-        const fullData = existingPartial + data;
-        // 改行で分割
-        const lines = fullData.split('\n');
-        // 最後の要素は部分的な行か空文字列
-        const partialLine = lines.pop() || '';
-        this.partialLines.set(type, partialLine);
-        // 完全な行を処理
-        for (const line of lines) {
-            if (line.length > 0) {
-                this.writeLogWithPreprocessing(type, line);
-            }
-        }
-    }
-    /**
-     * ログエントリの前処理を含む書き込み（10行以下に分割）
-     */
-    writeLogWithPreprocessing(type, message) {
-        const processedMessage = this.logPreprocessor.preprocessMessage(message);
-        const logEntry = this.createLogEntry(type, processedMessage);
-        const targetFiles = this.determineTargetFiles(type);
-        this.addToBufferAndEmitEvent(logEntry, targetFiles);
-    }
-    /**
-     * ログエントリの作成（10行以下）
-     */
-    createLogEntry(type, processedMessage) {
-        return {
-            timestamp: Date.now(),
-            level: this.logLevelStrategy.determineLevel(type, processedMessage),
-            message: processedMessage,
-            app: this.logInfo.appName,
-            namespace: this.logInfo.namespace,
-            type,
-        };
-    }
-    /**
-     * バッファ追加とイベント発行（10行以下）
-     */
-    addToBufferAndEmitEvent(logEntry, targetFiles) {
-        const bufferedEntry = {
-            logEntry,
-            targetFiles,
-            timestamp: Date.now(),
-        };
-        const added = this.logBuffer.addEntry(bufferedEntry);
-        this.handleBufferBackpressure(added);
-        this.eventManager.emitLogEvent(logEntry);
-    }
-    /**
-     * バッファバックプレッシャーの処理（10行以下）
-     */
-    handleBufferBackpressure(added) {
-        if (!added) {
-            const warningMessage = `Log buffer backpressure active for app: ${this.logInfo.appName}`;
-            console.warn(`[AppLogger] ${warningMessage}`);
-            // バックプレッシャーイベントを発行
-            this.eventEmitter.emit('bufferWarning', {
-                message: warningMessage,
-                appName: this.logInfo.appName,
-                timestamp: Date.now(),
-            });
-        }
-    }
-    /**
-     * 書き込み対象ファイルの決定（関数分割）
-     */
-    determineTargetFiles(type) {
-        const targetFiles = [];
-        if (this.logInfo.logFile) {
-            targetFiles.push(this.logInfo.logFile);
-        }
-        if (type === 'stdout' && this.logInfo.outFile) {
-            targetFiles.push(this.logInfo.outFile);
-        }
-        else if (type === 'stderr' && this.logInfo.errorFile) {
-            targetFiles.push(this.logInfo.errorFile);
-        }
-        return targetFiles;
-    }
-    /**
-     * ログエントリの書き込み（互換性のため維持）
-     */
-    writeLog(type, message) {
-        this.writeLogWithPreprocessing(type, message);
-    }
-    // preprocessLogMessage は LogPreprocessor に移動済み
-    /**
-     * バッファされたエントリをファイルに書き込み（20行以下に分割）
-     */
-    async flushBufferedEntries(entries) {
-        // ファイル別にエントリをグループ化
-        const fileEntries = this.groupEntriesByFile(entries);
-        // ファイル別に並列書き込み
-        const writePromises = this.createWritePromises(fileEntries);
-        // 全ての書き込みの完了を待機
-        await this.executeParallelWrites(writePromises);
-    }
-    /**
-     * エントリをファイル別にグループ化（関数分割）
-     */
-    groupEntriesByFile(entries) {
-        const fileEntries = new Map();
-        for (const bufferedEntry of entries) {
-            for (const filePath of bufferedEntry.targetFiles) {
-                if (!fileEntries.has(filePath)) {
-                    fileEntries.set(filePath, []);
-                }
-                fileEntries.get(filePath).push(bufferedEntry.logEntry);
-            }
-        }
-        return fileEntries;
-    }
-    /**
-     * 書き込みPromise配列を作成（関数分割）
-     */
-    createWritePromises(fileEntries) {
-        const writePromises = [];
-        for (const [filePath, logEntries] of fileEntries) {
-            const logLines = logEntries
-                .map((entry) => JSON.stringify(entry) + '\n')
-                .join('');
-            const writePromise = this.writeToFileWithRetryAndHandleError(filePath, logLines);
-            writePromises.push(writePromise);
-        }
-        return writePromises;
-    }
-    /**
-     * 並列書き込みを実行（関数分割）
-     */
-    async executeParallelWrites(writePromises) {
-        try {
-            await Promise.allSettled(writePromises);
-        }
-        catch (error) {
-            // Promise.allSettledは例外を投げないが、念のため
-            console.error(`[AppLogger] Unexpected error during batch write: ${error.message}`);
-        }
-    }
-    /**
-     * リトライ機能付きファイル書き込みとエラーハンドリング
-     */
-    async writeToFileWithRetryAndHandleError(filePath, content) {
-        try {
-            // FileManager に委譲
-            await this.fileManager.writeToFileWithRetry(filePath, content, this.managerConfig.file.maxRetries);
-        }
-        catch (error) {
-            const lastError = error;
-            // ディスク容量不足の場合は特別な処理
-            if (lastError.message.includes('ENOSPC')) {
-                this.handleDiskSpaceError(filePath);
-            }
-            else {
-                // その他のエラー（権限エラーなど）もイベント発行
-                this.eventEmitter.emit('error', {
-                    message: lastError.message,
-                    filePath,
-                    appName: this.logInfo.appName,
-                    timestamp: Date.now(),
-                    error: lastError,
-                });
-            }
-            // エラーを再スロー（上位でハンドリングできるように）
-            // throw lastError;
-        }
-    }
-    /**
-     * ディスク容量不足エラーの処理（EventManagerに委譲）
-     */
-    handleDiskSpaceError(filePath) {
-        const errorMessage = `Disk space error detected for ${filePath}. Consider implementing log rotation or cleanup.`;
-        console.error(`[AppLogger] ${errorMessage}`);
-        // イベントとして通知（EventManagerに委譲）
-        this.eventManager.emitDiskSpaceErrorEvent({
-            filePath,
-            appName: this.logInfo.appName,
-            timestamp: Date.now(),
-            message: errorMessage,
-        });
-    }
-    // determineLogLevel は LogLevelStrategy に移動済み
-    /**
-     * ファイル監視の開始
-     */
-    async startWatching() {
-        // 既存の監視を停止
-        this.stopWatching();
-        const filesToWatch = [];
-        if (this.logInfo.logFile) {
-            filesToWatch.push({ file: this.logInfo.logFile, type: 'combined' });
-        }
-        if (this.logInfo.outFile) {
-            filesToWatch.push({ file: this.logInfo.outFile, type: 'stdout' });
-        }
-        if (this.logInfo.errorFile) {
-            filesToWatch.push({ file: this.logInfo.errorFile, type: 'stderr' });
-        }
-        for (const { file, type } of filesToWatch) {
-            if (fs.existsSync(file)) {
-                try {
-                    const watcher = fs.watch(file, (eventType) => {
-                        if (eventType === 'change') {
-                            // EventManager に委譲
-                            this.eventManager.emitFileChangeEvent({
-                                appName: this.logInfo.appName,
-                                file,
-                                type,
-                            });
-                        }
-                    });
-                    this.watchers.push(watcher);
-                }
-                catch (error) {
-                    console.warn(`[AppLogger] Failed to watch ${file}: ${error.message}`);
-                }
-            }
-        }
-    }
-    /**
-     * ファイル監視の停止
-     */
-    stopWatching() {
-        for (const watcher of this.watchers) {
-            watcher.close();
-        }
-        this.watchers = [];
-    }
-    /**
-     * ログの読み込み（20行以下に分割）
-     */
-    async readLogs(options = {}) {
-        const { lines = 100 } = options;
-        // ログファイルの選択
-        const logFile = this.selectLogFile(options.type);
-        if (!logFile || !fs.existsSync(logFile)) {
-            return [];
-        }
-        // ファイルからログエントリを読み込み・解析
-        return this.readAndParseLogEntries(logFile, lines, options);
-    }
-    /**
-     * ログファイルの選択（関数分割）
-     */
-    selectLogFile(type) {
-        if (type && type.length === 1) {
-            switch (type[0]) {
-                case 'stdout':
-                    return this.logInfo.outFile || this.logInfo.logFile;
-                case 'stderr':
-                    return this.logInfo.errorFile || this.logInfo.logFile;
-                default:
-                    return this.logInfo.logFile;
-            }
-        }
-        return this.logInfo.logFile;
-    }
-    /**
-     * ログエントリの読み込みと解析（関数分割）
-     */
-    async readAndParseLogEntries(logFile, lines, options) {
-        try {
-            // FileManager に委譲
-            const recentLines = await this.fileManager.readTailLines(logFile, lines);
-            return this.parseLogLines(recentLines, options);
-        }
-        catch (error) {
-            console.error(`[AppLogger] Failed to read log file ${logFile}: ${error.message}`);
-            return [];
-        }
-    }
-    /**
-     * ログ行の解析とフィルタリング（関数分割）
-     */
-    parseLogLines(lines, options) {
-        const logEntries = [];
-        for (const line of lines) {
-            try {
-                const entry = JSON.parse(line);
-                // フィルタリング適用
-                if (this.matchesFilter(entry, options)) {
-                    logEntries.push(entry);
-                }
-            }
-            catch {
-                console.warn(`[AppLogger] Failed to parse log line: ${line}`);
-            }
-        }
-        return logEntries;
-    }
-    // readTailLines は FileManager に移動済み
-    /**
-     * ログエントリがフィルタ条件に一致するかチェック
-     */
-    matchesFilter(entry, options) {
-        // レベルフィルタ
-        if (options.level && !options.level.includes(entry.level)) {
-            return false;
-        }
-        // タイプフィルタ
-        if (options.type && !options.type.includes(entry.type)) {
-            return false;
-        }
-        // 時間範囲フィルタ
-        if (options.since && entry.timestamp < options.since) {
-            return false;
-        }
-        if (options.until && entry.timestamp > options.until) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * ログのクリア
-     */
-    async clearLogs() {
-        const filesToClear = [];
-        if (this.logInfo.logFile) {
-            filesToClear.push(this.logInfo.logFile);
-        }
-        if (this.logInfo.outFile) {
-            filesToClear.push(this.logInfo.outFile);
-        }
-        if (this.logInfo.errorFile) {
-            filesToClear.push(this.logInfo.errorFile);
-        }
-        for (const file of filesToClear) {
-            if (fs.existsSync(file)) {
-                fs.writeFileSync(file, '');
-            }
-        }
-    }
-    /**
-     * 残りの部分的な行を強制フラッシュ
-     */
-    flushPartialLines() {
-        for (const [type, partialLine] of this.partialLines) {
-            if (partialLine.trim().length > 0) {
-                this.writeLogWithPreprocessing(type, partialLine);
-            }
-        }
-        this.partialLines.clear();
-    }
-    /**
-     * バッファ統計情報の取得
-     */
-    getBufferStats() {
-        return this.logBuffer.getStats();
-    }
-    /**
-     * バッファを強制フラッシュ
-     */
-    async flushBuffer() {
-        await this.logBuffer.flush();
-    }
-    /**
-     * リソースのクリーンアップ
-     */
-    async close() {
-        // 残りの部分的な行をフラッシュ
-        this.flushPartialLines();
-        // バッファをクリーンアップ（フラッシュ含む）
-        await this.logBuffer.cleanup();
-        // ファイル監視停止
-        this.stopWatching();
-        // ストリーム管理は不要
-        this.logInfo.streams = {};
-    }
-    /**
-     * ログ統計情報の取得
-     */
-    getLogStats() {
-        const stats = {};
-        try {
-            if (this.logInfo.logFile && fs.existsSync(this.logInfo.logFile)) {
-                const stat = fs.statSync(this.logInfo.logFile);
-                stats.logFileSize = stat.size;
-                stats.lastModified = stat.mtime.getTime();
-            }
-            if (this.logInfo.outFile && fs.existsSync(this.logInfo.outFile)) {
-                const stat = fs.statSync(this.logInfo.outFile);
-                stats.outFileSize = stat.size;
-            }
-            if (this.logInfo.errorFile && fs.existsSync(this.logInfo.errorFile)) {
-                const stat = fs.statSync(this.logInfo.errorFile);
-                stats.errorFileSize = stat.size;
-            }
-        }
-        catch (error) {
-            console.warn(`[AppLogger] Failed to get stats: ${error.message}`);
-        }
-        return stats;
-    }
-}
+import { FileManager } from './log-file-manager.js';
+import { AppLogger } from './app-logger.js';
+// Re-export everything from split modules for backward compatibility
+export { ESCAPE_CHARS, } from './log-manager-types.js';
+export { FileManager } from './log-file-manager.js';
+export { LogPreprocessor } from './log-preprocessor.js';
+export { DefaultLogLevelStrategy } from './log-level-strategy.js';
+export { EventManager } from './log-event-manager.js';
+export { LogBuffer } from './log-buffer.js';
+export { AppLogger } from './app-logger.js';
 // =============================================================================
 // LogManager Class
 // =============================================================================