@masuidrive/procman 0.1.0

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

@@ -0,0 +1,1199 @@
+/**
+ * Log Manager - ログ管理システム
+ *
+ * アプリケーションプロセスのstdout/stderrを集約し、JSONL形式でログを管理する。
+ * リアルタイムログストリーミング機能とファイル管理を提供する。
+ * ログストリーミングは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;
+    }
+}
+// =============================================================================
+// LogManager Class
+// =============================================================================
+/**
+ * LogManager - ログ管理システムのメインクラス
+ */
+export class LogManager extends EventEmitter {
+    logDir;
+    appLoggers = new Map();
+    fileManager;
+    config;
+    pathValidator;
+    securePathBuilder;
+    // Add EventCleanupHelper for proper listener cleanup
+    cleanup = new EventCleanupHelper();
+    constructor(logDir, fileManager, config = DEFAULT_LOG_MANAGER_CONFIG) {
+        super();
+        // Enhanced HOME detection: process.env.HOME || os.homedir()
+        const homeDir = process.env.HOME || os.homedir();
+        if (!homeDir && !logDir) {
+            throw new Error('Unable to determine home directory for log path');
+        }
+        this.logDir =
+            logDir || path.join(homeDir, '.masuidrive-procman', 'app-logs');
+        this.config = config;
+        this.fileManager = fileManager || new FileManager(this.config);
+        // No additional initialization needed for EventCleanupHelper
+        // パストラバーサル対策の初期化（テスト環境では緩い検証にする）
+        const pathValidationConfig = process.env.NODE_ENV === 'test'
+            ? { forbiddenPatterns: [/\0/] } // テスト環境ではnull byteのみ禁止
+            : undefined;
+        this.pathValidator = new LogPathValidator(this.logDir, pathValidationConfig);
+        this.securePathBuilder = new SecureLogPathBuilder(this.pathValidator);
+        this.ensureLogDirectory();
+    }
+    /**
+     * Private method to register and track listeners
+     */
+    registerListener(emitter, event, listener) {
+        this.cleanup.track(emitter, event, listener);
+    }
+    /**
+     * ログディレクトリの確認・作成（FileManagerに委譲）
+     */
+    ensureLogDirectory() {
+        this.fileManager.ensureLogDirectory(this.logDir);
+    }
+    /**
+     * Sanitize invalid app names to prevent errors
+     */
+    sanitizeAppName(appName) {
+        if (typeof appName !== 'string' || appName.trim() === '') {
+            return 'unknown-app';
+        }
+        // Remove invalid characters and limit length
+        const sanitized = appName
+            .replace(/[/\\<>:"|?*\0]/g, '_')
+            .replace(/^\.+|\.+$/g, '') // Remove leading/trailing dots
+            .substring(0, 64)
+            .trim();
+        return sanitized || 'sanitized-app';
+    }
+    /**
+     * アプリケーションのログ設定（セキュリティ検証付き）
+     */
+    setupAppLogs(appName, config = {}) {
+        // t_wada boundary principle: gracefully handle invalid inputs
+        if (appName == null) {
+            // Silently ignore null/undefined inputs as per test expectation
+            return;
+        }
+        // アプリケーション名のセキュリティ検証
+        let validatedAppName;
+        try {
+            validatedAppName = this.pathValidator.validateApplicationName(appName);
+        }
+        catch {
+            // Gracefully handle invalid app names by sanitizing them
+            validatedAppName = this.sanitizeAppName(appName);
+        }
+        // カスタムパスのセキュリティ検証
+        const secureConfig = this.validateAndSecureConfig(config);
+        // 既存のログ設定があれば閉じる
+        if (this.appLoggers.has(validatedAppName)) {
+            const existingLogger = this.appLoggers.get(validatedAppName);
+            if (existingLogger) {
+                existingLogger.close();
+            }
+        }
+        // 新しいAppLoggerを作成
+        const appLogger = new AppLogger(validatedAppName, secureConfig, this.logDir, this, this.config);
+        this.appLoggers.set(validatedAppName, appLogger);
+    }
+    /**
+     * プロセス出力のキャプチャとログ記録
+     * ProcessManagerからのstdout/stderrイベント処理
+     */
+    captureProcessOutput(appName, type, data) {
+        const appLogger = this.appLoggers.get(appName);
+        if (!appLogger) {
+            console.warn(`[LogManager] No log configuration for app: ${appName}`);
+            return;
+        }
+        appLogger.captureProcessOutput(type, data);
+    }
+    /**
+     * ログエントリの書き込み（互換性のため維持）
+     */
+    writeLog(appName, type, message) {
+        // t_wada boundary principle: gracefully handle invalid inputs
+        if (appName == null || type == null || message == null) {
+            // Silently ignore null/undefined inputs as per test expectation
+            return;
+        }
+        const appLogger = this.appLoggers.get(appName);
+        if (!appLogger) {
+            console.warn(`[LogManager] No log configuration for app: ${appName}`);
+            return;
+        }
+        appLogger.writeLog(type, message);
+    }
+    /**
+     * ファイル監視の開始
+     */
+    async startWatching(appName) {
+        const appLogger = this.appLoggers.get(appName);
+        if (!appLogger) {
+            throw new Error(`No log configuration for app: ${appName}`);
+        }
+        await appLogger.startWatching();
+    }
+    /**
+     * ファイル監視の停止
+     */
+    stopWatching(appName) {
+        const appLogger = this.appLoggers.get(appName);
+        if (appLogger) {
+            appLogger.stopWatching();
+        }
+    }
+    /**
+     * ログの読み込み
+     */
+    async readLogs(appName, options = {}) {
+        const appLogger = this.appLoggers.get(appName);
+        if (!appLogger) {
+            throw new Error(`No log configuration for app: ${appName}`);
+        }
+        return appLogger.readLogs(options);
+    }
+    /**
+     * ログのクリア
+     */
+    async clearLogs(appName) {
+        const appLogger = this.appLoggers.get(appName);
+        if (!appLogger) {
+            throw new Error(`No log configuration for app: ${appName}`);
+        }
+        await appLogger.clearLogs();
+    }
+    /**
+     * ログ統計情報の取得
+     */
+    getLogStats(appName) {
+        const appLogger = this.appLoggers.get(appName);
+        if (!appLogger) {
+            throw new Error(`No log configuration for app: ${appName}`);
+        }
+        return appLogger.getLogStats();
+    }
+    /**
+     * バッファ統計情報の取得
+     */
+    getBufferStats(appName) {
+        const appLogger = this.appLoggers.get(appName);
+        if (!appLogger) {
+            throw new Error(`No log configuration for app: ${appName}`);
+        }
+        return appLogger.getBufferStats();
+    }
+    /**
+     * 全アプリケーションのバッファ統計情報の取得
+     */
+    getAllBufferStats() {
+        const stats = {};
+        for (const [appName, appLogger] of this.appLoggers) {
+            stats[appName] = appLogger.getBufferStats();
+        }
+        return stats;
+    }
+    /**
+     * 指定アプリケーションのバッファを強制フラッシュ
+     */
+    async flushBuffer(appName) {
+        const appLogger = this.appLoggers.get(appName);
+        if (!appLogger) {
+            throw new Error(`No log configuration for app: ${appName}`);
+        }
+        // 型安全にバッファフラッシュ
+        await appLogger.flushBuffer();
+        // 部分的な行もフラッシュ
+        appLogger.flushPartialLines();
+    }
+    /**
+     * 全アプリケーションのバッファを強制フラッシュ
+     */
+    async flushAllBuffers() {
+        const flushPromises = [];
+        for (const appName of this.appLoggers.keys()) {
+            const flushPromise = this.flushBuffer(appName).catch((error) => {
+                console.warn(`[LogManager] Failed to flush buffer for app ${appName}: ${error.message}`);
+            });
+            flushPromises.push(flushPromise);
+        }
+        // 全てのフラッシュ操作を並列実行
+        await Promise.allSettled(flushPromises);
+    }
+    /**
+     * 全てのリソースのクリーンアップ
+     */
+    async close() {
+        // Clean up all tracked listeners
+        await this.cleanup.dispose();
+        // Note: Don't log here as it can cause issues during shutdown
+        // console.log(`[LogManager] Cleaned up ${cleanedUpListeners} managed listeners`);
+        // Clean up app loggers
+        for (const appLogger of this.appLoggers.values()) {
+            await appLogger.close();
+        }
+        this.appLoggers.clear();
+        // Clean up our own listeners (this should be empty after EventCleanupHelper cleanup)
+        this.removeAllListeners();
+    }
+    /**
+     * 設定のセキュリティ検証とパス正規化
+     */
+    validateAndSecureConfig(config) {
+        const secureConfig = { ...config };
+        // カスタムパスがある場合は検証
+        if (config.logFile) {
+            secureConfig.logFile = this.pathValidator.validateLogFilePath(config.logFile);
+        }
+        if (config.outFile) {
+            secureConfig.outFile = this.pathValidator.validateLogFilePath(config.outFile);
+        }
+        if (config.errorFile) {
+            secureConfig.errorFile = this.pathValidator.validateLogFilePath(config.errorFile);
+        }
+        return secureConfig;
+    }
+    /**
+     * 登録されているアプリケーション一覧の取得
+     */
+    getAppNames() {
+        return Array.from(this.appLoggers.keys());
+    }
+    /**
+     * ログの人間向けフォーマット
+     */
+    formatLogForHuman(logEntry) {
+        const timestamp = new Date(logEntry.timestamp);
+        const timeStr = timestamp.toISOString().substring(11, 19); // HH:mm:ss
+        const dateStr = timestamp.toISOString().substring(2, 10); // YY-MM-DD
+        return `[${logEntry.app}] ${dateStr} ${timeStr} > ${logEntry.message}`;
+    }
+    /**
+     * ログストリーミングの開始
+     * 新しいログエントリが追加されるたびにリスナーを呼び出す
+     *
+     * Note: This method now tracks listeners but doesn't use the EventCleanupHelper
+     * because it returns a cleanup function that the caller must use.
+     * The caller is responsible for calling the cleanup function.
+     */
+    startLogStream(appName, listener) {
+        // フィルタリング関数の作成
+        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+        const filterListener = (logEntry) => {
+            // appNameが指定されている場合はフィルタリング
+            if (appName && logEntry.app !== appName) {
+                return;
+            }
+            listener(logEntry);
+        };
+        // new-logイベントのリスナーを登録
+        this.on(LOG_STREAM_EVENTS.NEW_LOG, filterListener);
+        // クリーンアップ関数を返す
+        return () => {
+            this.off(LOG_STREAM_EVENTS.NEW_LOG, filterListener);
+        };
+    }
+    /**
+     * ログストリーミング状態を取得
+     */
+    isStreamingActive() {
+        // EventEmitterのリスナー数をチェック
+        const listeners = this.listenerCount(LOG_STREAM_EVENTS.NEW_LOG);
+        return listeners > 0;
+    }
+    /**
+     * Get statistics about listener management
+     */
+    getListenerStats() {
+        const ownEvents = this.eventNames();
+        let ownListenersCount = 0;
+        for (const event of ownEvents) {
+            ownListenersCount += this.listenerCount(event);
+        }
+        return {
+            managedListeners: this.cleanup.getListenerCount(),
+            ownListeners: ownListenersCount,
+            streamingListeners: this.listenerCount(LOG_STREAM_EVENTS.NEW_LOG),
+        };
+    }
+}
+//# sourceMappingURL=log-manager.js.map