Node Events

The NodeManager emits events for node connectivity and lifecycle. Listen on manager.nodeManager.

Core Node Events

Event	Signature	Description
nodeCreate	(node)	A new node was added to the manager.
nodeConnect	(node)	Node WebSocket connected. Forwarded to manager.
nodeDisconnect	(node, reason)	Node WebSocket disconnected. reason.code, reason.reason. Forwarded to manager.
nodeError	(node, error, payload?)	Node encountered a REST or WebSocket error. Forwarded to manager.
nodeReady	(node, payload)	Node session ready. payload.resumed, payload.sessionId. Forwarded to manager.
nodeRaw	(node, payload)	Every raw WebSocket payload received from the node. Forwarded to manager.

Usage Examples

manager.nodeManager.on('nodeCreate', (node) => {
  console.log(`[NodeManager] Node created: ${node.id}`);
});

manager.nodeManager.on('nodeConnect', (node) => {
  console.log(`[NodeManager] ${node.id} connected | Session: ${node.sessionId}`);
});

manager.nodeManager.on('nodeDisconnect', (node, reason) => {
  console.warn(`[NodeManager] ${node.id} disconnected: ${reason.reason} (${reason.code})`);
});

manager.nodeManager.on('nodeReady', (node, payload) => {
  console.log(`[NodeManager] ${node.id} ready — resumed: ${payload.resumed}, session: ${payload.sessionId}`);
});

manager.nodeManager.on('nodeError', (node, error) => {
  console.error(`[NodeManager] ${node.id} error: ${error.message}`);
});

manager.nodeManager.on('nodeRaw', (node, payload) => {
  // Fires for every WebSocket message — use with caution in high-concurrency environments
  if (payload.op === 'stats') {
    console.log(`[NodeManager] ${node.id} stats: ${payload.players} players`);
  }
});

NodeManager Methods

// Create a node
const node = manager.nodeManager.createNode({
  id: 'extra',
  host: 'node2.example.com',
  port: 2333,
  authorization: 'pw',
});

// Get a node by id or instance
const node = manager.nodeManager.getNode('extra');

// Delete a node (movePlayers=true migrates players to another node)
manager.nodeManager.deleteNode('extra', false);
manager.nodeManager.deleteNode('extra', true); // migrate players

// Least-used nodes (only returns connected nodes)
const nodes = manager.nodeManager.leastUsedNodes('weighted');
const nodes2 = manager.nodeManager.leastUsedNodes('players'); // default

// Bulk operations
await manager.nodeManager.disconnectAll(deleteAllNodes, destroyPlayers);
await manager.nodeManager.connectAll();
await manager.nodeManager.reconnectAll();

// Serialize
const json = manager.nodeManager.toJSON();
// { nodeCount: 2, nodes: ['main', 'extra'] }

Node Health API

const node = manager.nodeManager.getNode('main');

// Metric summary
const metrics = node.nodeMetricSummary();
// { cpuLoad, systemLoad, memoryUsage, players, playingPlayers, uptime, ping, frameDeficit }

// Health status
const health = node.getHealthStatus();
// { status: 'healthy' | 'degraded' | 'critical' | 'offline', performance, isOverloaded, needsRestart, penaltyScore, estimatedRemainingCapacity, recommendations, metrics }

// Custom thresholds
const health2 = node.getHealthStatus({
  cpu: { excellent: 0.3, good: 0.5, fair: 0.7, poor: 0.85 },
  memory: { excellent: 60, good: 75, fair: 85, poor: 95 },
  ping: { excellent: 50, good: 100, fair: 200, poor: 300 },
});

// Weighted score (lower = healthier, Infinity if disconnected)
console.log(node.weightedScore);

// Connection state
console.log(node.connected);           // boolean
console.log(node.connectionStatus);    // 'CONNECTING' | 'OPEN' | 'CLOSING' | 'CLOSED'
console.log(node.isNodeReconnecting);  // boolean
console.log(node.reconnectionAttemptCount); // number
console.log(node.heartBeatPing);       // ms
console.log(node.handshakePing);       // ms (set on open)
console.log(node.isAlive);             // boolean

Route Planner API

const status = await node.routePlannerApi.getStatus();
await node.routePlannerApi.unmarkFailedAddress('1.2.3.4');
await node.routePlannerApi.unmarkAllFailedAddresses();

Use the nodeRaw event with caution — it fires for every WebSocket message and can be extremely verbose in high-concurrency environments.