Sprinle more logs

crates/proto/src/xfer/dns_handle.rs

@@ -65,7 +65,9 @@ pub trait DnsHandle: 'static + Clone + Send + Sync + Unpin {
     /// * `options` - options to use when constructing the message
     fn lookup(&self, query: Query, options: DnsRequestOptions) -> Self::Response {
         debug!("querying: {} {:?}", query.name(), query.query_type());
-        self.send(DnsRequest::new(build_message(query, options), options))
+        let r = self.send(DnsRequest::new(build_message(query, options), options));
+        tracing::debug!("lookup");
+        r
     }
 }
 

crates/proto/src/xfer/retry_dns_handle.rs

@@ -100,23 +100,30 @@ where
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         // loop over the stream, on errors, spawn a new stream
         //  on ready and not ready return.
+        tracing::debug!("poll_next");
         loop {
             match self.stream.poll_next_unpin(cx) {
                 Poll::Ready(Some(Err(e))) => {
+                    tracing::debug!("poll ready");
                     if self.remaining_attempts == 0 || !e.should_retry() {
                         return Poll::Ready(Some(Err(e)));
                     }
 
                     if e.attempted() {
+                        tracing::debug!("poll attempted");
                         self.remaining_attempts -= 1;
                     }
 
                     // TODO: if the "sent" Message is part of the error result,
                     //  then we can just reuse it... and no clone necessary
                     let request = self.request.clone();
+                    tracing::debug!("sending ready");
                     self.stream = self.handle.send(request);
                 }
-                poll => return poll,
+                poll => {
+                    tracing::debug!("poll return {:?}", poll);
+                    return poll;
+                }
             }
         }
     }

crates/resolver/src/lookup.rs

@@ -206,11 +206,13 @@ impl<P: ConnectionProvider> DnsHandle for LookupEither<P> {
 
     fn send<R: Into<DnsRequest> + Unpin + Send + 'static>(&self, request: R) -> Self::Response {
         tracing::debug!("Sending request");
-        match *self {
+        let r = match *self {
             Self::Retry(ref c) => c.send(request),
             #[cfg(feature = "dnssec")]
             Self::Secure(ref c) => c.send(request),
-        }
+        };
+        tracing::debug!("reply");
+        r
     }
 }