const { gpt, gptweb } = require("./API/gpt"); const { dalle } =…
- User
User: const { gpt, gptweb } = require("./API/gpt"); const { dalle } = require("./API/dalle"); const { gpt4o } = require("./API/gpt4o"); const { gpt3 } = require("./API/gpt3.5"); const { prompts } = require("./API/gpt-prompts"); const { blackbox } = require("./API/blackbox"); const { qwen } = require("./API/qwen"); const { gemini } = require("./API/gemini"); const WebSocket = require('ws'); const Bottleneck = require('bottleneck'); const { stats, scheduleDailyReset, resetStatistics } = require('./stats'); // Импортируем модуль статистики const fs = require('fs'); const path = require('path'); const Ajv = require('ajv');
// Создаем экземпляр Ajv (проверка входящей переписки на соответствие схеме) const ajv = new Ajv(); // Объект для хранения действий и состояния каждого клиента const clientActions = {}; // Объект для хранения ограничителей по каждому клиенту const limiters = {}; // Замените на ваш домен const allowedOrigin = 'http://gpt.loc';
// Создайте WebSocket-сервер const wss = new WebSocket.Server({ port: 3000 });
wss.on('connection', (ws, req) => {
const urlParams = new URLSearchParams(req.url.split('?')[1]); const userId = urlParams.get('token'); // Получаем UUID из URL const userIP = req.socket.remoteAddress; //console.log("IP-адрес - ", userIP, "Время подключения - ", new Date().toISOString()); const userHeaders = req.headers; // Проверяем Origin if (!checkOrigin(userHeaders.origin, ws)) { return; // Если отклонено, выходим из обработчика } // Увеличиваем общий счетчик подключений stats.totalConnections++; console.log('Client connected with user ID:', userId, 'Домен - ', userHeaders.origin); // Инициализируем состояние клиента, если его еще нет if (!clientActions[userId]) { clientActions[userId] = { actions: [], // Массив для хранения действий connected: true, // Статус подключения }; } else clientActions[userId].connected = true; if (!limiters[userId]) { // Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id) limiters[userId] = new Bottleneck({ maxConcurrent: 1, // Максимальное количество одновременных задач minTime: 1000, // Минимальное время между запросами в миллисекундах highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать) }); } ws.on('message', (message) => { // Проверяем, является ли сообщение экземпляром Buffer if (Buffer.isBuffer(message)) message = message.toString(); try { // Преобразуем строку JSON обратно в объект message = JSON.parse(message); //Получаем историю чата из запроса let messages = message.messages; let model = message.model; // Выполняем валидацию сообщений messages = validateMessages(messages); // Проверяем, остались ли сообщения после валидации if (messages.length === 0) { const response = { code: 2, message: "Нет валидных сообщений для обработки." }; sendMessage(ws, response); return; } // Урезаем последнее сообщение до 2000 символов, если оно от клиента if (messages[messages.length - 1].role === 'user') { messages[messages.length - 1].content = messages[messages.length - 1].content.substring(0, 2000000); } // Увеличиваем общий счетчик запросов stats.totalRequests++; // Используем Bottleneck для управления количеством запросов limiters[userId].schedule(() => { // Отправка запроса на сервер чата if (model == 'gpt-4o') return callGPT4o(messages, ws); else if (model == 'gemini-pro') return callGemini(messages, ws); else if (model == 'qwen') return callQwen(messages, ws); else if (model == 'blackbox') return callBlackbox(messages, ws); else if (model == 'gpt-3.5-turbo') return callGPT35Turbo(messages, ws); else return callGPT4o(messages, ws); }).catch(error => { stats.totalIPBlocks++; //console.error('Rate limit exceeded, message ignored:', error); const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." }; // Отправка ответа клиенту //sendMessage(ws, response); }); } catch (error) { stats.totalWsMessErrors++; console.error('Error parsing JSON:', error); const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."}; console.log(response); // Отправка ответа клиенту sendMessage(ws, response); } }); ws.on('close', () => { clientActions[userId].connected = false; // Обновление статуса подключения delete clientActions[userId]; // Удаление состояния клиента delete limiters[userId]; // Удаление ограничителя для данного клиента console.log('Client ',userId, ' disconnected'); });});
// Запускаем планировщик для статистики scheduleDailyReset();
// Очистка старых соединений раз в минуту (по желанию) setInterval(() => { console.log('Количество активных клиентов - ', Object.keys(clientActions).length); Object.keys(clientActions).forEach(userId => { if (!clientActions[userId].connected) { delete clientActions[userId]; // Удаляем пользователя из памяти, если он отключен delete limiters[userId]; } }); }, 10 * 60 * 1000); // Очистка каждые 10 минут
// Код выводит текущие метрики использования памяти приложения setInterval(() => { const memoryUsage = process.memoryUsage(); console.log(
Текущие метрики использования памяти: RSS: ${memoryUsage.rss / (1024 * 1024)} MB, Heap Total: ${memoryUsage.heapTotal / (1024 * 1024)} MB, Heap Used: ${memoryUsage.heapUsed / (1024 * 1024)} MB, External: ${memoryUsage.external / (1024 * 1024)} MB); }, 60000); // Вывод каждый 60 секундfunction checkOrigin(origin, socket) { if (origin !== allowedOrigin) { console.log('Недопустимый домен. Соединение разорвано: ', origin); socket.close(); // Закрываем соединение, если домен не разрешен return false; // Возвращаем false для индикатора отклонения } return true; // Возвращаем true, если домен разрешен }
// Отправляет ответ клиенту function sendMessage(ws, message) { if (ws.readyState === WebSocket.OPEN) { ws.send(JSON.stringify(message)); } else { console.warn(
Trying to send message to a closed WebSocket connection.); } }// Удаление из массива сообщений не соответствующих схеме function validateMessages(messages) { // Определяем схему для сообщений const schema = { type: 'object', properties: { role: { type: 'string' }, content: { type: 'string' } }, required: ['role', 'content'], additionalProperties: false };
// Фильтруем массив, оставляя только корректные сообщения return messages.filter(message => { // Проверяем, соответствует ли сообщение схеме if (ajv.validate(schema, message)) { // Обрезаем содержимое, если оно длиннее 2000 символов if (message.content.length > 2000000) { message.content = message.content.substring(0, 2000000); } return true; // Сообщение валидно, оставляем в массиве } return false; // Сообщение не валидно, исключаем из массива });}
console.log('WebSocket сервер запущен через порт 3000');
//============== ВЫЗОВ API МОДЕЛЕЙ ================================================= //================================================================================== //================================================================================== //==================================================================================
// GPT4o async function callGPT4o(messages, ws) { try { let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента к GPT4o===:', messages[messages.length - 1]); //console.log('Запрос клиента к GPT4o:', messages); //throw new Error("Намеренная ошибка для тестирования catch"); let messageSent = false; gpt4o({ messages: messages, markdown: false }, (result) => { // Обработка результата внутри колбэка if (result.error) { throw new Error(result.error); // Обрабатываем ошибку, если она есть } try { if (!result.finish) { // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления) fullResponse = result.message || ""; //console.log(result); } else { // Если завершено, выводим полный ответ let response = { code: 1, message: fullResponse}; console.log('Ответ чата: ', response); // Отправка ответа клиенту sendMessage(ws, response); } } catch (callbackError) { console.error('Error processing callback result:', callbackError); if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ stats.totalGPT4oCallbackErrors++; let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." }; sendMessage(ws, errorResponse); messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось } } }); } catch (error) { stats.totalGPT4oMessErrors++; console.error('Error:', error); let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."}; // Отправка ответа клиенту sendMessage(ws, response); }}
// Gemini async function callGemini(messages, ws) { try { let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента к Gemini:', messages[messages.length - 1]); //throw new Error("Намеренная ошибка для тестирования catch"); let messageSent = false; gemini({ messages: messages }, (result) => { // Обработка результата внутри колбэка if (result.error) { throw new Error(result.error); // Обрабатываем ошибку, если она есть } try { if (!result.finish) { // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления) fullResponse = result.message || ""; //console.log(result); } else { // Если завершено, выводим полный ответ let response = { code: 1, message: fullResponse}; console.log('Ответ чата: ', response); // Отправка ответа клиенту sendMessage(ws, response); } } catch (callbackError) { console.error('Error processing callback result:', callbackError); if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ stats.totalGeminiCallbackErrors++; let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." }; sendMessage(ws, errorResponse); messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось } } }); } catch (error) { stats.totalGeminiMessErrors++; console.error('Error:', error); let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."}; // Отправка ответа клиенту sendMessage(ws, response); }}
// Qwen async function callQwen(messages, ws) { try { let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента к Qwen:', messages[messages.length - 1]); //throw new Error("Намеренная ошибка для тестирования catch"); let messageSent = false; qwen({ messages: messages, markdown: false }, (result) => { // Обработка результата внутри колбэка if (result.error) { throw new Error(result.error); // Обрабатываем ошибку, если она есть } try { if (!result.finish) { // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления) fullResponse = result.message || ""; //console.log(result); } else { // Если завершено, выводим полный ответ let response = { code: 1, message: fullResponse}; console.log('Ответ чата: ', response); // Отправка ответа клиенту sendMessage(ws, response); } } catch (callbackError) { console.error('Error processing callback result:', callbackError); if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ stats.totalQwenCallbackErrors++; let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." }; sendMessage(ws, errorResponse); messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось } } }); } catch (error) { stats.totalQwenMessErrors++; console.error('Error:', error); let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."}; // Отправка ответа клиенту sendMessage(ws, response); }}
// Blackbox async function callBlackbox(messages, ws) { try { let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента к Blackbox:', messages[messages.length - 1]); //throw new Error("Намеренная ошибка для тестирования catch"); let messageSent = false; blackbox({ messages: messages, markdown: false, websearch: false, llama: false }, (result) => { // Обработка результата внутри колбэка if (result.error) { throw new Error(result.error); // Обрабатываем ошибку, если она есть } try { if (!result.finish) { // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления) fullResponse = result.message || ""; //console.log(result); } else { // Если завершено, выводим полный ответ let response = { code: 1, message: fullResponse}; console.log('Ответ чата: ', response); // Отправка ответа клиенту sendMessage(ws, response); } } catch (callbackError) { console.error('Error processing callback result:', callbackError); if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ stats.totalBlackboxCallbackErrors++; let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." }; sendMessage(ws, errorResponse); messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось } } }); } catch (error) { stats.totalBlackboxMessErrors++; console.error('Error:', error); let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."}; // Отправка ответа клиенту sendMessage(ws, response); }}
// GPT3.5-Turbo (Отключен в интерфейсе) async function callGPT35Turbo(messages, ws) { try { let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента к GPT3.5-Turbo:', messages[messages.length - 1]); //throw new Error("Намеренная ошибка для тестирования catch"); let messageSent = false; gpt3({ messages: messages, markdown: false }, (result) => { // Обработка результата внутри колбэка if (result.error) { //throw new Error(result.error); // Обрабатываем ошибку, если она есть } try { if (!result.finish) { // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления) fullResponse = result.message || ""; //console.log(result); } else { // Если завершено, выводим полный ответ let response = { code: 1, message: fullResponse}; console.log('Ответ чата: ', response); // Отправка ответа клиенту sendMessage(ws, response); } } catch (callbackError) { console.error('Error processing callback result:', callbackError); if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ stats.totalGPT35CallbackErrors++; let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." }; sendMessage(ws, errorResponse); messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось } } }); } catch (error) { stats.totalGPT35MessErrors++; console.error('Error:', error); let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."}; // Отправка ответа клиенту sendMessage(ws, response); }}
//============== ВЫЗОВ API МОДЕЛЕЙ (КОНЕЦ) ======================
как провести нагрузочное тестирование на этот код на сервере Assistant: провести нагрузочное тестирование на WebSocket сервере, описанном в вашем коде, вы можете использовать специальные инструменты и библиотеки. Я приведу несколько подходов и шагов, которые помогут вам организовать нагрузочное тестирование.
1. Использование специализированных инструментов
Существует несколько инструментов, которые позволяют проводить нагрузочное тестирование WebSocket серверов:
- Artillery: Это мощный инструмент для тестирования нагрузок, который поддерживает WebSockets.
- K6: Также поддерживает WebSocket, и может быть использован для сценарного тестирования с высоким уровнем настройки.
- Gatling: HTTP и WebSockets тестировщик с хорошей производительностью и возможностями визуализации.
- Locust: Позволяет писать сценарии тестирования на Python.
Пример с Artillery
Если вы выберете Artillery, вот как вы можете настроить его для тестирования вашего WebSocket сервера.
- Установите Artillery:
npm install -g artillery- Создайте файл конфигурации Artillery, например
test.yml:
config: target: 'ws://localhost:3000' phases: - duration: 300 arrivalRate: 10 scenarios: - flow: - send: text: '{"token": "user-1", "messages": [{"role":"user", "content":"Test message!"}], "model": "gpt-4o"}' - think: 1- Запустите тест:
artillery run test.yml2. Написание собственного скрипта на Node.js
Вы также можете написать собственный скрипт на Node.js для проведения нагрузочного тестирования. Вот пример простого теста, который создает множество соединений и отправляет сообщения:
const WebSocket = require('ws'); const totalConnections = 100; // Количество одновременных соединений const targetUrl = 'ws://localhost:3000'; const message = '{"token": "user-1", "messages": [{"role":"user", "content":"Test message!"}], "model": "gpt-4o"}'; for (let i = 0; i < totalConnections; i++) { const ws = new WebSocket(targetUrl); ws.on('open', () => { console.log(`Connection ${i + 1} opened.`); ws.send(message); // Отправить сообщение }); ws.on('message', (data) => { console.log(`Message from server: ${data}`); }); ws.on('close', () => { console.log(`Connection ${i + 1} closed.`); }); ws.on('error', (error) => { console.error(`Error in connection ${i + 1}:`, error); }); }Запустите этот скрипт с помощью Node.js. Он создаст указанное количество соединений и отправит тестовые сообщения. Вы можете адаптировать его для отслеживания времени отклика, успешных и неуспешных запросов.
3. Мониторинг результатов
Во время нагрузки мониторьте следующие параметры:
- Время отклика сервера
- Количество успешных и неуспешных соединений
- Загруженность CPU и памяти сервера
- Показатели производительности базы данных (если имеются)
4. Анализ результатов
После завершения теста проанализируйте результаты:
- Определите максимальную нагрузку, при которой сервер работает стабильно.
- Изучите точки отказа и узкие места в производительности.
- Используйте полученные данные для оптимизации и улучшения вашего WebSocket сервера.
Заключение
Нагрузочное тестирование — это важный этап для обеспечения стабильности и производительности вашего приложения. Выберите любой из описанных методов в зависимости от ваших потребностей и возможностей. User: config: target: 'ws://localhost:3000' phases: - duration: 300 arrivalRate: 10 scenarios:
- flow:
- send: text: '{"token": "user-1", "messages": [{"role":"user", "content":"Test message!"}], "model": "gpt-4o"}'
- think: 1
куда сохранить файл Assistant: айл конфигурации для
Artilleryможно сохранить в любом удобном для вас месте на вашем компьютере. Однако для удобства работы рекомендуется создать специальную папку для ваших тестов. Вот шаги, которые можно выполнить:-
Создайте папку для тестов (по желанию, например, в вашем рабочем каталоге):
mkdir artillery-tests cd artillery-tests -
Создайте файл конфигурации. Вы можете использовать текстовый редактор (например,
nano,vim,notepad, или редактор кода, как Visual Studio Code) для создания файла:nano test.yml -
Сохраните конфигурацию в файле
test.yml, вставив в него следующий текст:config: target: 'ws://localhost:3000' phases: - duration: 300 arrivalRate: 10 scenarios: - flow: - send: text: '{"token": "user-1", "messages": [{"role":"user", "content":"Test message!"}], "model": "gpt-4o"}' - think: 1 -
Сохраните файл и выйдите из редактора. Например, в
nanoэто делается с помощью комбинации клавишCtrl + O(для сохранения) иCtrl + X(для выхода).
Теперь файл
test.ymlбудет находиться в вашей папкеartillery-tests. Чтобы запустить тест, вы можете выполнить следующую команду в терминале, находясь в этой папке:artillery run test.ymlТаким образом, вы сможете управлять своими конфигурациями тестов и легко их находить. User: config: target: 'ws://localhost:3000' phases: - duration: 300 arrivalRate: 10 scenarios:
- flow:
- send: text: '{"token": "user-1", "messages": [{"role":"user", "content":"Test message!"}], "model": "gpt-4o"}'
- think: 1
что писать тут target: 'ws://localhost:3000', если сайт на локальном сервере доступен по адресу http://gpt.loc Assistant: ваш сайт доступен по адресу
http://gpt.locи вы хотите протестировать WebSocket-сервер, который работает на этом домене, вам нужно изменитьtargetв вашем файле конфигурации Artillery следующим образом:config: target: 'ws://gpt.loc:3000' # Обратите внимание на протокол ws:// вместо http:// phases: - duration: 300 arrivalRate: 10 scenarios: - flow: - send: text: '{"token": "user-1", "messages": [{"role":"user", "content":"Test message!"}], "model": "gpt-4o"}' - think: 1Вот что следует учитывать:
- Протокол: Убедитесь, что вы используете
ws://для WebSocket-соединений вместоhttp://. - Порт: Убедитесь, что ваш WebSocket-сервер действительно слушает на порту
3000. Если он работает на другом порту, замените3000на соответствующий номер порта. - Домен: Если
gpt.locнастроен правильно и указывает на ваш локальный сервер, тест будет выполняться корректно.
После внесения изменений сохраните файл и снова запускайте тест с помощью команды:
artillery run test.ymlЭто позволит Artillery протестировать ваш WebSocket-сервер по адресу
ws://gpt.loc:3000. User: Это тест на количество соединений? А как проверить нагрузку при большом количестве сообщений? Assistant: проверить нагрузку при большом количестве сообщений, вы можете модифицировать сценарий в вашем конфигурационном файле Artillery. Вместо того чтобы просто отправлять одно сообщение после подключения, можно организовать цикл отправки нескольких сообщений за определенное время, чтобы имитировать нагрузку от различных клиентов, которые активно используют WebSocket-соединение.Вот пример того, как можно изменить ваш конфигурационный файл, чтобы тестировать нагрузку с большим количеством сообщений:
config: target: 'ws://gpt.loc:3000' # Замените на ваш адрес и порт phases: - duration: 300 # Длительность теста в секундах arrivalRate: 10 # Количество новых соединений в секунду scenarios: - flow: - send: text: '{"token": "user-1", "messages": [{"role":"user", "content":"Test message 1!"}], "model": "gpt-4o"}' - send: text: '{"token": "user-1", "messages": [{"role":"user", "content":"Test message 2!"}], "model": "gpt-4o"}' - send: text: '{"token": "user-1", "messages": [{"role":"user", "content":"Test message 3!"}], "model": "gpt-4o"}' # Добавьте столько отправок, сколько необходимо для вашего теста - think: 1 # время ожидания перед следующей отправкой сообщенияПояснения:
-
Множественные сообщения: Вы можете добавить столько блоков
send, сколько вам нужно. Это позволит Artillery отправлять последовательные сообщения через одно и то же соединение. -
Кастомизация содержания сообщений: Вы можете создать очень различные сообщения для тестирования, чтобы имитировать реальных пользователей с разнообразными запросами.
-
Время ожидания (
think): Параметрthinkдобавляет задержку между отправками, имитируя пользователей, которые отправляют сообщения по очереди. Вы можете уменьшить или увеличить это время для тестирования различных сценариев нагрузки. -
Масштабирование сценариев: Вы можете создавать разные сценарии для различных пользователей и их сообщений, чтобы проверить нагрузку от большего числа пользователей с отправкой сообщений.
Запуск теста
Сохраните изменения в вашем
test.ymlфайл и запускайте тест, как раньше:artillery run test.ymlМониторинг
Во время тестирования следите за нагрузкой на сервер (CPU, память, и т.д.). Если ваш сервер достигает пределов, возможно, у вас возникнут ошибки или тайм-ауты, что можно использовать для оценки максимальной нагрузки, которую ваш WebSocket-сервер может выдержать без потери качества.
Дополнительные параметры
Artillery также поддерживает различные опции для повышения сложности ваших нагрузочных тестов, такие как:
- Пользователи с различными токенами: Генерация уникальных токенов для различных пользователей.
- Сложные сценарии: Смешивание разных действий, таких как отправка сообщений в ответ на другие сообщения.
- Генерация случайных данных: Использование случайных строк или чисел в сообщениях для более реалистичных тестов.
Это позволит вам более точно имитировать реальное использование вашего WebSocket-сервера, что даст больше информации о производительности вашего приложения под нагрузкой. User: artillery run test.yml Из какой папки это запускать? Как artillery узнает где лежит файл test.yml? Assistant: того чтобы
Artilleryзнал, где находится файл конфигурацииtest.yml, вам нужно запускать командуartillery run test.ymlиз той папки, в которой находится этот файл. Вот шаги, которые нужно выполнить:-
Откройте терминал: Вы можете использовать встроенный терминал вашего текстового редактора или терминал вашей операционной системы.
-
Перейдите в директорию: Используйте команду
cd(change directory), чтобы перейти в папку, где хранится ваш файлtest.yml. Например, если вы сохранили файл в папкеartillery-tests, выполните:cd путь/к/папке/artillery-testsЗамените
путь/к/папкена актуальный путь к вашей папке. -
Проверьте наличие файла: Вы можете использовать команду
ls(Linux/macOS) илиdir(Windows) для проверки, что файлtest.ymlдействительно находится в этой директории:ls # На Linux/macOS dir # На WindowsВ результате должна отображаться информация о файлах, и вы сможете увидеть
test.yml. -
Запустите тест: После того как вы убедитесь, что находитесь в нужной папке и файл доступен, запустите команду:
artillery run test.yml
Альтернативный способ
Если вы находитесь в другой папке и хотите запустить
Artillery, не перемещая вашу текущую директорию, вы можете указать полный путь к файлу:artillery run /полный/путь/к/вашей/папке/test.ymlНапример, если ваш файл расположен в
C:\artillery-tests\test.yml, вы можете запустить:artillery run C:\artillery-tests\test.ymlИли, если вы в Linux и файл находится в
/home/username/artillery-tests/test.yml:artillery run /home/username/artillery-tests/test.ymlЗаключение
Таким образом, вам нужно запустить
Artilleryиз каталога, где находится ваш тестовый файл, либо указать полный путь к файлу в команде, если вы находитесь в другой директории. User: vusers.failed: 100 Что это? Assistant: vusers.failed: 100означает, что 100 виртуальных пользователей (vusers) не смогли успешно подключиться к вашему WebSocket-серверу или завершить свои заданные сценарии во время теста нагрузки с помощьюArtillery`. Это может происходить по ряду причин:Причины отказов
-
Переполнение сервера: Сервер не может обработать количество подключений из-за исчерпания ресурсов. Это может привести к сбоям или тайм-аутам во время попыток соединения.
-
Ошибки аутентификации: Если ваши виртуальные пользователи используют токены или другие методы аутентификации, они могут не проходить проверку, что приводит к неправильным сообщениям или отказам в соединении.
-
Неверный адрес или порт: Убедитесь, что URL-адрес и порт, указанные в конфигурации, правильные и что сервер действительно работает на этих адресах.
-
Ошибки в сценариях: Если сценарий нагрузки содержит ошибки, например, некорректные или невалидные данные, это может вызывать проблемы при отправке сообщений и обработке запросов.
-
Ограничения WebSocket-сервера: Ваш сервер может иметь ограничения, касающиеся количества одновременно подключенных пользователей или частоты запросов, что может привести к сбоям.
Как решить проблему
-
Мониторинг ресурсов: Проверьте использование CPU, памяти и других ресурсов на сервере во время теста, используя системные утилиты мониторинга, такие как
top,htop,free, и т.п. Убедитесь, что сервер не перегружен. -
Логи сервера: Изучите логи вашего WebSocket-сервера на предмет ошибок или предупреждений. Это может дать вам подсказки о том, почему соединения не удались.
-
Настройка аутентификации: Убедитесь, что токены и другие методы аутентификации корректны для всех пользователей, или используйте разные токены для каждого виртуального пользователя.
-
Тестирование с меньшим числом пользователей: Начните тестирование с меньшего количества виртуальных пользователей и постепенно увеличивайте это число, чтобы увидеть, где начинается увеличение отказов.
-
Проверка конфигурации сервера: Убедитесь, что конфигурация вашего WebSocket-сервера позволяет количеству виртуальных пользователей, которые вы собираетесь протестировать. Проверьте параметры, такие как тайм-ауты соединения и лимиты на количество клиентов.
-
Настройка сценария в Artillery: Проверьте ваш сценарий в
Artilleryна наличие ошибок или некорректных данных, что могло вызвать недоразумения.
Пример логов Artillery
Вы также можете получить более подробную информацию о результатах теста, запустив тест с параметром
--verbose, например:artillery run test.yml --verboseЭто позволит вам увидеть больше информации о каждом подключении и причине его отказа.
Заключение
Итак,
vusers.failed: 100указывает на проблемы с подключением или исполнением сценариев вашими виртуальными пользователями. Проверка серверных логов, ресурсов и точности конфигурации может помочь вам диагностировать и решить эту проблему. User: errors.an URL must be specified что это Assistant:errors.an URL must be specifiedвArtilleryуказывает на то, что не был правильно указан адрес (URL) для целевого сервера в вашем конфигурационном файле. В частности, это происходит, если вы не указалиtargetили указали его неправильно.Что делать
- Проверьте файл конфигурации: Убедитесь, что у вас есть правильно указанный
targetв конфигурационном файлеtest.yml. Пример:
config: target: 'ws://gpt.loc:3000' # Убедитесь, что здесь указан правильный адрес и порт phases: - duration: 300 arrivalRate: 10 scenarios: - flow: - send: text: '{"token": "user-1", "messages": [{"role":"user", "content":"Test message!"}], "model": "gpt-4o"}' - think: 1-
Протокол: Проверьте, что вы используете правильный протокол. Для WebSocket-соединений используйте
ws://(илиwss://для защищенных соединений). Например, если ваш сервер не поддерживает WebSocket, это может вызвать такую ошибку. -
Пространство: Убедитесь, что в вашей строке
targetнет лишних пробелов или опечаток, которые могут вызвать проблемы при парсинге файла. Убедитесь, что строка заканчивается правильно. -
Синтаксис YAML: Убедитесь, что ваш YAML файл правильно отформатирован. Например, используйте пробелы, а не табуляцию, для отступов.
-
Перезапуск Artillery: После внесения изменений в файл конфигурации убедитесь, что вы правильно сохранили файл, и перезапустите команду:
artillery run test.ymlПример корректного файла
Вот пример файла конфигурации:
config: target: 'ws://gpt.loc:3000' # Обязательно укажите правильный адрес сервера phases: - duration: 300 arrivalRate: 10 scenarios: - flow: - send: text: '{"token": "user-1", "messages": [{"role":"user", "content":"Test message!"}], "model": "gpt-4o"}' - think: 1Заключение
Ошибки с указанием URL обычно возникают из-за неправильно указанных адресов или некорректного синтаксиса. Убедитесь в правильности конфигурации и повторите попытку запуска теста. Если ошибка продолжается, попробуйте проверить, работает ли WebSocket-сервер по указанному адресу. User: пользователи устанавливают соединение по ссылке ws://localhost:3000?token={userId}
), вы можете использовать функциюartillery` для динамического создания токена на основе сценариев.Вот как вы можете адаптировать ваш конфигурационный файл
test.yml, чтобы использовать динамические токены для каждого виртуального пользователя:Пример файла конфигурации Artillery
config: target: 'ws://gpt.loc:3000' # Замените на ваш адрес WebSocket phases: - duration: 300 arrivalRate: 10 scenarios: - flow: - function: "setToken" - send: text: '{"token": "${token}", "messages": [{"role":"user", "content":"Test message!"}], "model": "gpt-4o"}' - think: 1 # Функция для генерации токена для каждого пользователя functions: setToken: | function (userContext, events, done) { // Генерируем уникальный userId для каждого виртуального пользователя userContext.vars.token = `user-${userContext.idx + 1}`; // Многие пользователи будут иметь уникальные ID return done(); }Описание изменений:
-
Функция
setToken: Эта функция генерирует уникальный токен (user-1,user-2, и т.д.) для каждого виртуального пользователя на основе их индекса (userContext.idx). Это означает, что каждый виртуальный пользователь будет иметь уникальный токен. -
Использование переменной
${token}: В секцииsend, вместо жестко закодированного токена, используется${token}, который Artillery автоматически заменит на сгенерированный токен для каждого пользователя.
Запуск теста
После того как вы внесли эти изменения и сохранили файл, вы сможете запускать тест с помощью команд:
artillery run test.ymlДополнительные рекомендации:
- Тестирование без повторений: Убедитесь, что ваши токены не конфликтуют друг с другом (например, если у вас есть реализация аутентификации на сервере).
- Адаптация сценариев: Вы можете дополнительно адаптировать ваши сценарии для отправки различных сообщений и получения ответов, если это необходимо.
Таким образом, вы сможете динамически создавать токены для каждого соединения на основе ваших виртуальных пользователей, что поможет лучше смоделировать поведение реальных пользователей при нагрузочных тестах. User: Что такое text: '{"token": "${token}", "messages": [{"role":"user", "content":"Test message!"}], "model": "gpt-4o"}'
сообщение которое клиент отправляет серверу имеет вид {messages: [{"role":"user", "content":"Test message!"}], inputPrompt: "Test message!", model: "gpt-4o"}
Токен отправляется не в самом запросе а как гет параметр при подключении (const url =
ws://localhost:3000?token=${userId}; ws = new WebSocket(url);) Assistant: я понимаю, что токен необходимо передать не в теле сообщения, а в URL при установлении WebSocket-соединения. Для тестирования с помощью Artillery необходимо адаптировать конфигурацию так, чтобы токен передавался в URL, но при этом ваше сообщение должно соответствовать указанному формату.Пример конфигурации Artillery
Вы можете использовать функцию для генерации уникального токена для каждого виртуального пользователя и затем сформировать правильный URL для подключения. Однако Artillery не поддерживает динамическое формирование URL непосредственно в конфигурации. Вместо этого вы можете использовать настройку
beforeScenarioдля создания WebSocket-соединений с нужным URL.Вот пример, как вы можете настроить это:
config: target: 'ws://gpt.loc:3000' # Замените на ваш адрес WebSocket phases: - duration: 300 arrivalRate: 10 http: flushRequests: false # Не отправлять запросы на сервер, Artillery не подготавливает HTTP запросы scenarios: - flow: - function: "setToken" - function: "connectWebSocket" # Создание WebSocket-соединения с токеном - send: text: '{"messages": [{"role":"user", "content":"Test message!"}], "inputPrompt": "Test message!", "model": "gpt-4o"}' - think: 1 # Функция для генерации токена для каждого пользователя functions: setToken: | function (userContext, events, done) { userContext.vars.token = `user-${userContext.idx + 1}`; // Генерируем уникальный ID токена return done(); } connectWebSocket: | function (userContext, events, done) { userContext.ws = new WebSocket(`ws://gpt.loc:3000?token=${userContext.vars.token}`); userContext.ws.on('open', () => { console.log(`Connected with token: ${userContext.vars.token}`); done(); // Завершает процесс подключения }); userContext.ws.on('error', (err) => { console.error('WebSocket connection error: ', err); done(); // Обработать ошибку и завершить выполнение }); }Описание изменений:
-
Функция
setToken: Генерирует уникальный токен для каждого виртуального пользователя (как в предыдущем примере). -
Функция
connectWebSocket: Эта функция создаёт новое WebSocket-соединение с использованием токена в URL. Обратите внимание, что эта функция используетuserContext.wsдля хранения соединения WebSocket. -
Изменение структуры сообщения: Сообщение теперь отправляется в формате, который вы указали:
{ "messages": [{"role":"user", "content":"Test message!"}], "inputPrompt": "Test message!", "model": "gpt-4o" }
Запуск теста
После того как вы внесли необходимые изменения, запустите тест снова с помощью:
artillery run test.ymlЗамечания
- Убедитесь, что ваша версия Artillery поддерживает функциональность, которую вы пытаетесь использовать.
- Проверьте конфигурацию и соблюдение всех правил, чтобы гарантировать выполнение запросов и избегать ошибок.
Таким образом, вы сможете динамически передавать токен в URL при подключении к вашему WebSocket-серверу и отправлять сообщения в нужном формате. User: Вот код config: target: 'ws://localhost:3000' # Замените на ваш адрес WebSocket phases: - duration: 300 arrivalRate: 10 http: flushRequests: false # Не отправлять запросы на сервер, Artillery не подготавливает HTTP запросы scenarios:
- flow:
- function: "setToken"
- function: "connectWebSocket" # Создание WebSocket-соединения с токеном
- send: text: '{"messages": [{"role":"user", "content":"Test message!"}], "inputPrompt": "Test message!", "model": "gpt-4o"}'
- think: 5
Функция для генерации токена для каждого пользователя
functions: setToken: | function (userContext, events, done) { userContext.vars.token =
user-${userContext.idx + 1}; // Генерируем уникальный ID токена return done(); } connectWebSocket: | function (userContext, events, done) { userContext.ws = new WebSocket(ws://gpt.loc:3000?token=${userContext.vars.token}); userContext.ws.on('open', () => { console.log(Connected with token: ${userContext.vars.token}); done(); // Завершает процесс подключения }); userContext.ws.on('error', (err) => { console.error('WebSocket connection error: ', err); done(); // Обработать ошибку и завершить выполнение }); }вот результат
errors.Undefined function "connectWebSocket": .................................. 100 errors.Undefined function "setToken": .......................................... 100 errors.an URL must be specified: ............................................... 100 vusers.created: ................................................................ 100 vusers.created_by_name.0: ...................................................... 100 vusers.failed: ................................................................. 100 Assistant:
Undefined function "connectWebSocket"иUndefined function "setToken"указывает на то, что Artillery не распознаёт функции, которые вы пытаетесь использовать в вашем сценарии. Это может происходить по ряду причин, включая неверный синтаксис или неправильное структурирование вашего конфигурационного файла.Основные проблемы
-
Некорректное определение функций: Внимательно проверьте, указаны ли функции правильно в вашем конфигурационном файле. Они должны быть объявлены в секции
functions. -
Отсутствие библиотеки WebSocket: Artillery не поддерживает нативные WebSocket-соединения из-за ограничения Node.js API. Вы не сможете использовать конструктор
WebSocketпрямо так, как показано. Вместо этого, лучше использовать HTTP запросы, или другие средства, имеющие поддержку WebSocket.
Если вы хотите использовать WebSocket с Artillery, вам нужно выполнить запросы через сервер HTTP. В качестве альтернативы, вы можете использовать другие инструменты, такие как K6 или Locust, которые имеют встроенную поддержку WebSocket.
Пример исправленного теста с использованием HTTP
Если вам действительно нужно протестировать просто HTTP запросы (без WebSocket), вы можете изменить код так:
config: target: 'http://gpt.loc:3000' # Вы также можете использовать ws или wss для WebSocket phases: - duration: 300 arrivalRate: 10 scenarios: - flow: - get: url: "/?token=${token}" # Получение страницы с токеном - send: text: '{"messages": [{"role":"user", "content":"Test message!"}], "inputPrompt": "Test message!", "model": "gpt-4o"}' - think: 5 # Функция для генерации токена для каждого пользователя functions: setToken: | function (userContext, events, done) { userContext.vars.token = `user-${userContext.idx + 1}`; // Генерация уникального токена return done(); }Использование K6 для тестирования WebSocket
Если вы хотите выполнять запросы через WebSocket соединение, лучше использовать K6:
- Убедитесь, что у вас установлен K6.
- Создайте скрипт, например
test.js.
Пример использования K6:
import { check, sleep } from 'k6'; import ws from 'k6/ws'; export default function () { const userId = `user-${__VU}`; // Уникальный ID для каждого виртуального пользователя const url = `ws://gpt.loc:3000?token=${userId}`; const response = ws.connect(url, null, function (socket) { socket.on('open', function () { console.log(`Connected with token: ${userId}`); socket.send(JSON.stringify({ messages: [{ role: "user", content: "Test message!" }], inputPrompt: "Test message!", model: "gpt-4o" })); }); socket.on('message', function (message) { console.log('Received message: ' + message); }); socket.on('close', function () { console.log('Disconnected'); }); socket.on('error', function (e) { console.error('WebSocket error: ', e); }); }); check(response, { 'status is 101': (r) => r && r.status === 101 }); sleep(1); // Задержка между запросами }Запустите его через K6:
k6 run test.jsЗаключение
Если вам нужно тестировать именно WebSocket, я рекомендую использовать K6 или другой инструмент, поддерживающий WebSocket. Artillery хорошо подходит для HTTP-запросов, но имеет ограничения при работе с WebSocket-соединениями. User: как установить K6 на windows 10 Assistant: становка K6 на Windows 10 может быть выполнена несколькими способами. Вот подробные инструкции для каждого из них:
Способ 1: Установка через Chocolatey
Если у вас установлен пакетный менеджер Chocolatey, установка K6 — это самый простой способ:
-
Откройте терминал с правами администратора:
- Нажмите Win и введите cmd.
- Щелкните правой кнопкой мыши на Командной строке и выберите Запуск от имени администратора.
-
Установите K6, выполнив следующую команду:
choco install k6 -
После завершения установки проверьте, работает ли K6:
k6 version
Способ 2: Установка через WSL (Windows Subsystem for Linux)
Если вы используете WSL, вы можете установить K6, как и в обычной Linux-системе:
-
Откройте WSL (например, Ubuntu).
-
Добавьте K6 репозиторий и установите K6:
sudo apt update sudo apt install -y gnupg software-properties-common wget -q -O - https://bin.k6.io/public/key.asc | sudo apt-key add - sudo add-apt-repository "deb [arch=amd64] https://bin.k6.io/public/repo/ $(lsb_release -cs) main" sudo apt update sudo apt install k6 -
Проверьте установку:
k6 version
Способ 3: Загрузка исполняемого файла
-
Перейдите на официальную страницу загрузок K6.
-
Скачайте последнюю версию K6 для Windows:
- Найдите раздел Releases и загрузите
.zipфайл для Windows.
- Найдите раздел Releases и загрузите
-
Распакуйте скачанный файл в любую папку.
-
Добавьте путь к K6 в переменную окружения PATH:
- Щелкните правой кнопкой мыши на Этот компьютер и выберите Свойства.
- Нажмите на Дополнительные параметры системы.
- Нажмите на Переменные среды и найдите
PATHв списке системных переменных. - Нажмите Изменить и добавьте путь к папке, где находится K6 (например,
C:\path\to\k6).
-
Запустите терминал и проверьте установку:
k6 version
Заключение
Теперь у вас установлен K6 на Windows 10, и вы готовы начать нагрузочное тестирование ваших приложений. Вы можете ознакомиться с документацией на официальном сайте K6 для получения дополнительной информации о том, как использовать его для нагрузочного тестирования ваших серверов. User: Как установить Assistant: установить K6 на Windows 10, выполните следующие шаги в зависимости от способа установки:
Способ 1: Установка через Chocolatey
-
Убедитесь, что Chocolatey установлен: Если у вас еще нет Chocolatey, вы можете установить его, выполнив команду в терминале с правами администратора (нажмите Win, введите cmd, щелкните правой кнопкой мыши и выберите "Запуск от имени администратора"):
@"%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe" -NoProfile -InputFormat None -ExecutionPolicy Bypass -Command "iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))" && SET "PATH=%PATH%;%ALLUSERSPROFILE%\chocolatey\bin" -
Установите K6 с помощью Chocolatey:
В терминале с правами администратора выполните следующую команду:
choco install k6 -
Проверьте, была ли успешна установка:
Откройте новый терминал и выполните:
k6 version
Способ 2: Установка через WSL (Windows Subsystem for Linux)
Если вы используете WSL (Рекомендуется для лучшей совместимости с Linux-средами), вы можете установить K6 следующим образом:
-
Откройте WSL.
-
Добавьте K6 репозиторий и установите K6:
Сначала обновите пакеты и установите необходимые зависимости:
sudo apt update sudo apt install -y gnupg software-properties-common wget -q -O - https://bin.k6.io/public/key.asc | sudo apt-key add - sudo add-apt-repository "deb [arch=amd64] https://bin.k6.io/public/repo/ $(lsb_release -cs) main" sudo apt update sudo apt install k6 -
Проверьте установку:
k6 version
Способ 3: Загрузка исполняемого файла
-
Перейдите на официальную страницу K6 на GitHub.
-
Скачайте последнюю версию K6 для Windows:
- Найдите раздел Assets под последним релизом и загрузите
.zipфайл для Windows (например,k6-windows-amd64.zip).
- Найдите раздел Assets под последним релизом и загрузите
-
Распакуйте загруженный файл в желаемую папку (например, в
C:\k6). -
Добавьте путь к K6 в переменную окружения PATH:
- Щелкните правой кнопкой мыши на Этот компьютер и выберите Свойства.
- Нажмите на Дополнительные параметры системы.
- Нажмите на Переменные среды и найдите
PATHв списке системных переменных. - Нажмите Изменить и добавьте путь к папке, где расположен K6 (например,
C:\k6).
-
Проверьте установку:
Откройте новый терминал и выполните:
k6 version
Заключение
Теперь K6 установлен на вашем Windows 10. Вы можете ознакомиться с документацией на официальном сайте K6 для дальнейшего использования и понимания функциональности K6. User: import { check, sleep } from 'k6'; import ws from 'k6/ws';
export default function () { const userId =
user-${__VU}; // Уникальный ID для каждого виртуального пользователя const url =ws://gpt.loc:3000?token=${userId};const response = ws.connect(url, null, function (socket) { socket.on('open', function () { console.log(`Connected with token: ${userId}`); socket.send(JSON.stringify({ messages: [{ role: "user", content: "Test message!" }], inputPrompt: "Test message!", model: "gpt-4o" })); }); socket.on('message', function (message) { console.log('Received message: ' + message); }); socket.on('close', function () { console.log('Disconnected'); }); socket.on('error', function (e) { console.error('WebSocket error: ', e); }); }); check(response, { 'status is 101': (r) => r && r.status === 101 }); sleep(1); // Задержка между запросами}
сколько будет длиться тест? Сколько будет соединений? Assistant: сценарий тест на K6, как он написан, не определяет продолжительность теста и количество соединений напрямую. Эти параметры можно установить с помощью командной строки или параметров в самом скрипте. Давайте рассмотрим, как это можно сделать.
Длительность теста и количество соединений
-
Длительность теста: Вы можете установить общую длительность теста в командной строке при запуске скрипта. Например, если вы хотите запустить тест в течение 5 минут, вы можете сделать это так:
k6 run --duration 5m your_script.jsЭто означает, что тест будет выполняться 5 минут.
-
Количество виртуальных пользователей (VUs): Чтобы установить количество одновременных соединений (виртуальных пользователей), вы также можете указать это в командной строке. Например, если вы хотите протестировать 50 виртуальных пользователей на протяжении теста:
k6 run --vus 50 --duration 5m your_script.jsВ этом случае вы получите 50 соединений, и они будут активны на протяжении 5 минут.
Пример запуска теста
Вот команда, с помощью которой вы можете запустить свой тест, указав как длительность, так и количество виртуальных пользователей:
k6 run --vus 50 --duration 5m your_script.jsЭтот пример означает, что вы будете иметь 50 одновременно подключенных пользователей, которые будут работать в течение 5 минут.
Итоговая конфигурация
- Длительность теста: 5 минут (вы можете изменить на любое другое значение).
- Количество виртуальных пользователей: 50 (вы можете изменить на любое другое значение).
Вы можете зафиксировать эти настройки по умолчанию в конце файла K6, но чаще всего они задаются на этапе запуска.
Также помните, что в зависимости от вашегo приложения и его возможностей могут быть ограничения на количество соединений и производительность. Обязательно следите за статистикой, чтобы не перегружать сервер во время тестирования. User: data_received......: 10 kB 111 B/s data_sent..........: 16 kB 179 B/s vus................: 50 min=50 max=50 vus_max............: 50 min=50 max=50 ws_connecting......: avg=226.34ms min=50.46ms med=241.56ms max=354.58ms p(90)=342.54ms p(95)=343.02ms ws_msgs_received...: 50 0.55508/s ws_msgs_sent.......: 50 0.55508/s ws_sessions........: 50 0.55508/s
running (1m30.1s), 00/50 VUs, 0 complete and 50 interrupted iterations default ✓ [======================================] 50 VUs 1m0s
Вот результат. Расшифруй Assistant: авайте разберем предоставленный вами результат теста K6 подробно.
Общая информация о тесте:
-
data_received......: 10 kB
- Общее количество данных, полученных от сервера во время теста (10 килобайт).
-
data_sent..........: 16 kB
- Общее количество данных, отправленных на сервер (16 килобайт).
-
vus................: 50
- Это количество текущих виртуальных пользователей (VUs), участвующих в тесте. В данном случае их 50.
-
vus_max............: 50
- Максимальное количество виртуальных пользователей за всё время тестирования, также 50. Это показывает, что на протяжении теста количество виртуальных пользователей не изменялось.
Параметры WebSocket соединений:
-
ws_connecting......: avg=226.34ms min=50.46ms med=241.56ms max=354.58ms
- Эти значения представляют собой время, необходимое для соединения каждого WebSocket клиента:
avg: среднее время подключения — 226.34 мсmin: минимальное время подключения — 50.46 мсmed: медианное время подключения — 241.56 мсmax: максимальное время подключения — 354.58 мсp(90): 90-й процентиль — 342.54 мс, что означает, что 90% подключений проходили быстрее этого времени.p(95): 95-й процентиль — 343.02 мс.
- Эти значения представляют собой время, необходимое для соединения каждого WebSocket клиента:
-
ws_msgs_received...: 50 0.55508/s
- Общее количество полученных сообщений от сервера — 50 сообщений, со скоростью 0.55508 сообщения в секунду.
-
ws_msgs_sent.......: 50 0.55508/s
- Общее количество отправленных сообщений на сервер — 50 сообщений, со скоростью 0.55508 сообщения в секунду.
-
ws_sessions........: 50 0.55508/s
- Это показывает общее количество активных сеансов WebSocket за тест — 50, также со скоростью 0.55508 сеансов в секунду.
Статистика выполнения теста:
-
running (1m30.1s)
- Это общее время, в течение которого выполнялся тест, составляет 1 минута и 30.1 секунды.
-
00/50 VUs, 0 complete and 50 interrupted iterations
- Здесь указано, что 0 из 50 виртуальных пользователей выполнили свои итерации полностью, а все 50 были прерваны. Это может означать, что тест завершился до того, как пользователи успели завершить свои действия.
-
default ✓ [======================================] 50 VUs 1m0s
- Эта строка подтверждает, что 50 виртуальных пользователей были запущены, и процесс завершения (или остановки) завершился за 1 минуту.
Возможные выводы:
-
Задержки при подключении: Время подключения WebSocket (среднее 226.34 мс) выглядит разумно. Это указывает на то, что сервер обрабатывает соединения достаточно быстро.
-
Работа с сообщениями: Количество отправленных и полученных сообщений совпадает (50), но скорость отправки и получения сообщений достаточно низкая (0.55508 сообщения в секунду).
-
Проблема с завершением теста: Учитывая, что все итерации были прерваны и ни одна не завершилась, это может свидетельствовать о проблеме с кодом вашего теста или сервером. Возможно, сервер не обрабатывает сообщения должным образом, либо тайм-ауты соединений слишком короткие.
Рекомендации
-
Проверьте логи сервера на предмет ошибок или предупреждений. Это поможет определить, почему виртуальные пользователи не смогли завершить свои итерации.
-
Тестирование с меньшим количеством виртуальных пользователей: Попробуйте уменьшить количество виртуальных пользователей, чтобы посмотреть, как сервер справляется с меньшей нагрузкой.
-
Настройка тайм-аутов: Если вы уверены, что тест правильно написан, возможно, стоит проверить настройки тайм-аутов или другие серверные параметры, которые могут влиять на выполнение теста.
-
Анализируйте производительность: Убедитесь, что сервер может обрабатывать нагрузку и сообщения, и протестируйте его под различными условиями, чтобы найти оптимальные параметры для вашего приложения. User: Проверьте логи сервера на предмет ошибок или предупреждений. Это поможет определить, почему виртуальные пользователи не смогли завершить свои итерации. что будет означать завершение итерации. Как проверить? Assistant: авершение итерации контексте нагрузочного тестирования, проводимого с помощью K6 или любого другого инструмента, означает, что виртуальный пользователь (VU) успешно прошел весь определенный сценарий в тесте. Это включает в себя выполнение всех шагов, таких как установление соединения, отправка сообщений, получение ответов и завершение работы с соединением.
Когда считается, что итерация завершена
Итерация обычно считается завершенной, когда:
- Соединение установлено: Виртуальный пользователь успешно подключается к серверу по WebSocket.
- Сообщение отправлено: Пользователь отправляет ожидаемое сообщение через установленное соединение.
- Получен ответ: Пользователь получает ответ от сервера.
- Соединение закрыто: Пользователь корректно завершает соединение.
Если какой-либо из этих шагов не выполнен, итерация может считаться прерванной или незавершенной.
Как проверить логи сервера
Чтобы узнать, почему итерации не завершаются, вам следует исследовать логи вашего сервера. Вот как это можно сделать:
-
Определите, где хранятся логи:
- Логи могут располагаться в разных местах, в зависимости от вашего веб-сервера или приложения. Например:
- Для Node.js-приложений вы можете выводить логи в консоль или в файл (например, с использованием
winston,morganи т. д.). - Для других серверов (Nginx, Apache и т. д.) логи обычно находятся в
/var/log/nginx/error.logили/var/log/apache2/error.log.
- Для Node.js-приложений вы можете выводить логи в консоль или в файл (например, с использованием
- Логи могут располагаться в разных местах, в зависимости от вашего веб-сервера или приложения. Например:
-
Откройте логи на сервере:
- Используйте текстовый редактор, чтобы открыть логи, или используйте команды в терминале/консоли. Например:
tail -f /path/to/your/logfile.log tail -fпозволяет в реальном времени просматривать последние изменения в файле.
- Используйте текстовый редактор, чтобы открыть логи, или используйте команды в терминале/консоли. Например:
-
Ищите ошибки или предупреждения:
- Просмотрите логи на наличие сообщений об ошибках, исключений или предупреждений, которые могут указывать на то, почему виртуальные пользователи не смогли завершить итерации. Примеры сообщений, на которые следует обратить внимание:
- Ошибки из-за превышения тайм-аутов.
- Сообщения о недействительных запросах или данных.
- Исключения, связанные с обработкой сообщений.
- Проблемы с зависимостями или ресурсами (например, нехватка памяти).
- Просмотрите логи на наличие сообщений об ошибках, исключений или предупреждений, которые могут указывать на то, почему виртуальные пользователи не смогли завершить итерации. Примеры сообщений, на которые следует обратить внимание:
-
Журналируйте важные действия:
- Если у вас нет четких логов, вы можете добавить дополнительные журналы в код вашего приложения, чтобы отслеживать важные действия, особенно при установке подключения и обработке сообщений.
Пример логирования в Node.js
Если вы используете Node.js для сервера, вы можете добавить логирование, чтобы понять, где возникают проблемы. Пример:
ws.on('connection', (ws, req) => { console.log('New connection'); ws.on('message', (message) => { console.log('Received:', message); // Возможно, здесь происходит обработка, и могут возникать ошибки }); ws.on('error', (error) => { console.error('WebSocket error:', error); }); ws.on('close', () => { console.log('Connection closed'); }); });Этот код позволит вам отслеживать события подключения, полученные сообщения и возможные ошибки.
Заключение
Завершение итерации — это успешное прохождение всех шагов виртуальным пользователем. Чтобы выяснить, почему ваши итерации не завершаются, необходимо внимательно проверить логи вашего сервера на наличие ошибок или предупреждений и, возможно, добавить дополнительные журналы в код для диагностики. User: в моем тесте ответы были получены всеми? Assistant: вашем тесте, судя по данным, предоставленным вами, видно, что было получено 50 ответов:
- ws_received...: 50
Это показывает, что было получено 50 сообщений от сервера.
Таким образом, можно сделать вывод, что все виртуальные пользователи получили по одному ответу от сервера.
Что значит получение ответов всеми пользователями
Когда вы видите, что все (или почти все) виртуальные пользователи успешно получили ответы, это указывает на следующее:
- Сервер обрабатывает запросы: Сервер может корректно обрабатывать сообщения от множества пользователей одновременно.
- Правильная настройка сценария: Сценарий теста, скорее всего, правильно настроен и отправляет сообщения, которые ожидаются сервером.
- Отсутствие серьезных ошибок на стороне сервера: Если бы на сервере возникли серьезные ошибки при обработке запросов, вы, вероятно, увидели бы меньшее количество полученных сообщений.
Однако, обратите внимание:
-
Время задержки: Результаты также показывают, что время отвления или задержки при подключении относительно приемлемо (среднее значение 226.34 мс), но у вас могут быть случаи, когда это время может вызвать нежелательные задержки в откликах.
-
Виртуальные пользователи: Несмотря на то что все виртуальные пользователи (50) подключились и получили ответы, они могли не завершить свои итерации из-за прерывания соединений, тайм-аутов или других проблем.
Что сделать дальше
-
Проверка логов: Анализируйте логи сервера на предмет отклонённых запросов, ошибок или сообщений об исключениях, чтобы убедиться, что не было проблем, что могли создать прерванные итерации.
-
Мониторинг производительности: Если вы испытываете нагрузку на сервер, периодически проверяйте его производительность.
-
Дополнительное тестирование: Попробуйте протестировать с большим количеством пользователей или в изменённых условиях (например, с другими сообщениями) и внимательно наблюдайте за тем, как сервер обрабатывает эти изменения.
-
Анализ результатов: Обратите внимание на метрики, такие как время ответа, количество звонков, затраченных на соединение, чтобы лучше понять производительность вашего приложения под нагрузкой.
Если все виртуальные пользователи получили свои ответы, это хорошо, но нужно удостовериться, что они также корректно завершили итерации, а не просто остановились и были прерваны. User: Итерация обычно считается завершенной, когда:
Соединение установлено: Виртуальный пользователь успешно подключается к серверу по WebSocket. Сообщение отправлено: Пользователь отправляет ожидаемое сообщение через установленное соединение. Получен ответ: Пользователь получает ответ от сервера. Соединение закрыто: Пользователь корректно завершает соединение.
Чего из этого не хватает в моем тесте? Assistant: , чего может не хватать в вашем тесте по критериям завершения итерации, давайте внимательно рассмотрим каждый шаг и соотнесем его с результатами вашего теста:
-
Соединение установлено:
- Если вы видите, что в процессе тестирования виртуальные пользователи подключаются к серверу и это подтверждается сообщениями о созданных соединениях, то этот шаг выполнен. Проверяйте, было ли зафиксировано какое-либо сообщение о том, что соединение было установлено.
-
Сообщение отправлено:
- Вы указывали, что 50 сообщений были отправлены, и это отображается в результатах вашего тестирования с помощью
ws_msgs_sent.......: 50. Это значит, что все виртуальные пользователи отправили свои сообщения. Этот шаг также выполнен.
- Вы указывали, что 50 сообщений были отправлены, и это отображается в результатах вашего тестирования с помощью
-
Получен ответ:
- Ваши результаты показывают, что 50 ответов были получены (
ws_msgs_received...: 50). Это подтверждает, что все сообщения были правильно обработаны сервером и пользователи получили ответы. Этот шаг выполнен.
- Ваши результаты показывают, что 50 ответов были получены (
-
Соединение закрыто:
- Этот шаг может быть причиной того, почему итерации не завершились. Если соединения не закрываются корректно, это может привести к прерыванию итераций.
- Вы не упоминаете в своем тесте, как происходит закрытие соединения. Вам необходимо явно обрабатывать событие закрытия соединения (например, отправить закрывающее сообщение) и удостовериться, что это событие выполняется.
Рекомендации по исправлению:
- Добавьте закрытие соединения: Убедитесь, что после получения ответа или в самом конце теста вы корректно закрываете WebSocket-соединение. В K6 это можно сделать следующим образом:
socket.on('open', function () { console.log(`Connected with token: ${userId}`); socket.send(JSON.stringify({ messages: [{ role: "user", content: "Test message!" }], inputPrompt: "Test message!", model: "gpt-4o" })); }); socket.on('message', function (message) { console.log('Received message: ' + message); // Закрытие соединения socket.close(); // Добавьте эту строку для корректного закрытия соединения });-
Используйте тайм-ауты или задержки: Если ваш сценарий выполняется слишком быстро, это может повлиять на порядок сообщений и закрытие соединений. Добавьте небольшие задержки (например, с помощью
sleepв K6) перед закрытием соединения, чтобы убедиться, что все обмены сообщениями завершены. -
Проверьте, что сервер может обрабатывать закрытие: Убедитесь, что ваш сервер корректно обрабатывает запросы на закрытие соединения. Это важно для разработки устойчивого приложения.
Заключение
Итак, в вашем тесте все необходимые шаги выполнялись, кроме, вероятно, корректного закрытия соединения. Если вы добавите это в свой код и удостоверитесь, что ваше приложение обрабатывает закрытие соединения должным образом, это поможет гарантировать завершение итераций и повысит стабильность тестов. User: Соединение закрыто:
Этот шаг может быть причиной того, почему итерации не завершились. Если соединения не закрываются корректно, это может привести к прерыванию итераций. Вы не упоминаете в своем тесте, как происходит закрытие соединения. Вам необходимо явно обрабатывать событие закрытия соединения (например, отправить закрывающее сообщение) и удостовериться, что это событие выполняется.
В моем приложении соединение не закрывается пока клиент не закроет страницу в браузере. Учитывает ли тест это?
Вот мое приложение
const { gpt, gptweb } = require("./API/gpt"); const { dalle } = require("./API/dalle"); const { gpt4o } = require("./API/gpt4o"); const { gpt3 } = require("./API/gpt3.5"); const { prompts } = require("./API/gpt-prompts"); const { blackbox } = require("./API/blackbox"); const { qwen } = require("./API/qwen"); const { gemini } = require("./API/gemini"); const WebSocket = require('ws'); const Bottleneck = require('bottleneck'); const { stats, scheduleDailyReset, resetStatistics } = require('./stats'); // Импортируем модуль статистики const fs = require('fs'); const path = require('path'); const Ajv = require('ajv');
// Создаем экземпляр Ajv (проверка входящей переписки на соответствие схеме) const ajv = new Ajv(); // Объект для хранения действий и состояния каждого клиента const clientActions = {}; // Объект для хранения ограничителей по каждому клиенту const limiters = {}; // Замените на ваш домен const allowedOrigin = 'http://gpt.loc';
// Создайте WebSocket-сервер const wss = new WebSocket.Server({ port: 3000 });
wss.on('connection', (ws, req) => {
const urlParams = new URLSearchParams(req.url.split('?')[1]); const userId = urlParams.get('token'); // Получаем UUID из URL const userIP = req.socket.remoteAddress; //console.log("IP-адрес - ", userIP, "Время подключения - ", new Date().toISOString()); const userHeaders = req.headers; // Проверяем Origin //if (!checkOrigin(userHeaders.origin, ws)) { // return; // Если отклонено, выходим из обработчика //} // Увеличиваем общий счетчик подключений stats.totalConnections++; console.log('Client connected with user ID:', userId); // Инициализируем состояние клиента, если его еще нет if (!clientActions[userId]) { clientActions[userId] = { actions: [], // Массив для хранения действий connected: true, // Статус подключения }; } else clientActions[userId].connected = true; if (!limiters[userId]) { // Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id) limiters[userId] = new Bottleneck({ maxConcurrent: 1, // Максимальное количество одновременных задач minTime: 1000, // Минимальное время между запросами в миллисекундах highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать) }); } ws.on('message', (message) => { // Проверяем, является ли сообщение экземпляром Buffer if (Buffer.isBuffer(message)) message = message.toString(); try { // Преобразуем строку JSON обратно в объект message = JSON.parse(message); //Получаем историю чата из запроса let messages = message.messages; let model = message.model; // Выполняем валидацию сообщений messages = validateMessages(messages); // Проверяем, остались ли сообщения после валидации if (messages.length === 0) { const response = { code: 2, message: "Нет валидных сообщений для обработки." }; sendMessage(ws, response); return; } // Урезаем последнее сообщение до 2000 символов, если оно от клиента if (messages[messages.length - 1].role === 'user') { messages[messages.length - 1].content = messages[messages.length - 1].content.substring(0, 2000000); } // Увеличиваем общий счетчик запросов stats.totalRequests++; // Используем Bottleneck для управления количеством запросов limiters[userId].schedule(() => { // Отправка запроса на сервер чата if (model == 'gpt-4o') return callGPT4o(messages, ws); else if (model == 'gemini-pro') return callGemini(messages, ws); else if (model == 'qwen') return callQwen(messages, ws); else if (model == 'blackbox') return callBlackbox(messages, ws); else if (model == 'gpt-3.5-turbo') return callGPT35Turbo(messages, ws); else return callGPT4o(messages, ws); }).catch(error => { stats.totalIPBlocks++; //console.error('Rate limit exceeded, message ignored:', error); const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." }; // Отправка ответа клиенту //sendMessage(ws, response); }); } catch (error) { stats.totalWsMessErrors++; console.error('Error parsing JSON:', error); const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."}; console.log(response); // Отправка ответа клиенту sendMessage(ws, response); } }); ws.on('close', () => { clientActions[userId].connected = false; // Обновление статуса подключения delete clientActions[userId]; // Удаление состояния клиента delete limiters[userId]; // Удаление ограничителя для данного клиента console.log('Client ',userId, ' disconnected'); });});
// Запускаем планировщик для статистики scheduleDailyReset();
// Очистка старых соединений раз в минуту (по желанию) setInterval(() => { console.log('Количество активных клиентов - ', Object.keys(clientActions).length); Object.keys(clientActions).forEach(userId => { if (!clientActions[userId].connected) { delete clientActions[userId]; // Удаляем пользователя из памяти, если он отключен delete limiters[userId]; } }); }, 10 * 60 * 1000); // Очистка каждые 10 минут
// Код выводит текущие метрики использования памяти приложения setInterval(() => { const memoryUsage = process.memoryUsage(); console.log(
Текущие метрики использования памяти: RSS: ${memoryUsage.rss / (1024 * 1024)} MB, Heap Total: ${memoryUsage.heapTotal / (1024 * 1024)} MB, Heap Used: ${memoryUsage.heapUsed / (1024 * 1024)} MB, External: ${memoryUsage.external / (1024 * 1024)} MB); }, 10 * 60 * 1000); // Вывод каждый 60 секундfunction checkOrigin(origin, socket) { if (origin !== allowedOrigin) { console.log('Недопустимый домен. Соединение разорвано: ', origin); socket.close(); // Закрываем соединение, если домен не разрешен return false; // Возвращаем false для индикатора отклонения } return true; // Возвращаем true, если домен разрешен }
// Отправляет ответ клиенту function sendMessage(ws, message) { if (ws.readyState === WebSocket.OPEN) { ws.send(JSON.stringify(message)); } else { console.warn(
Trying to send message to a closed WebSocket connection.); } }// Удаление из массива сообщений не соответствующих схеме function validateMessages(messages) { // Определяем схему для сообщений const schema = { type: 'object', properties: { role: { type: 'string' }, content: { type: 'string' } }, required: ['role', 'content'], additionalProperties: false };
// Фильтруем массив, оставляя только корректные сообщения return messages.filter(message => { // Проверяем, соответствует ли сообщение схеме if (ajv.validate(schema, message)) { // Обрезаем содержимое, если оно длиннее 2000 символов if (message.content.length > 2000000) { message.content = message.content.substring(0, 2000000); } return true; // Сообщение валидно, оставляем в массиве } return false; // Сообщение не валидно, исключаем из массива });}
console.log('WebSocket сервер запущен через порт 3000');
//============== ВЫЗОВ API МОДЕЛЕЙ ================================================= //================================================================================== //================================================================================== //==================================================================================
// GPT4o async function callGPT4o(messages, ws) { try { let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента к GPT4o===:', messages[messages.length - 1]); //console.log('Запрос клиента к GPT4o:', messages); //throw new Error("Намеренная ошибка для тестирования catch"); let messageSent = false; gpt4o({ messages: messages, markdown: false }, (result) => { // Обработка результата внутри колбэка if (result.error) { throw new Error(result.error); // Обрабатываем ошибку, если она есть } try { if (!result.finish) { // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления) fullResponse = result.message || ""; //console.log(result); } else { // Если завершено, выводим полный ответ let response = { code: 1, message: fullResponse}; console.log('Ответ чата: ', response); // Отправка ответа клиенту sendMessage(ws, response); } } catch (callbackError) { console.error('Error processing callback result:', callbackError); if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ stats.totalGPT4oCallbackErrors++; let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." }; sendMessage(ws, errorResponse); messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось } } }); } catch (error) { stats.totalGPT4oMessErrors++; console.error('Error:', error); let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."}; // Отправка ответа клиенту sendMessage(ws, response); }}
// Gemini async function callGemini(messages, ws) { try { let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента к Gemini:', messages[messages.length - 1]); //throw new Error("Намеренная ошибка для тестирования catch"); let messageSent = false; gemini({ messages: messages }, (result) => { // Обработка результата внутри колбэка if (result.error) { throw new Error(result.error); // Обрабатываем ошибку, если она есть } try { if (!result.finish) { // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления) fullResponse = result.message || ""; //console.log(result); } else { // Если завершено, выводим полный ответ let response = { code: 1, message: fullResponse}; console.log('Ответ чата: ', response); // Отправка ответа клиенту sendMessage(ws, response); } } catch (callbackError) { console.error('Error processing callback result:', callbackError); if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ stats.totalGeminiCallbackErrors++; let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." }; sendMessage(ws, errorResponse); messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось } } }); } catch (error) { stats.totalGeminiMessErrors++; console.error('Error:', error); let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."}; // Отправка ответа клиенту sendMessage(ws, response); }}
// Qwen async function callQwen(messages, ws) { try { let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента к Qwen:', messages[messages.length - 1]); //throw new Error("Намеренная ошибка для тестирования catch"); let messageSent = false; qwen({ messages: messages, markdown: false }, (result) => { // Обработка результата внутри колбэка if (result.error) { throw new Error(result.error); // Обрабатываем ошибку, если она есть } try { if (!result.finish) { // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления) fullResponse = result.message || ""; //console.log(result); } else { // Если завершено, выводим полный ответ let response = { code: 1, message: fullResponse}; console.log('Ответ чата: ', response); // Отправка ответа клиенту sendMessage(ws, response); } } catch (callbackError) { console.error('Error processing callback result:', callbackError); if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ stats.totalQwenCallbackErrors++; let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." }; sendMessage(ws, errorResponse); messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось } } }); } catch (error) { stats.totalQwenMessErrors++; console.error('Error:', error); let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."}; // Отправка ответа клиенту sendMessage(ws, response); }}
// Blackbox async function callBlackbox(messages, ws) { try { let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента к Blackbox:', messages[messages.length - 1]); //throw new Error("Намеренная ошибка для тестирования catch"); let messageSent = false; blackbox({ messages: messages, markdown: false, websearch: false, llama: false }, (result) => { // Обработка результата внутри колбэка if (result.error) { throw new Error(result.error); // Обрабатываем ошибку, если она есть } try { if (!result.finish) { // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления) fullResponse = result.message || ""; //console.log(result); } else { // Если завершено, выводим полный ответ let response = { code: 1, message: fullResponse}; console.log('Ответ чата: ', response); // Отправка ответа клиенту sendMessage(ws, response); } } catch (callbackError) { console.error('Error processing callback result:', callbackError); if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ stats.totalBlackboxCallbackErrors++; let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." }; sendMessage(ws, errorResponse); messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось } } }); } catch (error) { stats.totalBlackboxMessErrors++; console.error('Error:', error); let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."}; // Отправка ответа клиенту sendMessage(ws, response); }}
// GPT3.5-Turbo (Отключен в интерфейсе) async function callGPT35Turbo(messages, ws) { try { let fullResponse = ""; // Переменная для результата
console.log('Запрос клиента к GPT3.5-Turbo:', messages[messages.length - 1]); //throw new Error("Намеренная ошибка для тестирования catch"); let messageSent = false; gpt3({ messages: messages, markdown: false }, (result) => { // Обработка результата внутри колбэка if (result.error) { //throw new Error(result.error); // Обрабатываем ошибку, если она есть } try { if (!result.finish) { // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления) fullResponse = result.message || ""; //console.log(result); } else { // Если завершено, выводим полный ответ let response = { code: 1, message: fullResponse}; console.log('Ответ чата: ', response); // Отправка ответа клиенту sendMessage(ws, response); } } catch (callbackError) { console.error('Error processing callback result:', callbackError); if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ stats.totalGPT35CallbackErrors++; let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." }; sendMessage(ws, errorResponse); messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось } } }); } catch (error) { stats.totalGPT35MessErrors++; console.error('Error:', error); let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."}; // Отправка ответа клиенту sendMessage(ws, response); }}
//============== ВЫЗОВ API МОДЕЛЕЙ (КОНЕЦ) ====================== Assistant: ная причина, по которой итции в вашем тесте могли не завершиться, заключается в том, что соединение WebSocket не закрывается автоматически после выполнения всех необходимых обменов сообщениями. В вашем приложении соединение остаётся открытым, пока клиент не закроет страницу в браузере. Это приводит к тому, что K6 не может отследить корректное завершение итерации, так как соединение остаётся активным.
Что такое завершение итерации в K6?
В контексте K6 итерация считается завершенной, когда виртуальный пользователь:
- Установил соединение с сервером.
- Отправил сообщение.
- Получил ответ от сервера.
- Закрыл соединение (или завершил свою работу корректно).
Если последний шаг (закрытие соединения) не выполняется, K6 считает, что итерация не завершена.
Что делать?
-
Закрытие соединения: Вы можете явно закрывать соединения в вашем приложении после обработки сообщения. В K6 вы можете добавить логику для закрытия WebSocket соединения в обработчик события
message, как показано ниже:socket.on('message', function (message) { console.log('Received message: ' + message); // После получения сообщения закройте соединение socket.close(); });Это позволит K6 отслеживать завершение итераций, поскольку виртуальные пользователи будут завершать свои работы.
-
Настройка обработки на стороне сервера: Если ваше приложение предназначено для работы с постоянными соединениями (например, для чатов), вы можете рассмотреть возможность расширения логики обработки, чтобы она могла корректно завершать соединения по запросу клиента.
-
Логи на стороне сервера: Убедитесь, что ваш серверный код может правильно обрабатывать закрытие соединений. Например, логика в обработчике события
closeвзаимодействует с клиентом и проверяет, корректно ли закрываются соединения. -
Проверка отказов: Также проверьте соответствие ожидаемого поведения и фактического поведения вашего приложения. Браузерные приложения могут автоматически завершать соединения при закрытии вкладки, а это может не всегда будет отражаться в серверной логике.
Заключение
Ваше приложение должно предусматривать логику закрытия соединений для обеспечения того, чтобы K6 корректно отслеживало завершение итераций. Обеспечив правильное закрытие соединений, вы сможете более точно отслеживать и анализировать результаты ваших нагрузочных тестов. User: Закрытие соединения: Вы можете явно закрывать соединения в вашем приложении после обработки сообщения. В K6 вы можете добавить логику для закрытия WebSocket соединения в обработчик события message, как показано ниже:
socket.on('message', function (message) { console.log('Received message: ' + message); // После получения сообщения закройте соединение socket.close(); });
Это нужно исключительно в рамках тестирования? Потому что в продакшене это не имеет смысла, ведь это чат. Будет странно если соединение закрывается после каждого сообщения клиента Assistant: , вы правы. ЗакрытиеSocket-соединения после каждого сообщения в реальном приложении для чата действительно может привести к нежелательному поведению и ухудшению пользовательского опыта. В случае чата соединение должно оставаться открытым, чтобы обеспечить возможность обмена сообщениями в реальном времени.
Различия между тестированием и продакшеном
-
Тестирование:
- В тестах, особенно во время нагрузочного тестирования, может быть необходимо закрыть соединение после получения ответа, чтобы K6 мог корректно отслеживать завершение итераций и оценивать производительность приложения. Это особенно важно для тестирования под нагрузкой, где вы хотите убедиться, что сервер может обрабатывать множество подключений и сообщений, но без необходимости держать соединения открытыми между тестами.
- В таких случаях вы можете добавить логику закрытия соединения временно для исключительных случаев тестирования.
-
Продакшен:
- В реальных условиях вашего чат-приложения соединения должны оставаться открытыми, чтобы поддерживать возможность постоянно продолжать диалог между пользователями. Закрытие соединения в чате, без необходимости перезапуска, будет восприниматься как ошибка и может привести к потере контекста общения.
Рекомендации для тестирования и разработки
-
Тесты должны симулировать реальное поведение: Вместо того чтобы закрывать соединение после каждого сообщения в тестах, вы можете использовать более подходящий подход:
- Создайте тест, который активирует пользователей, отправляющих несколько сообщений в течение своего «времени жизни». Вместо закрытия соединения можно поддерживать его открытым в течение теста, а затем корректно завершать с определённым таймаутом после последнего отправленного сообщения.
Пример:
socket.on('open', function () { console.log(`Connected with token: ${userId}`); socket.send(JSON.stringify({ messages: [{ role: "user", content: "Test message!" }], inputPrompt: "Test message!", model: "gpt-4o" })); }); socket.on('message', function (message) { console.log('Received message: ' + message); // В этом случае не закрывайте соединение сразу, а поддерживайте его открытым }); // Откройте соединение на определённое время, затем закройте setTimeout(() => { socket.close(); }, 10000); // Закрытие соединения через 10 секунд, например -
Тестирование производительности: Обратите внимание на масштабирование нагрузки, особенно на возможность обработки больших имён пользователей и сообщений, чтобы протестировать сервер.
-
Логирование ошибок: Добавьте логирование в вашем приложении, чтобы отследить проблемы, связанные с производительностью или ошибками и при необходимости улучшить обработку сообщений.
-
Мониторинг сервера: Используйте мониторинг (например, для использования CPU, памяти и количества соединений), чтобы выявить узкие места в производительности.
Заключение
Таким образом, в тестировании вы можете применять разные подходы для закрытия соединений, но в производственном окружении для вашего чат-приложения соединения, как правило, должны оставаться открытыми. Обратите внимание на правильную настройку и мониторинг производительности для обеспечения корректной работы вашего приложения под нагрузкой. User: socket.on('open', function () { console.log(
Connected with token: ${userId}); socket.send(JSON.stringify({ messages: [{ role: "user", content: "Test message!" }], inputPrompt: "Test message!", model: "gpt-4o" })); });socket.on('message', function (message) { console.log('Received message: ' + message); // В этом случае не закрывайте соединение сразу, а поддерживайте его открытым });
// Откройте соединение на определённое время, затем закройте setTimeout(() => { socket.close(); }, 10000); // Закрытие соединения через 10 секунд, например
Как это сделать в рамках моего приложения, покажи Assistant:
- Assistant
Для интеграции логики, которую вы описали, в ваше приложение на Node.js с использованием WebSocket-сервера, давайте внесем соответствующие изменения в ваш обработчик соединений WebSocket. Мы будем поддерживать соединение открытым в течение определенного времени, а затем закроем его.
Внесение изменений в ваше приложение
-
Добавление логики для закрытия соединения через определенное время: В вашем блоке кода, где находится обработчик события
connection, вам нужно будет добавить таймер, который закроет соединение после определенного периода времени (например, 10 секунд). -
Пример Кода:
Вот обновленный код вашего WebSocket-сервера с учетом описанных изменений:
const WebSocket = require('ws'); const Bottleneck = require('bottleneck'); // Ваш остальной код... // Создайте WebSocket-сервер const wss = new WebSocket.Server({ port: 3000 }); wss.on('connection', (ws, req) => { const urlParams = new URLSearchParams(req.url.split('?')[1]); const userId = urlParams.get('token'); console.log('Client connected with user ID:', userId); // Примите сообщение от клиента ws.on('message', (message) => { // Здесь вы можете обрабатывать входящие сообщения console.log('Received message: ' + message); // Допустим, вы хотите отправить ответ клиенту const response = { code: 1, message: 'Message received' }; ws.send(JSON.stringify(response)); }); // Установите таймер для закрытия соединения через 10 секунд setTimeout(() => { ws.close(); // Закрытие соединения после 10 секунд console.log('Connection closed for user ID:', userId); }, 10000); // Можно настроить время на свое усмотрение ws.on('close', () => { console.log('Client disconnected with user ID:', userId); }); ws.on('error', (error) => { console.error('WebSocket error:', error); }); }); console.log('WebSocket сервер запущен через порт 3000');Объяснение внесенных изменений:
-
Установка таймера:
- После установки соединения добавляется функция
setTimeout, которая запускается через 10 секунд (10000миллисекунд). Эта функция вызываетws.close(), закрывающий соединение.
- После установки соединения добавляется функция
-
Обработка сообщений:
- При получении сообщения клиентом логируется текст сообщения, и сервер отправляет базовый ответ, указывающий, что сообщение было получено.
-
Обработка ошибок:
- Добавлена обработка ошибок с помощью
ws.on('error', ...)для отслеживания возможных проблем.
- Добавлена обработка ошибок с помощью
-
Сообщение при закрытии соединения:
- Когда соединение закрывается, выводится сообщение в консоль, чтобы указать, что клиент отключился.
Важно:
- В реальных чат-приложениях вам может понадобиться более сложная логика: например, периодическое обновление сообщений, статусы пользователей и т.д. В этом случае вам может потребоваться управлять состоянием подключений и сообщений более эффективно.
- В этом примере я использую простую логику, которая удобно иллюстрирует, как можно открывать и закрывать соединения. Вы можете доработать это под ваши конкретные требования.
-