Exception Handling & Logging

• 💥 Errors and/vs exceptions
• 🛡️ Handling exceptions
• ☝️ Raising exceptions
• 💡 Advanced topics & best practices
• 📜 Logging

1. 1.Detection: Identifying that something has gone wrong or is outside the expected operating parameters.
2. 2.Containment: Preventing the initial problem from causing further damage or system-wide failure.
3. 3.Alternative Action: Having a pre-defined way to respond to the error, whether it's a fallback mechanism, alerting a user, or attempting to recover.
4. 4.Logging/Reporting: Recording the error for later analysis and debugging.

The purpose of exception handling is not just to prevent software crashes but also to:

• 🐛 Deal with logical errors
• 💬 Provide meaningful error messages to users
• 🚪 Ensure the program exits safely if needed

It is a fundamental aspect of writing robust, reliable software that can handle the unpredictable nature of real-world operation.

When writing a program, we, more often than not, will encounter errors.

Error caused by not following the proper structure (syntax) of the language is called a syntax error or parsing error.

Syntax errors are detected by the interpreter during the parsing stage, before the execution begins. Examples include missing colons, incorrect indentation, or unmatched parentheses.

Definition:

Exceptions are events that occur during the execution of a program, disrupting its normal flow.

They often arise from errors in the program's logic or unexpected conditions, such as:

• 📂 A file not being found
• ⚠️ An invalid input
• ❌ A division by zero

Nature of Exceptions:

Unlike syntax errors, which are identified before the program runs, exceptions can happen at any time during execution. They need to be explicitly handled to maintain the stability and reliability of the software.

After learning about errors and exceptions, we will learn to handle them by using try, except, else, and finally blocks.

So, what do we mean by handling them?

In normal circumstances, these errors will stop the code execution and display the error message.

To create stable systems, we need to anticipate these errors and come up with alternative solutions or warning messages.

In this example, we will try to print the undefined x variable.

try:
    print(x)

except:
    print("An exception has occurred!")

• The program will run the code under the try statement
• As we know that x is not defined, it will run the except statement and print the warning

As a Python developer, you have the option to throw an exception if certain conditions are met.

It allows you to interrupt the program based on your requirement.

To throw an exception, we have to use the raise keyword followed by an exception name:

raise ExceptionType("Error message")

✅ Validation: To enforce certain conditions or validate inputs. If a function requires a positive integer, you can raise an exception if a negative value is passed.

📣 Error Reporting: To signal errors in a way that's consistent with Python's error handling model, making your code more intuitive to other Python developers.

🔀 Control Flow: In complex functions, to signal that an error condition has occurred, leading to an early exit from a function or triggering specific error handling logic.

Use exceptions to communicate that something unexpected has happened, to enforce correct usage of functions, and to make your code more robust and maintainable.

• 🔎 Clarity: Makes your intent clear to anyone reading your code, indicating that a specific situation is considered an error state
• 🧩 Consistency: Keeps your error handling consistent with that of Python itself, making your code more predictable
• 💪 Robustness: Allows upstream code to handle errors gracefully instead of failing silently or crashing

Custom exceptions are defined by subclassing Python's built-in Exception class.

The simplest form:

class MyCustomError(Exception):
    pass

With a constructor:

class ValidationError(Exception):
    def __init__(self, message, value):
        self.message = message
        self.value = value
        super().__init__(message)

The assert statement in Python is a debugging aid that tests a condition as an internal self-check in your program.

It is intended as a debugging aid, not as a mechanism for handling run-time errors.

assert condition, "Optional error message"

• condition: If True, nothing happens. If False, an AssertionError is raised
• The error message is optional; if omitted, the AssertionError will be raised without a message

Logging exceptions is a crucial practice in software development, allowing developers to record errors that occur during the execution of a program.

This practice not only aids in debugging by providing a historical record of what went wrong and when, but it also helps in monitoring the health of applications in production.

import logging

try:
    1 / 0
except ZeroDivisionError:
    logging.exception("Exception occurred")

Output: 2023-04-04 12:30:55 - root - ERROR - Exception occurred

• DEBUG: Detailed operational insights useful for development
• INFO: Milestones such as successfully loading configuration and starting the web server
• WARNING: Potentially suspicious operations, such as unrecognized login attempts
• ERROR: Issues preventing a specific operation from completing correctly
• CRITICAL: Severe problems that affect the application's ability to function

In real applications, use getLogger(__name__) instead of the root logger. This creates a logger named after your module:

import logging

logger = logging.getLogger(__name__)

def process_order(order_id):
    logger.info(f"Processing order {order_id}")
    try:
        validate(order_id)
    except ValueError as e:
        logger.error(f"Invalid order {order_id}: {e}")
        raise

• 🏭 Each module gets its own named logger — easy to filter
• 🔎 Log output shows which module produced each message
• 🛠️ You can configure different levels per module

• 🎯 Use Appropriate Log Levels: Use logging.exception within except blocks to include the stack trace automatically
• 🔍 Include Contextual Information: When logging exceptions, include as much context as possible — the logging module allows you to insert variable data into your log messages
• 🌐 Centralize Logging: In larger applications, aggregate logs from various parts of the application. This makes monitoring and analysis easier
• 🔒 Secure Sensitive Information: Be cautious about logging sensitive information. Logs can contain user data, credentials, or internal details which could be exploited if exposed

• 🎯 Catch Specific Exceptions: Always target specific exceptions in your except blocks to avoid unintended side effects and make your error handling more precise
• 🚫 Manage Resources with finally or Context Managers: Ensure resources are properly released or cleaned up, even when exceptions occur, by using finally blocks or context managers (with statements)
• ⚡ Use Exceptions for Exceptional Conditions: Exceptions should be used for handling error states or unexpected conditions, not as a part of normal program flow
• 📝 Provide Detailed Error Information: When raising an exception, include clear, descriptive messages and consider adding extra attributes for more context

• 🙄 Avoid Catching General Exceptions: Refrain from using broad except Exception: clauses, which can catch more than you intend and obscure programming errors
• 🙈 Don't Swallow Exceptions Silently: Never catch an exception and do nothing with it. At minimum, log the exception to aid in debugging
• 🚫 Don't Use Exceptions for Control Flow: Exceptions should not replace control flow structures like loops or conditionals
• 🚦 Don't Overuse Custom Exceptions: While custom exceptions can make error handling clearer, too many can clutter your code
• 🐍 Follow Pythonic Error Handling Practices: Embrace the EAFP (Easier to Ask for Forgiveness than Permission) principle

• ⛔ Syntax errors are caught before execution — fix them in code
• 💥 Exceptions happen at runtime — handle them with try/except
• ✅ Use else for code that runs only when try succeeds
• 🚫 Use finally for cleanup that always runs
• ☝️ raise to throw your own exceptions for validation & control flow
• 🧩 Custom exceptions inherit from Exception — name them with "Error" suffix
• 🐛 assert is for debugging, not production validation
• 📜 Use Python's logging module instead of print for production apps
• 🐍 Follow EAFP — Easier to Ask for Forgiveness than Permission