优化代码

exchanges/Cargo.toml

@@ -25,6 +25,9 @@ hmac = "0.8.1"
 sha2 = "0.9.8"
 
 tokio-tungstenite = "0.14"
-#tokio-tungstenite = "0.14"
-#websockets= "0.3.0"
-#futures = "0.3.21"
+
+
+##日志
+global = { path="../global" }
+tracing = "0.1"
+tracing-subscriber = "0.3.17"

exchanges/src/binance_usdt_swap_rest.rs

@@ -2,6 +2,7 @@ use std::collections::BTreeMap;
 use reqwest::header::HeaderMap;
 use ring::hmac;
 use hex;
+use tracing::trace;
 use crate::http_tool::RestTool;
 use crate::response_base::ResponseData;
 
@@ -22,7 +23,7 @@ impl BinanceUsdtSwapRest {
     }
     pub fn new_label(label: String, is_colo: bool, login_param: BTreeMap<String, String>) -> BinanceUsdtSwapRest {
         let base_url = if is_colo {
-            println!("不支持colo高速线路");
+            trace!("不支持colo高速线路");
             "https://fapi.binance.com".to_string()
         } else {
             "https://fapi.binance.com".to_string()
@@ -75,7 +76,7 @@ impl BinanceUsdtSwapRest {
                 }
             }
         }
-        // println!("----组装headers:{:?}", headers);
+        // trace!("----组装headers:{:?}", headers);
         headers
     }
 
@@ -87,23 +88,23 @@ impl BinanceUsdtSwapRest {
         }
         // params.insert("timestamp".to_string(), chrono::Utc::now().timestamp_millis().to_string());
 
-        // println!("login_param参数：{:?}", self.login_param);
+        // trace!("login_param参数：{:?}", self.login_param);
         let mut secret_key = "";
         if self.login_param.contains_key("secret_key") {
             secret_key = self.login_param.get("secret_key").unwrap()
         }
-        // println!("---参数:{}", params_str);
-        // println!("---参数:{}", params.to_string());
+        // trace!("---参数:{}", params_str);
+        // trace!("---参数:{}", params.to_string());
         /*签名生成*/
         let params_str = RestTool::parse_params_to_str(params.to_string());
-        // println!("---参数:{}", params_str);
+        // trace!("---参数:{}", params_str);
         let message = format!("{}", params_str);
 
         // let secret_key2 = "2b5eb11e18796d12d88f13dc27dbbd02c2cc51ff7059765ed9821957d82bb4d9";
         // let message2 = "symbol=BTCUSDT&side=BUY&type=LIMIT&quantity=1&price=9000&timeInForce=GTC&recvWindow=5000&timestamp=1591702613943";
         let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_ref());
         let signature = hex::encode(hmac::sign(&signed_key, message.as_bytes()).as_ref());
-        // println!("---signature:{}", signature);
+        // trace!("---signature:{}", signature);
 
         // $ echo -n "symbol=BTCUSDT&side=BUY&type=LIMIT&quantity=1&price=9000&timeInForce=GTC&recvWindow=5000&timestamp=1591702613943" | openssl dgst -sha256 -hmac "2b5eb11e18796d12d88f13dc27dbbd02c2cc51ff7059765ed9821957d82bb4d9"
         //     (stdin)= 3c661234138461fcc7a7d8746c6558c9842d4e10870d2ecbedf7777cad694af9
@@ -113,7 +114,7 @@ impl BinanceUsdtSwapRest {
             map.insert("signature".to_owned(), serde_json::Value::from(signature.clone()));
         }
 
-        // println!("----组装params:{:?}", params);
+        // trace!("----组装params:{:?}", params);
         params.to_string()
     }
 }

exchanges/src/binance_usdt_swap_ws.rs

@@ -4,6 +4,7 @@ use std::io::{Write};
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use serde_json::{json, Value};
 use tokio::sync::mpsc::Sender;
+use tracing::trace;
 use crate::proxy;
 use crate::response_base::ResponseData;
 use tungstenite::client::{AutoStream, connect_with_proxy, ProxyAutoStream};
@@ -41,7 +42,7 @@ impl BinanceUsdtSwapWs {
                      sender: Sender<ResponseData>) -> BinanceUsdtSwapWs
     {
         let base_url = if is_colo {
-            println!("不支持colo高速线路");
+            trace!("不支持colo高速线路");
             "wss://stream.binance.com:443/ws".to_string()
         } else {
             "wss://stream.binance.com:443/ws".to_string()
@@ -120,7 +121,7 @@ impl BinanceUsdtSwapWs {
         });
         // let parse_fn_arc = Arc::new(Mutex::new(parse_fn)); // Wrap the closure in an Arc<Mutex<_>>
         loop {
-            println!("要连接咯~~！！");
+            trace!("要连接咯~~！！");
             //币安-登陆流程-rest请求获取k然后拿到 key 拼接地址
             // if self.is_login { //暂时没看到有订阅的频道需要登陆 所以暂时不做
             // }
@@ -147,7 +148,7 @@ impl BinanceUsdtSwapWs {
                         self.proxy_subscription(ws.0, &subscription).await;
                     }
                     Err(err) => {
-                        println!("Can't connect(无法连接): {}", err);
+                        trace!("Can't connect(无法连接): {}", err);
                     }
                 };
             } else {
@@ -157,19 +158,19 @@ impl BinanceUsdtSwapWs {
                     }
                     Err(err) => {
                         // 连接失败时执行的操作
-                        println!("Can't connect(无法连接): {}", err);
+                        trace!("Can't connect(无法连接): {}", err);
                         // 返回一个默认的 WebSocket 对象或其他适当的值
                         // 或者根据需要触发 panic 或返回错误信息
                     }
                 };
             }
-            println!("退出来咯")
+            trace!("退出来咯")
         }
     }
 
     //代理
     async fn proxy_subscription(&self, mut web_socket: WebSocket<ProxyAutoStream>,
-                          subscription: &serde_json::Value,
+                                subscription: &serde_json::Value,
     )
     {
         let label = self.label.clone();
@@ -178,13 +179,13 @@ impl BinanceUsdtSwapWs {
         // let mut stderr = io::stderr();
         // /*****是否需要登陆****/
         // if self.is_login {
-        //     println!("----需要登陆");
+        //     trace!("----需要登陆");
         // } else {
-        //     println!("----no longin(不需要登陆)");
+        //     trace!("----no longin(不需要登陆)");
         // }
         /******订阅信息********/
         let sub_json = subscription.clone();
-        println!("--订阅内容：{:?}", sub_json.to_string());
+        trace!("--订阅内容：{:?}", sub_json.to_string());
         let sub_json_str = sub_json.to_string();
         web_socket.write_message(Message::Text(sub_json_str))
             .unwrap();
@@ -209,15 +210,15 @@ impl BinanceUsdtSwapWs {
                     writeln!(stdout, "回应-pong---{:?}", String::from_utf8(s.clone())).unwrap();
                 }
                 Ok(Message::Pong(s)) => {
-                    // println!("Pong-响应--{:?}", String::from_utf8(s));
+                    // trace!("Pong-响应--{:?}", String::from_utf8(s));
                     writeln!(stdout, "Pong-响应--{:?}", String::from_utf8(s.clone())).unwrap();
                 }
                 Ok(Message::Close(_)) => {
-                    // println!("socket 关闭: ");
+                    // trace!("socket 关闭: ");
                     writeln!(stdout, "Close-响应").unwrap();
                 }
                 Err(error) => {
-                    // println!("Error receiving message: {}", error);
+                    // trace!("Error receiving message: {}", error);
                     writeln!(stdout, "Err-响应{}", error).unwrap();
                     break;
                 }
@@ -228,7 +229,7 @@ impl BinanceUsdtSwapWs {
     }
     //非代理
     async fn subscription(&self, mut web_socket: WebSocket<AutoStream>,
-                    subscription: &serde_json::Value,
+                          subscription: &serde_json::Value,
     )
     {
         let label = self.label.clone();
@@ -237,16 +238,16 @@ impl BinanceUsdtSwapWs {
         // let mut stderr = io::stderr();
         /*****是否需要登陆****/
         // if self.is_login {
-        //     println!("----需要登陆");
+        //     trace!("----需要登陆");
         //     // let login_json_str = self.log_in_to_str();
         //     // web_socket.write_message(Message::Text(login_json_str)).unwrap();
         //     // thread::sleep(Duration::from_secs(1));
         // } else {
-        //     println!("----no longin(不需要登陆)");
+        //     trace!("----no longin(不需要登陆)");
         // }
         /******订阅信息********/
         let sub_json = subscription.clone();
-        println!("--订阅内容：{:?}", sub_json);
+        trace!("--订阅内容：{:?}", sub_json);
         let sub_json_str = sub_json.to_string();
         web_socket.write_message(Message::Text(sub_json_str))
             .unwrap();
@@ -264,16 +265,16 @@ impl BinanceUsdtSwapWs {
                     // });
                 }
                 Ok(Message::Ping(s)) => {
-                    println!("Ping-响应--{:?}", String::from_utf8(s));
+                    trace!("Ping-响应--{:?}", String::from_utf8(s));
                 }
                 Ok(Message::Pong(s)) => {
-                    println!("Pong-响应--{:?}", String::from_utf8(s));
+                    trace!("Pong-响应--{:?}", String::from_utf8(s));
                 }
                 Ok(Message::Close(_)) => {
-                    println!("socket 关闭: ");
+                    trace!("socket 关闭: ");
                 }
                 Err(error) => {
-                    println!("Error receiving message: {}", error);
+                    trace!("Error receiving message: {}", error);
                     break;
                 }
                 _ => {}
@@ -290,7 +291,7 @@ impl BinanceUsdtSwapWs {
         if json_value.get("result").is_some() {
             //订阅反馈
         } else {
-            // println!("????-----:{}", json_value);
+            // trace!("????-----:{}", json_value);
             //数据解析
             if let Some(json_obj) = json_value.as_object() {
                 if Self::channel_agg_trade(json_obj.clone()) {

exchanges/src/gate_swap_rest.rs

@@ -7,6 +7,7 @@ use reqwest::Client;
 use crate::http_tool::RestTool;
 use crate::response_base::ResponseData;
 use sha2::Sha512;
+use tracing::trace;
 
 #[derive(Clone)]
 pub struct GateSwapRest {
@@ -29,7 +30,7 @@ impl GateSwapRest {
     pub fn new_label(label: String, is_colo: bool, login_param: BTreeMap<String, String>) -> GateSwapRest
     {
         let base_url = if is_colo {
-            println!("使用colo高速线路");
+            trace!("使用colo高速线路");
             "https://apiv4-private.gateapi.io".to_string()
         } else {
             "https://api.gateio.ws".to_string()
@@ -188,7 +189,7 @@ impl GateSwapRest {
             }
             _ => {} // 处理未知请求类型
         };
-        println!("----param{}", param.to_string());
+        trace!("----param{}", param.to_string());
         let data = self.swap_order(settle, param).await;
         data
     }
@@ -322,7 +323,7 @@ impl GateSwapRest {
                      is_login: bool,
                      params: String) -> ResponseData
     {
-        // println!("login_param:{:?}", self.login_param);
+        // trace!("login_param:{:?}", self.login_param);
         //解析账号信息
         let mut access_key = "".to_string();
         let mut secret_key = "".to_string();
@@ -369,13 +370,13 @@ impl GateSwapRest {
                                       body.clone(),
                                       timestamp.clone(),
                 );
-                // println!("sing:{}", sing);
+                // trace!("sing:{}", sing);
                 //组装header
                 headers.extend(Self::headers(access_key, timestamp, sing));
             }
         }
 
-        // println!("headers:{:?}", headers);
+        // trace!("headers:{:?}", headers);
         let get_response = self.http_toll(
             format!("{}{}", prefix_url.clone(), request_url.clone()),
             requesst_type.to_string(),
@@ -407,7 +408,7 @@ impl GateSwapRest {
         } else {
             String::new()
         };
-        // println!("hashed_payload:{}", hashed_payload);
+        // trace!("hashed_payload:{}", hashed_payload);
 
         let message = format!("{}\n{}\n{}\n{}\n{}",
                               requesst_type,
@@ -415,9 +416,9 @@ impl GateSwapRest {
                               params_str,
                               hashed_payload,
                               timestamp);
-        // println!("**********", );
-        // println!("组装数据：{}", message);
-        // println!("**********", );
+        // trace!("**********", );
+        // trace!("组装数据：{}", message);
+        // trace!("**********", );
 
         let mut mac = Hmac::<Sha512>::new_varkey(secret_key.as_bytes()).expect("Failed to create HMAC");
         mac.update(message.as_bytes());
@@ -434,10 +435,10 @@ impl GateSwapRest {
         let request_type = request_type.clone().to_uppercase();
         let addrs_url = format!("{}?{}", url.clone(), RestTool::parse_params_to_str(params.clone()));
         // let params_json: serde_json::Value = serde_json::from_str(&params).unwrap();
-        // println!("url:{}",url);
-        // println!("addrs_url:{}",url);
-        // println!("params_json:{}",params_json);
-        // println!("headers:{:?}",headers);
+        // trace!("url:{}",url);
+        // trace!("addrs_url:{}",url);
+        // trace!("params_json:{}",params_json);
+        // trace!("headers:{:?}",headers);
 
         let req = match request_type.as_str() {
             "GET" => self.client.get(addrs_url.clone()).headers(headers),
@@ -451,11 +452,11 @@ impl GateSwapRest {
         if response.status().is_success() {
             // 读取响应的内容
             let body = response.text().await?;
-            // println!("ok-----{}", body);
+            // trace!("ok-----{}", body);
             res_data = ResponseData::new(self.label.clone(),"200".to_string(), "success".to_string(), body);
         } else {
             let body = response.text().await?;
-            // println!("error-----{}", body);
+            // trace!("error-----{}", body);
             res_data = ResponseData::error(self.label.clone(),body.to_string())
         }
         Ok(res_data)

exchanges/src/gate_swap_ws.rs

@@ -7,6 +7,7 @@ use serde_json::{json, Value};
 use hex;
 use hmac::{Hmac, Mac, NewMac};
 use sha2::Sha512;
+use tracing::trace;
 use crate::{proxy};
 use tungstenite::client::{AutoStream, connect_with_proxy, ProxyAutoStream};
 use tungstenite::{connect, Message, WebSocket};
@@ -68,7 +69,7 @@ impl GateSwapWs {
     ) -> GateSwapWs
     {
         if is_colo {
-            println!("支持高速通道-未配置")
+            trace!("支持高速通道-未配置")
         } else {}
 
         /*******走代理：根据环境变量配置来决定,如果配置了走代理，没有配置不走*******/
@@ -236,7 +237,7 @@ impl GateSwapWs {
         //订阅信息组装
         let subscription = self.get_subscription();
         loop {
-            println!("要连接咯~~！！{}", self.request_url);
+            trace!("要连接咯~~！！{}", self.request_url);
 
             let request_url = Url::parse(self.request_url.as_str()).unwrap();
             //1. 判断是否需要代理,根据代理地址是否存来选择
@@ -261,7 +262,7 @@ impl GateSwapWs {
                         self.proxy_subscription(ws.0, subscription.clone()).await;
                     }
                     Err(err) => {
-                        println!("Can't connect(无法连接): {}", err);
+                        trace!("Can't connect(无法连接): {}", err);
                     }
                 };
             } else {
@@ -271,13 +272,13 @@ impl GateSwapWs {
                     }
                     Err(err) => {
                         // 连接失败时执行的操作
-                        println!("Can't connect(无法连接): {}", err);
+                        trace!("Can't connect(无法连接): {}", err);
                         // 返回一个默认的 WebSocket 对象或其他适当的值
                         // 或者根据需要触发 panic 或返回错误信息
                     }
                 };
             }
-            println!("退出来咯")
+            trace!("退出来咯")
         }
     }
 
@@ -287,7 +288,7 @@ impl GateSwapWs {
         let label = self.label.clone();
         /*****订阅***/
         for sub in &subscription {
-            println!("订阅信息：{}", sub.to_string());
+            trace!("订阅信息：{}", sub.to_string());
             web_socket.write_message(Message::Text(sub.to_string()))
                 .unwrap();
         }
@@ -310,15 +311,15 @@ impl GateSwapWs {
                     writeln!(stdout, "回应-pong---{:?}", String::from_utf8(s.clone())).unwrap();
                 }
                 Ok(Message::Pong(s)) => {
-                    // println!("Pong-响应--{:?}", String::from_utf8(s));
+                    // trace!("Pong-响应--{:?}", String::from_utf8(s));
                     writeln!(stdout, "Pong-响应--{:?}", String::from_utf8(s.clone())).unwrap();
                 }
                 Ok(Message::Close(_)) => {
-                    // println!("socket 关闭: ");
+                    // trace!("socket 关闭: ");
                     writeln!(stdout, "Close-响应").unwrap();
                 }
                 Err(error) => {
-                    // println!("Error receiving message: {}", error);
+                    // trace!("Error receiving message: {}", error);
                     writeln!(stdout, "Err-响应{}", error).unwrap();
                     break;
                 }
@@ -352,16 +353,16 @@ impl GateSwapWs {
                     }
                 }
                 Ok(Message::Ping(s)) => {
-                    println!("Ping-响应--{:?}", String::from_utf8(s));
+                    trace!("Ping-响应--{:?}", String::from_utf8(s));
                 }
                 Ok(Message::Pong(s)) => {
-                    println!("Pong-响应--{:?}", String::from_utf8(s));
+                    trace!("Pong-响应--{:?}", String::from_utf8(s));
                 }
                 Ok(Message::Close(_)) => {
-                    println!("socket 关闭: ");
+                    trace!("socket 关闭: ");
                 }
                 Err(error) => {
-                    println!("Error receiving message: {}", error);
+                    trace!("Error receiving message: {}", error);
                     break;
                 }
                 _ => {}
@@ -373,7 +374,7 @@ impl GateSwapWs {
     //数据解析
     pub fn ok_text(label: String, text: String) -> ResponseData
     {
-        // println!("原始数据：{}", text);
+        // trace!("原始数据：{}", text);
         let mut res_data = ResponseData::new(label.to_string(), "200".to_string(), "success".to_string(), "".to_string());
         let json_value: serde_json::Value = serde_json::from_str(&text).unwrap();
 
@@ -382,7 +383,7 @@ impl GateSwapWs {
             let mes = message.trim_end_matches('\n');
 
             // let mes_json_value: serde_json::Value = serde_json::from_str(mes).unwrap();
-            // // println!("错误信息：{}", mes_json_value.to_string());
+            // // trace!("错误信息：{}", mes_json_value.to_string());
             res_data.code = json_value["error"]["code"].to_string();
             res_data.message = mes.clone().to_string();
         } else if json_value["result"]["status"].as_str() == Option::from("success") {//订阅返回

exchanges/src/http_tool.rs

@@ -1,5 +1,6 @@
 use reqwest::{Client};
 use reqwest::header::HeaderMap;
+use tracing::trace;
 use crate::response_base::ResponseData;
 #[derive(Clone)]
 pub struct RestTool {
@@ -24,7 +25,7 @@ impl RestTool {
             HeaderMap::new(),
         ).await;
         let res_data = RestTool::res_data_analysis(get_response);
-        println!("GET Response: {:?}", res_data);
+        trace!("GET Response: {:?}", res_data);
 
 
         Ok(())
@@ -36,10 +37,10 @@ impl RestTool {
         let request_type = request_type.clone().to_uppercase();
         let addrs_url = format!("{}?{}", url.clone(), RestTool::parse_params_to_str(params.clone()));
         // let params_json: serde_json::Value = serde_json::from_str(&params).unwrap();
-        // println!("url:{}",url);
-        // println!("addrs_url:{}",url);
-        // println!("params_json:{}",params_json);
-        // println!("headers:{:?}",headers);
+        // trace!("url:{}",url);
+        // trace!("addrs_url:{}",url);
+        // trace!("params_json:{}",params_json);
+        // trace!("headers:{:?}",headers);
 
         let req = match request_type.as_str() {
             "GET" => self.client.get(addrs_url.clone()).headers(headers),
@@ -53,11 +54,11 @@ impl RestTool {
         if response.status().is_success() {
             // 读取响应的内容
             let body = response.text().await?;
-            // println!("ok-----{}", body);
+            // trace!("ok-----{}", body);
             res_data = ResponseData::new("".to_string(),"200".to_string(), "success".to_string(), body);
         } else {
             let body = response.text().await?;
-            // println!("error-----{}", body);
+            // trace!("error-----{}", body);
             res_data = ResponseData::error("".to_string(),body.to_string())
         }
         Ok(res_data)
@@ -74,8 +75,8 @@ impl RestTool {
                     serde_json::Value::String(s) => s.clone(),
                     _ => value.to_string()
                 };
-                // println!("Key: {}", key);
-                // println!("Value: {}", formatted_value);
+                // trace!("Key: {}", key);
+                // trace!("Value: {}", formatted_value);
                 // let formatted_value = match value {
                 //     Value::String(s) => s.clone(),
                 //     _ => value.to_string()
@@ -85,7 +86,7 @@ impl RestTool {
                 params_str = format_str;
             }
         }
-        // println!("---json-转字符串拼接:{}",params_str);
+        // trace!("---json-转字符串拼接:{}",params_str);
         params_str.to_string()
     }
     //res_data 解析
@@ -102,9 +103,9 @@ impl RestTool {
                     let data = serde_json::to_string(&json_value["data"]).unwrap();
                     let msg = json_value["msg"].as_str().unwrap();
 
-                    // //println!("--解析成功----code:{}",code);
-                    // //println!("--解析成功----data:{}",data);
-                    // //println!("--解析成功----msg:{}",msg);
+                    // //trace!("--解析成功----code:{}",code);
+                    // //trace!("--解析成功----data:{}",data);
+                    // //trace!("--解析成功----msg:{}",msg);
                     let success = ResponseData::new("".to_string(),
                                                     code.parse().unwrap(),
                                                     msg.parse().unwrap(),

exchanges/src/kucoin_swap_rest.rs

@@ -3,6 +3,7 @@ use reqwest::header::HeaderMap;
 use hmac::{Hmac, Mac, NewMac};
 use reqwest::{Client};
 use sha2::Sha256;
+use tracing::trace;
 use crate::http_tool::RestTool;
 use crate::response_base::ResponseData;
 
@@ -29,7 +30,7 @@ impl KucoinSwapRest {
     }
     pub fn new_lable(label: String, is_colo: bool, login_param: BTreeMap<String, String>) -> KucoinSwapRest {
         let base_url = if is_colo {
-            println!("不支持colo高速线路");
+            trace!("不支持colo高速线路");
             "https://api-futures.kucoin.com".to_string()
         } else {
             "https://api-futures.kucoin.com".to_string()
@@ -264,7 +265,7 @@ impl KucoinSwapRest {
                          is_login: bool,
                          params: String) -> ResponseData
     {
-        println!("login_param:{:?}", self.login_param);
+        trace!("login_param:{:?}", self.login_param);
         //解析账号信息
         let mut access_key = "".to_string();
         let mut secret_key = "".to_string();
@@ -301,8 +302,8 @@ impl KucoinSwapRest {
                 let e = ResponseData::error(self.label.clone(), "登陆参数错误！".to_string());
                 return e;
             } else {//需要登陆-且登陆参数齐全
-                println!("param:{}", params);
-                println!("body:{}", body);
+                trace!("param:{}", params);
+                trace!("body:{}", body);
                 //组装sing
                 let sing = Self::sign(secret_key.clone(),
                                       method.clone(),
@@ -312,16 +313,16 @@ impl KucoinSwapRest {
                                       body.clone(),
                                       timestamp.clone(),
                 );
-                println!("sing:{}", sing);
+                trace!("sing:{}", sing);
                 let passphrase = Self::passphrase(secret_key, pass_key);
-                println!("passphrase:{}", passphrase);
+                trace!("passphrase:{}", passphrase);
                 //组装header
                 headers.extend(Self::headers(sing, timestamp, passphrase, access_key));
             }
         }
 
 
-        // println!("headers:{:?}", headers);
+        // trace!("headers:{:?}", headers);
         let get_response = self.http_toll(
             format!("{}{}", prefix_url.clone(), request_url.clone()),
             method.to_string(),
@@ -348,7 +349,7 @@ impl KucoinSwapRest {
     {
         let url = format!("{}{}", prefix_url, request_url);
         let params_str = RestTool::parse_params_to_str(params.clone());
-        println!("body_data:{}", body_data);
+        trace!("body_data:{}", body_data);
         // let body = Some(body_data);
         // let hashed_payload = if let Some(body) = body {
         //     let mut m = digest::Context::new(&digest::SHA256);
@@ -357,7 +358,7 @@ impl KucoinSwapRest {
         // } else {
         //     String::new()
         // };
-        // println!("hashed_payload:{}", hashed_payload);
+        // trace!("hashed_payload:{}", hashed_payload);
 
         let mut message = format!("{}{}{}",
                                   timestamp,
@@ -374,9 +375,9 @@ impl KucoinSwapRest {
             message = format!("{}{}", message, body_data);
         }
 
-        println!("**********", );
-        println!("组装数据：{}", message);
-        println!("**********", );
+        trace!("**********", );
+        trace!("组装数据：{}", message);
+        trace!("**********", );
 
         let mut mac = Hmac::<Sha256>::new_varkey(secret_key.as_bytes()).expect("Failed to create HMAC");
         mac.update(message.as_bytes());
@@ -405,8 +406,8 @@ impl KucoinSwapRest {
         } else {
             format!("{}?{}", url.clone(), RestTool::parse_params_to_str(params.clone()))
         };
-        println!("url:{}", url);
-        println!("addrs_url:{}", addrs_url);
+        trace!("url:{}", url);
+        trace!("addrs_url:{}", addrs_url);
 
         let req = match request_type.as_str() {
             "GET" => self.client.get(addrs_url.clone()).headers(headers),
@@ -420,11 +421,11 @@ impl KucoinSwapRest {
         if response.status().is_success() {
             // 读取响应的内容
             let body = response.text().await?;
-            // println!("ok-----{}", body);
+            // trace!("ok-----{}", body);
             res_data = ResponseData::new(self.label.clone(), "200".to_string(), "success".to_string(), body);
         } else {
             let body = response.text().await?;
-            // println!("error-----{}", body);
+            // trace!("error-----{}", body);
             res_data = ResponseData::error(self.label.clone(), body.to_string())
         }
         Ok(res_data)

exchanges/src/kuconin_swap_ws.rs

@@ -4,6 +4,7 @@ use std::io::{Write};
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use tokio::sync::mpsc::Sender;
 use serde_json::{json};
+use tracing::trace;
 use crate::{proxy};
 use tungstenite::client::{AutoStream, connect_with_proxy, ProxyAutoStream};
 use tungstenite::{connect, Message, WebSocket};
@@ -75,7 +76,7 @@ impl KuconinSwapWs {
     ) -> KuconinSwapWs
     {
         if is_colo {
-            println!("不支持高速通道")
+            trace!("不支持高速通道")
         }
 
         /*******走代理：根据环境变量配置来决定,如果配置了走代理，没有配置不走*******/
@@ -218,7 +219,7 @@ impl KuconinSwapWs {
         let subscription = self.get_subscription();
         let subscription: Vec<String> = subscription.into_iter().collect::<HashSet<String>>().into_iter().collect();
         loop {
-            println!("要连接咯~~！！{}", self.request_url);
+            trace!("要连接咯~~！！{}", self.request_url);
             //币安-登陆流程-rest请求获取k然后拿到 key 拼接地址
             // if self.is_login { //暂时没看到有订阅的频道需要登陆 所以暂时不做
             // }
@@ -246,7 +247,7 @@ impl KuconinSwapWs {
                         self.proxy_subscription(ws.0, subscription.clone()).await;
                     }
                     Err(err) => {
-                        println!("Can't connect(无法连接): {}", err);
+                        trace!("Can't connect(无法连接): {}", err);
                     }
                 };
             } else {
@@ -256,13 +257,13 @@ impl KuconinSwapWs {
                     }
                     Err(err) => {
                         // 连接失败时执行的操作
-                        println!("Can't connect(无法连接): {}", err);
+                        trace!("Can't connect(无法连接): {}", err);
                         // 返回一个默认的 WebSocket 对象或其他适当的值
                         // 或者根据需要触发 panic 或返回错误信息
                     }
                 };
             }
-            println!("退出来咯")
+            trace!("退出来咯")
         }
     }
 
@@ -284,24 +285,24 @@ impl KuconinSwapWs {
 
                     if res_data.code == "-200" {//表示链接成功
                         for sub in &subscription {
-                            println!("--订阅-成功-内容：{:?}", sub);
+                            trace!("--订阅-成功-内容：{:?}", sub);
                             web_socket.write_message(Message::Text(sub.parse().unwrap()))
                                 .unwrap();
                         }
                     } else {
                         //心跳-一定时间间隔发送心跳
                         let get_time = chrono::Utc::now().timestamp_millis();
-                        // println!("--心跳-{}-{}-{}-{}-{}", get_time, ping_interval
+                        // trace!("--心跳-{}-{}-{}-{}-{}", get_time, ping_interval
                         //          , (get_time - ping_interval), self.ws_param.ws_ping_interval, (get_time - ping_interval) >= self.ws_param.ws_ping_interval);
                         if (get_time - ping_interval) >= self.ws_param.ws_ping_interval {
                             web_socket.write_message(Message::Ping(Vec::from("ping")))
                                 .unwrap();
-                            println!("--发送心跳-ping");
+                            trace!("--发送心跳-ping");
                             ping_interval = get_time;
                             ping_timeout = get_time;
                         } else if (get_time - ping_timeout) > (self.ws_param.ws_ping_timeout + self.ws_param.ws_ping_interval) {
                             //心跳超时-发送心跳之后 一定时间没有响应
-                            println!("--心跳相应超时-重连");
+                            trace!("--心跳相应超时-重连");
                             break;
                         }
 
@@ -314,16 +315,16 @@ impl KuconinSwapWs {
                     writeln!(stdout, "回应-pong---{:?}", String::from_utf8(s.clone())).unwrap();
                 }
                 Ok(Message::Pong(s)) => {
-                    // println!("Pong-响应--{:?}", String::from_utf8(s));
+                    // trace!("Pong-响应--{:?}", String::from_utf8(s));
                     writeln!(stdout, "Pong-响应--{:?}", String::from_utf8(s.clone())).unwrap();
                     ping_timeout = chrono::Utc::now().timestamp_millis();
                 }
                 Ok(Message::Close(_)) => {
-                    // println!("socket 关闭: ");
+                    // trace!("socket 关闭: ");
                     writeln!(stdout, "Close-响应").unwrap();
                 }
                 Err(error) => {
-                    // println!("Error receiving message: {}", error);
+                    // trace!("Error receiving message: {}", error);
                     writeln!(stdout, "Err-响应{}", error).unwrap();
                     break;
                 }
@@ -351,24 +352,24 @@ impl KuconinSwapWs {
 
                     if res_data.code == "-200" {//表示链接成功
                         for sub in &subscription {
-                            println!("--订阅-成功-内容：{:?}", sub);
+                            trace!("--订阅-成功-内容：{:?}", sub);
                             web_socket.write_message(Message::Text(sub.parse().unwrap()))
                                 .unwrap();
                         }
                     } else {
                         //心跳-一定时间间隔发送心跳
                         let get_time = chrono::Utc::now().timestamp_millis();
-                        // println!("--心跳-{}-{}-{}-{}-{}", get_time, ping_interval
+                        // trace!("--心跳-{}-{}-{}-{}-{}", get_time, ping_interval
                         //          , (get_time - ping_interval), self.ws_param.ws_ping_interval, (get_time - ping_interval) >= self.ws_param.ws_ping_interval);
                         if (get_time - ping_interval) >= self.ws_param.ws_ping_interval {
                             web_socket.write_message(Message::Ping(Vec::from("ping")))
                                 .unwrap();
-                            println!("--发送心跳-ping");
+                            trace!("--发送心跳-ping");
                             ping_interval = get_time;
                             ping_timeout = get_time;
                         } else if (get_time - ping_timeout) > (self.ws_param.ws_ping_timeout + self.ws_param.ws_ping_interval) {
                             //心跳超时-发送心跳之后 一定时间没有响应
-                            println!("--心跳相应超时-重连");
+                            trace!("--心跳相应超时-重连");
                             break;
                         }
 
@@ -381,16 +382,16 @@ impl KuconinSwapWs {
                     writeln!(stdout, "回应-pong---{:?}", String::from_utf8(s.clone())).unwrap();
                 }
                 Ok(Message::Pong(s)) => {
-                    // println!("Pong-响应--{:?}", String::from_utf8(s));
+                    // trace!("Pong-响应--{:?}", String::from_utf8(s));
                     writeln!(stdout, "Pong-响应--{:?}", String::from_utf8(s.clone())).unwrap();
                     ping_timeout = chrono::Utc::now().timestamp_millis();
                 }
                 Ok(Message::Close(_)) => {
-                    // println!("socket 关闭: ");
+                    // trace!("socket 关闭: ");
                     writeln!(stdout, "Close-响应").unwrap();
                 }
                 Err(error) => {
-                    // println!("Error receiving message: {}", error);
+                    // trace!("Error receiving message: {}", error);
                     writeln!(stdout, "Err-响应{}", error).unwrap();
                     break;
                 }

exchanges/src/okx_swap_ws.rs

@@ -7,6 +7,7 @@ use chrono::Utc;
 use serde_json::{json, Value};
 use ring::hmac;
 use tokio::sync::mpsc::Sender;
+use tracing::trace;
 use crate::{proxy};
 use tungstenite::client::{AutoStream, connect_with_proxy, ProxyAutoStream};
 use tungstenite::{connect, Message, WebSocket};
@@ -67,7 +68,7 @@ impl OkxSwapWs {
     ) -> OkxSwapWs
     {
         if is_colo {
-            println!("不支持高速通道")
+            trace!("不支持高速通道")
         }
 
         /*******走代理：根据环境变量配置来决定,如果配置了走代理，没有配置不走*******/
@@ -159,7 +160,7 @@ impl OkxSwapWs {
             "args": args
         });
 
-        println!("订阅信息：{}", str.to_string());
+        trace!("订阅信息：{}", str.to_string());
 
         str.to_string()
     }
@@ -197,8 +198,8 @@ impl OkxSwapWs {
                                 "sign": sign  }]
                         });
 
-            println!("---login_json：{0}", login_json.to_string());
-            println!("--登陆：{:?}", login_json);
+            trace!("---login_json：{0}", login_json.to_string());
+            trace!("--登陆：{:?}", login_json);
             login_json_str = login_json.to_string();
         }
         login_json_str
@@ -211,7 +212,7 @@ impl OkxSwapWs {
         //订阅信息组装
         let subscription = self.get_subscription();
         loop {
-            println!("要连接咯~~！！{}", self.request_url);
+            trace!("要连接咯~~！！{}", self.request_url);
 
             let request_url = Url::parse(self.request_url.as_str()).unwrap();
             //1. 判断是否需要代理,根据代理地址是否存来选择
@@ -236,7 +237,7 @@ impl OkxSwapWs {
                         self.proxy_subscription(ws.0, subscription.clone()).await;
                     }
                     Err(err) => {
-                        println!("Can't connect(无法连接): {}", err);
+                        trace!("Can't connect(无法连接): {}", err);
                     }
                 };
             } else {
@@ -246,13 +247,13 @@ impl OkxSwapWs {
                     }
                     Err(err) => {
                         // 连接失败时执行的操作
-                        println!("Can't connect(无法连接): {}", err);
+                        trace!("Can't connect(无法连接): {}", err);
                         // 返回一个默认的 WebSocket 对象或其他适当的值
                         // 或者根据需要触发 panic 或返回错误信息
                     }
                 };
             }
-            println!("退出来咯")
+            trace!("退出来咯")
         }
     }
 
@@ -288,15 +289,15 @@ impl OkxSwapWs {
                     writeln!(stdout, "回应-pong---{:?}", String::from_utf8(s.clone())).unwrap();
                 }
                 Ok(Message::Pong(s)) => {
-                    // println!("Pong-响应--{:?}", String::from_utf8(s));
+                    // trace!("Pong-响应--{:?}", String::from_utf8(s));
                     writeln!(stdout, "Pong-响应--{:?}", String::from_utf8(s.clone())).unwrap();
                 }
                 Ok(Message::Close(_)) => {
-                    // println!("socket 关闭: ");
+                    // trace!("socket 关闭: ");
                     writeln!(stdout, "Close-响应").unwrap();
                 }
                 Err(error) => {
-                    // println!("Error receiving message: {}", error);
+                    // trace!("Error receiving message: {}", error);
                     writeln!(stdout, "Err-响应{}", error).unwrap();
                     break;
                 }
@@ -328,16 +329,16 @@ impl OkxSwapWs {
                     }
                 }
                 Ok(Message::Ping(s)) => {
-                    println!("Ping-响应--{:?}", String::from_utf8(s));
+                    trace!("Ping-响应--{:?}", String::from_utf8(s));
                 }
                 Ok(Message::Pong(s)) => {
-                    println!("Pong-响应--{:?}", String::from_utf8(s));
+                    trace!("Pong-响应--{:?}", String::from_utf8(s));
                 }
                 Ok(Message::Close(_)) => {
-                    println!("socket 关闭: ");
+                    trace!("socket 关闭: ");
                 }
                 Err(error) => {
-                    println!("Error receiving message: {}", error);
+                    trace!("Error receiving message: {}", error);
                     break;
                 }
                 _ => {}

exchanges/src/proxy.rs

@@ -19,7 +19,7 @@ impl ParsingDetail {
         // 使用std::env::var函数获取环境变量的值，如果返回Err，则说明环境变量不存在
         match proxy_address {
             Ok(value) => {
-                //println!("环境变量读取成功：key：proxy_address , val：{}", value);
+                //trace!("环境变量读取成功：key：proxy_address , val：{}", value);
                 env::set_var("http_proxy", value.to_string());
                 env::set_var("https_proxy", value.to_string());
 
@@ -28,7 +28,7 @@ impl ParsingDetail {
                 parsing_detail
             }
             Err(_) => {
-                //println!("环境变量读取失败:'proxy_address'");
+                //trace!("环境变量读取失败:'proxy_address'");
                 let parsing_detail = ParsingDetail::new("".to_string(), "".to_string());
                 parsing_detail
             }
@@ -44,10 +44,10 @@ impl ParsingDetail {
             let http_proxy = format!("http://{}:{}", parsing_detail.ip_address, parsing_detail.port);
             env::set_var("http_proxy", http_proxy.clone());
             env::set_var("https_proxy", http_proxy.clone());
-            //println!("代理设置成功{0}", http_proxy.to_string());
+            //trace!("代理设置成功{0}", http_proxy.to_string());
             true
         } else {
-            //println!("无法开启代理：环境变量获取失败：{:?}", parsing_detail);
+            //trace!("无法开启代理：环境变量获取失败：{:?}", parsing_detail);
             false
         }
     }

exchanges/tests/test.rs

@@ -17,14 +17,19 @@ use std::net::{TcpStream, ToSocketAddrs};
 use std::time::Duration;
 use tokio::sync::mpsc::channel;
 use tokio::try_join;
+use tracing::{debug, trace};
+use tracing::field::debug;
 use exchanges::gate_swap_ws::{GateSubscribeType, GateSwapWs, GateWsType};
 
 
 #[tokio::test]
 async fn test_import() {
+    global::log_utils::init_log_with_trace();
+
+
     /*******走代理：根据环境变量配置来决定,如果配置了走代理，没有配置不走*******/
     if proxy::ParsingDetail::http_enable_proxy() {
-        println!("检测有代理配置，配置走代理")
+        trace!("检测有代理配置，配置走代理");
     }
 
     //获取代理
@@ -53,7 +58,7 @@ async fn test_import() {
     //okx - Business 频道
     // demo_ws_okx_bu().await;
     //okx - public 频道
-    demo_ws_okx_pu().await;
+    // demo_ws_okx_pu().await;
 
 
     // demo_so();
@@ -110,7 +115,7 @@ fn demo_so() {
     //
     //   // 检查代理响应是否成功
     //   if !response.contains("200 Connection established") {
-    //       println!("Proxy connection failed: {}", response);
+    //       trace!("Proxy connection failed: {}", response);
     //   }
     //
     //   // 从代理连接中获取原始 TCP 流
@@ -127,9 +132,9 @@ fn demo_so() {
     //
     //           // 将读取的数据转换为字符串并打印
     //           if let Ok(data) = std::str::from_utf8(&buffer[..bytes_read]) {
-    //               println!("Received data: {}", data);
+    //               trace!("Received data: {}", data);
     //           } else {
-    //               println!("Received data contains non-UTF8 characters");
+    //               trace!("Received data contains non-UTF8 characters");
     //           }
     //       }
     //
@@ -186,7 +191,7 @@ async fn demo_ws_kucoin_pr() {
     btree_map.insert("access_key".to_string(), "6393f3565f0d4500011f846b".to_string());
     btree_map.insert("secret_key".to_string(), "9c0df8b7-daaa-493e-a53a-82703067f7dd".to_string());
     btree_map.insert("pass_key".to_string(), "b87d055f".to_string());
-    println!("----------------------btree_map{:?}", btree_map.clone());
+    trace!("----------------------btree_map{:?}", btree_map.clone());
     let (tx, mut rx) = channel(1024);
     let mut ku_ws = KuconinSwapWs::new(false, btree_map.clone(),
                                        KuconinWsType::Private, tx).await;
@@ -237,21 +242,21 @@ async fn demo_rest_kucoin() {
 
     let kucoin_exc = KucoinSwapRest::new(false, btree_map);
     let res_data = kucoin_exc.get_server_time().await;
-    println!("kucoin_exc-rest - get_server_time- {:?}", res_data);
+    trace!("kucoin_exc-rest - get_server_time- {:?}", res_data);
     // let res_data = kucoin_exc.get_account("USDT".to_string()).await;
-    // println!("kucoin_exc-rest - get_account- {:?}", res_data);
+    // trace!("kucoin_exc-rest - get_account- {:?}", res_data);
     // let res_data = kucoin_exc.get_position("XBTUSDM".to_string()).await;
-    // println!("kucoin_exc-rest - get_position- {:?}", res_data);
+    // trace!("kucoin_exc-rest - get_position- {:?}", res_data);
     // let res_data = kucoin_exc.get_market_details().await;
-    // println!("kucoin_exc-rest - get_market_details- {:?}", res_data);
+    // trace!("kucoin_exc-rest - get_market_details- {:?}", res_data);
     // let res_data = kucoin_exc.get_ticker("ROSEUSDTM".to_string()).await;
-    // println!("kucoin_exc-rest - get_ticker- {:?}", res_data);
+    // trace!("kucoin_exc-rest - get_ticker- {:?}", res_data);
     // let res_data = kucoin_exc.get_orders("active".to_string(), "ROSEUSDTM".to_string()).await;
-    // println!("kucoin_exc-rest - get_orders- {:?}", res_data);
+    // trace!("kucoin_exc-rest - get_orders- {:?}", res_data);
     // let res_data = kucoin_exc.get_positions("USDT".to_string()).await;
-    // println!("kucoin_exc-rest - get_positions- {:?}", res_data);
+    // trace!("kucoin_exc-rest - get_positions- {:?}", res_data);
     // let res_data = kucoin_exc.get_orders_details("111".to_string(), "".to_string()).await;
-    // println!("kucoin_exc-rest - get_orders_details- {:?}", res_data);
+    // trace!("kucoin_exc-rest - get_orders_details- {:?}", res_data);
     // let res_data = kucoin_exc.swap_bazaar_order(
     //     "cs_202309111808".to_string(),
     //     "ROSEUSDTM".to_string(),
@@ -261,12 +266,12 @@ async fn demo_rest_kucoin() {
     //     "0.03856".to_string(),
     //     "limit".to_string(),
     // ).await;
-    // println!("kucoin_exc-rest - swap_bazaar_order- {:?}
+    // trace!("kucoin_exc-rest - swap_bazaar_order- {:?}
     // let res_data = kucoin_exc.cancel_order("12312".to_string(), "".to_string()).await;
-    // println!("kucoin_exc-rest - cancel_order- {:?}", res_data);
+    // trace!("kucoin_exc-rest - cancel_order- {:?}", res_data);
 
     // let res_data = kucoin_exc.get_public_token().await;
-    // println!("kucoin_exc-rest - get_public_token- {:?}", res_data);
+    // trace!("kucoin_exc-rest - get_public_token- {:?}", res_data);
 }
 
 async fn demo_rest_gate() {
@@ -276,19 +281,19 @@ async fn demo_rest_gate() {
 
     let gate_exc = GateSwapRest::new(false, btree_map);
     let res_data = gate_exc.get_account("usdt".to_string()).await;
-    println!("gate-rest -账户信息{:?}", res_data);
+    trace!("gate-rest -账户信息{:?}", res_data);
     // let res_data = gate_exc.get_position("usdt".to_string(), "CYBER_USDT".to_string()).await;
-    // println!("gate-rest -持仓信息{:?}", res_data);
+    // trace!("gate-rest -持仓信息{:?}", res_data);
     // let res_data = gate_exc.get_ticker("usdt".to_string()).await;
-    // println!("gate-rest -ticker{:?}", res_data);
+    // trace!("gate-rest -ticker{:?}", res_data);
     // let res_data = gate_exc.get_server_time().await;
-    // println!("gate-rest -get_server_time{:?}", res_data);
+    // trace!("gate-rest -get_server_time{:?}", res_data);
     // let res_data = gate_exc.get_user_position("usdt".to_string()).await;
-    // println!("gate-rest -get_server_time{:?}", res_data);
+    // trace!("gate-rest -get_server_time{:?}", res_data);
     // let res_data = gate_exc.get_order_details("usdt".to_string(), "11335522".to_string()).await;
-    // println!("gate-rest -get_order_details{:?}", res_data);
+    // trace!("gate-rest -get_order_details{:?}", res_data);
     // let res_data = gate_exc.get_orders("usdt".to_string(), "open".to_string()).await;
-    // println!("gate-rest -get_orders{:?}", res_data);
+    // trace!("gate-rest -get_orders{:?}", res_data);
     // let params = serde_json::json!({
     //         "contract":"CYBER_USDT",
     //         "size":-1,
@@ -296,27 +301,27 @@ async fn demo_rest_gate() {
     //         "tif":"ioc",
     //      });
     // let res_data = gate_exc.take_order("usdt".to_string(), params).await;
-    // println!("gate-rest -get_orders{:?}", res_data);
+    // trace!("gate-rest -get_orders{:?}", res_data);
     // let res_data = gate_exc.setting_dual_mode("usdt".to_string(), true).await;
-    // println!("gate-rest -setting_dual_mode{:?}", res_data);
+    // trace!("gate-rest -setting_dual_mode{:?}", res_data);
     // let res_data = gate_exc.setting_dual_leverage("usdt".to_string(),
     //                                               "CYBER_USDT".to_string(),
     //                                               "20".to_string(),
     // ).await;
-    // println!("gate-rest -setting_dual_mode{:?}", res_data);
+    // trace!("gate-rest -setting_dual_mode{:?}", res_data);
     // let res_data = gate_exc.wallet_transfers("usdt".to_string(),
     //                                               "CYBER_USDT".to_string(),
     //                                               "20".to_string(),
     // ).await;
-    // println!("gate-rest -setting_dual_mode{:?}", res_data);
+    // trace!("gate-rest -setting_dual_mode{:?}", res_data);
     // let res_data = gate_exc.cancel_order("usdt".to_string(),
     //                                      "12345".to_string(),
     // ).await;
-    // println!("gate-rest -setting_dual_mode{:?}", res_data);
+    // trace!("gate-rest -setting_dual_mode{:?}", res_data);
     // let res_data = gate_exc.cancel_orders("usdt".to_string(),
     //                                      "CYBER_USDT".to_string(),
     // ).await;
-    // println!("gate-rest -cancel_orders{:?}", res_data);
+    // trace!("gate-rest -cancel_orders{:?}", res_data);
     // let res_data = gate_exc.order(
     //     "usdt".to_string(),
     //     "long".to_string(),
@@ -326,7 +331,7 @@ async fn demo_rest_gate() {
     //     "0.03888".to_string(),
     //     "t-my-custom-id-001".to_string(),
     // ).await;
-    // println!("gate-rest -order{:?}", res_data);
+    // trace!("gate-rest -order{:?}", res_data);
 }
 
 async fn demo_rest_ba() {
@@ -336,7 +341,7 @@ async fn demo_rest_ba() {
 
     let ba_exc = BinanceUsdtSwapRest::new(false, btree_map);
     let res_data = ba_exc.get_account().await;
-    println!("币安-rest-获取账户信息{:?}", res_data);
+    trace!("币安-rest-获取账户信息{:?}", res_data);
 }
 
 async fn demo_pub_ws_ba() {
@@ -365,7 +370,7 @@ async fn demo_pub_ws_ba() {
 fn demo_get_http_proxy() {
     //代理地址
     let parsing_detail = proxy::ParsingDetail::parsing_environment_variables();
-    println!("----代理信息：{:?}", parsing_detail);
+    trace!("----代理信息：{:?}", parsing_detail);
 }
 
 
@@ -387,9 +392,9 @@ fn handle_connection(mut stream: TcpStream) {
         .map(|result| result.unwrap())
         .take_while(|line| !line.is_empty())
         .collect();
-    println!("Request: {:#?}", http_request);
-    println!("Request2: {:#?}", http_request[0]);
-    println!("Request3: {:#?}", http_request[1]);
+    trace!("Request: {:#?}", http_request);
+    trace!("Request2: {:#?}", http_request[0]);
+    trace!("Request3: {:#?}", http_request[1]);
 
     let (status_line, filename) = if http_request[0] == "GET / HTTP/1.1" {
         ("HTTP/1.1 200 OK", "hello.html")