Trying to update diesel_logger to work with diesel_async, trouble with lifetime issue

[JonRCahill]

I am attempting to update diesel_logger (https://github.com/shssoichiro/diesel-logger) to work with diesel_ayncand have hit a final roadblock I can't solve with a lifetime issue around an AsyncConnection implementation of execute_returning_count the specific code with the lifetime issue is:

fn execute_returning_count<'conn, 'query, T>(
    &'conn mut self,
    source: T,
) -> Self::ExecuteFuture<'conn, 'query>
where
    T: QueryFragment<Self::Backend> + QueryId + Send + 'query,
{
    let debug_query = debug_query::<Self::Backend, _>(&source);
    let query_sql = format!("{}", debug_query);

    async move {
        let start_time = Instant::now();
        let result = self.connection.execute_returning_count(source).await;
        let duration = start_time.elapsed();
        log_query(&query_sql, duration);
        result
    }.boxed()
}

With the error being:

error: lifetime may not live long enough
  --> src/lib.rs:88:9
   |
78 |       fn execute_returning_count<'conn, 'query, T>(
   |                                  -----  ------ lifetime `'query` defined here
   |                                  |
   |                                  lifetime `'conn` defined here
...
88 | /         async move {
89 | |             let start_time = Instant::now();
90 | |             let result = self.connection.execute_returning_count(source).await;
91 | |             let duration = start_time.elapsed();
92 | |             log_query(&query_sql, duration);
93 | |             result
94 | |         }.boxed()
   | |_________________^ method was supposed to return data with lifetime `'query` but it is returning data with lifetime `'conn`
   |
   = help: consider adding the following bound: `'conn: 'query`

Any help/advice with resolving this lifetime would be great!

I have got it working using a concret implementatation with AsyncPgConnection rather than generic but was hoping to make it generic if possible. If it is not possible to resolve this lifetime I guess I could just provide conrete implementations for PostgreSQL and MySQL.

The whole implementation is:

#[async_trait::async_trait]
impl<C> AsyncConnection for LoggingConnection<C>
where
    C: AsyncConnection + 'static,
    <C as AsyncConnection>::Backend: std::default::Default,
    <C::Backend as Backend>::QueryBuilder: Default,
{
    type LoadFuture<'conn, 'query> = <C as AsyncConnection>::LoadFuture<'conn, 'query>;
    type ExecuteFuture<'conn, 'query> = BoxFuture<'query, QueryResult<usize>>;
    type Stream<'conn, 'query> = <C as AsyncConnection>::Stream<'conn, 'query>;
    type Row<'conn, 'query> = <C as AsyncConnection>::Row<'conn, 'query>;
    type Backend = <C as AsyncConnection>::Backend;
    type TransactionManager = LoggingTransactionManager<C>;

    async fn establish(database_url: &str) -> ConnectionResult<Self> {
        Ok(LoggingConnection::new(C::establish(database_url).await?))
    }

    fn load<'conn, 'query, T>(&'conn mut self, source: T) -> Self::LoadFuture<'conn, 'query>
    where
        T: AsQuery + Send + 'query,
        T::Query: QueryFragment<Self::Backend> + QueryId + Send + 'query,
    {
        let query = source.as_query();
        let debug_query = debug_query::<Self::Backend, _>(&query);
        let debug_string = format!("{}", debug_query);

        let begin = Self::bench_query_begin();
        let res = self.connection.load(query);
        Self::bench_query_end(begin, &debug_string);
        res
    }

    fn execute_returning_count<'conn, 'query, T>(
        &'conn mut self,
        source: T,
    ) -> Self::ExecuteFuture<'conn, 'query>
    where
        T: QueryFragment<Self::Backend> + QueryId + Send + 'query,
    {
        let debug_query = debug_query::<Self::Backend, _>(&source);
        let query_sql = format!("{}", debug_query);

        async move {
            let start_time = Instant::now();
            let result = self.connection.execute_returning_count(source).await;
            let duration = start_time.elapsed();
            log_query(&query_sql, duration);
            result
        }.boxed()
    }

    fn transaction_state(&mut self) -> &mut LoggingTransactionManager<C> {
        &mut self.transaction_manager
    }
}

Full code can be accessed from: https://github.com/Zero41/diesel-logger/tree/add-support-for-diesel-async

[weiznich]

The error message is not that surprising. In this code block:

        async move {
            let start_time = Instant::now();
            let result = self.connection.execute_returning_count(source).await;
            let duration = start_time.elapsed();
            log_query(&query_sql, duration);
            result
        }.boxed()

you move &self into the async block, and therefore into the returned future. That means the returned future needs to live at least for 'conn (== the lifetime of &self).

Now the question is how to fix that. Due to time constraints I cannot do experimentation there myself but the first thing I would try is to change the ExecuteFuture to be BoxFuture<'conn, QueryResult<usize>> instead. If that does not work you likely need to go with a manually constructed future type there as rustc does then the lifetime inference for you.

As semi releated side note:

  fn load<'conn, 'query, T>(&'conn mut self, source: T) -> Self::LoadFuture<'conn, 'query>
    where
        T: AsQuery + Send + 'query,
        T::Query: QueryFragment<Self::Backend> + QueryId + Send + 'query,
    {
        let query = source.as_query();
        let debug_query = debug_query::<Self::Backend, _>(&query);
        let debug_string = format!("{}", debug_query);

        let begin = Self::bench_query_begin();
        let res = self.connection.load(query);
        Self::bench_query_end(begin, &debug_string);
        res
    }

That code will not do what you expect it to do. It will only measure the time that's required to construct the corresponding future, not the execution time of the query.