Enhancement: Add success message and callback capability to `logger.catch()`

[HomerusJa]

Description:

When working with logger.catch(), users often want to log a success message and perform additional actions when operations complete without exceptions. This enhancement would streamline error handling and success reporting.

Updated Proposed Signature:

def catch(
    self,
    exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]] = Exception,
    *,
    level: Union[str, int] = "ERROR",
    reraise: bool = False,
    onerror: Optional[Callable[[BaseException], None]] = None,
    exclude: Optional[Union[Type[BaseException], Tuple[Type[BaseException], ...]]] = None,
    default: Any = None,
    message: str = "An error has been caught in function '{record[function]}', "
    "process '{record[process].name}' ({record[process].id}), "
    "thread '{record[thread].name}' ({record[thread].id}):",
    # New parameters:
    success_message: Optional[str] = None,
    success_level: Union[str, int] = "SUCCESS",
    on_success: Optional[Callable[[], None]] = None
) -> "Catcher":

Implementation Notes:

1. Added success_message parameter - when None (default), no success message is logged
2. Added success_level parameter with "SUCCESS" as the default level
3. Added on_success callback parameter for more complex success handling
4. Maintained all existing parameters with their original defaults

Note: I've included type hints to clarify, make the proposal more complete, and avoid repeating myself.

Example Usage:

# With success message only
@logger.catch(success_message="Database connection established successfully")
def connect_to_database():
    # risky connection code here
    return connection

# With both success message and callback
@logger.catch(
    success_message="Operation '{record[function]}' completed",
    on_success=lambda: notify_admin("Operation completed")
)
def some_operation():
    ...

# As a context manager
with logger.catch(
    success_message="File processed successfully", 
    on_success=lambda: update_status_dashboard()
):
    process_file(filename)

Implementation Considerations:

• For context managers, the success message and callback would be triggered when exiting the context without an exception
• For decorators, they would be triggered before returning the result
• The success message would support the same formatting capabilities as other logger messages
• The callback function could potentially receive the function's return value as a parameter

I'm ready to contribute to implementing this feature if the maintainers are interested in the enhancement.

[Delgan]

Hi @HomerusJa.

I can see how it could be useful to extend the behavior of logger.catch() with such "on success" parameters. However, the logger.catch() has evolved over the years into a decorator that is far more extensive and complex than its original intention. Initially, it was only intended to log unexpected exceptions coming from threads or the from main() function.

I'm less and less convinced that the additions that have been made (the onerror, the default, etc.) are relevant. They turn the logger into a control flow operator, which I don't believe the logger should be used for. I don't think we should pursue this path and add new onsuccess related arguments.

Actually, I've discussed here how we could and should reduce the logger.catch() API: #1016 (comment)

[HomerusJa]

Thank you for considering my proposal and for your detailed response.

I understand your perspective about keeping the logger focused on its primary purpose rather than extending it into control flow territory. Your comment on issue #1016 provides helpful context on the direction you're considering for logger.catch().

Given your feedback, perhaps an alternative approach would be more appropriate. Would you be open to documentation examples showing how users could implement similar functionality through composition? For example:

def with_logging(func):
    @functools.wraps(func)
    @logger.catch(message="Error in {record[function]}")
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        logger.success("Successfully completed {func.__name__}")
        return result
    return wrapper

This would maintain the separation of concerns while still providing users with patterns to achieve similar functionality.

Thanks again for maintaining this excellent library!

[Delgan]

Hey @HomerusJa. Thanks for understanding. Yes, we definitely could consider extending the documentation with new snippets. This would be a welcome addition that would surely prove useful to developers.

[HomerusJa]

Could you assign this issue to me? I will create and test a solution when I have time (currently, I am pretty busy because of a deadline right now)