Оптимизация производительности Node.js с помощью кластеризации

console.log('Начало выполнения');
 
setTimeout(() => {
  console.log('Таймер сработал через 2 секунды');
}, 2000);
 
console.log('Продолжение выполнения');

function blockingOperation() {
  const start = Date.now();
  // Имитация сложных вычислений
  while (Date.now() - start < 5000) {
    // Блокирует поток выполнения на 5 секунд
  }
  return 'Результат вычислений';
}
 
app.get('/heavy-calculation', (req, res) => {
  const result = blockingOperation();
  res.send(result);
});

app.post('/parse-csv', async (req, res) => {
  const fileBuffer = await fs.promises.readFile(req.body.filePath);
  
  // Эта операция блокирует Event Loop
  const results = parseCSV(fileBuffer.toString());
  
  // Сохранение в БД происходит асинхронно
  await database.saveResults(results);
  
  res.send({ status: 'success', count: results.length });
});

app.get('/generate-report', (req, res) => {
  // Получаем данные из БД асинхронно
  database.getReportData(req.query.filters)
    .then(data => {
      // Ресурсоемкая обработка начинается здесь
      const processedData = processReportData(data);
      const report = generatePDF(processedData);
      
      res.setHeader('Content-Type', 'application/pdf');
      res.send(report);
    })
    .catch(err => res.status(500).send(err));
});
 
function processReportData(data) {
  // Тяжелые математические операции и преобразования
  // Могут занимать сотни миллисекунд или секунды
  // ...
  return transformedData;
}

const { Worker, isMainThread, parentPort } = require('worker_threads');
 
if (isMainThread) {
  // Код в основном потоке
  const worker = new Worker(__filename);
  worker.on('message', result => {
    console.log('Результат вычислений:', result);
  });
  worker.postMessage('Начать вычисления');
} else {
  // Код в воркере
  parentPort.on('message', message => {
    // Выполняем тяжелые вычисления
    const result = performHeavyCalculation();
    // Отправляем результат обратно в главный поток
    parentPort.postMessage(result);
  });
}

const { exec } = require('child_process');
 
app.get('/expensive-operation', (req, res) => {
  exec('node heavy-calculation.js', (error, stdout, stderr) => {
    if (error) {
      return res.status(500).send(error);
    }
    res.send(stdout);
  });
});

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;
 
if (cluster.isMaster) {
  console.log(`Мастер-процесс ${process.pid} запущен`);
  
  // Создаем воркеры
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
  
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Воркер ${worker.process.pid} завершился`);
    // Перезапускаем упавший воркер
    cluster.fork();
  });
} else {
  // Код сервера для воркеров
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('Привет от сервера\n');
  }).listen(8000);
  
  console.log(`Воркер ${process.pid} запущен`);
}

if (cluster.isMaster) {
  // Использование Round-robin алгоритма
  cluster.schedulingPolicy = cluster.SCHED_RR;
  
  // Или использование стратегии ОС
  // cluster.schedulingPolicy = cluster.SCHED_NONE;
  
  // Создание воркеров...
}

if (cluster.isMaster) {
  const worker = cluster.fork();
  
  // Отправка сообщения от мастера к воркеру
  worker.send({ type: 'config', data: { timeout: 5000 } });
  
  // Получение сообщения от воркера
  worker.on('message', (msg) => {
    console.log('Мастер получил:', msg);
  });
} else {
  // Получение сообщения от мастера
  process.on('message', (msg) => {
    console.log('Воркер получил:', msg);
    
    // Ответ мастеру
    process.send({ type: 'status', data: 'ready' });
  });
}

// В каждом воркере
let localCounter = 0;
 
app.get('/increment', (req, res) => {
  localCounter++;
  res.send(`Локальный счетчик: ${localCounter}`);
});

// Пример проблемы с сессиями
const express = require('express');
const session = require('express-session');
const app = express();
 
app.use(session({
  secret: 'secret-key',
  resave: false,
  saveUninitialized: true
}));
 
app.get('/set', (req, res) => {
  req.session.user = { name: 'John' };
  res.send('Сессия установлена');
});
 
app.get('/get', (req, res) => {
  res.send(req.session.user || 'Сессия не найдена');
});

const express = require('express');
const session = require('express-session');
const RedisStore = require('connect-redis').default;
const { createClient } = require('redis');
const app = express();
 
// Создаем клиент Redis
const redisClient = createClient();
redisClient.connect().catch(console.error);
 
app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: 'secret-key',
  resave: false,
  saveUninitialized: true
}));

if (cluster.isMaster) {
  // Отслеживаем завершение воркеров
  cluster.on('exit', (worker, code, signal) => {
    const exitCode = worker.process.exitCode;
 
    console.log(`Воркер ${worker.process.pid} завершился с кодом: ${exitCode}`);
 
    if (exitCode !== 0) {
      console.log('Воркер завершился с ошибкой. Создаем новый...');
      cluster.fork();
    }
  });
 
  // Отслеживаем онлайн-статус воркеров
  cluster.on('online', (worker) => {
    console.log(`Воркер ${worker.process.pid} запущен и работает`);
  });
}

const cluster = require('cluster');
const express = require('express');
const numCPUs = require('os').cpus().length;
 
// Определяем, является ли текущий процесс мастером
if (cluster.isMaster) {
  console.log(`Мастер ${process.pid} запущен`);
  
  // Создаем воркеры для каждого доступного CPU
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
  
  // Обработка событий завершения воркеров
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Воркер ${worker.process.pid} завершил работу`);
    console.log('Создаем новый воркер...');
    cluster.fork();
  });
} else {
  // Код приложения для воркеров
  const app = express();
  
  app.get('/', (req, res) => {
    res.send(`Привет от воркера ${process.pid}`);
  });
  
  // Имитация CPU-интенсивной операции
  app.get('/compute', (req, res) => {
    let result = 0;
    for (let i = 0; i < 10000000; i++) {
      result += i;
    }
    res.send(`Результат: ${result}, обработано воркером ${process.pid}`);
  });
  
  app.listen(3000, () => {
    console.log(`Воркер ${process.pid} запущен и прослушивает порт 3000`);
  });
}

if (cluster.isMaster) {
  // Мастер-код без подключения к БД
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  // Подключение к БД делается ВНУТРИ каждого воркера
  const mongoose = require('mongoose');
  
  mongoose.connect('mongodb://localhost:27017/myapp', {
    poolSize: 10, // Лимит соединений для каждого воркера
    useNewUrlParser: true,
    useUnifiedTopology: true
  })
  .then(() => {
    console.log(`Воркер ${process.pid} подключился к MongoDB`);
  })
  .catch(err => {
    console.error(`Ошибка подключения к MongoDB в воркере ${process.pid}:`, err);
    process.exit(1); // Завершаем воркер при ошибке подключения
  });
  
  // Код приложения...
}

const WORKERS_RATIO = 1.5; // Коэффициент для I/O-интенсивных задач
const MAX_WORKERS = 16;    // Верхний лимит воркеров
 
let numWorkers = Math.ceil(numCPUs * WORKERS_RATIO);
numWorkers = Math.min(numWorkers, MAX_WORKERS);
 
console.log(`Запуск ${numWorkers} воркеров на ${numCPUs} ядрах CPU`);
 
for (let i = 0; i < numWorkers; i++) {
  cluster.fork();
}

if (cluster.isMaster) {
  const workers = {};
  
  function createWorker() {
    const worker = cluster.fork();
    workers[worker.id] = { 
      id: worker.id,
      pid: worker.process.pid,
      lastHeartbeat: Date.now()
    };
    return worker;
  }
  
  // Создаем начальных воркеров
  for (let i = 0; i < numCPUs; i++) {
    createWorker();
  }
  
  // Проверяем здоровье воркеров каждые 30 секунд
  setInterval(() => {
    const now = Date.now();
    
    for (const id in workers) {
      const worker = workers[id];
      
      // Если последний heartbeat старше 60 секунд, перезапускаем воркер
      if (now - worker.lastHeartbeat > 60000) {
        console.log(`Воркер ${worker.pid} не отвечает, перезапускаем...`);
        
        // Принудительно завершаем зависший воркер
        cluster.workers[id].kill();
        
        // Удаляем из нашего кэша
        delete workers[id];
        
        // Создаем нового воркера
        createWorker();
      }
    }
  }, 30000);
  
  // Обрабатываем сообщения от воркеров
  cluster.on('message', (worker, message) => {
    if (message.type === 'heartbeat') {
      if (workers[worker.id]) {
        workers[worker.id].lastHeartbeat = Date.now();
      }
    }
  });
} else {
  // Каждый воркер отправляет heartbeat каждые 30 секунд
  setInterval(() => {
    process.send({ type: 'heartbeat' });
  }, 30000);
  
  // Код приложения...
}

if (cluster.isWorker) {
  // Обрабатываем необработанные исключения
  process.on('uncaughtException', (err) => {
    console.error(`Необработанное исключение в воркере ${process.pid}:`, err);
    
    // Отправляем уведомление мастеру перед завершением
    process.send({ 
      type: 'error', 
      error: err.message,
      stack: err.stack
    });
    
    // Завершаем процесс с задержкой, чтобы успеть обработать текущие запросы
    setTimeout(() => {
      process.exit(1);
    }, 1000);
  });
  
  // Обрабатываем необработанные отклонения промисов
  process.on('unhandledRejection', (reason, promise) => {
    console.error(`Необработанное отклонение промиса в воркере ${process.pid}:`, reason);
    
    // Дополнительная логика обработки...
  });
}

if (cluster.isMaster) {
  let totalRequests = 0;
  
  // Принимаем обновления счетчика от воркеров
  cluster.on('message', (worker, message) => {
    if (message.type === 'increment_counter') {
      totalRequests += message.value;
      
      // Рассылаем обновленный счетчик всем воркерам
      for (const id in cluster.workers) {
        cluster.workers[id].send({ 
          type: 'counter_update', 
          value: totalRequests 
        });
      }
    }
  });
} else {
  let localCounter = 0;
  let globalCounter = 0;
  
  // Обновление глобального счетчика
  function updateCounter(value) {
    localCounter += value;
    process.send({ type: 'increment_counter', value });
  }
  
  // Получение обновлений от мастера
  process.on('message', (message) => {
    if (message.type === 'counter_update') {
      globalCounter = message.value;
    }
  });
  
  app.get('/api/count', (req, res) => {
    updateCounter(1);
    res.send({
      localRequests: localCounter,
      totalRequests: globalCounter
    });
  });
}

if (cluster.isMaster) {
  const workerCount = numCPUs;
  let workersToRestart = [];
  
  // Начальный запуск воркеров
  for (let i = 0; i < workerCount; i++) {
    cluster.fork();
  }
  
  // Обработчик сигнала для плавного перезапуска
  process.on('SIGUSR2', () => {
    console.log('Получен сигнал для плавного перезапуска');
    
    // Создаем список всех текущих воркеров для перезапуска
    workersToRestart = Object.keys(cluster.workers);
    
    // Запускаем процесс постепенного перезапуска
    restartNextWorker();
  });
  
  // Функция для перезапуска воркеров по одному
  function restartNextWorker() {
    if (workersToRestart.length === 0) {
      console.log('Обновление завершено, все воркеры перезапущены');
      return;
    }
    
    const workerId = workersToRestart.pop();
    const worker = cluster.workers[workerId];
    
    console.log(`Готовим к перезапуску воркер ${worker.process.pid}`);
    
    // Создаем нового воркера перед завершением старого
    const newWorker = cluster.fork();
    
    // Ждем запуска нового воркера
    newWorker.on('online', () => {
      console.log(`Новый воркер ${newWorker.process.pid} запущен`);
      
      // Даем новому воркеру время на инициализацию
      setTimeout(() => {
        // Мягко завершаем старый воркер
        if (worker.isConnected()) {
          worker.disconnect();
          
          // Принудительно убиваем если завис
          const killTimer = setTimeout(() => {
            if (worker.isConnected()) {
              console.log(`Принудительное завершение воркера ${worker.process.pid}`);
              worker.kill();
            }
          }, 5000);
          
          // Очищаем таймер если воркер корректно завершился
          worker.on('exit', () => {
            clearTimeout(killTimer);
            console.log(`Воркер ${worker.process.pid} успешно завершен`);
            
            // Продолжаем с следующим воркером
            setTimeout(restartNextWorker, 1000);
          });
        }
      }, 5000);
    });
  }
}

const express = require('express');
const session = require('express-session');
const RedisStore = require('connect-redis').default;
const { createClient } = require('redis');
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;
 
if (cluster.isMaster) {
  console.log(`Мастер ${process.pid} запущен`);
  
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
  
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Воркер ${worker.process.pid} завершился, запускаем новый...`);
    cluster.fork();
  });
} else {
  const app = express();
  
  // Создаем клиент Redis с опциями повторного подключения
  const redisClient = createClient({
    socket: {
      host: 'localhost',
      port: 6379,
      reconnectStrategy: (retries) => {
        // Экспоненциальная задержка при повторных попытках
        return Math.min(retries * 50, 2000);
      }
    }
  });
  
  // Обработка ошибок подключения
  redisClient.on('error', (err) => {
    console.error(`Ошибка Redis в воркере ${process.pid}:`, err);
  });
  
  // Подключаемся к Redis
  redisClient.connect().catch(console.error);
  
  // Настраиваем сессии с хранилищем Redis
  app.use(session({
    store: new RedisStore({ client: redisClient }),
    secret: 'clustered-session-secret',
    resave: false,
    saveUninitialized: false,
    cookie: {
      secure: process.env.NODE_ENV === 'production',
      maxAge: 24 * 60 * 60 * 1000 // 24 часа
    }
  }));
  
  // Эндпоинты для работы с сессией
  app.get('/set-session', (req, res) => {
    req.session.data = { 
      user: 'test-user', 
      timestamp: Date.now(),
      worker: process.pid 
    };
    res.send('Сессия установлена');
  });
  
  app.get('/get-session', (req, res) => {
    if (req.session.data) {
      res.send({
        sessionData: req.session.data,
        currentWorker: process.pid
      });
    } else {
      res.status(404).send('Сессия не найдена');
    }
  });
  
  app.listen(3000, () => {
    console.log(`Воркер ${process.pid} прослушивает порт 3000`);
  });
}

if (cluster.isMaster) {
  // Определяем роли для воркеров
  const roles = ['api', 'api', 'api', 'background'];
  
  // Создаем воркеры с различными ролями
  roles.forEach((role, index) => {
    const env = { WORKER_ROLE: role };
    const worker = cluster.fork(env);
    
    console.log(`Запущен воркер #${index + 1} с ролью: ${role}`);
  });
} else {
  const app = express();
  const workerRole = process.env.WORKER_ROLE || 'api';
  
  console.log(`Воркер ${process.pid} запущен с ролью: ${workerRole}`);
  
  if (workerRole === 'api') {
    // Настройка API-сервера
    app.get('/api/data', (req, res) => {
      res.send({ status: 'success', worker: process.pid });
    });
    
    app.listen(3000, () => {
      console.log(`API-воркер ${process.pid} прослушивает порт 3000`);
    });
  } else if (workerRole === 'background') {
    // Настройка фонового обработчика
    console.log(`Фоновый воркер ${process.pid} запущен для обработки задач`);
    
    // Не запускаем HTTP-сервер, только обработка фоновых задач
    setInterval(() => {
      console.log(`Фоновый воркер ${process.pid} выполняет плановую задачу`);
      // Логика обработки фоновых задач...
    }, 5000);
  }
}

if (cluster.isWorker) {
  // Массив для хранения активных соединений
  const connections = [];
  
  // Перехватываем создание новых соединений
  server.on('connection', (connection) => {
    const key = connections.length;
    connections.push(connection);
    
    // Удаляем соединение из массива при закрытии
    connection.on('close', () => {
      delete connections[key];
    });
  });
  
  // Обработка сигналов завершения
  process.on('SIGTERM', gracefulShutdown);
  process.on('SIGINT', gracefulShutdown);
  
  function gracefulShutdown() {
    console.log(`Воркер ${process.pid} начинает корректное завершение...`);
    
    // Перестаем принимать новые соединения
    server.close(() => {
      console.log(`Воркер ${process.pid}: HTTP-сервер закрыт`);
    });
    
    // Закрываем все активные соединения
    connections.forEach((connection, key) => {
      connection.end();
      delete connections[key];
    });
    
    // Закрываем соединения с БД и другими сервисами
    if (mongoose.connection) {
      mongoose.connection.close(false, () => {
        console.log(`Воркер ${process.pid}: соединение с MongoDB закрыто`);
      });
    }
    
    // Даем время для завершения текущих операций
    setTimeout(() => {
      console.log(`Воркер ${process.pid} завершает работу...`);
      process.exit(0);
    }, 5000);
  }
}

module.exports = {
  apps: [{
    name: "api-server",
    script: "./app.js",
    instances: "max",
    exec_mode: "cluster",
    watch: true,
    env: {
      NODE_ENV: "development",
    },
    env_production: {
      NODE_ENV: "production",
    },
    // Автоматическое перезапуск при превышении пределов памяти
    max_memory_restart: "1G",
    // Подробное логирование
    log_date_format: "YYYY-MM-DD HH:mm Z",
    // Мониторинг метрик
    merge_logs: true
  }]
}

const cluster = require('cluster');
const numCPUs = require('os').cpus().length;
 
if (cluster.isMaster) {
  console.log(`Главный процесс ${process.pid} запущен`);
  
  // Большой массив данных для обработки
  const bigData = generateBigDataArray(1000000);
  const chunkSize = Math.ceil(bigData.length / numCPUs);
  
  // Создаем воркеры
  for (let i = 0; i < numCPUs; i++) {
    const worker = cluster.fork();
    
    // Передаем каждому воркеру свой сегмент данных
    const start = i * chunkSize;
    const end = Math.min(start + chunkSize, bigData.length);
    worker.send({ 
      type: 'PROCESS_DATA',
      data: bigData.slice(start, end) 
    });
  }
  
  let completedWorkers = 0;
  let results = [];
  
  // Собираем результаты от воркеров
  cluster.on('message', (worker, message) => {
    if (message.type === 'RESULT') {
      results = results.concat(message.data);
      completedWorkers++;
      
      if (completedWorkers === numCPUs) {
        console.log(`Обработка завершена, получено ${results.length} результатов`);
        // Финальная агрегация результатов
        const finalResult = processFinalResult(results);
        console.log(`Финальный результат: ${finalResult}`);
        
        // Завершаем все воркеры
        Object.values(cluster.workers).forEach(w => w.kill());
      }
    }
  });
} else {
  process.on('message', (message) => {
    if (message.type === 'PROCESS_DATA') {
      console.log(`Воркер ${process.pid} начал обработку ${message.data.length} элементов`);
      
      // Произвольная обработка данных (например, фильтрация и трансформация)
      const processedData = message.data
        .filter(item => item > 100)
        .map(item => item * 2);
      
      // Отправляем результаты главному процессу
      process.send({ 
        type: 'RESULT', 
        data: processedData 
      });
    }
  });
}

if (cluster.isMaster) {
  // Агрегированная статистика
  let stats = {
    totalRequests: 0,
    responseTime: {
      sum: 0,
      count: 0,
      avg: 0
    },
    memory: {
      workers: {}
    },
    errors: 0
  };
  
  // Периодически вычисляем метрики
  setInterval(() => {
    stats.responseTime.avg = stats.responseTime.count > 0 
      ? stats.responseTime.sum / stats.responseTime.count 
      : 0;
    
    // Отправка метрик во внешнюю систему мониторинга
    sendMetricsToMonitoring({
      requestsPerSecond: stats.totalRequests / 60, // За последнюю минуту
      avgResponseTime: stats.responseTime.avg,
      workerCount: Object.keys(cluster.workers).length,
      memoryUsage: stats.memory,
      errorRate: stats.errors
    });
    
    // Сбрасываем счетчики для следующего интервала
    stats.totalRequests = 0;
    stats.responseTime.sum = 0;
    stats.responseTime.count = 0;
    stats.errors = 0;
  }, 60000);
  
  // Получаем метрики от воркеров
  cluster.on('message', (worker, message) => {
    if (message.type === 'metrics') {
      stats.totalRequests += message.requests;
      stats.responseTime.sum += message.responseTime.sum;
      stats.responseTime.count += message.responseTime.count;
      stats.memory.workers[worker.id] = message.memory;
      stats.errors += message.errors;
    }
  });
} else {
  // Локальные метрики воркера
  let workerStats = {
    requests: 0,
    responseTime: {
      sum: 0,
      count: 0
    },
    errors: 0
  };
  
  // Отправляем статистику главному процессу каждые 10 секунд
  setInterval(() => {
    process.send({
      type: 'metrics',
      requests: workerStats.requests,
      responseTime: {
        sum: workerStats.responseTime.sum,
        count: workerStats.responseTime.count
      },
      memory: process.memoryUsage(),
      errors: workerStats.errors
    });
    
    // Сбрасываем счетчики
    workerStats.requests = 0;
    workerStats.responseTime.sum = 0;
    workerStats.responseTime.count = 0;
    workerStats.errors = 0;
  }, 10000);
  
  // Измеряем каждый запрос
  app.use((req, res, next) => {
    const start = Date.now();
    
    // Перехватываем завершение запроса
    res.on('finish', () => {
      const duration = Date.now() - start;
      workerStats.requests++;
      workerStats.responseTime.sum += duration;
      workerStats.responseTime.count++;
      
      if (res.statusCode >= 400) {
        workerStats.errors++;
      }
    });
    
    next();
  });
}

if (cluster.isMaster) {
  // Создаем N воркеров для обработки потока данных
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork({ WORKER_ID: i });
  }
} else {
  const workerId = parseInt(process.env.WORKER_ID);
  
  // Подключаемся к источнику потоковых данных
  const streamSource = connectToDataStream();
  
  // Определяем, какие данные должен обрабатывать этот воркер
  streamSource.on('data', (data) => {
    // Простая стратегия шардирования: распределение по хешу ключа
    const hash = calculateHash(data.key);
    if (hash % numCPUs === workerId) {
      // Этот элемент предназначен для обработки данным воркером
      processStreamItem(data);
    }
  });
}

// config для API-шлюза, где важна скорость ответа и высокая доступность
const gatewayConfig = {
  name: "api-gateway",
  script: "./gateway.js",
  instances: Math.max(2, Math.floor(numCPUs / 2)), // Минимум 2 экземпляра 
  exec_mode: "cluster",
  max_memory_restart: "500M",
  exp_backoff_restart_delay: 100 // Быстрый перезапуск при сбоях
};
 
// config для сервиса аналитики, где важна производительность
const analyticsConfig = {
  name: "analytics-service",
  script: "./analytics.js",
  instances: numCPUs, // Используем все ядра
  exec_mode: "cluster", 
  node_args: "--max-old-space-size=4096", // Увеличиваем лимит памяти
};
 
// config для фонового обработчика очередей
const queueProcessorConfig = {
  name: "queue-processor",
  script: "./processor.js",
  instances: Math.max(1, Math.floor(numCPUs / 4)), // Умеренное количество
  exec_mode: "cluster",
  watch: false, // Отключаем автоперезагрузку
};

const circuitBreaker = require('opossum');
 
// Настройка предохранителя для удалённого сервиса
const serviceCall = circuitBreaker(callRemoteService, {
  timeout: 3000,              // Время ожидания ответа
  errorThresholdPercentage: 50, // % ошибок для размыкания цепи
  resetTimeout: 10000         // Время до новой попытки после размыкания
});
 
serviceCall.fallback(() => { 
  return { error: "Сервис временно недоступен", cached: getCachedData() };
});
 
// Метрики предохранителя для мониторинга
serviceCall.stats.on('snapshot', stats => {
  if (cluster.isMaster) {
    console.log(`Состояние предохранителя: ${serviceCall.status}`);
    console.log(`Успешных запросов: ${stats.successes}`);
    console.log(`Ошибок: ${stats.failures}`);
    console.log(`Таймаутов: ${stats.timeouts}`);
  }
});

const io = require('socket.io')(server);
const redisAdapter = require('socket.io-redis');
io.adapter(redisAdapter({ host: 'localhost', port: 6379 }));
 
if (cluster.isWorker) {
  // Глобальная рассылка сообщений работает для всех воркеров через Redis
  io.on('connection', (socket) => {
    console.log(`Клиент подключился к воркеру ${process.pid}`);
    
    socket.on('broadcast', (message) => {
      // Сообщение получат все клиенты, независимо от воркера
      io.emit('message', { 
        text: message,
        from: socket.id,
        worker: process.pid
      });
    });
  });
}