# Part 1: Basic Logging Configuration
import logging
import sys

# 1. Basic configuration: Console output
# This sets up a default handler to print to console (stderr)
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

def simple_operation(x, y):
    logging.info(f"Attempting simple_operation with x={x}, y={y}")
    try:
        result = x / y
        logging.info(f"Operation successful: {x} / {y} = {result}")
        return result
    except ZeroDivisionError as e:
        logging.error(f"A ZeroDivisionError occurred: {e}")
        # logging.exception() automatically includes traceback info
        logging.exception("Detailed error info for ZeroDivisionError")
        return None

simple_operation(10, 2)
simple_operation(5, 0)

# 2. Advanced configuration: File output and custom format
# Create a logger instance
file_logger = logging.getLogger('file_logger')
file_logger.setLevel(logging.DEBUG) # Log all messages at DEBUG level and above for this logger

# Remove any default handlers added by basicConfig to prevent duplicate output
if not file_logger.handlers:
    # Create a file handler
    file_handler = logging.FileHandler('app_errors.log')
    file_handler.setLevel(logging.WARNING) # Only log WARNING and above to file

    # Create a formatter
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    file_handler.setFormatter(formatter)

    # Add the handler to the logger
    file_logger.addHandler(file_handler)

    # Also add a StreamHandler for console output (optional, but good for dual output)
    console_handler = logging.StreamHandler(sys.stdout)
    console_handler.setLevel(logging.INFO) # Only log INFO and above to console for this logger
    console_handler.setFormatter(formatter)
    file_logger.addHandler(console_handler)

def risky_calculation(a, b):
    file_logger.debug(f"DEBUG: risky_calculation called with a={a}, b={b}")
    if b == 0:
        file_logger.error("ERROR: Division by zero attempted in risky_calculation!")
        raise ValueError("Cannot divide by zero")
    file_logger.info("INFO: Performing calculation...")
    result = a / b
    file_logger.warning("WARNING: Calculation completed, potential for large result.")
    return result

try:
    file_logger.info("Executing risky_calculation(20, 4)")
    risky_calculation(20, 4)
    file_logger.info("Executing risky_calculation(10, 0)")
    risky_calculation(10, 0)
except ValueError as e:
    file_logger.critical(f"CRITICAL: Application fault due to: {e}")

print("\nCheck 'app_errors.log' for file logging output.")

# Part 2: Advanced Exception Handling and Contextual Logging
import logging
import json
import sys

# Configure a logger for contextual and structured logging
contextual_logger = logging.getLogger('contextual_app')
contextual_logger.setLevel(logging.INFO)

# Ensure handlers are not duplicated if run multiple times in same session
if not contextual_logger.handlers:
    # Create a handler for console output
    console_handler = logging.StreamHandler(sys.stdout)
    console_handler.setLevel(logging.INFO)

    # Use a custom JSON formatter for structured logs
    # In a real application, you might use a library like `python-json-logger`
    # For this example, we'll demonstrate a basic structured approach.
    class JsonFormatter(logging.Formatter):
        def format(self, record):
            log_entry = {
                "timestamp": self.formatTime(record, self.datefmt),
                "level": record.levelname,
                "logger": record.name,
                "message": record.getMessage()
            }
            # Add any extra attributes passed
            if hasattr(record, 'extra_data') and record.extra_data:
                log_entry.update(record.extra_data)

            # If an exception is present, add traceback information
            if record.exc_info:
                log_entry["exception_type"] = record.exc_info[0].__name__
                log_entry["exception_message"] = str(record.exc_info[1])
                log_entry["traceback"] = self.formatException(record.exc_info)
            return json.dumps(log_entry)

    json_formatter = JsonFormatter()
    console_handler.setFormatter(json_formatter)
    contextual_logger.addHandler(console_handler)

def process_user_data(user_id, data_payload):
    # Simulate some processing that might fail
    try:
        if not isinstance(user_id, int):
            raise TypeError("User ID must be an integer")
        if not data_payload or not isinstance(data_payload, dict):
            raise ValueError("Data payload must be a non-empty dictionary")
        
        # Simulate a database operation or complex logic
        required_field = data_payload.get('operation')
        if not required_field:
            raise KeyError("'operation' field is missing")

        contextual_logger.info(
            f"Processing initiated for user {user_id}",
            extra={'extra_data': {'user_id': user_id, 'payload_size': len(data_payload)}}
        )

        # Simulate a successful outcome
        return f"Processed {required_field} for user {user_id}"

    except (TypeError, ValueError, KeyError) as e:
        # Using logging.exception() logs the current exception info automatically
        contextual_logger.exception(
            f"Data processing failed for user {user_id} due to {type(e).__name__}",
            extra={'extra_data': {'user_id': user_id, 'error_type': type(e).__name__, 'error_message': str(e)}}
        )
        return None
    except Exception as e:
        contextual_logger.critical(
            f"An unhandled critical error occurred during processing for user {user_id}",
            extra={'extra_data': {'user_id': user_id, 'error_type': type(e).__name__, 'error_message': str(e)}}
        )
        return None

# Test cases
print("\n--- Test Case 1: Successful Processing ---")
process_user_data(101, {'operation': 'update_profile', 'data': 'some_data'})

print("\n--- Test Case 2: TypeError (Invalid User ID) ---")
process_user_data('abc', {'operation': 'read_settings'})

print("\n--- Test Case 3: KeyError (Missing 'operation' field) ---")
process_user_data(102, {'data': 'invalid_payload'})

print("\n--- Test Case 4: ValueError (Empty Payload) ---")
process_user_data(103, {})

# Part 3: Mastering Python Debugger (pdb)
import pdb

def factorial(n):
    if n < 0:
        raise ValueError("Factorial is not defined for negative numbers")
    if n == 0:
        return 1
    else:
        # Intentional bug: Let's say we made a typo and used n*2 instead of n
        # Or, we want to trace the recursion step by step.
        print(f"Calculating factorial for {n}") # Helper print to see progress
        # pdb.set_trace() # Uncomment to start debugger here at each recursion step
        return n * factorial(n - 1) # This is the correct line

def main():
    print("\n--- Demonstrating factorial with a breakpoint ---")
    # Start debugger right before calling factorial
    pdb.set_trace() 
    try:
        res = factorial(3)
        print(f"Factorial of 3 is: {res}") # Expected: 6

        print("\n--- Demonstrating factorial with a different input ---")
        # We can add another breakpoint or restart the debugging session
        pdb.set_trace() # Another breakpoint for tracing
        res_neg = factorial(-1)
        print(f"Factorial of -1 is: {res_neg}")
    except ValueError as e:
        print(f"Caught an expected error: {e}")

# To run this script and activate pdb:
# 1. Save as a .py file (e.g., debug_example.py)
# 2. Run from terminal: python -m pdb debug_example.py
#    (Or just run 'python debug_example.py' and it will hit pdb.set_trace() calls)

# Common pdb commands:
# n (next): Execute current line, stop at next line in current function.
# s (step): Execute current line, step into function call if any.
# c (continue): Continue execution until next breakpoint or program end.
# p <variable>: Print the value of a variable.
# l (list): List source code around the current line.
# b <line_number>: Set a breakpoint at a specific line.
# cl <line_number>: Clear a breakpoint.
# r (return): Continue execution until the current function returns.
# q (quit): Quit the debugger.
# h (help): Show help for commands.

if __name__ == "__main__":
    main()

# Part 4: Conceptual reminder for good log messages and external tools
# This section primarily focuses on architectural and strategic advice,
# rather than executable code snippets.

# Good log messages are:
# 1. Actionable: Indicate what happened and what to do.
# 2. Contextual: Include relevant IDs, states, or parameters.
# 3. Specific: Avoid vague terms. e.g., 'Failed to process' vs. 'Failed to process order 123 due to DB connection timeout'.
# 4. Consistent: Follow a standardized format across the application.

def example_log_message_principles(user_id, order_id, status_code, error_detail=None):
    logger = logging.getLogger('observability_logger')
    # In a real setup, logger would be configured for JSON or similar structured output
    logger.setLevel(logging.INFO)
    if not logger.handlers:
        handler = logging.StreamHandler(sys.stdout)
        formatter = logging.Formatter('%(asctime)s - %(levelname)s - User:%(user_id)s - Order:%(order_id)s - %(message)s')
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    extra_context = {'user_id': user_id, 'order_id': order_id}

    if error_detail:
        logger.error(
            f"Order processing failed with status {status_code}: {error_detail}",
            extra=extra_context
        )
    else:
        logger.info(
            f"Order {order_id} processed successfully with status {status_code}",
            extra=extra_context
        )

# Example usage demonstrating good context
print("\n--- Demonstrating Good Log Message Principles ---")
example_log_message_principles(1, 'ORD001', 200)
example_log_message_principles(2, 'ORD002', 500, 'Database connection error')


# Reminder for external tools and strategies:
# Centralized Logging:
#   - ELK Stack (Elasticsearch, Logstash, Kibana): Collect, parse, store, search, and visualize logs.
#   - Splunk: Enterprise solution for machine data analytics.
#   - Grafana Loki: Log aggregation system for Prometheus.

# Error Tracking Services:
#   - Sentry: Real-time error tracking and performance monitoring.
#   - Rollbar: Error monitoring and incident management.
#   - Bugsnag: Full-stack error monitoring.

# Performance Monitoring / Profiling:
#   - cProfile: Python's built-in profiler.
#   - Py-Spy: Sampling profiler for Python programs.
#   - DataDog, New Relic, Prometheus/Grafana: APM and infrastructure monitoring.

# Key Strategies:
#   - Log Aggregation: Centralize logs from all services.
#   - Alerting: Set up alerts for critical errors or abnormal log patterns.
#   - Dashboards: Visualize log data for trends and anomalies.
#   - Root Cause Analysis: Use logs and traces to methodically identify underlying issues.
#   - Security: Sanitize sensitive data from logs.
#   - Performance: Optimize logging frequency and verbosity in production.