From df18ac72c5224fb349de35c431dccf8c24b48dc6 Mon Sep 17 00:00:00 2001
From: Jane Lusby <jane@zfnd.org>
Date: Wed, 17 Jun 2020 13:08:11 -0700
Subject: [PATCH] fix sharedpeererror to propagate tracing context

---
 Cargo.lock                      |  1 +
 zebra-network/Cargo.toml        |  1 +
 zebra-network/src/peer/error.rs |  7 ++++---
 zebrad/src/commands/start.rs    | 19 +++++++++++--------
 4 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 660febcc..09a25d52 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2344,6 +2344,7 @@ dependencies = [
  "tower",
  "tower-load",
  "tracing",
+ "tracing-error",
  "tracing-futures",
  "zebra-chain",
 ]
diff --git a/zebra-network/Cargo.toml b/zebra-network/Cargo.toml
index 06076a26..4393997a 100644
--- a/zebra-network/Cargo.toml
+++ b/zebra-network/Cargo.toml
@@ -36,3 +36,4 @@ tower-load = "0.3"
 metrics = "0.12"
 
 zebra-chain = { path = "../zebra-chain" }
+tracing-error = { version = "0.1.2", features = ["traced-error"] }
diff --git a/zebra-network/src/peer/error.rs b/zebra-network/src/peer/error.rs
index 53dca602..82b2a3ea 100644
--- a/zebra-network/src/peer/error.rs
+++ b/zebra-network/src/peer/error.rs
@@ -2,19 +2,20 @@ use std::sync::{Arc, Mutex};
 
 use thiserror::Error;
 
+use tracing_error::TracedError;
 use zebra_chain::serialization::SerializationError;
 
 /// A wrapper around `Arc<PeerError>` that implements `Error`.
 #[derive(Error, Debug, Clone)]
-#[error("{0}")]
-pub struct SharedPeerError(Arc<PeerError>);
+#[error(transparent)]
+pub struct SharedPeerError(Arc<TracedError<PeerError>>);
 
 impl<E> From<E> for SharedPeerError
 where
     PeerError: From<E>,
 {
     fn from(source: E) -> Self {
-        Self(Arc::new(PeerError::from(source)))
+        Self(Arc::new(TracedError::from(PeerError::from(source))))
     }
 }
 
diff --git a/zebrad/src/commands/start.rs b/zebrad/src/commands/start.rs
index b85134e7..263697a8 100644
--- a/zebrad/src/commands/start.rs
+++ b/zebrad/src/commands/start.rs
@@ -211,8 +211,14 @@ where
 
     async fn drain_requests(&mut self, request_goal: usize) -> Result<(), Report> {
         while self.block_requests.len() > request_goal {
-            match self.block_requests.next().await {
-                Some(Ok(zebra_network::Response::Blocks(blocks))) => {
+            match self
+                .block_requests
+                .next()
+                .await
+                .expect("expected: block_requests is never empty")
+                .map_err::<Report, _>(|e| eyre!(e))
+            {
+                Ok(zebra_network::Response::Blocks(blocks)) => {
                     for block in blocks {
                         self.downloaded_block_heights
                             .insert(block.coinbase_height().unwrap());
@@ -225,12 +231,9 @@ where
                             .map_err(|e| eyre!(e))?;
                     }
                 }
-                Some(Ok(_)) => continue,
-                Some(Err(e)) => {
-                    error!(%e);
-                }
-                None => {
-                    unreachable!("None is never encountered due to the condition on the while loop")
+                Ok(_) => continue,
+                Err(e) => {
+                    error!("{:?}", e);
                 }
             }
         }