No results for

Powered byAlgolia
⚠️ This is the archived documentation for k6 v0.46. Go to the latest version.

websockets

Experimental module

While we intend to keep experimental modules as stable as possible, we may need to introduce breaking changes. This could happen at future k6 releases until the module becomes fully stable and graduates as a k6 core module. For more information, refer to the extension graduation process.

Experimental modules maintain a high level of stability and follow regular maintenance and security measures. Feel free to open an issue if you have any feedback or suggestions.

This experimental API implements the browser WebSocket API with additional k6-specific functionalities (cookies, tags, headers and so on).

The main difference between this module and k6/ws is that this module uses a global event loop instead of a local one. A global event loop lets a single VU have multiple concurrent connections, which improves performance.

The WebSocket API is not fully implemented, and we're working on it, but we believe it's usable for most users. So whether you're writing a new WebSocket test, or currently using the k6/ws module, we invite you to give it a try, and report any issues in the project's issue tracker. Our midterm goal is to make this module part of k6 core, and long-term to replace the k6/ws module.

Class/MethodDescription
ParamsUsed for setting various WebSocket connection parameters such as headers, cookie jar, compression, etc.
WebSocket(url, protocols, params)Constructs a new WebSocket connection.
WebSocket.close()Close the WebSocket connection.
WebSocket.ping()Send a ping.
WebSocket.send(data)Send string data.
WebSocket.addEventListener(event, handler)Add an event listener on the connection for specific event.

A WebSocket instance also has the following properties:

Class/PropertyDescription
WebSocket.readyStateThe current state of the connection. Could be one of the four states.
WebSocket.urlThe URL of the connection as resolved by the constructor.
WebSocket.bufferedAmountThe number of bytes of data that have been queued using calls to send() but not yet transmitted to the network.
WebSocket.binaryTypeThe binaryType is by default "ArrayBuffer". Setting it throws an exception, as k6 does not support the Blob type.
WebSocket.onmessageA handler for message events.
WebSocket.onerrorA handler for error events.
WebSocket.onopenA handler for open events.
WebSocket.oncloseA handler for close events.
WebSocket.onpingA handler for ping events.
WebSocket.onpongA handler for pong events.

Websocket metrics

k6 takes specific measurements for Websockets. For the complete list, refer to the Metrics reference.

Example

This example shows:

  • How a single VU can run multiple WebSockets connections asynchronously.
  • How to use the timeout and interval functions to stop the connections after some period.
example-websocket.js
import { randomString, randomIntBetween } from 'https://jslib.k6.io/k6-utils/1.1.0/index.js';
import { WebSocket } from 'k6/experimental/websockets';
import { setTimeout, clearTimeout, setInterval, clearInterval } from 'k6/experimental/timers';
const chatRoomName = 'publicRoom'; // choose any chat room name
const sessionDuration = randomIntBetween(5000, 60000); // user session between 5s and 1m
export default function () {
for (let i = 0; i < 4; i++) {
startWSWorker(i);
}
}
function startWSWorker(id) {
// create a new websocket connection
const ws = new WebSocket(`wss://test-api.k6.io/ws/crocochat/${chatRoomName}/`);
ws.addEventListener('open', () => {
// change the user name
ws.send(JSON.stringify({ event: 'SET_NAME', new_name: `Croc ${__VU}:${id}` }));
// listen for messages/errors and log them into console
ws.addEventListener('message', (e) => {
const msg = JSON.parse(e.data);
if (msg.event === 'CHAT_MSG') {
console.log(`VU ${__VU}:${id} received: ${msg.user} says: ${msg.message}`);
} else if (msg.event === 'ERROR') {
console.error(`VU ${__VU}:${id} received:: ${msg.message}`);
} else {
console.log(`VU ${__VU}:${id} received unhandled message: ${msg.message}`);
}
});
// send a message every 2-8 seconds
const intervalId = setInterval(() => {
ws.send(JSON.stringify({ event: 'SAY', message: `I'm saying ${randomString(5)}` }));
}, randomIntBetween(2000, 8000)); // say something every 2-8 seconds
// after a sessionDuration stop sending messages and leave the room
const timeout1id = setTimeout(function () {
clearInterval(intervalId);
console.log(`VU ${__VU}:${id}: ${sessionDuration}ms passed, leaving the chat`);
ws.send(JSON.stringify({ event: 'LEAVE' }));
}, sessionDuration);
// after a sessionDuration + 3s close the connection
const timeout2id = setTimeout(function () {
console.log(`Closing the socket forcefully 3s after graceful LEAVE`);
ws.close();
}, sessionDuration + 3000);
// when connection is closing, clean up the previously created timers
ws.addEventListener('close', () => {
clearTimeout(timeout1id);
clearTimeout(timeout2id);
console.log(`VU ${__VU}:${id}: disconnected`);
});
});
}