Update stats-reporter.js

stats-reporter.js

@@ -10,7 +10,10 @@ const config = {
   STATS_GIST_ID: process.env.STATS_GIST_ID || '',
   ENV_GIST_ID: process.env.ENV_GIST_ID || '',
   UPDATE_INTERVAL_MINUTES: parseInt(process.env.UPDATE_INTERVAL_MINUTES || '1440', 10),
+  // Основной путь для данных Telegram Bot API
   TELEGRAM_DATA_DIR: process.env.TELEGRAM_DATA_DIR || '/var/lib/telegram-bot-api',
+  // Дополнительные пути для сканирования, разделенные запятыми
+  ADDITIONAL_SCAN_DIRS: (process.env.ADDITIONAL_SCAN_DIRS || '').split(',').filter(Boolean),
   FILES_TTL: parseInt(process.env.FILES_TTL || '-1', 10),
   DEBUG_MODE: process.env.DEBUG_MODE === 'true' // Для включения подробного логирования
 };
@@ -24,6 +27,24 @@ for (const envVar of requiredEnvVars) {
   }
 }
 
+// Вначале сканируем систему, чтобы найти большие директории
+async function findLargeDirectories() {
+  try {
+    console.log(`[${new Date().toISOString()}] Scanning filesystem for large directories...`);
+    
+    // Ищем директории с файлами размером больше 10MB
+    const output = execSync(`find / -type d -path "/proc" -prune -o -path "/sys" -prune -o -path "/dev" -prune -o -type f -size +10M -exec dirname {} \\; 2>/dev/null | sort | uniq`).toString().trim();
+    
+    const largeDirs = output.split('\n').filter(Boolean);
+    console.log(`Found large files in these directories: ${largeDirs.join(', ')}`);
+    
+    return largeDirs;
+  } catch (error) {
+    console.error(`Error finding large directories: ${error.message}`);
+    return [];
+  }
+}
+
 // Функция для подсчета файлов и логирования всех путей
 async function countFilesWithLogging(dirPath) {
   try {
@@ -66,15 +87,21 @@ async function countFilesWithLogging(dirPath) {
     // Записываем список файлов для отладки
     if (config.DEBUG_MODE) {
       console.log(`=== DEBUG: Found ${count} files in ${dirPath} with total size ${formatBytes(totalSize)} ===`);
-      const debugFilename = `/tmp/telegram-api-files-${Date.now()}.txt`;
-      await fs.writeFile(debugFilename, filesList.join('\n'));
-      console.log(`DEBUG: Full file list saved to ${debugFilename}`);
+      
+      // Пишем в файл только если количество файлов не слишком большое
+      if (filesList.length <= 10000) {
+        const debugFilename = `/tmp/telegram-api-files-${path.basename(dirPath)}-${Date.now()}.txt`;
+        await fs.writeFile(debugFilename, filesList.join('\n'));
+        console.log(`DEBUG: Full file list saved to ${debugFilename}`);
+      } else {
+        console.log(`DEBUG: Too many files (${filesList.length}) to save to disk, skipping file listing`);
+      }
       
       // Записываем размеры 10 самых больших файлов
       console.log(`=== DEBUG: Top 10 largest files in ${dirPath} ===`);
       const largestFiles = await findLargestFiles(dirPath, 10);
       for (const file of largestFiles) {
-        console.log(`${file.path}: ${formatBytes(file.size)}`);
+        console.log(`${file.path}: ${file.sizeHuman}`);
       }
     }
     
@@ -270,30 +297,56 @@ async function updateStats() {
   try {
     console.log(`[${new Date().toISOString()}] Updating statistics...`);
     
-    // Запуск очистки, если настроено
+    // Сначала найдем все крупные директории в системе
+    const largeDirs = await findLargeDirectories();
+    
+    // Запускаем очистку старых файлов, если настроено
     const cleanupResults = config.FILES_TTL > 0 
       ? await cleanupOldFiles(config.TELEGRAM_DATA_DIR, config.FILES_TTL)
       : { processed: 0, deleted: 0 };
     
-    // Получаем статистику с подробным логированием
-    const { count: fileCount, sizeFromFiles } = await countFilesWithLogging(config.TELEGRAM_DATA_DIR);
-    const totalSize = await getDirSize(config.TELEGRAM_DATA_DIR);
+    // Основная директория
+    const mainDirResult = await countFilesWithLogging(config.TELEGRAM_DATA_DIR);
+    let fileCount = mainDirResult.count;
+    let totalSize = await getDirSize(config.TELEGRAM_DATA_DIR);
     
-    console.log(`Directory ${config.TELEGRAM_DATA_DIR}: ${fileCount} files`);
-    console.log(`Size from du command: ${formatBytes(totalSize)}`);
-    console.log(`Size from summing files: ${formatBytes(sizeFromFiles)}`);
+    console.log(`Main directory ${config.TELEGRAM_DATA_DIR}: ${fileCount} files, ${formatBytes(totalSize)}`);
     
-    // Проверяем, если есть значительное расхождение
-    if (Math.abs(totalSize - sizeFromFiles) > 1024 * 1024) { // Больше 1 МБ разницы
-      console.log(`WARNING: Significant difference between directory size and sum of file sizes: ${formatBytes(Math.abs(totalSize - sizeFromFiles))}`);
-    }
+    // Информация о каждой директории
+    const dirStats = {
+      [config.TELEGRAM_DATA_DIR]: {
+        files: fileCount,
+        sizeBytes: totalSize,
+        sizeHuman: formatBytes(totalSize)
+      }
+    };
+    
+    // Добавляем все дополнительные директории
+    const allDirs = [...config.ADDITIONAL_SCAN_DIRS, ...largeDirs];
     
-    // Проверяем наличие скрытых файлов
-    const hiddenFilesCommand = `find "${config.TELEGRAM_DATA_DIR}" -name ".*" -not -name "." -not -name ".." -type f | wc -l`;
-    const hiddenFilesCount = parseInt(execSync(hiddenFilesCommand).toString().trim());
+    // Уникальные директории (исключаем дубликаты и вложенные)
+    const uniqueDirs = Array.from(new Set(allDirs))
+      .filter(dir => dir && dir !== config.TELEGRAM_DATA_DIR);
     
-    if (hiddenFilesCount > 0) {
-      console.log(`Found ${hiddenFilesCount} hidden files`);
+    // Проверяем также все дополнительные директории
+    for (const dir of uniqueDirs) {
+      try {
+        const dirResult = await countFilesWithLogging(dir);
+        const dirSize = await getDirSize(dir);
+        
+        console.log(`Additional directory ${dir}: ${dirResult.count} files, ${formatBytes(dirSize)}`);
+        
+        dirStats[dir] = {
+          files: dirResult.count,
+          sizeBytes: dirSize,
+          sizeHuman: formatBytes(dirSize)
+        };
+        
+        fileCount += dirResult.count;
+        totalSize += dirSize;
+      } catch (e) {
+        console.error(`Error processing directory ${dir}: ${e.message}`);
+      }
     }
     
     const now = Date.now();
@@ -303,6 +356,8 @@ async function updateStats() {
       fileCount,
       totalSizeBytes: totalSize,
       totalSizeHuman: formatBytes(totalSize),
+      directoryStats: dirStats,
+      scannedDirectories: [config.TELEGRAM_DATA_DIR, ...uniqueDirs].filter(Boolean),
       cleanupResults: config.FILES_TTL > 0 ? {
         ttlHours: config.FILES_TTL,
         processedItems: cleanupResults.processed,
@@ -313,24 +368,29 @@ async function updateStats() {
     // Если включен режим отладки, добавляем информацию о самых больших файлах
     if (config.DEBUG_MODE) {
       try {
-        // Список всех файлов в директории (только имена без размеров)
-        const allFilesCommand = `find "${config.TELEGRAM_DATA_DIR}" -type f | sort`;
-        const allFiles = execSync(allFilesCommand).toString().trim().split('\n');
+        // Поиск самых больших файлов во всех директориях
+        const allLargestFiles = [];
+        
+        for (const dir of [config.TELEGRAM_DATA_DIR, ...uniqueDirs]) {
+          try {
+            const largestFiles = await findLargestFiles(dir, 5);
+            allLargestFiles.push(...largestFiles.map(file => ({
+              directory: dir,
+              path: file.path,
+              size: file.size,
+              sizeHuman: file.sizeHuman
+            })));
+          } catch (e) {
+            console.error(`Error finding largest files in ${dir}: ${e.message}`);
+          }
+        }
         
-        // Поиск самых больших файлов
-        const largestFiles = await findLargestFiles(config.TELEGRAM_DATA_DIR, 20);
+        // Сортируем по размеру
+        allLargestFiles.sort((a, b) => b.size - a.size);
         
+        // Добавляем отладочную информацию
         stats.debug = {
-          totalFiles: fileCount,
-          hiddenFiles: hiddenFilesCount,
-          sizeFromDu: totalSize,
-          sizeFromFiles: sizeFromFiles,
-          fileListSample: allFiles.slice(0, 100), // Первые 100 файлов
-          largestFiles: largestFiles.map(file => ({
-            path: file.path,
-            size: file.size,
-            sizeHuman: file.sizeHuman
-          }))
+          largestFiles: allLargestFiles.slice(0, 20)  // Top 20 largest files overall
         };
       } catch (e) {
         console.error(`Error collecting debug info: ${e.message}`);