Flask-SQLAlchemy event listeners, unable to get old DB data before update

I'm trying to build an audit log mechanism in Flask-SQLAlchemy using the event.listens_for function.
I need to capture old DB row data before the new transaction is committed so I keep a log of the changes. I have tried all kind of ways, session events, mapper events.. I can't get the old row data from any of the objects in the event listener decorator.

Here's a quick example

from flask_sqlalchemy import SQLAlchemy
from sqlalchemy import event
from flask import Flask

app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///db"

db = SQLAlchemy(app)


class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100))
    email = db.Column(db.String(100))


with app.app_context():
    db.drop_all()
    db.create_all()


@event.listens_for(User, 'before_update')
def receive_before_update(mapper, connection, target):
    # Get the original state of the user from the database
    original_user = User.query.get(target.id)

    # Record the original values
    original_name = original_user.name
    original_email = original_user.email

    # Log the changes
    print(f"Updating user: {original_name} ({original_email}) to {target.name} ({target.email})")


# Add new user
new_user = User(name="First_User", email="s@s.com")

with app.app_context():
    db.session.add(new_user)
    db.session.commit()

# Update name on the existing user
with app.app_context():
    update_record = User.query.filter_by(name="First_User").first()
    update_record.name = "new_name"
    db.session.merge(update_record)
    db.session.commit()

Calling the existing DB entry by using the target.id inside of the decorator brings up a record that already has the new data.

Here is the output if you run the above code:
Updating user: new_name (s@s.com) to new_name (s@s.com)

I'm expecting:
Updating user: "First_User" (s@s.com) to new_name (s@s.com)

You can access the original values through the history interface. The ORM tracks the state of each instrumented attribute between flushes, updating the history's added attribute with new values and storing the old values in its deleted attribute. This version of your listener:

@event.listens_for(User, 'before_update')
def receive_before_update(mapper, connection, target):
    # Attributes to track.
    tracked = dict.fromkeys(['name', 'email'])

    insp = db.inspect(target)
    for k in tracked:
        attr = getattr(insp.attrs, k)
        history = attr.history
        # If a scalar attribute has been changed, the old value will be in
        # deleted.
        if history.added:
            tracked[k] = history.deleted[-1]
        else:
            tracked[k] = attr.loaded_value
    # Log the changes
    print(
        f"Updating user: {tracked['name']} ({tracked['email']}) to {target.name} ({target.email})"
    )

outputs

Updating user: First_User (s@s.com) to new_name (s@s.com)