Add remaining log statements

tokio-postgres/src/copy_in.rs

@@ -7,6 +7,7 @@ use bytes::{Buf, BufMut, BytesMut};
 use futures::channel::mpsc;
 use futures::future;
 use futures::{ready, Sink, SinkExt, Stream, StreamExt};
+use log::debug;
 use pin_project_lite::pin_project;
 use postgres_protocol::message::backend::Message;
 use postgres_protocol::message::frontend;
@@ -199,6 +200,8 @@ pub async fn copy_in<T>(client: &InnerClient, statement: Statement) -> Result<Co
 where
     T: Buf + 'static + Send,
 {
+    debug!("executing copy in statement {}", statement.name());
+
     let buf = query::encode(client, &statement, slice_iter(&[]))?;
 
     let (mut sender, receiver) = mpsc::channel(1);

tokio-postgres/src/copy_out.rs

@@ -4,6 +4,7 @@ use crate::connection::RequestMessages;
 use crate::{query, slice_iter, Error, Statement};
 use bytes::Bytes;
 use futures::{ready, Stream};
+use log::debug;
 use pin_project_lite::pin_project;
 use postgres_protocol::message::backend::Message;
 use std::marker::PhantomPinned;
@@ -11,6 +12,8 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 
 pub async fn copy_out(client: &InnerClient, statement: Statement) -> Result<CopyOutStream, Error> {
+    debug!("executing copy out statement {}", statement.name());
+
     let buf = query::encode(client, &statement, slice_iter(&[]))?;
     let responses = start(client, buf).await?;
     Ok(CopyOutStream {

tokio-postgres/src/prepare.rs

@@ -8,6 +8,7 @@ use crate::{Column, Error, Statement};
 use bytes::Bytes;
 use fallible_iterator::FallibleIterator;
 use futures::{pin_mut, TryStreamExt};
+use log::debug;
 use postgres_protocol::message::backend::Message;
 use postgres_protocol::message::frontend;
 use std::future::Future;
@@ -111,6 +112,12 @@ fn prepare_rec<'a>(
 }
 
 fn encode(client: &InnerClient, name: &str, query: &str, types: &[Type]) -> Result<Bytes, Error> {
+    if types.is_empty() {
+        debug!("preparing query {}: {}", name, query);
+    } else {
+        debug!("preparing query {} with types {:?}: {}", name, types, query);
+    }
+
     client.with_buf(|buf| {
         frontend::parse(name, query, types.iter().map(Type::oid), buf).map_err(Error::encode)?;
         frontend::describe(b'S', &name, buf).map_err(Error::encode)?;

tokio-postgres/src/query.rs

@@ -5,6 +5,7 @@ use crate::types::{IsNull, ToSql};
 use crate::{Error, Portal, Row, Statement};
 use bytes::{Bytes, BytesMut};
 use futures::{ready, Stream};
+use log::{debug, log_enabled, Level};
 use pin_project_lite::pin_project;
 use postgres_protocol::message::backend::Message;
 use postgres_protocol::message::frontend;
@@ -21,9 +22,9 @@ where
     I: IntoIterator<Item = &'a dyn ToSql>,
     I::IntoIter: ExactSizeIterator,
 {
-    let buf = if log::log_enabled!(log::Level::Debug) {
+    let buf = if log_enabled!(Level::Debug) {
         let params = params.into_iter().collect::<Vec<_>>();
-        log::debug!(
+        debug!(
             "executing statement {} with parameters: {:?}",
             statement.name(),
             params,
@@ -69,9 +70,9 @@ where
     I: IntoIterator<Item = &'a dyn ToSql>,
     I::IntoIter: ExactSizeIterator,
 {
-    let buf = if log::log_enabled!(log::Level::Debug) {
+    let buf = if log_enabled!(Level::Debug) {
         let params = params.into_iter().collect::<Vec<_>>();
-        log::debug!(
+        debug!(
             "executing statement {} with parameters: {:?}",
             statement.name(),
             params,

tokio-postgres/src/simple_query.rs

@@ -5,6 +5,7 @@ use crate::{Error, SimpleQueryMessage, SimpleQueryRow};
 use bytes::Bytes;
 use fallible_iterator::FallibleIterator;
 use futures::{ready, Stream};
+use log::debug;
 use pin_project_lite::pin_project;
 use postgres_protocol::message::backend::Message;
 use postgres_protocol::message::frontend;
@@ -14,6 +15,8 @@ use std::sync::Arc;
 use std::task::{Context, Poll};
 
 pub async fn simple_query(client: &InnerClient, query: &str) -> Result<SimpleQueryStream, Error> {
+    debug!("executing simple query: {}", query);
+
     let buf = encode(client, query)?;
     let responses = client.send(RequestMessages::Single(FrontendMessage::Raw(buf)))?;
 
@@ -25,6 +28,8 @@ pub async fn simple_query(client: &InnerClient, query: &str) -> Result<SimpleQue
 }
 
 pub async fn batch_execute(client: &InnerClient, query: &str) -> Result<(), Error> {
+    debug!("executing statement batch: {}", query);
+
     let buf = encode(client, query)?;
     let mut responses = client.send(RequestMessages::Single(FrontendMessage::Raw(buf)))?;