Inconsistent instrumentation with `TransactionBuilder`

[sgoll]

Setup

Versions

• Rust: 1.86.0
• Diesel: 2.2.9
• Diesel_async: 0.5.2
• Database: PostgreSQL
• Operating System: Linux

Feature Flags

• diesel: postgres, uuid
• diesel_async: async-connection-wrapper, bb8, postgres

Problem Description

Transactions that are started with conn.build_transaction().run() do not emit the BeginTransaction instrumentation event. Transactions that are started with conn.transaction() do, as do synchronous connections with either method.

What are you trying to accomplish?

Get full and consistent instrumentation events for database transactions.

What is the expected output?

Transactions should emit BeginTransaction independently of whether started through TransactionBuilder or directly on the connection and independently of whether running on an asynchronous or a synchronous connection.

What is the actual output?

The instrumentation event BeginTransaction is is not emitted.

Are you seeing any additional errors?

No.

Steps to reproduce

use diesel::{
    connection::{Instrumentation, InstrumentationEvent},
    prelude::*,
    result::Error,
};
use diesel_async::{AsyncConnection as _, AsyncPgConnection};

#[tokio::main]
async fn main() {
    println!("=== PgConnection ===");
    let mut conn = PgConnection::establish("postgres://localhost").unwrap();

    conn.set_instrumentation(CustomInstrumentation);

    println!("--- conn.transaction() ---");
    conn.transaction(|_tx| Ok::<(), Error>(())).unwrap();

    println!("--- conn.build_transaction().run() ---");
    conn.build_transaction()
        .run(|_tx| Ok::<(), Error>(()))
        .unwrap();

    println!("=== AsyncPgConnection ===");
    let mut conn = AsyncPgConnection::establish("postgres://localhost")
        .await
        .unwrap();

    conn.set_instrumentation(CustomInstrumentation);

    println!("--- conn.transaction() ---");
    conn.transaction(|_tx| Box::pin(async { Ok::<(), Error>(()) }))
        .await
        .unwrap();

    println!("--- conn.build_transaction().run() ---");
    conn.build_transaction()
        .run(|_tx| Box::pin(async { Ok::<(), Error>(()) }))
        .await
        .unwrap();
}

struct CustomInstrumentation;

impl Instrumentation for CustomInstrumentation {
    fn on_connection_event(&mut self, event: InstrumentationEvent<'_>) {
        println!("{event:?}");
    }
}

This results in the following output (blank lines introduced for clarity):

=== PgConnection ===

--- conn.transaction() ---
BeginTransaction { depth: 1 }
StartQuery { query: "BEGIN" }
FinishQuery { query: "BEGIN", error: None }
CommitTransaction { depth: 1 }
StartQuery { query: "COMMIT" }
FinishQuery { query: "COMMIT", error: None }

--- conn.build_transaction().run() ---
BeginTransaction { depth: 1 }
StartQuery { query: "BEGIN TRANSACTION" }
FinishQuery { query: "BEGIN TRANSACTION", error: None }
CommitTransaction { depth: 1 }
StartQuery { query: "COMMIT" }
FinishQuery { query: "COMMIT", error: None }


=== AsyncPgConnection ===

--- conn.transaction() ---
BeginTransaction { depth: 1 }
StartQuery { query: "BEGIN" }
FinishQuery { query: "BEGIN", error: None }
CommitTransaction { depth: 1 }
StartQuery { query: "COMMIT" }
FinishQuery { query: "COMMIT", error: None }

--- conn.build_transaction().run() ---
StartQuery { query: "BEGIN TRANSACTION" }
FinishQuery { query: "BEGIN TRANSACTION", error: None }
CommitTransaction { depth: 1 }
StartQuery { query: "COMMIT" }
FinishQuery { query: "COMMIT", error: None }

The last section is missing the line BeginTransaction { depth: 1 } that should be there for consistent instrumentation.

Checklist

• I have already looked over the issue tracker for similar possible closed issues.
• This issue can be reproduced on Rust's stable channel. (Your issue will be
  closed if this is not the case)
• This issue can be reproduced without requiring a third party crate