37. Decorators for Method Logging

Using decorators to log method calls is a powerful way to dynamically add logging functionality to methods without modifying their core logic. Below are several Python snippets demonstrating how to use decorators for method logging in a reusable and flexible way.

---

1. Basic Logging Decorator

This decorator logs the function name and arguments whenever the decorated method is called.

import functools

def log_method_call(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with arguments {args} and keyword arguments {kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper

class MyClass:
    @log_method_call
    def greet(self, name):
        return f"Hello, {name}"

obj = MyClass()
obj.greet("Alice")

---

2. Logging Method Call with Timestamp

This version of the decorator includes the timestamp of when the method is called.

import functools
import time

def log_method_call_with_timestamp(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
        print(f"[{timestamp}] Calling {func.__name__} with arguments {args} and keyword arguments {kwargs}")
        result = func(*args, **kwargs)
        print(f"[{timestamp}] {func.__name__} returned {result}")
        return result
    return wrapper

class MyClass:
    @log_method_call_with_timestamp
    def greet(self, name):
        return f"Hello, {name}"

obj = MyClass()
obj.greet("Bob")

---

3. Logging Method Call with Exception Handling

In case of an exception, the decorator logs the error message.

import functools

def log_method_call_with_error_handling(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        try:
            print(f"Calling {func.__name__} with arguments {args} and keyword arguments {kwargs}")
            result = func(*args, **kwargs)
            print(f"{func.__name__} returned {result}")
            return result
        except Exception as e:
            print(f"Error occurred in {func.__name__}: {e}")
            raise
    return wrapper

class MyClass:
    @log_method_call_with_error_handling
    def divide(self, a, b):
        return a / b

obj = MyClass()
try:
    obj.divide(4, 0)
except ZeroDivisionError:
    pass

---

4. Logging Method Call with Return Value Modification

This decorator allows modifying the return value before it is returned.

import functools

def log_method_call_with_return_modification(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with arguments {args} and keyword arguments {kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}")
        return f"Modified result: {result}"
    return wrapper

class MyClass:
    @log_method_call_with_return_modification
    def greet(self, name):
        return f"Hello, {name}"

obj = MyClass()
print(obj.greet("Charlie"))

---

5. Logging Method Call with Function Arguments and Method Name

This decorator logs method calls along with the method name and argument values, showing both positional and keyword arguments.

import functools

def log_method_call(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Method: {func.__name__} | Positional arguments: {args} | Keyword arguments: {kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned: {result}")
        return result
    return wrapper

class MyClass:
    @log_method_call
    def add(self, x, y):
        return x + y

    @log_method_call
    def greet(self, name, message="Hello"):
        return f"{message}, {name}"

obj = MyClass()
obj.add(3, 4)
obj.greet("David", message="Hi")

---

6. Logging Method Call with Performance Measurement

This decorator logs the execution time of the method.

import functools
import time

def log_method_call_with_performance(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        execution_time = end_time - start_time
        print(f"{func.__name__} executed in {execution_time:.4f} seconds")
        return result
    return wrapper

class MyClass:
    @log_method_call_with_performance
    def slow_method(self):
        time.sleep(2)
        return "Completed"

obj = MyClass()
obj.slow_method()

---

7. Logging Method Call with Caller Information

This decorator logs the name of the caller method as well.

import functools
import inspect

def log_method_call_with_caller(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        caller = inspect.stack()[1]
        caller_name = caller.function
        print(f"Called from {caller_name}, method {func.__name__} with arguments {args} and keyword arguments {kwargs}")
        result = func(*args, **kwargs)
        return result
    return wrapper

class MyClass:
    @log_method_call_with_caller
    def method_one(self):
        return "Method One"
    
    def method_two(self):
        return self.method_one()

obj = MyClass()
obj.method_two()

---

8. Logging Method Call with Indentation for Nested Calls

This decorator allows you to add indentation for nested method calls to make logs easier to follow.

import functools

def log_method_call_with_indentation(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        indent_level = wrapper.indent_level
        wrapper.indent_level += 1
        print("  " * indent_level + f"Calling {func.__name__} with arguments {args} and keyword arguments {kwargs}")
        result = func(*args, **kwargs)
        print("  " * indent_level + f"{func.__name__} returned {result}")
        wrapper.indent_level -= 1
        return result

    wrapper.indent_level = 0
    return wrapper

class MyClass:
    @log_method_call_with_indentation
    def level_one(self):
        self.level_two()

    @log_method_call_with_indentation
    def level_two(self):
        self.level_three()

    @log_method_call_with_indentation
    def level_three(self):
        return "Final level"

obj = MyClass()
obj.level_one()

---

9. Logging Method Call for Class Methods

This decorator works for both instance methods and class methods.

import functools

def log_method_call(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with arguments {args} and keyword arguments {kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper

class MyClass:
    @classmethod
    @log_method_call
    def class_method(cls, value):
        return f"Class method with value {value}"

    @log_method_call
    def instance_method(self, value):
        return f"Instance method with value {value}"

obj = MyClass()
obj.class_method(10)
obj.instance_method(20)

---

10. Logging Method Call with Custom Logging Function

This version allows the user to define a custom logging function.

import functools

def custom_logger(message):
    print(f"Custom log: {message}")

def log_method_call(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        custom_logger(f"Calling {func.__name__} with arguments {args} and keyword arguments {kwargs}")
        result = func(*args, **kwargs)
        custom_logger(f"{func.__name__} returned {result}")
        return result
    return wrapper

class MyClass:
    @log_method_call
    def greet(self, name):
        return f"Hello, {name}"

obj = MyClass()
obj.greet("Eve")

---

These snippets demonstrate different ways to log method calls, with various customizations such as timestamp logging, performance measurement, exception handling, return value modification, and support for both class methods and instance methods. You can choose the one that fits your needs or further enhance them to suit your specific use case.