Using Savepoints for Logging in Django Transactions

To ensure your HTTP logs are saved regardless of whether the main transaction rolls back, you can use Django's savepoint functionality. Here's how you can modify your code to achieve this:

Solution: Using a Non-Atomic Context for Logging

You can modify your save_log function to use a separate database connection that isn't part of the current transaction:

PYTHONCopied
from django.db import transaction, connections

def save_log(...):
    # Force the log to be saved in a separate transaction
    with transaction.atomic(using='default'):
        # Set the connection's autocommit mode to True for this operation
        old_autocommit = connections['default'].get_autocommit()
        try:
            connections['default'].set_autocommit(True)
            HttpLog.objects.create(...)
        finally:
            connections['default'].set_autocommit(old_autocommit)

@transaction.atomic
def do_something_that_could_fail():
    # do something
    
    save_log(...)
    # do something else

Alternative Approach: Using transaction.on_commit

Another approach is to use Django's on_commit hook, but this would only work if the transaction successfully commits:

PYTHONCopied
from django.db import transaction

def save_log(...):
    HttpLog.objects.create(...)

@transaction.atomic
def do_something_that_could_fail():
    # do something
    
    # Register the log function to run only if the transaction commits
    transaction.on_commit(lambda: save_log(...))
    
    # do something else

However, this doesn't solve your specific problem since you want logs even when transactions fail.

Best Solution: Using a Separate Database Connection

The most reliable approach is to use a completely separate database connection for logging:

PYTHONCopied
from django.db import transaction

def save_log(...):
    # Use a separate database connection for logging
    with transaction.atomic(using='logging_db'):
        HttpLog.objects.using('logging_db').create(...)

@transaction.atomic
def do_something_that_could_fail():
    # do something
    
    save_log(...)
    # do something else

This requires configuring a separate database connection in your Django settings:

PYTHONCopied
DATABASES = {
    'default': {
        # Your main database configuration
    },
    'logging_db': {
        # This can point to the same physical database
        # but will use a separate connection
        'NAME': 'same_db_name',
        # other connection parameters
    }
}

This approach ensures that your logs are saved in a completely separate transaction, unaffected by the main transaction's rollback.