Update stats-reporter.js

stats-reporter.js

@@ -10,11 +10,9 @@ 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)
+  FILES_TTL: parseInt(process.env.FILES_TTL || '-1', 10),
+  DEBUG_MODE: process.env.DEBUG_MODE === 'true' // Для включения подробного логирования
 };
 
 // Проверка обязательных переменных
@@ -26,63 +24,126 @@ for (const envVar of requiredEnvVars) {
   }
 }
 
-// Вначале сканируем систему, чтобы найти большие директории
-async function findLargeDirectories() {
+// Функция для подсчета файлов и логирования всех путей
+async function countFilesWithLogging(dirPath) {
   try {
-    console.log(`[${new Date().toISOString()}] Scanning filesystem for large directories...`);
+    let count = 0;
+    let filesList = [];
+    let totalSize = 0;
+    
+    async function traverse(dir) {
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+          
+          try {
+            if (entry.isDirectory()) {
+              await traverse(fullPath);
+            } else {
+              count++;
+              // Получаем размер файла
+              const stats = await fs.stat(fullPath);
+              totalSize += stats.size;
+              
+              // Собираем пути всех файлов
+              if (config.DEBUG_MODE) {
+                filesList.push(`${fullPath} (${formatBytes(stats.size)})`);
+              }
+            }
+          } catch (e) {
+            console.error(`Error processing ${fullPath}: ${e.message}`);
+          }
+        }
+      } catch (e) {
+        console.error(`Error reading directory ${dir}: ${e.message}`);
+      }
+    }
     
-    // Ищем директории с файлами размером больше 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();
+    await traverse(dirPath);
     
-    const largeDirs = output.split('\n').filter(Boolean);
-    console.log(`Found large files in these directories: ${largeDirs.join(', ')}`);
+    // Записываем список файлов для отладки
+    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}`);
+      
+      // Записываем размеры 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)}`);
+      }
+    }
     
-    return largeDirs;
+    return { count, filesList, sizeFromFiles: totalSize };
   } catch (error) {
-    console.error(`Error finding large directories: ${error.message}`);
-    return [];
+    console.error(`Error counting files in ${dirPath}: ${error.message}`);
+    return { count: 0, filesList: [], sizeFromFiles: 0 };
   }
 }
 
-// Функция для получения размера директории
-async function getDirSize(dirPath) {
+// Находим самые большие файлы
+async function findLargestFiles(dirPath, limit = 10) {
   try {
-    // Проверяем существование директории перед измерением
-    await fs.access(dirPath);
+    // Используем find и sort для поиска самых больших файлов
+    const cmd = `find "${dirPath}" -type f -exec du -sh {} \\; | sort -rh | head -n ${limit}`;
+    const output = execSync(cmd).toString().trim();
     
-    // Используем du для получения размера директории
-    const output = execSync(`du -sb "${dirPath}" | cut -f1`).toString().trim();
-    return parseInt(output, 10);
+    return output.split('\n')
+      .filter(Boolean)
+      .map(line => {
+        const parts = line.trim().split(/\s+/);
+        const size = parts[0];
+        const path = parts.slice(1).join(' ');
+        
+        // Преобразуем размер в байты для сортировки
+        const sizeInBytes = humanReadableToBytes(size);
+        
+        return {
+          size: sizeInBytes,
+          sizeHuman: size,
+          path: path
+        };
+      });
   } catch (error) {
-    console.error(`Error getting directory size for ${dirPath}: ${error.message}`);
-    return 0;
+    console.error(`Error finding largest files: ${error.message}`);
+    return [];
   }
 }
 
-// Функция для подсчета файлов в директории (рекурсивно)
-async function countFiles(dirPath) {
+// Преобразование человекочитаемого размера в байты
+function humanReadableToBytes(sizeStr) {
+  const units = {
+    'B': 1,
+    'K': 1024,
+    'M': 1024 * 1024,
+    'G': 1024 * 1024 * 1024,
+    'T': 1024 * 1024 * 1024 * 1024
+  };
+  
   try {
-    await fs.access(dirPath);
-    let count = 0;
-    
-    async function traverse(dir) {
-      const entries = await fs.readdir(dir, { withFileTypes: true });
-      
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        
-        if (entry.isDirectory()) {
-          await traverse(fullPath);
-        } else {
-          count++;
-        }
-      }
+    const matches = sizeStr.match(/^(\d+(?:\.\d+)?)([KMGT]?)$/i);
+    if (matches) {
+      const size = parseFloat(matches[1]);
+      const unit = matches[2].toUpperCase() || 'B';
+      return size * (units[unit] || 1);
     }
-    
-    await traverse(dirPath);
-    return count;
+    return 0;
+  } catch (e) {
+    return 0;
+  }
+}
+
+// Функция для получения размера директории
+async function getDirSize(dirPath) {
+  try {
+    const output = execSync(`du -sb "${dirPath}" | cut -f1`).toString().trim();
+    return parseInt(output, 10);
   } catch (error) {
-    console.error(`Error counting files in ${dirPath}: ${error.message}`);
+    console.error(`Error getting directory size: ${error.message}`);
     return 0;
   }
 }
@@ -209,54 +270,30 @@ async function updateStats() {
   try {
     console.log(`[${new Date().toISOString()}] Updating statistics...`);
     
-    // Сначала найдем все крупные директории в системе
-    const largeDirs = await findLargeDirectories();
-    
-    // Запускаем очистку старых файлов, если настроено
-    const cleanupResults = await cleanupOldFiles(config.TELEGRAM_DATA_DIR, config.FILES_TTL);
-    
-    // Основная директория
-    let fileCount = await countFiles(config.TELEGRAM_DATA_DIR);
-    let totalSize = await getDirSize(config.TELEGRAM_DATA_DIR);
+    // Запуск очистки, если настроено
+    const cleanupResults = config.FILES_TTL > 0 
+      ? await cleanupOldFiles(config.TELEGRAM_DATA_DIR, config.FILES_TTL)
+      : { processed: 0, deleted: 0 };
     
-    console.log(`Main directory ${config.TELEGRAM_DATA_DIR}: ${fileCount} files, ${formatBytes(totalSize)}`);
+    // Получаем статистику с подробным логированием
+    const { count: fileCount, sizeFromFiles } = await countFilesWithLogging(config.TELEGRAM_DATA_DIR);
+    const totalSize = await getDirSize(config.TELEGRAM_DATA_DIR);
     
-    // Добавляем все дополнительные директории
-    const allDirs = [...config.ADDITIONAL_SCAN_DIRS, ...largeDirs];
+    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)}`);
     
-    // Уникальные директории (исключаем дубликаты и вложенные)
-    const uniqueDirs = Array.from(new Set(allDirs));
+    // Проверяем, если есть значительное расхождение
+    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 hiddenFilesCommand = `find "${config.TELEGRAM_DATA_DIR}" -name ".*" -not -name "." -not -name ".." -type f | wc -l`;
+    const hiddenFilesCount = parseInt(execSync(hiddenFilesCommand).toString().trim());
     
-    // Проверяем также все дополнительные директории
-    for (const dir of uniqueDirs) {
-      if (dir && dir !== config.TELEGRAM_DATA_DIR) {
-        try {
-          const dirFileCount = await countFiles(dir);
-          const dirSize = await getDirSize(dir);
-          
-          console.log(`Additional directory ${dir}: ${dirFileCount} files, ${formatBytes(dirSize)}`);
-          
-          dirStats[dir] = {
-            files: dirFileCount,
-            sizeBytes: dirSize,
-            sizeHuman: formatBytes(dirSize)
-          };
-          
-          fileCount += dirFileCount;
-          totalSize += dirSize;
-        } catch (e) {
-          console.error(`Error processing directory ${dir}: ${e.message}`);
-        }
-      }
+    if (hiddenFilesCount > 0) {
+      console.log(`Found ${hiddenFilesCount} hidden files`);
     }
     
     const now = Date.now();
@@ -266,8 +303,6 @@ 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,
@@ -275,6 +310,36 @@ async function updateStats() {
       } : { enabled: false }
     };
     
+    // Если включен режим отладки, добавляем информацию о самых больших файлах
+    if (config.DEBUG_MODE) {
+      try {
+        // Список всех файлов в директории (только имена без размеров)
+        const allFilesCommand = `find "${config.TELEGRAM_DATA_DIR}" -type f | sort`;
+        const allFiles = execSync(allFilesCommand).toString().trim().split('\n');
+        
+        // Поиск самых больших файлов
+        const largestFiles = await findLargestFiles(config.TELEGRAM_DATA_DIR, 20);
+        
+        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
+          }))
+        };
+      } catch (e) {
+        console.error(`Error collecting debug info: ${e.message}`);
+        stats.debug = {
+          error: e.message
+        };
+      }
+    }
+    
     // Обновляем статистику в Gist
     const statsJson = JSON.stringify(stats, null, 2);
     await updateGist(config.STATS_GIST_ID, 'telegram-bot-api-stats.json', statsJson);
@@ -304,6 +369,7 @@ async function updateEnvInfo(statsLink) {
       SPACE_ID: spaceId,
       FILES_TTL: config.FILES_TTL,
       UPDATE_INTERVAL_MINUTES: config.UPDATE_INTERVAL_MINUTES,
+      DEBUG_MODE: config.DEBUG_MODE,
       statsLink: statsLink || ''
     };
     
@@ -390,4 +456,5 @@ const intervalMs = config.UPDATE_INTERVAL_MINUTES * 60 * 1000;
 setInterval(runUpdate, intervalMs);
 
 console.log(`[${new Date().toISOString()}] Stats reporter started, updating every ${config.UPDATE_INTERVAL_MINUTES} minutes`);
-console.log(`[${new Date().toISOString()}] File TTL set to ${config.FILES_TTL} hours ${config.FILES_TTL <= 0 ? '(cleanup disabled)' : ''}`);
+console.log(`[${new Date().toISOString()}] File TTL set to ${config.FILES_TTL} hours ${config.FILES_TTL <= 0 ? '(cleanup disabled)' : ''}`);
+console.log(`[${new Date().toISOString()}] Debug mode is ${config.DEBUG_MODE ? 'enabled' : 'disabled'}`);