Remove uses of log

10 files changed, 146 insertions, 149 deletions

diff --git a/src/libstd/arc.rs b/src/libstd/arc.rs
index d7d878fa192..b91af9a0069 100644
--- a/src/libstd/arc.rs
+++ b/src/libstd/arc.rs
@@ -509,7 +509,7 @@ mod tests {
 
         fail_unless!((*arc::get(&arc_v))[2] == 3);
 
-        log(info, arc_v);
+        info!(arc_v);
     }
 
     #[test]
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index 33b0fd4eb68..b1ba838865d 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -116,7 +116,6 @@ mod tests {
     use super::*;
     use core::cmp::Eq;
     use core::kinds::{Durable, Copy};
-    use core::prelude::debug;
 
     #[test]
     fn test_simple() {
@@ -128,21 +127,21 @@ mod tests {
         fail_unless!(d.len() == 3u);
         d.add_back(137);
         fail_unless!(d.len() == 4u);
-        log(debug, d.peek_front());
+        debug!(d.peek_front());
         fail_unless!(*d.peek_front() == 42);
-        log(debug, d.peek_back());
+        debug!(d.peek_back());
         fail_unless!(*d.peek_back() == 137);
         let mut i: int = d.pop_front();
-        log(debug, i);
+        debug!(i);
         fail_unless!(i == 42);
         i = d.pop_back();
-        log(debug, i);
+        debug!(i);
         fail_unless!(i == 137);
         i = d.pop_back();
-        log(debug, i);
+        debug!(i);
         fail_unless!(i == 137);
         i = d.pop_back();
-        log(debug, i);
+        debug!(i);
         fail_unless!(i == 17);
         fail_unless!(d.len() == 0u);
         d.add_back(3);
@@ -153,10 +152,10 @@ mod tests {
         fail_unless!(d.len() == 3u);
         d.add_front(1);
         fail_unless!(d.len() == 4u);
-        log(debug, d.get(0));
-        log(debug, d.get(1));
-        log(debug, d.get(2));
-        log(debug, d.get(3));
+        debug!(d.get(0));
+        debug!(d.get(1));
+        debug!(d.get(2));
+        debug!(d.get(3));
         fail_unless!(*d.get(0) == 1);
         fail_unless!(*d.get(1) == 2);
         fail_unless!(*d.get(2) == 3);
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index eed00ccacff..4cf60695266 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -881,7 +881,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Err(copy f) => {
-            log(error, fail_str(f));
+            error!(fail_str(f));
             check_fail_type(f, UnexpectedArgument_);
           }
           _ => fail!()
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index a5e68907773..04283674d88 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -117,7 +117,7 @@ pub fn get_addr(node: &str, iotask: &iotask)
     do str::as_buf(node) |node_ptr, len| {
         let output_ch = output_ch.swap_unwrap();
         unsafe {
-            log(debug, fmt!("slice len %?", len));
+            debug!("slice len %?", len);
             let handle = create_uv_getaddrinfo_t();
             let handle_ptr = ptr::addr_of(&handle);
             let handle_data = GetAddrData {
@@ -228,8 +228,8 @@ pub mod v4 {
 
             let new_addr = uv_ip4_addr(str::from_slice(ip), 22);
             let reformatted_name = uv_ip4_name(&new_addr);
-            log(debug, fmt!("try_parse_addr: input ip: %s reparsed ip: %s",
-                            ip, reformatted_name));
+            debug!("try_parse_addr: input ip: %s reparsed ip: %s",
+                            ip, reformatted_name);
             let ref_ip_rep_result = parse_to_ipv4_rep(reformatted_name);
             if result::is_err(&ref_ip_rep_result) {
                 let err_str = result::get_err(&ref_ip_rep_result);
@@ -282,8 +282,8 @@ pub mod v6 {
             // need to figure out how to establish a parse failure..
             let new_addr = uv_ip6_addr(str::from_slice(ip), 22);
             let reparsed_name = uv_ip6_name(&new_addr);
-            log(debug, fmt!("v6::try_parse_addr ip: '%s' reparsed '%s'",
-                            ip, reparsed_name));
+            debug!("v6::try_parse_addr ip: '%s' reparsed '%s'",
+                            ip, reparsed_name);
             // '::' appears to be uv_ip6_name() returns for bogus
             // parses..
             if  ip != &"::" && reparsed_name == ~"::" {
@@ -303,14 +303,14 @@ struct GetAddrData {
 extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
                       res: *addrinfo) {
     unsafe {
-        log(debug, ~"in get_addr_cb");
+        debug!("in get_addr_cb");
         let handle_data = get_data_for_req(handle) as
             *GetAddrData;
         let output_ch = (*handle_data).output_ch.clone();
         if status == 0i32 {
             if res != (ptr::null::<addrinfo>()) {
                 let mut out_vec = ~[];
-                log(debug, fmt!("initial addrinfo: %?", res));
+                debug!("initial addrinfo: %?", res);
                 let mut curr_addr = res;
                 loop {
                     let new_ip_addr = if ll::is_ipv4_addrinfo(curr_addr) {
@@ -322,8 +322,8 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
                             *ll::addrinfo_as_sockaddr_in6(curr_addr))))
                     }
                     else {
-                        log(debug, ~"curr_addr is not of family AF_INET or "+
-                            ~"AF_INET6. Error.");
+                        debug!("curr_addr is not of family AF_INET or \
+                                AF_INET6. Error.");
                         output_ch.send(
                             result::Err(GetAddrUnknownError));
                         break;
@@ -332,33 +332,33 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
 
                     let next_addr = ll::get_next_addrinfo(curr_addr);
                     if next_addr == ptr::null::<addrinfo>() as *addrinfo {
-                        log(debug, ~"null next_addr encountered. no mas");
+                        debug!("null next_addr encountered. no mas");
                         break;
                     }
                     else {
                         curr_addr = next_addr;
-                        log(debug, fmt!("next_addr addrinfo: %?", curr_addr));
+                        debug!("next_addr addrinfo: %?", curr_addr);
                     }
                 }
-                log(debug, fmt!("successful process addrinfo result, len: %?",
-                                vec::len(out_vec)));
+                debug!("successful process addrinfo result, len: %?",
+                                vec::len(out_vec));
                 output_ch.send(result::Ok(out_vec));
             }
             else {
-                log(debug, ~"addrinfo pointer is NULL");
+                debug!("addrinfo pointer is NULL");
                 output_ch.send(
                     result::Err(GetAddrUnknownError));
             }
         }
         else {
-            log(debug, ~"status != 0 error in get_addr_cb");
+            debug!("status != 0 error in get_addr_cb");
             output_ch.send(
                 result::Err(GetAddrUnknownError));
         }
         if res != (ptr::null::<addrinfo>()) {
             uv_freeaddrinfo(res);
         }
-        log(debug, ~"leaving get_addr_cb");
+        debug!("leaving get_addr_cb");
     }
 }
 
@@ -384,15 +384,15 @@ mod test {
     fn test_ip_ipv6_parse_and_format_ip() {
         let localhost_str = ~"::1";
         let format_result = format_addr(&v6::parse_addr(localhost_str));
-        log(debug, fmt!("results: expected: '%s' actual: '%s'",
-            localhost_str, format_result));
+        debug!("results: expected: '%s' actual: '%s'",
+            localhost_str, format_result);
         fail_unless!(format_result == localhost_str);
     }
     #[test]
     fn test_ip_ipv4_bad_parse() {
         match v4::try_parse_addr(~"b4df00d") {
           result::Err(ref err_info) => {
-            log(debug, fmt!("got error as expected %?", err_info));
+            debug!("got error as expected %?", err_info);
             fail_unless!(true);
           }
           result::Ok(ref addr) => {
@@ -405,7 +405,7 @@ mod test {
     fn test_ip_ipv6_bad_parse() {
         match v6::try_parse_addr(~"::,~2234k;") {
           result::Err(ref err_info) => {
-            log(debug, fmt!("got error as expected %?", err_info));
+            debug!("got error as expected %?", err_info);
             fail_unless!(true);
           }
           result::Ok(ref addr) => {
@@ -425,15 +425,15 @@ mod test {
         // note really sure how to realiably test/assert
         // this.. mostly just wanting to see it work, atm.
         let results = result::unwrap(ga_result);
-        log(debug, fmt!("test_get_addr: Number of results for %s: %?",
-                        localhost_name, vec::len(results)));
+        debug!("test_get_addr: Number of results for %s: %?",
+                        localhost_name, vec::len(results));
         for vec::each(results) |r| {
             let ipv_prefix = match *r {
               Ipv4(_) => ~"IPv4",
               Ipv6(_) => ~"IPv6"
             };
-            log(debug, fmt!("test_get_addr: result %s: '%s'",
-                            ipv_prefix, format_addr(r)));
+            debug!("test_get_addr: result %s: '%s'",
+                            ipv_prefix, format_addr(r));
         }
         // at least one result.. this is going to vary from system
         // to system, based on stuff like the contents of /etc/hosts
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index 5328975f82a..0224927df57 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -559,14 +559,14 @@ pub fn accept(new_conn: TcpNewConnection)
                     server_handle_ptr);
                 match uv::ll::tcp_init(loop_ptr, client_stream_handle_ptr) {
                     0i32 => {
-                        log(debug, ~"uv_tcp_init successful for \
+                        debug!("uv_tcp_init successful for \
                                      client stream");
                         match uv::ll::accept(
                             server_handle_ptr as *libc::c_void,
                             client_stream_handle_ptr as *libc::c_void) {
                             0i32 => {
-                                log(debug,
-                                    ~"successfully accepted client \
+                                debug!(
+                                    "successfully accepted client \
                                       connection");
                                 uv::ll::set_data_for_uv_handle(
                                     client_stream_handle_ptr,
@@ -575,7 +575,7 @@ pub fn accept(new_conn: TcpNewConnection)
                                 result_ch.send(None);
                             }
                             _ => {
-                                log(debug, ~"failed to accept client conn");
+                                debug!("failed to accept client conn");
                                 result_ch.send(Some(
                                     uv::ll::get_last_err_data(
                                         loop_ptr).to_tcp_err()));
@@ -583,7 +583,7 @@ pub fn accept(new_conn: TcpNewConnection)
                         }
                     }
                     _ => {
-                        log(debug, ~"failed to accept client stream");
+                        debug!("failed to accept client stream");
                         result_ch.send(Some(
                             uv::ll::get_last_err_data(
                                 loop_ptr).to_tcp_err()));
@@ -694,7 +694,7 @@ fn listen_common(host_ip: ip::IpAddr,
                         let addr_str = ip::format_addr(&loc_ip);
                         let bind_result = match loc_ip {
                             ip::Ipv4(ref addr) => {
-                                log(debug, fmt!("addr: %?", addr));
+                                debug!("addr: %?", addr);
                                 let in_addr = uv::ll::ip4_addr(
                                     addr_str,
                                     port as int);
@@ -702,7 +702,7 @@ fn listen_common(host_ip: ip::IpAddr,
                                                  ptr::addr_of(&in_addr))
                             }
                             ip::Ipv6(ref addr) => {
-                                log(debug, fmt!("addr: %?", addr));
+                                debug!("addr: %?", addr);
                                 let in_addr = uv::ll::ip6_addr(
                                     addr_str,
                                     port as int);
@@ -718,8 +718,8 @@ fn listen_common(host_ip: ip::IpAddr,
                                     tcp_lfc_on_connection_cb) {
                                     0i32 => setup_ch.send(None),
                                     _ => {
-                                        log(debug,
-                                            ~"failure to uv_tcp_init");
+                                        debug!(
+                                            "failure to uv_tcp_init");
                                         let err_data =
                                             uv::ll::get_last_err_data(
                                                 loop_ptr);
@@ -728,7 +728,7 @@ fn listen_common(host_ip: ip::IpAddr,
                                 }
                             }
                             _ => {
-                                log(debug, ~"failure to uv_tcp_bind");
+                                debug!("failure to uv_tcp_bind");
                                 let err_data = uv::ll::get_last_err_data(
                                     loop_ptr);
                                 setup_ch.send(Some(err_data));
@@ -736,7 +736,7 @@ fn listen_common(host_ip: ip::IpAddr,
                         }
                     }
                     _ => {
-                        log(debug, ~"failure to uv_tcp_bind");
+                        debug!("failure to uv_tcp_bind");
                         let err_data = uv::ll::get_last_err_data(
                             loop_ptr);
                         setup_ch.send(Some(err_data));
@@ -751,9 +751,9 @@ fn listen_common(host_ip: ip::IpAddr,
             Some(ref err_data) => {
                 do iotask::interact(iotask) |loop_ptr| {
                     unsafe {
-                        log(debug,
-                            fmt!("tcp::listen post-kill recv hl interact %?",
-                                 loop_ptr));
+                        debug!(
+                            "tcp::listen post-kill recv hl interact %?",
+                                 loop_ptr);
                         (*server_data_ptr).active = false;
                         uv::ll::close(server_stream_ptr, tcp_lfc_close_cb);
                     }
@@ -761,16 +761,16 @@ fn listen_common(host_ip: ip::IpAddr,
                 stream_closed_po.recv();
                 match err_data.err_name {
                     ~"EACCES" => {
-                        log(debug, ~"Got EACCES error");
+                        debug!("Got EACCES error");
                         result::Err(AccessDenied)
                     }
                     ~"EADDRINUSE" => {
-                        log(debug, ~"Got EADDRINUSE error");
+                        debug!("Got EADDRINUSE error");
                         result::Err(AddressInUse)
                     }
                     _ => {
-                        log(debug, fmt!("Got '%s' '%s' libuv error",
-                                        err_data.err_name, err_data.err_msg));
+                        debug!("Got '%s' '%s' libuv error",
+                                        err_data.err_name, err_data.err_msg);
                         result::Err(
                             GenericListenErr(err_data.err_name,
                                              err_data.err_msg))
@@ -782,9 +782,9 @@ fn listen_common(host_ip: ip::IpAddr,
                 let kill_result = kill_po.recv();
                 do iotask::interact(iotask) |loop_ptr| {
                     unsafe {
-                        log(debug,
-                            fmt!("tcp::listen post-kill recv hl interact %?",
-                                 loop_ptr));
+                        debug!(
+                            "tcp::listen post-kill recv hl interact %?",
+                                 loop_ptr);
                         (*server_data_ptr).active = false;
                         uv::ll::close(server_stream_ptr, tcp_lfc_close_cb);
                     }
@@ -981,9 +981,9 @@ impl io::Writer for TcpSocketBuf {
                                                       ).to_vec());
             if w_result.is_err() {
                 let err_data = w_result.get_err();
-                log(debug,
-                    fmt!("ERROR sock_buf as io::writer.writer err: %? %?",
-                         err_data.err_name, err_data.err_msg));
+                debug!(
+                    "ERROR sock_buf as io::writer.writer err: %? %?",
+                         err_data.err_name, err_data.err_msg);
             }
         }
     }
@@ -1015,9 +1015,9 @@ fn tear_down_socket_data(socket_data: @TcpSocketData) {
         let stream_handle_ptr = (*socket_data).stream_handle_ptr;
         do iotask::interact(&(*socket_data).iotask) |loop_ptr| {
             unsafe {
-                log(debug,
-                    fmt!("interact dtor for tcp_socket stream %? loop %?",
-                         stream_handle_ptr, loop_ptr));
+                debug!(
+                    "interact dtor for tcp_socket stream %? loop %?",
+                         stream_handle_ptr, loop_ptr);
                 uv::ll::set_data_for_uv_handle(stream_handle_ptr,
                                                close_data_ptr);
                 uv::ll::close(stream_handle_ptr, tcp_socket_dtor_close_cb);
@@ -1028,7 +1028,7 @@ fn tear_down_socket_data(socket_data: @TcpSocketData) {
         //log(debug, fmt!("about to free socket_data at %?", socket_data));
         rustrt::rust_uv_current_kernel_free(stream_handle_ptr
                                             as *libc::c_void);
-        log(debug, ~"exiting dtor for tcp_socket");
+        debug!("exiting dtor for tcp_socket");
     }
 }
 
@@ -1038,7 +1038,7 @@ fn read_common_impl(socket_data: *TcpSocketData, timeout_msecs: uint)
     unsafe {
         use timer;
 
-        log(debug, ~"starting tcp::read");
+        debug!("starting tcp::read");
         let iotask = &(*socket_data).iotask;
         let rs_result = read_start_common_impl(socket_data);
         if result::is_err(&rs_result) {
@@ -1046,17 +1046,17 @@ fn read_common_impl(socket_data: *TcpSocketData, timeout_msecs: uint)
             result::Err(err_data)
         }
         else {
-            log(debug, ~"tcp::read before recv_timeout");
+            debug!("tcp::read before recv_timeout");
             let read_result = if timeout_msecs > 0u {
                 timer::recv_timeout(
                     iotask, timeout_msecs, result::unwrap(rs_result))
             } else {
                 Some(result::get(&rs_result).recv())
             };
-            log(debug, ~"tcp::read after recv_timeout");
+            debug!("tcp::read after recv_timeout");
             match read_result {
                 None => {
-                    log(debug, ~"tcp::read: timed out..");
+                    debug!("tcp::read: timed out..");
                     let err_data = TcpErrData {
                         err_name: ~"TIMEOUT",
                         err_msg: ~"req timed out"
@@ -1065,7 +1065,7 @@ fn read_common_impl(socket_data: *TcpSocketData, timeout_msecs: uint)
                     result::Err(err_data)
                 }
                 Some(data_result) => {
-                    log(debug, ~"tcp::read got data");
+                    debug!("tcp::read got data");
                     read_stop_common_impl(socket_data);
                     data_result
                 }
@@ -1082,15 +1082,15 @@ fn read_stop_common_impl(socket_data: *TcpSocketData) ->
         let (stop_po, stop_ch) = stream::<Option<TcpErrData>>();
         do iotask::interact(&(*socket_data).iotask) |loop_ptr| {
             unsafe {
-                log(debug, ~"in interact cb for tcp::read_stop");
+                debug!("in interact cb for tcp::read_stop");
                 match uv::ll::read_stop(stream_handle_ptr
                                         as *uv::ll::uv_stream_t) {
                     0i32 => {
-                        log(debug, ~"successfully called uv_read_stop");
+                        debug!("successfully called uv_read_stop");
                         stop_ch.send(None);
                     }
                     _ => {
-                        log(debug, ~"failure in calling uv_read_stop");
+                        debug!("failure in calling uv_read_stop");
                         let err_data = uv::ll::get_last_err_data(loop_ptr);
                         stop_ch.send(Some(err_data.to_tcp_err()));
                     }
@@ -1111,21 +1111,21 @@ fn read_start_common_impl(socket_data: *TcpSocketData)
     unsafe {
         let stream_handle_ptr = (*socket_data).stream_handle_ptr;
         let (start_po, start_ch) = stream::<Option<uv::ll::uv_err_data>>();
-        log(debug, ~"in tcp::read_start before interact loop");
+        debug!("in tcp::read_start before interact loop");
         do iotask::interact(&(*socket_data).iotask) |loop_ptr| {
             unsafe {
-                log(debug, fmt!("in tcp::read_start interact cb %?",
-                                loop_ptr));
+                debug!("in tcp::read_start interact cb %?",
+                                loop_ptr);
                 match uv::ll::read_start(stream_handle_ptr
                                          as *uv::ll::uv_stream_t,
                                          on_alloc_cb,
                                          on_tcp_read_cb) {
                     0i32 => {
-                        log(debug, ~"success doing uv_read_start");
+                        debug!("success doing uv_read_start");
                         start_ch.send(None);
                     }
                     _ => {
-                        log(debug, ~"error attempting uv_read_start");
+                        debug!("error attempting uv_read_start");
                         let err_data = uv::ll::get_last_err_data(loop_ptr);
                         start_ch.send(Some(err_data));
                     }
@@ -1164,19 +1164,19 @@ fn write_common_impl(socket_data_ptr: *TcpSocketData,
         let write_data_ptr = ptr::addr_of(&write_data);
         do iotask::interact(&(*socket_data_ptr).iotask) |loop_ptr| {
             unsafe {
-                log(debug, fmt!("in interact cb for tcp::write %?",
-                                loop_ptr));
+                debug!("in interact cb for tcp::write %?",
+                                loop_ptr);
                 match uv::ll::write(write_req_ptr,
                                     stream_handle_ptr,
                                     write_buf_vec_ptr,
                                     tcp_write_complete_cb) {
                     0i32 => {
-                        log(debug, ~"uv_write() invoked successfully");
+                        debug!("uv_write() invoked successfully");
                         uv::ll::set_data_for_req(write_req_ptr,
                                                  write_data_ptr);
                     }
                     _ => {
-                        log(debug, ~"error invoking uv_write()");
+                        debug!("error invoking uv_write()");
                         let err_data = uv::ll::get_last_err_data(loop_ptr);
                         let result_ch = (*write_data_ptr).result_ch.clone();
                         result_ch.send(TcpWriteError(err_data.to_tcp_err()));
@@ -1281,8 +1281,8 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
                     nread: libc::ssize_t,
                     ++buf: uv::ll::uv_buf_t) {
     unsafe {
-        log(debug, fmt!("entering on_tcp_read_cb stream: %? nread: %?",
-                        stream, nread));
+        debug!("entering on_tcp_read_cb stream: %? nread: %?",
+                        stream, nread);
         let loop_ptr = uv::ll::get_loop_for_uv_handle(stream);
         let socket_data_ptr = uv::ll::get_data_for_uv_handle(stream)
             as *TcpSocketData;
@@ -1290,8 +1290,8 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
           // incoming err.. probably eof
           -1 => {
             let err_data = uv::ll::get_last_err_data(loop_ptr).to_tcp_err();
-            log(debug, fmt!("on_tcp_read_cb: incoming err.. name %? msg %?",
-                            err_data.err_name, err_data.err_msg));
+            debug!("on_tcp_read_cb: incoming err.. name %? msg %?",
+                            err_data.err_name, err_data.err_msg);
             let reader_ch = &(*socket_data_ptr).reader_ch;
             reader_ch.send(result::Err(err_data));
           }
@@ -1300,7 +1300,7 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
           // have data
           _ => {
             // we have data
-            log(debug, fmt!("tcp on_read_cb nread: %d", nread as int));
+            debug!("tcp on_read_cb nread: %d", nread as int);
             let reader_ch = &(*socket_data_ptr).reader_ch;
             let buf_base = uv::ll::get_base_from_buf(buf);
             let new_bytes = vec::from_buf(buf_base, nread as uint);
@@ -1308,7 +1308,7 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
           }
         }
         uv::ll::free_base_of_buf(buf);
-        log(debug, ~"exiting on_tcp_read_cb");
+        debug!("exiting on_tcp_read_cb");
     }
 }
 
@@ -1316,12 +1316,12 @@ extern fn on_alloc_cb(handle: *libc::c_void,
                       suggested_size: size_t)
     -> uv::ll::uv_buf_t {
     unsafe {
-        log(debug, ~"tcp read on_alloc_cb!");
+        debug!("tcp read on_alloc_cb!");
         let char_ptr = uv::ll::malloc_buf_base_of(suggested_size);
-        log(debug, fmt!("tcp read on_alloc_cb h: %? char_ptr: %u sugsize: %u",
+        debug!("tcp read on_alloc_cb h: %? char_ptr: %u sugsize: %u",
                          handle,
                          char_ptr as uint,
-                         suggested_size as uint));
+                         suggested_size as uint);
         uv::ll::buf_init(char_ptr, suggested_size as uint)
     }
 }
@@ -1336,7 +1336,7 @@ extern fn tcp_socket_dtor_close_cb(handle: *uv::ll::uv_tcp_t) {
             as *TcpSocketCloseData;
         let closed_ch = (*data).closed_ch.clone();
         closed_ch.send(());
-        log(debug, ~"tcp_socket_dtor_close_cb exiting..");
+        debug!("tcp_socket_dtor_close_cb exiting..");
     }
 }
 
@@ -1346,7 +1346,7 @@ extern fn tcp_write_complete_cb(write_req: *uv::ll::uv_write_t,
         let write_data_ptr = uv::ll::get_data_for_req(write_req)
             as *WriteReqData;
         if status == 0i32 {
-            log(debug, ~"successful write complete");
+            debug!("successful write complete");
             let result_ch = (*write_data_ptr).result_ch.clone();
             result_ch.send(TcpWriteSuccess);
         } else {
@@ -1354,7 +1354,7 @@ extern fn tcp_write_complete_cb(write_req: *uv::ll::uv_write_t,
                 write_req);
             let loop_ptr = uv::ll::get_loop_for_uv_handle(stream_handle_ptr);
             let err_data = uv::ll::get_last_err_data(loop_ptr);
-            log(debug, ~"failure to write");
+            debug!("failure to write");
             let result_ch = (*write_data_ptr).result_ch.clone();
             result_ch.send(TcpWriteError(err_data.to_tcp_err()));
         }
@@ -1376,13 +1376,13 @@ extern fn stream_error_close_cb(handle: *uv::ll::uv_tcp_t) {
             *ConnectReqData;
         let closed_signal_ch = (*data).closed_signal_ch.clone();
         closed_signal_ch.send(());
-        log(debug, fmt!("exiting steam_error_close_cb for %?", handle));
+        debug!("exiting steam_error_close_cb for %?", handle);
     }
 }
 
 extern fn tcp_connect_close_cb(handle: *uv::ll::uv_tcp_t) {
     unsafe {
-        log(debug, fmt!("closed client tcp handle %?", handle));
+        debug!("closed client tcp handle %?", handle);
     }
 }
 
@@ -1392,27 +1392,27 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
         let conn_data_ptr = (uv::ll::get_data_for_req(connect_req_ptr)
                           as *ConnectReqData);
         let result_ch = (*conn_data_ptr).result_ch.clone();
-        log(debug, fmt!("tcp_connect result_ch %?", result_ch));
+        debug!("tcp_connect result_ch %?", result_ch);
         let tcp_stream_ptr =
             uv::ll::get_stream_handle_from_connect_req(connect_req_ptr);
         match status {
           0i32 => {
-            log(debug, ~"successful tcp connection!");
+            debug!("successful tcp connection!");
             result_ch.send(ConnSuccess);
           }
           _ => {
-            log(debug, ~"error in tcp_connect_on_connect_cb");
+            debug!("error in tcp_connect_on_connect_cb");
             let loop_ptr = uv::ll::get_loop_for_uv_handle(tcp_stream_ptr);
             let err_data = uv::ll::get_last_err_data(loop_ptr);
-            log(debug, fmt!("err_data %? %?", err_data.err_name,
-                            err_data.err_msg));
+            debug!("err_data %? %?", err_data.err_name,
+                            err_data.err_msg);
             result_ch.send(ConnFailure(err_data));
             uv::ll::set_data_for_uv_handle(tcp_stream_ptr,
                                            conn_data_ptr);
             uv::ll::close(tcp_stream_ptr, stream_error_close_cb);
           }
         }
-        log(debug, ~"leaving tcp_connect_on_connect_cb");
+        debug!("leaving tcp_connect_on_connect_cb");
     }
 }
 
@@ -1758,10 +1758,10 @@ pub mod test {
         };
 
         let actual_req = server_result_po.recv();
-        log(debug, fmt!("REQ: expected: '%s' actual: '%s'",
-                       expected_req, actual_req));
-        log(debug, fmt!("RESP: expected: '%s' actual: '%s'",
-                       expected_resp, actual_resp));
+        debug!("REQ: expected: '%s' actual: '%s'",
+                       expected_req, actual_req);
+        debug!("RESP: expected: '%s' actual: '%s'",
+                       expected_resp, actual_resp);
         fail_unless!(str::contains(actual_req, expected_req));
         fail_unless!(str::contains(actual_resp, expected_resp));
     }
diff --git a/src/libstd/par.rs b/src/libstd/par.rs
index a33effba8e0..17ae48e03b9 100644
--- a/src/libstd/par.rs
+++ b/src/libstd/par.rs
@@ -41,7 +41,7 @@ fn map_slices<A:Copy + Owned,B:Copy + Owned>(
 
     let len = xs.len();
     if len < min_granularity {
-        log(info, ~"small slice");
+        info!("small slice");
         // This is a small vector, fall back on the normal map.
         ~[f()(0u, xs)]
     }
@@ -52,7 +52,7 @@ fn map_slices<A:Copy + Owned,B:Copy + Owned>(
 
         let mut futures = ~[];
         let mut base = 0u;
-        log(info, ~"spawning tasks");
+        info!("spawning tasks");
         while base < len {
             let end = uint::min(len, base + items_per_task);
             do vec::as_imm_buf(xs) |p, _len| {
@@ -63,11 +63,11 @@ fn map_slices<A:Copy + Owned,B:Copy + Owned>(
                         let len = end - base;
                         let slice = (ptr::offset(p, base),
                                      len * sys::size_of::<A>());
-                        log(info, fmt!("pre-slice: %?", (base, slice)));
+                        info!("pre-slice: %?", (base, slice));
                         let slice : &[A] =
                             cast::reinterpret_cast(&slice);
-                        log(info, fmt!("slice: %?",
-                                       (base, vec::len(slice), end - base)));
+                        info!("slice: %?",
+                                       (base, vec::len(slice), end - base));
                         fail_unless!((vec::len(slice) == end - base));
                         f(base, slice)
                     }
@@ -76,9 +76,9 @@ fn map_slices<A:Copy + Owned,B:Copy + Owned>(
             };
             base += items_per_task;
         }
-        log(info, ~"tasks spawned");
+        info!("tasks spawned");
 
-        log(info, fmt!("num_tasks: %?", (num_tasks, futures.len())));
+        info!("num_tasks: %?", (num_tasks, futures.len()));
         fail_unless!((num_tasks == futures.len()));
 
         let r = do futures.map() |ys| {
@@ -114,7 +114,7 @@ pub fn mapi<A:Copy + Owned,B:Copy + Owned>(
         result
     });
     let r = vec::concat(slices);
-    log(info, (r.len(), xs.len()));
+    info!("%?", (r.len(), xs.len()));
     fail_unless!((r.len() == xs.len()));
     r
 }
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index 50de528762f..a13617a57ac 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -721,7 +721,7 @@ mod test_qsort3 {
         quick_sort3::<int>(v1);
         let mut i = 0;
         while i < len {
-            log(debug, v2[i]);
+            debug!(v2[i]);
             fail_unless!((v2[i] == v1[i]));
             i += 1;
         }
@@ -768,7 +768,7 @@ mod test_qsort {
         quick_sort::<int>(v1, leual);
         let mut i = 0u;
         while i < len {
-            log(debug, v2[i]);
+            debug!(v2[i]);
             fail_unless!((v2[i] == v1[i]));
             i += 1;
         }
@@ -834,7 +834,7 @@ mod tests {
         let v3 = merge_sort::<int>(v1, f);
         let mut i = 0u;
         while i < len {
-            log(debug, v3[i]);
+            debug!(v3[i]);
             fail_unless!((v3[i] == v2[i]));
             i += 1;
         }
@@ -918,7 +918,7 @@ mod test_tim_sort {
         tim_sort::<int>(v1);
         let mut i = 0u;
         while i < len {
-            log(debug, v2[i]);
+            debug!(v2[i]);
             fail_unless!((v2[i] == v1[i]));
             i += 1u;
         }
diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs
index 60469d0b0f2..8ed541c7140 100644
--- a/src/libstd/timer.rs
+++ b/src/libstd/timer.rs
@@ -142,8 +142,8 @@ pub fn recv_timeout<T:Copy + Owned>(iotask: &IoTask,
 extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t,
                                 status: libc::c_int) {
     unsafe {
-        log(debug,
-            fmt!("delayed_send_cb handle %? status %?", handle, status));
+        debug!(
+            "delayed_send_cb handle %? status %?", handle, status);
         // Faking a borrowed pointer to our ~SharedChan
         let timer_done_ch_ptr: &*c_void = &uv::ll::get_data_for_uv_handle(
             handle);
@@ -163,7 +163,7 @@ extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t,
 
 extern fn delayed_send_close_cb(handle: *uv::ll::uv_timer_t) {
     unsafe {
-        log(debug, fmt!("delayed_send_close_cb handle %?", handle));
+        debug!("delayed_send_close_cb handle %?", handle);
         let timer_done_ch_ptr = uv::ll::get_data_for_uv_handle(handle);
         let timer_done_ch = transmute::<*c_void, ~SharedChan<()>>(
             timer_done_ch_ptr);
diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs
index db3570941e8..1f3dc2f01de 100644
--- a/src/libstd/uv_global_loop.rs
+++ b/src/libstd/uv_global_loop.rs
@@ -136,26 +136,25 @@ mod test {
                 timer_ptr as *libc::c_void);
             let exit_ch = transmute::<*c_void, ~Chan<bool>>(exit_ch_ptr);
             exit_ch.send(true);
-            log(debug,
-                fmt!("EXIT_CH_PTR simple_timer_close_cb exit_ch_ptr: %?",
-                     exit_ch_ptr));
+            debug!("EXIT_CH_PTR simple_timer_close_cb exit_ch_ptr: %?",
+                     exit_ch_ptr);
         }
     }
     extern fn simple_timer_cb(timer_ptr: *ll::uv_timer_t,
                              _status: libc::c_int) {
         unsafe {
-            log(debug, ~"in simple timer cb");
+            debug!(~"in simple timer cb");
             ll::timer_stop(timer_ptr);
             let hl_loop = &get_gl();
             do iotask::interact(hl_loop) |_loop_ptr| {
-                log(debug, ~"closing timer");
+                debug!(~"closing timer");
                 unsafe {
                     ll::close(timer_ptr, simple_timer_close_cb);
                 }
-                log(debug, ~"about to deref exit_ch_ptr");
-                log(debug, ~"after msg sent on deref'd exit_ch");
+                debug!(~"about to deref exit_ch_ptr");
+                debug!(~"after msg sent on deref'd exit_ch");
             };
-            log(debug, ~"exiting simple timer cb");
+            debug!(~"exiting simple timer cb");
         }
     }
 
@@ -163,13 +162,13 @@ mod test {
         unsafe {
             let (exit_po, exit_ch) = stream::<bool>();
             let exit_ch_ptr: *libc::c_void = transmute(~exit_ch);
-            log(debug, fmt!("EXIT_CH_PTR newly created exit_ch_ptr: %?",
-                            exit_ch_ptr));
+            debug!("EXIT_CH_PTR newly created exit_ch_ptr: %?",
+                            exit_ch_ptr);
             let timer_handle = ll::timer_t();
             let timer_ptr = ptr::addr_of(&timer_handle);
             do iotask::interact(iotask) |loop_ptr| {
                 unsafe {
-                    log(debug, ~"user code inside interact loop!!!");
+                    debug!(~"user code inside interact loop!!!");
                     let init_status = ll::timer_init(loop_ptr, timer_ptr);
                     if(init_status == 0i32) {
                         ll::set_data_for_uv_handle(
@@ -188,7 +187,7 @@ mod test {
                 }
             };
             exit_po.recv();
-            log(debug,
+            debug!(
                 ~"global_loop timer test: msg recv on exit_po, done..");
         }
     }
@@ -225,7 +224,7 @@ mod test {
         for iter::repeat(cycles) {
             exit_po.recv();
         };
-        log(debug, ~"test_stress_gl_uv_global_loop_high_level_global_timer"+
+        debug!(~"test_stress_gl_uv_global_loop_high_level_global_timer"+
             ~" exiting sucessfully!");
     }
 }
diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs
index 522a613f02d..1c7a7c22a9d 100644
--- a/src/libstd/uv_iotask.rs
+++ b/src/libstd/uv_iotask.rs
@@ -132,10 +132,10 @@ fn run_loop(iotask_ch: &Chan<IoTask>) {
         };
         iotask_ch.send(iotask);
 
-        log(debug, ~"about to run uv loop");
+        debug!("about to run uv loop");
         // enter the loop... this blocks until the loop is done..
         ll::run(loop_ptr);
-        log(debug, ~"uv loop ended");
+        debug!("uv loop ended");
         ll::loop_delete(loop_ptr);
     }
 }
@@ -158,8 +158,8 @@ fn send_msg(iotask: &IoTask,
 extern fn wake_up_cb(async_handle: *ll::uv_async_t,
                     status: int) {
 
-    log(debug, fmt!("wake_up_cb extern.. handle: %? status: %?",
-                     async_handle, status));
+    debug!("wake_up_cb extern.. handle: %? status: %?",
+                     async_handle, status);
 
     unsafe {
         let loop_ptr = ll::get_loop_for_uv_handle(async_handle);
@@ -178,13 +178,13 @@ extern fn wake_up_cb(async_handle: *ll::uv_async_t,
 
 fn begin_teardown(data: *IoTaskLoopData) {
     unsafe {
-        log(debug, ~"iotask begin_teardown() called, close async_handle");
+        debug!("iotask begin_teardown() called, close async_handle");
         let async_handle = (*data).async_handle;
         ll::close(async_handle as *c_void, tear_down_close_cb);
     }
 }
 extern fn tear_down_walk_cb(handle: *libc::c_void, arg: *libc::c_void) {
-    log(debug, ~"IN TEARDOWN WALK CB");
+    debug!("IN TEARDOWN WALK CB");
     // pretty much, if we still have an active handle and it is *not*
     // the async handle that facilities global loop communication, we
     // want to barf out and fail
@@ -194,7 +194,7 @@ extern fn tear_down_walk_cb(handle: *libc::c_void, arg: *libc::c_void) {
 extern fn tear_down_close_cb(handle: *ll::uv_async_t) {
     unsafe {
         let loop_ptr = ll::get_loop_for_uv_handle(handle);
-        log(debug, ~"in tear_down_close_cb");
+        debug!("in tear_down_close_cb");
         ll::walk(loop_ptr, tear_down_walk_cb, handle as *libc::c_void);
     }
 }
@@ -202,7 +202,7 @@ extern fn tear_down_close_cb(handle: *ll::uv_async_t) {
 #[cfg(test)]
 extern fn async_close_cb(handle: *ll::uv_async_t) {
     unsafe {
-        log(debug, fmt!("async_close_cb handle %?", handle));
+        debug!("async_close_cb handle %?", handle);
         let exit_ch = &(*(ll::get_data_for_uv_handle(handle)
                         as *AhData)).exit_ch;
         let exit_ch = exit_ch.clone();
@@ -213,8 +213,7 @@ extern fn async_close_cb(handle: *ll::uv_async_t) {
 #[cfg(test)]
 extern fn async_handle_cb(handle: *ll::uv_async_t, status: libc::c_int) {
     unsafe {
-        log(debug,
-            fmt!("async_handle_cb handle %? status %?",handle,status));
+        debug!("async_handle_cb handle %? status %?",handle,status);
         ll::close(handle, async_close_cb);
     }
 }
@@ -269,15 +268,15 @@ unsafe fn spawn_test_loop(exit_ch: ~Chan<()>) -> IoTask {
 #[cfg(test)]
 extern fn lifetime_handle_close(handle: *libc::c_void) {
     unsafe {
-        log(debug, fmt!("lifetime_handle_close ptr %?", handle));
+        debug!("lifetime_handle_close ptr %?", handle);
     }
 }
 
 #[cfg(test)]
 extern fn lifetime_async_callback(handle: *libc::c_void,
                                  status: libc::c_int) {
-    log(debug, fmt!("lifetime_handle_close ptr %? status %?",
-                    handle, status));
+    debug!("lifetime_handle_close ptr %? status %?",
+                    handle, status);
 }
 
 #[test]
@@ -311,9 +310,9 @@ fn test_uv_iotask_async() {
             debug!("waiting");
             work_exit_po.recv();
         };
-        log(debug, ~"sending teardown_loop msg..");
+        debug!(~"sending teardown_loop msg..");
         exit(iotask);
         exit_po.recv();
-        log(debug, ~"after recv on exit_po.. exiting..");
+        debug!(~"after recv on exit_po.. exiting..");
     }
 }