添加获取请求时间方法

standard/src/binance_spot.rs

@@ -50,51 +50,57 @@ impl Platform for BinanceSpot {
 
     fn get_self_market(&self) -> Market { todo!() }
 
-    async fn get_server_time(&self) -> Result<String, Error> {
+    fn get_request_delays(&self) -> Vec<i64> { todo!() }
+
+    fn get_request_avg_delay(&self) -> Decimal { todo!() }
+
+    fn get_request_max_delay(&self) -> i64 { todo!() }
+
+    async fn get_server_time(&mut self) -> Result<String, Error> {
         todo!()
     }
 
     // 获取账号信息
-    async fn get_account(&self) -> Result<Account, Error> { todo!() }
+    async fn get_account(&mut self) -> Result<Account, Error> { todo!() }
     // 获取仓位信息
-    async fn get_position(&self) -> Result<Vec<Position>, Error> {
+    async fn get_position(&mut self) -> Result<Vec<Position>, Error> {
         todo!()
     }
 
-    async fn get_positions(&self) -> Result<Vec<Position>, Error> {
+    async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
         todo!()
     }
 
     // 获取市场行情
-    async fn get_ticker(&self) -> Result<Ticker, Error> {
+    async fn get_ticker(&mut self) -> Result<Ticker, Error> {
         todo!()
     }
 
-    async fn get_market(&self) -> Result<Market, Error> {
+    async fn get_market(&mut self) -> Result<Market, Error> {
         todo!()
     }
 
-    async fn get_order_detail(&self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
+    async fn get_order_detail(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
 
-    async fn get_orders_list(&self, _status: &str) -> Result<Vec<Order>, Error> {
+    async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> {
         todo!()
     }
 
-    async fn set_dual_mode(&self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> { todo!() }
+    async fn set_dual_mode(&mut self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> { todo!() }
 
-    async fn set_dual_leverage(&self, _leverage: &str) -> Result<String, Error> {
+    async fn set_dual_leverage(&mut self, _leverage: &str) -> Result<String, Error> {
         todo!()
     }
 
-    async fn wallet_transfers(&self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> { todo!() }
+    async fn wallet_transfers(&mut self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> { todo!() }
 
-    async fn take_order(&self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { todo!() }
+    async fn take_order(&mut self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { todo!() }
 
-    async fn cancel_order(&self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
+    async fn cancel_order(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
 
-    async fn cancel_orders(&self) -> Result<Vec<Order>, Error> {
+    async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
         todo!()
     }
 
-    async fn command_order(&self, _order_command: OrderCommand) { todo!() }
+    async fn command_order(&mut self, _order_command: OrderCommand) { todo!() }
 }

standard/src/binance_swap.rs

@@ -7,7 +7,7 @@ use rust_decimal::Decimal;
 use rust_decimal_macros::dec;
 use serde_json::json;
 use crate::{Platform, ExchangeEnum, Account, Position, Ticker, Market, Order, OrderCommand};
-use exchanges::binance_usdt_swap_rest::BinanceUsdtSwapRest;
+use exchanges::binance_swap_rest::BinanceSwapRest;
 
 #[allow(dead_code)]
 #[derive(Clone)]
@@ -16,7 +16,7 @@ pub struct BinanceSwap {
     symbol: String,
     is_colo: bool,
     params: BTreeMap<String, String>,
-    request: BinanceUsdtSwapRest,
+    request: BinanceSwapRest,
 }
 
 impl BinanceSwap {
@@ -26,7 +26,7 @@ impl BinanceSwap {
             symbol,
             is_colo,
             params: params.clone(),
-            request: BinanceUsdtSwapRest::new(is_colo, params.clone()),
+            request: BinanceSwapRest::new(is_colo, params.clone()),
         }
     }
 }
@@ -51,13 +51,18 @@ impl Platform for BinanceSwap {
     }
     // 获取market信息
     fn get_self_market(&self) -> Market { todo!() }
-
+    // 获取请求时间
+    fn get_request_delays(&self) -> Vec<i64> { self.request.get_delays() }
+    // 获取请求平均时间
+    fn get_request_avg_delay(&self) -> Decimal { self.request.get_avg_delay()}
+    // 获取请求最大时间
+    fn get_request_max_delay(&self) -> i64 { self.request.get_max_delay() }
     // 获取服务器时间
-    async fn get_server_time(&self) -> Result<String, Error> {
+    async fn get_server_time(&mut self) -> Result<String, Error> {
         todo!()
     }
     // 获取账号信息
-    async fn get_account(&self) -> Result<Account, Error> {
+    async fn get_account(&mut self) -> Result<Account, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_account().await;
         if res_data.code == "200" {
@@ -83,77 +88,42 @@ impl Platform for BinanceSwap {
         }
     }
     // 获取仓位信息
-    async fn get_position(&self) -> Result<Vec<Position>, Error> {
+    async fn get_position(&mut self) -> Result<Vec<Position>, Error> {
         todo!()
     }
 
-    async fn get_positions(&self) -> Result<Vec<Position>, Error> {
+    async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
         todo!()
     }
 
     // 获取市场行情
-    async fn get_ticker(&self) -> Result<Ticker, Error> {
+    async fn get_ticker(&mut self) -> Result<Ticker, Error> {
         todo!()
     }
 
-    async fn get_market(&self) -> Result<Market, Error> { todo!() }
+    async fn get_market(&mut self) -> Result<Market, Error> { todo!() }
 
-    async fn get_order_detail(&self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
+    async fn get_order_detail(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
 
-    async fn get_orders_list(&self, _status: &str) -> Result<Vec<Order>, Error> {
+    async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> {
         todo!()
     }
 
-    async fn set_dual_mode(&self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> { todo!() }
+    async fn set_dual_mode(&mut self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> { todo!() }
 
-    async fn set_dual_leverage(&self, _leverage: &str) -> Result<String, Error> {
+    async fn set_dual_leverage(&mut self, _leverage: &str) -> Result<String, Error> {
         todo!()
     }
 
-    async fn wallet_transfers(&self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> { todo!() }
+    async fn wallet_transfers(&mut self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> { todo!() }
 
-    async fn take_order(&self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { todo!() }
+    async fn take_order(&mut self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { todo!() }
 
-    async fn cancel_order(&self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
+    async fn cancel_order(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
 
-    async fn cancel_orders(&self) -> Result<Vec<Order>, Error> {
+    async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
         todo!()
     }
 
-    async fn command_order(&self, _order_command: OrderCommand) { todo!() }
-
-    // 订阅深度信息
-    // fn subscribe_depth(&self, symbol: &str) {
-    //     let symbol_format = &utils::format_symbol(symbol, "");
-    //     let get_res_data = move |res_data: ResponseData| {
-    //         async move {
-    //             if res_data.code == "200" && res_data.channel == "depth" {
-    //                 let res_data_str = res_data.data;
-    //                 let res_data_json: serde_json::Value = serde_json::from_str(&*res_data_str).unwrap();
-    //                 let mut depth_asks: Vec<MarketOrder> = parse_depth_items(&res_data_json["asks"]);
-    //                 let mut depth_bids: Vec<MarketOrder> = parse_depth_items(&res_data_json["bids"]);
-    //                 depth_asks.sort_by(|a, b| a.price.partial_cmp(&b.price).unwrap_or(Ordering::Equal));
-    //                 depth_bids.sort_by(|a, b| b.price.partial_cmp(&a.price).unwrap_or(Ordering::Equal));
-    //                 let result = Depth {
-    //                     time: 123456,
-    //                     asks: depth_asks,
-    //                     bids: depth_bids,
-    //                 };
-    //                 println!("subscribe_depth: {:?}", result);
-    //             }
-    //         }
-    //     };
-    //     self.wss.custom_subscribe(vec![symbol_format], 0, 0, get_res_data)
-    // }
+    async fn command_order(&mut self, _order_command: OrderCommand) { todo!() }
 }
-
-// fn parse_depth_items(value: &serde_json::Value) -> Vec<MarketOrder> {
-//     let mut depth_items: Vec<MarketOrder> = vec![];
-//     for value in value.as_array().unwrap() {
-//         depth_items.push(MarketOrder {
-//             price: value[0].as_str().unwrap_or("0").parse().unwrap_or(dec!(0)),
-//             amount: value[1].as_str().unwrap_or("0").parse().unwrap_or(dec!(0)),
-//         })
-//     }
-//     return depth_items;
-// }

standard/src/gate_spot.rs

@@ -48,53 +48,59 @@ impl Platform for GateSpot {
 
     fn get_self_market(&self) -> Market { todo!() }
 
-    async fn get_server_time(&self) -> Result<String, Error> {
+    fn get_request_delays(&self) -> Vec<i64> { todo!() }
+
+    fn get_request_avg_delay(&self) -> Decimal { todo!() }
+
+    fn get_request_max_delay(&self) -> i64 { todo!() }
+
+    async fn get_server_time(&mut self) -> Result<String, Error> {
         todo!()
     }
 
     // 获取账号信息
-    async fn get_account(&self) -> Result<Account, Error> {
+    async fn get_account(&mut self) -> Result<Account, Error> {
         todo!()
     }
     // 获取仓位信息
-    async fn get_position(&self) -> Result<Vec<Position>, Error> {
+    async fn get_position(&mut self) -> Result<Vec<Position>, Error> {
         todo!()
     }
 
-    async fn get_positions(&self) -> Result<Vec<Position>, Error> {
+    async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
         todo!()
     }
 
     // 获取市场行情
-    async fn get_ticker(&self) -> Result<Ticker, Error> {
+    async fn get_ticker(&mut self) -> Result<Ticker, Error> {
         todo!()
     }
 
-    async fn get_market(&self) -> Result<Market, Error> {
+    async fn get_market(&mut self) -> Result<Market, Error> {
         todo!()
     }
 
-    async fn get_order_detail(&self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
+    async fn get_order_detail(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
 
-    async fn get_orders_list(&self, _status: &str) -> Result<Vec<Order>, Error> {
+    async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> {
         todo!()
     }
 
-    async fn set_dual_mode(&self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> { todo!() }
+    async fn set_dual_mode(&mut self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> { todo!() }
 
-    async fn set_dual_leverage(&self, _leverage: &str) -> Result<String, Error> {
+    async fn set_dual_leverage(&mut self, _leverage: &str) -> Result<String, Error> {
         todo!()
     }
 
-    async fn wallet_transfers(&self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> { todo!() }
+    async fn wallet_transfers(&mut self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> { todo!() }
 
-    async fn take_order(&self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { todo!() }
+    async fn take_order(&mut self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { todo!() }
 
-    async fn cancel_order(&self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
+    async fn cancel_order(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
 
-    async fn cancel_orders(&self) -> Result<Vec<Order>, Error> {
+    async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
         todo!()
     }
 
-    async fn command_order(&self, _order_command: OrderCommand) { todo!() }
+    async fn command_order(&mut self, _order_command: OrderCommand) { todo!() }
 }

standard/src/gate_swap.rs

@@ -9,6 +9,7 @@ use rust_decimal_macros::dec;
 use serde_json::{json};
 use futures::stream::FuturesUnordered;
 use futures::{TryStreamExt};
+use tracing::error;
 use crate::{Platform, ExchangeEnum, Account, Position, PositionModeEnum, Ticker, Market, Order, OrderCommand};
 use exchanges::gate_swap_rest::GateSwapRest;
 
@@ -38,7 +39,7 @@ impl GateSwap {
             order_sender,
             error_sender,
         };
-        gate_swap.market = GateSwap::get_market(&gate_swap).await.unwrap_or(gate_swap.market);
+        gate_swap.market = GateSwap::get_market(&mut gate_swap).await.unwrap_or(gate_swap.market);
         return gate_swap;
     }
 }
@@ -63,9 +64,15 @@ impl Platform for GateSwap {
     }
     // 获取market信息
     fn get_self_market(&self) -> Market { self.market.clone() }
+    // 获取请求时间
+    fn get_request_delays(&self) -> Vec<i64> { self.request.get_delays() }
+    // 获取请求平均时间
+    fn get_request_avg_delay(&self) -> Decimal { self.request.get_avg_delay()}
+    // 获取请求最大时间
+    fn get_request_max_delay(&self) -> i64 { self.request.get_max_delay() }
 
     // 获取服务器时间
-    async fn get_server_time(&self) -> Result<String, Error> {
+    async fn get_server_time(&mut self) -> Result<String, Error> {
         let res_data = self.request.get_server_time().await;
         if res_data.code == "200" {
             let res_data_str = &res_data.data;
@@ -76,12 +83,11 @@ impl Platform for GateSwap {
         }
     }
     // 获取账号信息
-    async fn get_account(&self) -> Result<Account, Error> {
+    async fn get_account(&mut self) -> Result<Account, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_account(symbol_array[1].to_string().to_lowercase()).await;
         if res_data.code == "200" {
             let res_data_str = &res_data.data;
-            println!("{}", res_data_str);
             let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
             let balance = res_data_json["total"].as_str().unwrap().parse().unwrap_or(dec!(0.0));
             let available_balance = res_data_json["available"].as_str().unwrap().parse().unwrap_or(dec!(0.0));
@@ -100,7 +106,7 @@ impl Platform for GateSwap {
         }
     }
     // 获取持仓信息
-    async fn get_position(&self) -> Result<Vec<Position>, Error> {
+    async fn get_position(&mut self) -> Result<Vec<Position>, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let amount_size = self.market.amount_size;
         let res_data = self.request.get_position(symbol_array[1].to_string().to_lowercase(), self.symbol.clone()).await;
@@ -114,7 +120,7 @@ impl Platform for GateSwap {
         }
     }
     // 获取所有持仓
-    async fn get_positions(&self) -> Result<Vec<Position>, Error> {
+    async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let amount_size = self.market.amount_size;
         let res_data = self.request.get_user_position(symbol_array[1].to_string().to_lowercase()).await;
@@ -128,7 +134,7 @@ impl Platform for GateSwap {
         }
     }
     // 获取市场行情
-    async fn get_ticker(&self) -> Result<Ticker, Error> {
+    async fn get_ticker(&mut self) -> Result<Ticker, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_ticker(symbol_array[1].to_string().to_lowercase()).await;
         if res_data.code == "200" {
@@ -151,7 +157,7 @@ impl Platform for GateSwap {
         }
     }
 
-    async fn get_market(&self) -> Result<Market, Error> {
+    async fn get_market(&mut self) -> Result<Market, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_market_details(symbol_array[1].to_string().to_lowercase()).await;
         if res_data.code == "200" {
@@ -184,7 +190,7 @@ impl Platform for GateSwap {
         }
     }
     // 获取订单详情
-    async fn get_order_detail(&self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
+    async fn get_order_detail(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let amount_size = self.market.amount_size;
         let id = if order_id.eq("") { format!("t-my-custom-id_{}", custom_id) } else { order_id.to_string() };
@@ -199,7 +205,7 @@ impl Platform for GateSwap {
         }
     }
     // 获取订单列表
-    async fn get_orders_list(&self, status: &str) -> Result<Vec<Order>, Error> {
+    async fn get_orders_list(&mut self, status: &str) -> Result<Vec<Order>, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let amount_size = self.market.amount_size;
         let res_data = self.request.get_orders(symbol_array[1].to_string().to_lowercase(), status.to_string()).await;
@@ -214,7 +220,7 @@ impl Platform for GateSwap {
         }
     }
     // 设置持仓模式
-    async fn set_dual_mode(&self, coin: &str, is_dual_mode: bool) -> Result<String, Error> {
+    async fn set_dual_mode(&mut self, coin: &str, is_dual_mode: bool) -> Result<String, Error> {
         let coin_format = coin.to_string().to_lowercase();
         let res_data = self.request.setting_dual_mode(coin_format, is_dual_mode).await;
         if res_data.code == "200" {
@@ -226,7 +232,7 @@ impl Platform for GateSwap {
         }
     }
     // 更新双持仓模式下杠杆
-    async fn set_dual_leverage(&self, leverage: &str) -> Result<String, Error> {
+    async fn set_dual_leverage(&mut self, leverage: &str) -> Result<String, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.setting_dual_leverage(symbol_array[1].to_string().to_lowercase(), self.symbol.to_string(), leverage.to_string()).await;
         if res_data.code == "200" {
@@ -238,7 +244,7 @@ impl Platform for GateSwap {
         }
     }
     // 交易账户互转
-    async fn wallet_transfers(&self, coin: &str, from: &str, to: &str, amount: Decimal) -> Result<String, Error> {
+    async fn wallet_transfers(&mut self, coin: &str, from: &str, to: &str, amount: Decimal) -> Result<String, Error> {
         let coin_format = coin.to_string().to_lowercase();
         let res_data = self.request.wallet_transfers(coin_format.clone(), from.to_string(), to.to_string(), amount.to_string(), coin_format.clone()).await;
         if res_data.code == "200" {
@@ -250,7 +256,7 @@ impl Platform for GateSwap {
         }
     }
     // 下单接口
-    async fn take_order(&self, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
+    async fn take_order(&mut self, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let amount_size = self.market.amount_size;
         let mut params = json!({
@@ -279,21 +285,20 @@ impl Platform for GateSwap {
                 params["reduce_only"] = json!(true);
                 params["size"] = json!(size.to_i64());
             }
-            _ => { println!("下单参数错误"); }
+            _ => { error!("下单参数错误"); }
         };
         let res_data = self.request.swap_order(symbol_array[1].to_string().to_lowercase(), params).await;
         if res_data.code == "200" {
             let res_data_str = &res_data.data;
             let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
             let result = parse_order_item(&res_data_json, amount_size);
-            println!("{:?}", result);
             Ok(result)
         } else {
             Err(Error::new(ErrorKind::Other, res_data.message))
         }
     }
     // 撤销订单
-    async fn cancel_order(&self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
+    async fn cancel_order(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let amount_size = self.market.amount_size;
         let settle = symbol_array[1].to_string().to_lowercase();
@@ -303,15 +308,13 @@ impl Platform for GateSwap {
             let res_data_str = &res_data.data;
             let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
             let result = parse_order_item(&res_data_json, amount_size);
-
-            println!("{:?}", result);
             Ok(result)
         } else {
             Err(Error::new(ErrorKind::Other, res_data.message))
         }
     }
     // 批量撤销订单
-    async fn cancel_orders(&self) -> Result<Vec<Order>, Error> {
+    async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let amount_size = self.market.tick_size;
         let res_data = self.request.cancel_orders(symbol_array[1].to_string().to_lowercase(), self.symbol.to_string()).await;
@@ -325,12 +328,12 @@ impl Platform for GateSwap {
         }
     }
     // 指令下单
-    async fn command_order(&self, order_command: OrderCommand) {
+    async fn command_order(&mut self, order_command: OrderCommand) {
         let mut handles = vec![];
         // 撤销订单
         let cancel = order_command.cancel;
         for item in cancel.keys() {
-            let self_clone = self.clone();
+            let mut self_clone = self.clone();
             let cancel_clone = cancel.clone();
             let item_clone = item.clone();
             let order_id = cancel_clone[&item_clone].get(1).unwrap_or(&"".to_string()).clone();
@@ -355,7 +358,7 @@ impl Platform for GateSwap {
         limits.extend(order_command.limits_open);
         limits.extend(order_command.limits_close);
         for item in limits.keys() {
-            let self_clone = self.clone();
+            let mut self_clone = self.clone();
             let limits_clone = limits.clone();
             let item_clone = item.clone();
             let result_sd = self.order_sender.clone();
@@ -383,7 +386,7 @@ impl Platform for GateSwap {
         // 检查订单指令
         let check = order_command.check;
         for item in check.keys() {
-            let self_clone = self.clone();
+            let mut self_clone = self.clone();
             let check_clone = check.clone();
             let item_clone = item.clone();
             let order_id = check_clone[&item_clone].get(1).unwrap_or(&"".to_string()).clone();

standard/src/kucoin_swap.rs

@@ -9,6 +9,7 @@ use rust_decimal::Decimal;
 use rust_decimal::prelude::ToPrimitive;
 use rust_decimal_macros::dec;
 use serde_json::{json};
+use tracing::{debug, error};
 use exchanges::kucoin_swap_rest::KucoinSwapRest;
 use crate::exchange::ExchangeEnum;
 use crate::{Account, Market, Order, OrderCommand, Platform, Position, PositionModeEnum, Ticker, utils};
@@ -39,7 +40,7 @@ impl KucoinSwap {
             order_sender,
             error_sender,
         };
-        kucoin_swap.market = KucoinSwap::get_market(&kucoin_swap).await.unwrap_or(kucoin_swap.market);
+        kucoin_swap.market = KucoinSwap::get_market(&mut kucoin_swap).await.unwrap_or(kucoin_swap.market);
         return kucoin_swap;
     }
 }
@@ -63,8 +64,14 @@ impl Platform for KucoinSwap {
     }
     // 获取market信息
     fn get_self_market(&self) -> Market { self.market.clone() }
+    // 获取请求时间
+    fn get_request_delays(&self) -> Vec<i64> { self.request.get_delays() }
+    // 获取请求平均时间
+    fn get_request_avg_delay(&self) -> Decimal { self.request.get_avg_delay()}
+    // 获取请求最大时间
+    fn get_request_max_delay(&self) -> i64 { self.request.get_max_delay() }
     // 获取服务器时间
-    async fn get_server_time(&self) -> Result<String, Error> {
+    async fn get_server_time(&mut self) -> Result<String, Error> {
         let res_data = self.request.get_server_time().await;
         if res_data.code == "200" {
             let res_data_str = &res_data.data;
@@ -75,7 +82,7 @@ impl Platform for KucoinSwap {
         }
     }
     // 获取账号信息
-    async fn get_account(&self) -> Result<Account, Error> {
+    async fn get_account(&mut self) -> Result<Account, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_account(symbol_array[1].to_string()).await;
         if res_data.code == "200" {
@@ -98,7 +105,7 @@ impl Platform for KucoinSwap {
         }
     }
 
-    async fn get_position(&self) -> Result<Vec<Position>, Error> {
+    async fn get_position(&mut self) -> Result<Vec<Position>, Error> {
         let symbol_format = format!("{}M", utils::format_symbol(self.symbol.clone(), ""));
         let amount_size = self.market.amount_size;
         let res_data = self.request.get_position(symbol_format).await;
@@ -112,7 +119,7 @@ impl Platform for KucoinSwap {
         }
     }
 
-    async fn get_positions(&self) -> Result<Vec<Position>, Error> {
+    async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let amount_size = self.market.amount_size;
         let res_data = self.request.get_positions(symbol_array[1].to_string().to_uppercase()).await;
@@ -126,7 +133,7 @@ impl Platform for KucoinSwap {
         }
     }
 
-    async fn get_ticker(&self) -> Result<Ticker, Error> {
+    async fn get_ticker(&mut self) -> Result<Ticker, Error> {
         let symbol_format = format!("{}M", utils::format_symbol(self.symbol.clone(), ""));
         let res_data = self.request.get_ticker(symbol_format).await;
         if res_data.code == "200" {
@@ -149,7 +156,7 @@ impl Platform for KucoinSwap {
         }
     }
 
-    async fn get_market(&self) -> Result<Market, Error> {
+    async fn get_market(&mut self) -> Result<Market, Error> {
         let symbol_format = format!("{}M", utils::format_symbol(self.symbol.clone(), ""));
         let res_data = self.request.get_market_details().await;
         if res_data.code == "200" {
@@ -157,7 +164,7 @@ impl Platform for KucoinSwap {
             let res_data_json: Vec<serde_json::Value> = serde_json::from_str(res_data_str).unwrap();
             let default_info = json!({});
             let market_info = res_data_json.iter().find(|item| item["symbol"].as_str().unwrap() == symbol_format).unwrap_or(&default_info);
-            println!("{}", market_info);
+            debug!("{}", market_info);
 
             let result = Market {
                 symbol: self.symbol.clone(),
@@ -179,13 +186,12 @@ impl Platform for KucoinSwap {
         }
     }
 
-    async fn get_order_detail(&self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
+    async fn get_order_detail(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
         let amount_size = self.market.amount_size;
         let res_data = self.request.get_orders_details(order_id.to_string(), custom_id.to_string()).await;
         if res_data.code == "200" {
             let res_data_str = &res_data.data;
             let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
-            println!("{}", res_data_json);
             let result = parse_order_item(&res_data_json, amount_size);
             Ok(result)
         } else {
@@ -193,7 +199,7 @@ impl Platform for KucoinSwap {
         }
     }
 
-    async fn get_orders_list(&self, status: &str) -> Result<Vec<Order>, Error> {
+    async fn get_orders_list(&mut self, status: &str) -> Result<Vec<Order>, Error> {
         let symbol_format = format!("{}M", utils::format_symbol(self.symbol.clone(), ""));
         let amount_size = self.market.amount_size;
         let res_data = self.request.get_orders(status.to_string(), symbol_format).await;
@@ -208,19 +214,19 @@ impl Platform for KucoinSwap {
         }
     }
 
-    async fn set_dual_mode(&self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> {
+    async fn set_dual_mode(&mut self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> {
         todo!()
     }
 
-    async fn set_dual_leverage(&self, _leverage: &str) -> Result<String, Error> {
+    async fn set_dual_leverage(&mut self, _leverage: &str) -> Result<String, Error> {
         todo!()
     }
 
-    async fn wallet_transfers(&self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> {
+    async fn wallet_transfers(&mut self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> {
         todo!()
     }
 
-    async fn take_order(&self, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
+    async fn take_order(&mut self, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
         let symbol_format = format!("{}M", utils::format_symbol(self.symbol.clone(), ""));
         let amount_size = self.market.amount_size;
         let mut params = json!({
@@ -244,7 +250,7 @@ impl Platform for KucoinSwap {
             "pk" => {
                 params["side"] = json!("buy");
             }
-            _ => { println!("下单参数错误"); }
+            _ => { error!("下单参数错误"); }
         };
 
         let res_data = self.request.swap_order(Default::default()).await;
@@ -258,7 +264,7 @@ impl Platform for KucoinSwap {
         }
     }
 
-    async fn cancel_order(&self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
+    async fn cancel_order(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
         let amount_size = self.market.amount_size;
         let res_data = self.request.cancel_order(order_id.to_string(), custom_id.to_string()).await;
         if res_data.code == "200" {
@@ -271,17 +277,17 @@ impl Platform for KucoinSwap {
         }
     }
 
-    async fn cancel_orders(&self) -> Result<Vec<Order>, Error> {
+    async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
         todo!()
     }
 
     // 指令下单
-    async fn command_order(&self, order_command: OrderCommand) {
+    async fn command_order(&mut self, order_command: OrderCommand) {
         let mut handles = vec![];
         // 撤销订单
         let cancel = order_command.cancel;
         for item in cancel.keys() {
-            let self_clone = self.clone();
+            let mut self_clone = self.clone();
             let cancel_clone = cancel.clone();
             let item_clone = item.clone();
             let order_id = cancel_clone[&item_clone].get(1).unwrap_or(&"".to_string()).clone();
@@ -306,7 +312,7 @@ impl Platform for KucoinSwap {
         limits.extend(order_command.limits_open);
         limits.extend(order_command.limits_close);
         for item in limits.keys() {
-            let self_clone = self.clone();
+            let mut self_clone = self.clone();
             let limits_clone = limits.clone();
             let item_clone = item.clone();
             let result_sd = self.order_sender.clone();
@@ -334,7 +340,7 @@ impl Platform for KucoinSwap {
         // 检查订单指令
         let check = order_command.check;
         for item in check.keys() {
-            let self_clone = self.clone();
+            let mut self_clone = self.clone();
             let check_clone = check.clone();
             let item_clone = item.clone();
             let order_id = check_clone[&item_clone].get(1).unwrap_or(&"".to_string()).clone();

standard/src/lib.rs

@@ -373,34 +373,40 @@ pub trait Platform {
     fn get_self_params(&self) -> BTreeMap<String, String>;
     // 获取market信息
     fn get_self_market(&self) -> Market;
+    // 获取请求时间
+    fn get_request_delays(&self) -> Vec<i64>;
+    // 获取请求平均时间
+    fn get_request_avg_delay(&self) -> Decimal;
+    // 获取请求最大时间
+    fn get_request_max_delay(&self) -> i64;
     // 获取服务器时间
-    async fn get_server_time(&self) -> Result<String, Error>;
+    async fn get_server_time(&mut self) -> Result<String, Error>;
     // 获取账号信息
-    async fn get_account(&self) -> Result<Account, Error>;
+    async fn get_account(&mut self) -> Result<Account, Error>;
     // 获取持仓信息
-    async fn get_position(&self) -> Result<Vec<Position>, Error>;
+    async fn get_position(&mut self) -> Result<Vec<Position>, Error>;
     // 获取所有持仓
-    async fn get_positions(&self) -> Result<Vec<Position>, Error>;
+    async fn get_positions(&mut self) -> Result<Vec<Position>, Error>;
     // 获取市场行情
-    async fn get_ticker(&self) -> Result<Ticker, Error>;
+    async fn get_ticker(&mut self) -> Result<Ticker, Error>;
     // 查询所有的合约信息
-    async fn get_market(&self) -> Result<Market, Error>;
+    async fn get_market(&mut self) -> Result<Market, Error>;
     // 查询订单详情
-    async fn get_order_detail(&self, order_id: &str, custom_id: &str) -> Result<Order, Error>;
+    async fn get_order_detail(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error>;
     // 获取订单列表
-    async fn get_orders_list(&self, status: &str) -> Result<Vec<Order>, Error>;
+    async fn get_orders_list(&mut self, status: &str) -> Result<Vec<Order>, Error>;
     // 设置持仓模式
-    async fn set_dual_mode(&self, coin: &str, is_dual_mode: bool) -> Result<String, Error>;
+    async fn set_dual_mode(&mut self, coin: &str, is_dual_mode: bool) -> Result<String, Error>;
     // 更新双持仓模式下杠杆
-    async fn set_dual_leverage(&self, leverage: &str) -> Result<String, Error>;
+    async fn set_dual_leverage(&mut self, leverage: &str) -> Result<String, Error>;
     // 交易账户互转
-    async fn wallet_transfers(&self, coin: &str, from: &str, to: &str, amount: Decimal) -> Result<String, Error>;
+    async fn wallet_transfers(&mut self, coin: &str, from: &str, to: &str, amount: Decimal) -> Result<String, Error>;
     // 下单接口
-    async fn take_order(&self, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error>;
+    async fn take_order(&mut self, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error>;
     // 撤销订单
-    async fn cancel_order(&self, order_id: &str, custom_id: &str) -> Result<Order, Error>;
+    async fn cancel_order(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error>;
     // 批量撤销订单
-    async fn cancel_orders(&self) -> Result<Vec<Order>, Error>;
+    async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error>;
     // 指令下单
-    async fn command_order(&self, order_command: OrderCommand);
+    async fn command_order(&mut self, order_command: OrderCommand);
 }

standard/tests/libs_test.rs

@@ -74,11 +74,12 @@ async fn test_binance_swap_account() {
     let self_params = binance_swap_exchange.get_self_params();
     trace!(?self_exchange);
     trace!(?self_is_colo);
-    trace!(?self_params);
+    trace!("self_params={:?}",self_params);
 }
 
 // 测试获取Binance交易所现货实体
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_binance_spot_account() {
     global::log_utils::init_log_with_trace();
 
@@ -88,7 +89,7 @@ async fn test_binance_spot_account() {
     let self_params = binance_spot_exchange.get_self_params();
     trace!(?self_exchange);
     trace!(?self_is_colo);
-    trace!(?self_params);
+    trace!("self_params={:?}",self_params);
 }
 
 // 测试获取Gate交易所期货实体
@@ -104,146 +105,237 @@ async fn test_gate_swap_account() {
     let self_market = gate_swap_exchange.get_self_market();
     trace!(?self_exchange);
     trace!(?self_is_colo);
-    trace!(?self_params);
+    trace!("self_params={:?}",self_params);
     trace!(?self_market);
 }
 
 // 测试获取Gate交易所现货实体
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_gate_spot_account() {
+    global::log_utils::init_log_with_trace();
+
     let gate_spot_exchange = test_new_exchange(ExchangeEnum::GateSpot).await;
-    println!("exchange: {:?}", gate_spot_exchange.get_self_exchange());
-    println!("is_colo: {:?}", gate_spot_exchange.get_self_is_colo());
-    println!("params: {:?}", gate_spot_exchange.get_self_params());
+    let self_exchange = gate_spot_exchange.get_self_exchange();
+    let self_is_colo = gate_spot_exchange.get_self_is_colo();
+    trace!(?self_exchange);
+    trace!(?self_is_colo);
 }
 
 // 测试获取Gate交易所现货实体
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_kucoin_swap_account() {
+    global::log_utils::init_log_with_trace();
+
     let kucoin_swap_exchange = test_new_exchange(ExchangeEnum::KucoinSwap).await;
-    println!("exchange: {:?}", kucoin_swap_exchange.get_self_exchange());
-    println!("is_colo: {:?}", kucoin_swap_exchange.get_self_is_colo());
-    println!("params: {:?}", kucoin_swap_exchange.get_self_params());
+    let self_exchange = kucoin_swap_exchange.get_self_exchange();
+    let self_is_colo = kucoin_swap_exchange.get_self_is_colo();
+    let self_params = kucoin_swap_exchange.get_self_params();
+    trace!(?self_exchange);
+    trace!(?self_is_colo);
+    trace!("self_params={:?}",self_params);
 }
 
 // 测试币对连接符号替换
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_replace_symbol() {
-    println!("test_replace_symbol: {}", utils::format_symbol("BTC_USDT".to_string(), "-"))
+    global::log_utils::init_log_with_trace();
+
+    let format_symbol = utils::format_symbol("BTC_USDT".to_string(), "-");
+    trace!(?format_symbol);
 }
 
 // 测试Binance期货K线推送
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_get_account() {
-    let binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap).await;
-    println!("binance_swap account:{:?}", binance_swap_exchange.get_account().await);
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
-    println!("gate_swap account:{:?}", gate_swap_exchange.get_account().await);
-    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
-    println!("kucoin_swap account:{:?}", kucoin_swap_exchange.get_account().await);
+    global::log_utils::init_log_with_trace();
+
+    let mut binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap).await;
+    let binance_account = binance_swap_exchange.get_account().await;
+    trace!(?binance_account);
+    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
+    let gate_account = gate_swap_exchange.get_account().await;
+    trace!(?gate_account);
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
+    let kucoin_account = kucoin_swap_exchange.get_account().await;
+    trace!(?kucoin_account);
 }
 
 // 测试Gate 获取持仓信息
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_gate_swap_get_position() {
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
-    println!("gate_swap get_position:{:?}", gate_swap_exchange.get_position().await);
+    global::log_utils::init_log_with_trace();
+
+    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
+    let gate_get_position = gate_swap_exchange.get_position().await;
+    trace!(?gate_get_position);
 }
 
 // 测试Gate 获取所有持仓信息
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_gate_swap_get_positions() {
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
-    println!("gate_swap get_positions:{:?}", gate_swap_exchange.get_positions().await);
+    global::log_utils::init_log_with_trace();
+
+    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
+    let gate_get_positions = gate_swap_exchange.get_positions().await;
+    trace!(?gate_get_positions);
 }
 
 // 测试Gate获取Ticker信息
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_gate_swap_get_ticker() {
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
-    println!("gate_swap get_ticker:{:?}", gate_swap_exchange.get_ticker().await);
+    global::log_utils::init_log_with_trace();
+
+    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
+    let gate_get_ticker = gate_swap_exchange.get_ticker().await;
+    trace!(?gate_get_ticker);
 }
 
 // 测试Gate获取Market信息
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_gate_swap_get_market() {
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
-    println!("gate_swap get_market:{:?}", gate_swap_exchange.get_market().await);
+    global::log_utils::init_log_with_trace();
+
+    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
+    let gate_get_market = gate_swap_exchange.get_market().await;
+    trace!(?gate_get_market);
 }
 
 // 测试Gate获取Order详情信息
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_gate_swap_get_order_detail() {
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
-    println!("gate_swap get_order_detail:{:?}", gate_swap_exchange.get_order_detail("336321097375", "").await);
+    global::log_utils::init_log_with_trace();
+
+    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
+    let gate_get_order_detail = gate_swap_exchange.get_order_detail("336321097375", "").await;
+    trace!(?gate_get_order_detail);
 }
 
 // 测试Gate获取Order列表信息
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_gate_swap_get_orders_list() {
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
-    println!("gate_swap get_orders_list:{:?}", gate_swap_exchange.get_orders_list("finished").await);
+    global::log_utils::init_log_with_trace();
+
+    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
+    let gate_get_orders_list = gate_swap_exchange.get_orders_list("finished").await;
+    trace!(?gate_get_orders_list);
 }
 
 // 测试Gate 设置持仓模式
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_set_dual_mode() {
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
-    println!("gate_swap set_dual_mode:{:?}", gate_swap_exchange.set_dual_mode("usdt", true).await);
+    global::log_utils::init_log_with_trace();
+
+    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
+    let gate_set_dual_mode = gate_swap_exchange.set_dual_mode("usdt", true).await;
+    trace!(?gate_set_dual_mode);
 }
 
 // 测试Gate 设置持仓模式
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_set_dual_leverage() {
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
-    println!("gate_swap set_dual_leverage:{:?}", gate_swap_exchange.set_dual_leverage("10").await);
+    global::log_utils::init_log_with_trace();
+
+    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
+    let gate_set_dual_leverage = gate_swap_exchange.set_dual_leverage("10").await;
+    trace!(?gate_set_dual_leverage);
 }
 
 // 测试Gate 测试下单
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_take_order() {
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
-    println!("gate_swap take_order:{:?}", gate_swap_exchange.take_order("123", "kd", dec!(25000), dec!(0.0001)).await);
+    global::log_utils::init_log_with_trace();
+
+    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
+    let gate_take_order = gate_swap_exchange.take_order("123", "kd", dec!(25000), dec!(0.0001)).await;
+    trace!(?gate_take_order);
 }
 
 // 测试Gate 撤销订单
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_cancel_order() {
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
-    println!("gate_swap cancel_order:{:?}", gate_swap_exchange.cancel_order("", "123").await);
+    global::log_utils::init_log_with_trace();
+
+    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap).await;
+    let gate_cancel_order = gate_swap_exchange.cancel_order("", "123").await;
+    trace!(?gate_cancel_order);
 }
 
 // 测试kucoin 获取持仓信息
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_kucoin_swap_get_position() {
-    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
-    println!("kucoin_swap get_position:{:?}", kucoin_swap_exchange.get_position().await);
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
+    let kucoin_get_position = kucoin_swap_exchange.get_position().await;
+    trace!(?kucoin_get_position);
 }
 
 // 测试kucoin 获取所有持仓信息
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_kucoin_swap_get_positions() {
-    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
-    println!("kucoin_swap get_positions:{:?}", kucoin_swap_exchange.get_positions().await);
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
+    let kucoin_get_positions = kucoin_swap_exchange.get_positions().await;
+    trace!(?kucoin_get_positions);
 }
 
 // 测试kucoin 获取Ticker信息
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_kucoin_swap_get_ticker() {
-    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
-    println!("kucoin_swap get_ticker:{:?}", kucoin_swap_exchange.get_ticker().await);
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
+    let kucoin_get_ticker = kucoin_swap_exchange.get_ticker().await;
+    trace!(?kucoin_get_ticker);
 }
 
 // 测试kucoin 获取Market信息
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_kucoin_swap_get_market() {
-    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
-    println!("kucoin_swap get_market:{:?}", kucoin_swap_exchange.get_market().await);
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
+    let kucoin_get_market = kucoin_swap_exchange.get_market().await;
+    trace!(?kucoin_get_market);
 }
 
 // 测试kucoin 获取订单信息
 #[tokio::test]
+#[instrument(level = "TRACE")]
 async fn test_kucoin_swap_get_order_detail() {
-    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
-    println!("kucoin_swap get_market:{:?}", kucoin_swap_exchange.get_order_detail("123", "").await);
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
+    let kucoin_get_order_detail = kucoin_swap_exchange.get_order_detail("123", "").await;
+    trace!(?kucoin_get_order_detail);
+}
+
+// 测试kucoin 获取订单列表
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_kucoin_swap_get_orders_list() {
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
+    let kucoin_get_orders_list = kucoin_swap_exchange.get_orders_list("").await;
+    trace!(?kucoin_get_orders_list);
 }