Propagación y recuperación robustas de errores
Desarrolle estrategias de gestión de errores, registro y degradación controlada en aplicaciones WebSocket.
Propagación y recuperación robustas de errores es una lección gratuita de WebSockets & Realtime Systems Programming en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de WebSockets & Realtime Systems Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de WebSockets & Realtime Systems Programming incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
Handling Realtime Errors
Building reliable realtime applications requires more than just handling disconnections. You need a solid strategy for dealing with errors that occur within your WebSocket communication.
Robust error handling ensures your application remains stable, provides a good user experience, and helps you diagnose issues quickly.
Different Error Types
Errors in WebSocket applications can come from various sources:
- Protocol Errors: These are issues like malformed frames or invalid opcodes. Your WebSocket library usually handles these automatically.
- Application Logic Errors: Bugs in your server or client code that cause unexpected behavior or crashes during message processing.
- Network Errors: Problems like firewalls, proxy issues, or unstable internet connections, often leading to connection loss.
We'll focus on handling application and network-related errors effectively.
Server Error Handling
On the server, WebSocket libraries provide mechanisms to catch errors. For example, in Node.js with the popular ws library, both the server instance and individual client connections can emit 'error' events.
It's crucial to listen for these events to prevent your server from crashing and to log issues for debugging.
Server Error in Action
This Node.js example shows a simple WebSocket server that intentionally throws an error when a specific message is received. Notice how the wss.on('error') and ws.on('error') handlers catch it.
const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });
wss.on('connection', function connection(ws) {
console.log('Client connected');
ws.on('message', function incoming(message) {
console.log('Received: %s', message);
if (message.toString() === 'cause error') {
// Simulate an application logic error
try {
throw new Error('Simulated application error!');
} catch (e) {
console.error('Caught application error:', e.message);
// In a real app, you might send this error to the client
ws.send(JSON.stringify({ type: 'error', message: e.message }));
}
} else {
ws.send(`Echo: ${message}`);
}
});
ws.on('error', (error) => {
console.error('WebSocket connection error:', error.message);
});
ws.on('close', () => {
console.log('Client disconnected');
});
});
wss.on('error', (error) => {
console.error('WebSocket server error:', error.message);
});
console.log('WebSocket server started on port 8080');
// To run this example:
// 1. npm init -y
// 2. npm install ws
// 3. node server.js
// Then connect with a client and send 'cause error'Client Error Handling
On the client side, the browser's native WebSocket object provides an onerror event. This event fires when errors occur during connection establishment, or at any point during the connection's lifetime.
It's important to note that onerror often precedes or accompanies a onclose event, indicating a problematic connection termination.
Client Error in Action
This HTML and JavaScript snippet demonstrates how to set up an onerror handler for a WebSocket client. Try running the server from the previous scene and then this client in your browser.
<!DOCTYPE html>
<html>
<head>
<title>WebSocket Client Error Handling</title>
</head>
<body>
<h1>Client Error Handler</h1>
<p id="status">Connecting...</p>
<script>
const statusElement = document.getElementById('status');
const ws = new WebSocket('ws://localhost:8080');
ws.onopen = () => {
statusElement.textContent = 'Connected! Try sending "cause error" from a different client.';
console.log('WebSocket connected.');
ws.send('Hello server!');
};
ws.onmessage = (event) => {
console.log('Message from server:', event.data);
statusElement.textContent = `Received: ${event.data}`;
};
ws.onerror = (error) => {
// The error object itself might not contain detailed info
// but it signals that an error occurred.
statusElement.textContent = 'Error occurred! Check console.';
console.error('WebSocket error event:', error);
};
ws.onclose = (event) => {
statusElement.textContent = `Disconnected. Code: ${event.code}, Reason: ${event.reason}`;
console.log('WebSocket disconnected:', event);
};
</script>
</body>
</html>Propagating Custom Errors
Sometimes, errors aren't about the connection itself, but about your application's logic. For example, a user trying to access unauthorized data or submitting invalid input. In these cases, you need to explicitly send an error message.
It's best practice to structure these as standard messages (e.g., JSON) with a specific type or status to differentiate them from regular data.
Server Sending Custom Errors
Here's how a server can send a structured error message back to the client. The client then needs to parse and handle this specific message type to react appropriately.
const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8081 }); // Using a different port
wss.on('connection', function connection(ws) {
console.log('Client connected to custom error server');
ws.on('message', function incoming(message) {
const msgStr = message.toString();
if (msgStr === 'fetch_sensitive_data') {
// Simulate an authorization error
const errorResponse = {
type: 'error',
code: 403,
message: 'Access denied: You are not authorized for this data.'
};
ws.send(JSON.stringify(errorResponse));
} else {
ws.send(`Echo: ${msgStr}`);
}
});
ws.on('error', (error) => console.error('Connection error:', error.message));
ws.on('close', () => console.log('Client disconnected from custom error server'));
});
console.log('WebSocket server for custom errors started on port 8081');
// To run this example:
// 1. npm init -y
// 2. npm install ws
// 3. node server_custom_error.js
// Then connect a client and send 'fetch_sensitive_data'Graceful Degradation
When a severe error occurs, instead of completely failing, your application can "gracefully degrade" its functionality. This means offering a reduced but still usable experience.
- Partial Functionality: Disable features that rely on the problematic component, but keep others working.
- Fallback Mechanisms: Use alternative (perhaps less real-time) methods, like refreshing data via traditional HTTP requests.
- Inform User: Clearly communicate the issue and what functionality is affected, managing their expectations.
Error Strategy Check
Which of the following is an effective strategy for graceful degradation in a WebSocket application when a critical server-side error prevents real-time updates?
Error Handling Summary
You've learned that robust error handling in WebSocket applications involves understanding different error types, catching both server-side and client-side events, and explicitly propagating application-level errors.
Crucially, implementing graceful degradation ensures your application remains resilient and user-friendly even when things go wrong. Keep practicing these strategies to build more robust realtime systems!
Aprende WebSockets & Realtime Systems Programming con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 12
- Lecciones
- 47
Preguntas frecuentes
¿La lección «Propagación y recuperación robustas de errores» es gratis?
Sí — el texto completo de «Propagación y recuperación robustas de errores» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de WebSockets & Realtime Systems Programming, actualiza a CoddyKit PRO. El curso de WebSockets & Realtime Systems Programming incluye 4 lecciones en total.
¿Qué aprenderé en «Propagación y recuperación robustas de errores»?
Desarrolle estrategias de gestión de errores, registro y degradación controlada en aplicaciones WebSocket. Practicas WebSockets & Realtime Systems Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar WebSockets & Realtime Systems Programming?
No se requiere experiencia previa. WebSockets & Realtime Systems Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Propagación y recuperación robustas de errores»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de WebSockets & Realtime Systems Programming?
Sí. Cada lección de WebSockets & Realtime Systems Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Gestión de desconexiones y reconexiones
- Propagación y recuperación robustas de errores
- Heartbeats y mantenimiento de conexiones
- Confirmación de mensajes y garantías de entrega