Advanced Error Handling | Error Handling

Introduction

Error handling is a critical aspect of software development. It involves anticipating, detecting, and resolving errors that occur during the execution of a program. Advanced error handling goes beyond basic try-catch blocks and involves techniques like custom error types, logging, and recovery mechanisms.

Custom Error Types

Creating custom error types allows you to handle different error scenarios more effectively. In most programming languages, you can extend the base error class to create your own error types.

class ValidationError extends Error {
    constructor(message) {
        super(message);
        this.name = "ValidationError";
    }
}

try {
    throw new ValidationError("This is a validation error");
} catch (error) {
    if (error instanceof ValidationError) {
        console.error("Caught a validation error: ", error.message);
    } else {
        console.error("Caught an unknown error: ", error.message);
    }
}

Error Logging

Error logging is essential for diagnosing and fixing issues. It involves recording error information to a file, database, or monitoring system.

const fs = require('fs');

function logErrorToFile(error) {
    const errorMessage = `${new Date().toISOString()} - ${error.name}: ${error.message}\n`;
    fs.appendFileSync('error.log', errorMessage, 'utf8');
}

try {
    throw new Error("Something went wrong");
} catch (error) {
    logErrorToFile(error);
    console.error("An error occurred: ", error.message);
}

Retry Mechanisms

Retry mechanisms are useful when dealing with transient errors, such as network issues. They involve reattempting an operation a certain number of times before giving up.

function retryOperation(operation, delay, retries) {
    return new Promise((resolve, reject) => {
        function attempt() {
            operation()
                .then(resolve)
                .catch((error) => {
                    if (retries === 0) {
                        reject(error);
                    } else {
                        setTimeout(() => {
                            retries--;
                            attempt();
                        }, delay);
                    }
                });
        }
        attempt();
    });
}

function fetchData() {
    return new Promise((resolve, reject) => {
        // Simulate a network request
        if (Math.random() < 0.7) {
            reject(new Error("Network error"));
        } else {
            resolve("Data fetched successfully");
        }
    });
}

retryOperation(fetchData, 1000, 3)
    .then((result) => console.log(result))
    .catch((error) => console.error("Failed to fetch data: ", error.message));

Graceful Degradation

Graceful degradation involves providing fallback options in case of an error, ensuring that the user experience is minimally affected.

function fetchDataWithFallback() {
    return fetchData()
        .catch((error) => {
            console.error("Primary data fetch failed, falling back to cached data: ", error.message);
            return getCachedData();
        });
}

function getCachedData() {
    return Promise.resolve("Cached data");
}

fetchDataWithFallback()
    .then((data) => console.log(data))
    .catch((error) => console.error("Failed to fetch data: ", error.message));

Conclusion

Advanced error handling involves creating custom error types, logging errors, implementing retry mechanisms, and ensuring graceful degradation. By adopting these techniques, you can build more resilient and user-friendly applications.