From 207fca63ce1073a832b5a6b08ef811d09ff4b080 Mon Sep 17 00:00:00 2001 From: Sean McArthur Date: Tue, 15 Aug 2017 16:04:56 -0700 Subject: [PATCH] fix(lib): remove logs that contain request and response data Closes #1281 --- src/header/common/authorization.rs | 8 ++++---- src/header/mod.rs | 16 ---------------- src/http/conn.rs | 13 ++++++------- src/http/h1/encode.rs | 5 ++--- src/http/h1/parse.rs | 15 ++++----------- src/http/io.rs | 7 ++++--- src/http/mod.rs | 17 ----------------- src/http/request.rs | 15 --------------- src/http/response.rs | 4 ---- 9 files changed, 20 insertions(+), 80 deletions(-) diff --git a/src/header/common/authorization.rs b/src/header/common/authorization.rs index 68c24c0264..09a34c5cf3 100644 --- a/src/header/common/authorization.rs +++ b/src/header/common/authorization.rs @@ -184,13 +184,13 @@ impl FromStr for Basic { password: password }) }, - Err(e) => { - debug!("Basic::from_utf8 error={:?}", e); + Err(_) => { + debug!("Basic::from_str utf8 error"); Err(::Error::Header) } }, - Err(e) => { - debug!("Basic::from_base64 error={:?}", e); + Err(_) => { + debug!("Basic::from_str base64 error"); Err(::Error::Header) } } diff --git a/src/header/mod.rs b/src/header/mod.rs index bee26f22c6..883568980b 100644 --- a/src/header/mod.rs +++ b/src/header/mod.rs @@ -240,17 +240,6 @@ impl<'a> fmt::Display for ValueString<'a> { } } -struct HeaderValueString<'a, H: Header + 'a>(&'a H); - -impl<'a, H: Header> fmt::Debug for HeaderValueString<'a, H> { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - try!(f.write_str("\"")); - try!(self.0.fmt_header(&mut Formatter(Multi::Join(true, f)))); - f.write_str("\"") - } -} - struct NewlineReplacer<'a, F: fmt::Write + 'a>(&'a mut F); impl<'a, F: fmt::Write + 'a> fmt::Write for NewlineReplacer<'a, F> { @@ -394,7 +383,6 @@ impl Headers { /// /// The field is determined by the type of the value being set. pub fn set(&mut self, value: H) { - trace!("Headers.set( {:?}, {:?} )", header_name::(), HeaderValueString(&value)); self.data.insert(HeaderName(Ascii::new(Cow::Borrowed(header_name::()))), Item::new_typed(value)); } @@ -432,7 +420,6 @@ impl Headers { /// Note that this function may return `None` even though a header was removed. If you want to /// know whether a header exists, rather rely on `has`. pub fn remove(&mut self) -> Option { - trace!("Headers.remove( {:?} )", header_name::()); self.data.remove(&HeaderName(Ascii::new(Cow::Borrowed(header_name::())))) .and_then(Item::into_typed::) } @@ -488,7 +475,6 @@ impl Headers { pub fn set_raw>, V: Into>(&mut self, name: K, value: V) { let name = name.into(); let value = value.into(); - trace!("Headers.set_raw( {:?}, {:?} )", name, value); self.data.insert(HeaderName(Ascii::new(name)), Item::new_raw(value)); } @@ -510,7 +496,6 @@ impl Headers { pub fn append_raw>, V: Into>(&mut self, name: K, value: V) { let name = name.into(); let value = value.into(); - trace!("Headers.append_raw( {:?}, {:?} )", name, value); let name = HeaderName(Ascii::new(name)); if let Some(item) = self.data.get_mut(&name) { item.raw_mut().push(value); @@ -521,7 +506,6 @@ impl Headers { /// Remove a header by name. pub fn remove_raw(&mut self, name: &str) { - trace!("Headers.remove_raw( {:?} )", name); self.data.remove(name); } diff --git a/src/http/conn.rs b/src/http/conn.rs index 608f72118e..261b133ba8 100644 --- a/src/http/conn.rs +++ b/src/http/conn.rs @@ -7,7 +7,7 @@ use futures::task::Task; use tokio_io::{AsyncRead, AsyncWrite}; use tokio_proto::streaming::pipeline::{Frame, Transport}; -use http::{self, Http1Transaction, DebugTruncate}; +use http::{self, Http1Transaction}; use http::io::{Cursor, Buffered}; use http::h1::{Encoder, Decoder}; use method::Method; @@ -90,13 +90,13 @@ where I: AsyncRead + AsyncWrite, self.io.consume_leading_lines(); let was_mid_parse = !self.io.read_buf().is_empty(); return if was_mid_parse { - debug!("parse error ({}) with bytes: {:?}", e, self.io.read_buf()); + debug!("parse error ({}) with {} bytes", e, self.io.read_buf().len()); Ok(Async::Ready(Some(Frame::Error { error: e }))) } else if must_respond_with_error { trace!("parse error with 0 input, err = {:?}", e); Ok(Async::Ready(Some(Frame::Error { error: e }))) } else { - debug!("socket complete"); + debug!("read eof"); Ok(Async::Ready(None)) }; } @@ -669,20 +669,19 @@ struct DebugFrame<'a, T: fmt::Debug + 'a, B: AsRef<[u8]> + 'a>(&'a Frame + 'a> fmt::Debug for DebugFrame<'a, T, B> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self.0 { - Frame::Message { ref message, ref body } => { + Frame::Message { ref body, .. } => { f.debug_struct("Message") - .field("message", message) .field("body", body) .finish() }, Frame::Body { chunk: Some(ref chunk) } => { f.debug_struct("Body") - .field("chunk", &DebugTruncate(chunk.as_ref())) + .field("bytes", &chunk.as_ref().len()) .finish() }, Frame::Body { chunk: None } => { f.debug_struct("Body") - .field("chunk", &None::<()>) + .field("bytes", &None::<()>) .finish() }, Frame::Error { ref error } => { diff --git a/src/http/h1/encode.rs b/src/http/h1/encode.rs index 3f374ddf8c..6068b7a7f3 100644 --- a/src/http/h1/encode.rs +++ b/src/http/h1/encode.rs @@ -59,7 +59,7 @@ impl Encoder { } let n = { let max = cmp::min(*remaining as usize, msg.len()); - trace!("sized write, len = {}, remaining = {}", max, remaining); + trace!("sized write = {}", max); let slice = &msg[..max]; try!(w.write_atomic(&[slice])) @@ -70,8 +70,7 @@ impl Encoder { } *remaining -= n as u64; - debug!("encoded {} bytes", n); - trace!("encode sized complete, remaining = {}", remaining); + trace!("encoded {} bytes, remaining = {}", n, remaining); Ok(n) }, } diff --git a/src/http/h1/parse.rs b/src/http/h1/parse.rs index 71bcb77c73..6d7b2f0398 100644 --- a/src/http/h1/parse.rs +++ b/src/http/h1/parse.rs @@ -23,7 +23,6 @@ impl Http1Transaction for ServerTransaction { if buf.len() == 0 { return Ok(None); } - trace!("parse({:?})", buf); let mut headers_indices = [HeaderIndices { name: (0, 0), value: (0, 0) @@ -34,7 +33,7 @@ impl Http1Transaction for ServerTransaction { let mut req = httparse::Request::new(&mut headers); match try!(req.parse(&buf)) { httparse::Status::Complete(len) => { - trace!("httparse Complete({})", len); + trace!("Request.parse Complete({})", len); let method = try!(req.method.unwrap().parse()); let path = req.path.unwrap(); let bytes_ptr = buf.as_ref().as_ptr() as usize; @@ -110,11 +109,9 @@ impl Http1Transaction for ServerTransaction { fn encode(mut head: MessageHead, has_body: bool, method: &mut Option, dst: &mut Vec) -> Encoder { - trace!("ServerTransaction::encode head={:?}, has_body={}, method={:?}", - head, has_body, method); + trace!("ServerTransaction::encode has_body={}, method={:?}", has_body, method); let body = ServerTransaction::set_length(&mut head, has_body, method.as_ref()); - debug!("encode headers = {:?}", head.headers); let init_cap = 30 + head.headers.len() * AVERAGE_HEADER_SIZE; dst.reserve(init_cap); @@ -180,7 +177,6 @@ impl Http1Transaction for ClientTransaction { if buf.len() == 0 { return Ok(None); } - trace!("parse({:?})", buf); let mut headers_indices = [HeaderIndices { name: (0, 0), value: (0, 0) @@ -192,7 +188,7 @@ impl Http1Transaction for ClientTransaction { let bytes = buf.as_ref(); match try!(res.parse(bytes)) { httparse::Status::Complete(len) => { - trace!("Response.try_parse Complete({})", len); + trace!("Response.parse Complete({})", len); let code = res.code.unwrap(); let status = try!(StatusCode::try_from(code).map_err(|_| ::Error::Status)); let reason = match status.canonical_reason() { @@ -273,14 +269,11 @@ impl Http1Transaction for ClientTransaction { } fn encode(mut head: MessageHead, has_body: bool, method: &mut Option, dst: &mut Vec) -> Encoder { - trace!("ClientTransaction::encode head={:?}, has_body={}, method={:?}", - head, has_body, method); - + trace!("ClientTransaction::encode has_body={}, method={:?}", has_body, method); *method = Some(head.subject.0.clone()); let body = ClientTransaction::set_length(&mut head, has_body); - debug!("encode headers = {:?}", head.headers); let init_cap = 30 + head.headers.len() * AVERAGE_HEADER_SIZE; dst.reserve(init_cap); diff --git a/src/http/io.rs b/src/http/io.rs index 971a3e840d..594b51e4e5 100644 --- a/src/http/io.rs +++ b/src/http/io.rs @@ -6,7 +6,7 @@ use std::ptr; use futures::{Async, Poll}; use tokio_io::{AsyncRead, AsyncWrite}; -use http::{Http1Transaction, MessageHead, DebugTruncate}; +use http::{Http1Transaction, MessageHead}; use bytes::{BytesMut, Bytes}; const INIT_BUFFER_SIZE: usize = 8192; @@ -224,8 +224,9 @@ impl> Cursor { impl> fmt::Debug for Cursor { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_tuple("Cursor") - .field(&DebugTruncate(self.buf())) + f.debug_struct("Cursor") + .field("pos", &self.pos) + .field("len", &self.bytes.as_ref().len()) .finish() } } diff --git a/src/http/mod.rs b/src/http/mod.rs index 20213b6e3e..53fe49f4ed 100644 --- a/src/http/mod.rs +++ b/src/http/mod.rs @@ -150,23 +150,6 @@ pub trait Http1Transaction { pub type ParseResult = ::Result, usize)>>; -struct DebugTruncate<'a>(&'a [u8]); - -impl<'a> fmt::Debug for DebugTruncate<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let bytes = self.0; - if bytes.len() > 32 { - try!(f.write_str("[")); - for byte in &bytes[..32] { - try!(write!(f, "{:?}, ", byte)); - } - write!(f, "... {}]", bytes.len()) - } else { - fmt::Debug::fmt(bytes, f) - } - } -} - #[test] fn test_should_keep_alive() { let mut headers = Headers::new(); diff --git a/src/http/request.rs b/src/http/request.rs index ddb869bab1..2d08bace90 100644 --- a/src/http/request.rs +++ b/src/http/request.rs @@ -132,24 +132,9 @@ impl fmt::Debug for Request { } } -struct MaybeAddr<'a>(&'a Option); - -impl<'a> fmt::Display for MaybeAddr<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match *self.0 { - Some(ref addr) => { - write!(f, "addr={}, ", addr) - }, - None => Ok(()), - } - } -} - /// Constructs a request using a received ResponseHead and optional body pub fn from_wire(addr: Option, incoming: RequestHead, body: B) -> Request { let MessageHead { version, subject: RequestLine(method, uri), headers } = incoming; - info!("Request::new: {}\"{} {} {}\"", MaybeAddr(&addr), method, uri, version); - debug!("Request::new: headers={:?}", headers); Request:: { method: method, diff --git a/src/http/response.rs b/src/http/response.rs index 9a81404504..480702dbbf 100644 --- a/src/http/response.rs +++ b/src/http/response.rs @@ -147,8 +147,6 @@ impl fmt::Debug for Response { #[cfg(not(feature = "raw_status"))] pub fn from_wire(incoming: ResponseHead, body: Option) -> Response { let status = incoming.status(); - info!("Response::new \"{} {}\"", incoming.version, status); - debug!("Response::new headers={:?}", incoming.headers); Response:: { status: status, @@ -163,8 +161,6 @@ pub fn from_wire(incoming: ResponseHead, body: Option) -> Response { #[cfg(feature = "raw_status")] pub fn from_wire(incoming: ResponseHead, body: Option) -> Response { let status = incoming.status(); - info!("Response::new \"{} {}\"", incoming.version, status); - debug!("Response::new headers={:?}", incoming.headers); Response:: { status: status,