fix(logging): adjust several logging messages

examples/hello.rs

@@ -13,4 +13,5 @@ fn hello(_: Request, res: Response) {
 
 fn main() {
     hyper::Server::http(Ipv4Addr(127, 0, 0, 1), 3000).listen(hello).unwrap();
+    println!("Listening on http://127.0.0.1:3000");
 }

examples/server.rs

@@ -52,4 +52,5 @@ fn echo(mut req: Request, mut res: Response) {
 fn main() {
     let server = Server::http(Ipv4Addr(127, 0, 0, 1), 1337);
     server.listen(echo).unwrap();
+    println!("Listening on http://127.0.0.1:1337");
 }

src/header/mod.rs

@@ -114,7 +114,7 @@ impl Headers {
         loop {
             match try!(http::read_header(rdr)) {
                 Some((name, value)) => {
-                    debug!("raw header: {}={}", name, value);
+                    debug!("raw header: {}={}", name, value[].to_ascii());
                     let name = CaseInsensitive(Owned(name));
                     let item = match headers.data.entry(name) {
                         Vacant(entry) => entry.set(RWLock::new(Item::raw(vec![]))),
@@ -389,15 +389,13 @@ fn get_or_parse<H: Header + HeaderFormat>(item: &RWLock<Item>) -> Option<&RWLock
 }
 
 fn downcast<H: Header + HeaderFormat>(read: &Item) -> &H {
-    debug!("downcasting {}", *read);
     match read.typed {
         Some(ref val) => unsafe { val.downcast_ref_unchecked() },
         _ => unreachable!()
     }
 }
 
 fn downcast_mut<H: Header + HeaderFormat>(write: &mut Item) -> &mut H {
-    debug!("downcasting {}", *write);
     match write.typed {
         Some(ref mut val) => unsafe { val.downcast_mut_unchecked() },
         _ => unreachable!()

src/http.rs

@@ -522,7 +522,7 @@ pub fn read_header<R: Reader>(stream: &mut R) -> HttpResult<Option<RawHeaderLine
         };
     }
 
-    debug!("header value = {}", value);
+    debug!("header value = {}", value[].to_ascii());
 
     match try!(stream.read_byte()) {
         LF => Ok(Some((name, value))),

src/server/mod.rs

@@ -11,6 +11,7 @@ pub use self::response::Response;
 
 pub use net::{Fresh, Streaming};
 
+use HttpError::HttpIoError;
 use {HttpResult};
 use header::common::Connection;
 use header::common::connection::{KeepAlive, Close};
@@ -92,9 +93,13 @@ impl<L: NetworkListener<S, A>, S: NetworkStream, A: NetworkAcceptor<S>> Server<L
                                 let mut res = Response::new(&mut wrt);
                                 let req = match Request::new(&mut rdr, addr) {
                                     Ok(req) => req,
+                                    Err(e@HttpIoError(_)) => {
+                                        debug!("ioerror in keepalive loop = {}", e);
+                                        return;
+                                    }
                                     Err(e) => {
                                         //TODO: send a 400 response
-                                        error!("request error: {}", e);
+                                        error!("request error = {}", e);
                                         return;
                                     }
                                 };