Propagação e recuperação robustas de erros
Desenvolva estratégias para tratamento de erros, registro de eventos e degradação controlada em aplicações WebSocket.
Propagação e recuperação robustas de erros é uma aula grátis de WebSockets & Realtime Systems Programming no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de WebSockets & Realtime Systems Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de WebSockets & Realtime Systems Programming inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em 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!
Aprenda WebSockets & Realtime Systems Programming com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 12
- Aulas
- 47
Perguntas Frequentes
A aula “Propagação e recuperação robustas de erros” é grátis?
Sim — o texto completo de “Propagação e recuperação robustas de erros” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de WebSockets & Realtime Systems Programming, atualize para CoddyKit PRO. O curso de WebSockets & Realtime Systems Programming inclui 4 aulas no total.
O que vou aprender em “Propagação e recuperação robustas de erros”?
Desenvolva estratégias para tratamento de erros, registro de eventos e degradação controlada em aplicações WebSocket. Você pratica WebSockets & Realtime Systems Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar WebSockets & Realtime Systems Programming?
Nenhuma experiência prévia é necessária. WebSockets & Realtime Systems Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Propagação e recuperação robustas de erros”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de WebSockets & Realtime Systems Programming?
Sim. Cada aula de WebSockets & Realtime Systems Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Como lidar com desconexões e reconexões
- Propagação e recuperação robustas de erros
- Sinais de atividade e manutenção da conexão
- Confirmação de mensagens e garantias de entrega