可以在开局清仓时报耗时，用于检查耗时。

global/src/trace_stack.rs

@@ -86,15 +86,37 @@ impl TraceStack {
 
 impl fmt::Display for TraceStack {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "订单来源:{}，通道+锁耗时{}微秒，数据格式化耗时{}微秒，计算层执行耗时{}微秒, 进入协程耗时{}微秒, 发送订单耗时(发送-服务器处理-响应到本地){}毫秒，总共耗时{}毫秒。",
-            self.source,
-            self.before_quant - self.after_network,
-            self.after_format - self.before_format,
-            self.after_strategy - self.before_strategy,
-            self.before_send - self.before_send_thread,
-            (self.after_send - self.before_send).to_f64().unwrap() / 1000.0,
-            (self.after_send - self.after_network).to_f64().unwrap() / 1000.0
-        )
+        let mut msg = String::new();
+
+        if !self.source.is_empty() {
+            msg.push_str(format!("订单来源：{} ", self.source).as_str());
+        }
+
+        if self.before_quant != 0 && self.after_network != 0 {
+            msg.push_str(format!("通道+锁耗时{}微秒  ", self.before_quant - self.after_network).as_str());
+        }
+
+        if self.after_format != 0 && self.before_format != 0 {
+            msg.push_str(format!("数据格式化耗时{}微秒  ", self.after_format - self.before_format).as_str());
+        }
+
+        if self.after_strategy != 0 && self.before_strategy != 0 {
+            msg.push_str(format!("计算层执行耗时{}微秒  ", self.after_strategy - self.before_strategy).as_str());
+        }
+
+        if self.before_send != 0 && self.before_send_thread != 0 {
+            msg.push_str(format!("进入协程耗时{}微秒  ", self.before_send - self.before_send_thread).as_str());
+        }
+
+        if self.after_send != 0 && self.before_send != 0 {
+            msg.push_str(format!("发送订单耗时(发送-服务器处理-响应到本地){}毫秒  ", (self.after_send - self.before_send).to_f64().unwrap() / 1000.0).as_str());
+        }
+
+        if self.after_send != 0 && self.after_network != 0 {
+            msg.push_str(format!("总共耗时{}毫秒", (self.after_send - self.after_network).to_f64().unwrap() / 1000.0).as_str());
+        }
+
+        write!(f, "{}", msg)
     }
 }
 

strategy/src/quant.rs

@@ -1131,42 +1131,48 @@ impl Quant {
                             ap = ticker.sell;
                             bp = ticker.buy;
                             mp = (ap + bp) / Decimal::TWO;
+
+                            let coin_value = account.balance * mp;
+                            let diff = _hold_coin - coin_value;
+                            let side;
+                            let price = Decimal::ZERO;
+                            let amount;
+                            if diff > Decimal::from(10) {
+                                side = "kd";
+                                // price = mp*1.001;
+                                amount = diff;
+                            } else if diff < Decimal::from(-10) {
+                                side = "kk";
+                                // price = mp*0.999;
+                                amount = -diff / mp;
+                            } else {
+                                continue;
+                            }
+                            info!(?ticker);
+                            info!("需要调整现货仓位 {}USDT(目标：{}USDT) 共计{}{}。", diff, _hold_coin, amount, coin_name);
+                            let mut ts = TraceStack::default();
+                            ts.on_before_send();
+                            // 价格0，市价单
+                            match self.platform_rest.take_order_symbol(symbol.clone(), Decimal::ONE, utils::generate_client_id(None).as_str(), side, price, amount).await {
+                                Ok(v) => {
+                                    ts.on_after_send();
+                                    info!("side: {}, {} 下单，{:?}, {}", side, symbol, v, ts.to_string());
+                                    // 执行完当前币对  结束循环
+                                    continue;
+                                }
+                                Err(ex) => {
+                                    ts.on_after_send();
+                                    error!("side: {}, {} {}, {}", side, symbol, ex, ts.to_string());
+                                    // 执行完当前币对  结束循环
+                                    continue;
+                                }
+                            }
                         }
                         Err(_e) => {
                             error!("清仓中- 获取 {} 币对行情错误，该币对无法调整仓位。", symbol);
                             continue;
                         }
                     }
-                    let coin_value = account.balance * mp;
-                    let diff = _hold_coin - coin_value;
-                    let side;
-                    let price = Decimal::ZERO;
-                    let amount;
-                    if diff > Decimal::from(10) {
-                        side = "kd";
-                        // price = mp*1.001;
-                        amount = diff;
-                    } else if diff < Decimal::from(-10) {
-                        side = "kk";
-                        // price = mp*0.999;
-                        amount = -diff / mp;
-                    } else {
-                        continue;
-                    }
-                    info!("需要调整现货仓位 {}USDT(目标：{}USDT) 共计{}{}。", diff, _hold_coin, amount, coin_name);
-                    // 价格0，市价单
-                    match self.platform_rest.take_order_symbol(symbol.clone(), Decimal::ONE, utils::generate_client_id(None).as_str(), side, price, amount).await {
-                        Ok(v) => {
-                            info!("side: {}, {} 下单，{:?}", side, symbol, v);
-                            // 执行完当前币对  结束循环
-                            continue;
-                        }
-                        Err(ex) => {
-                            error!("side: {}, {} {}", side, symbol, ex);
-                            // 执行完当前币对  结束循环
-                            continue;
-                        }
-                    }
                 }
 
                 // 补仓之后获取最新余额
@@ -1226,14 +1232,18 @@ impl Quant {
                             }
                             // 发起清仓订单
                             info!(?ticker);
+                            let mut ts = TraceStack::default();
+                            ts.on_before_send();
                             match self.platform_rest.take_order_symbol(position.symbol.clone(), Decimal::ONE, utils::generate_client_id(None).as_str(), side, price, position.amount.abs()).await {
                                 Ok(order) => {
-                                    info!("{}仓位清除下单成功 {:?}", position.symbol.clone(), order);
+                                    ts.on_after_send();
+                                    info!("{}仓位清除下单成功 {:?}, {}", position.symbol.clone(), order, ts.to_string());
                                     // 执行完当前币对  结束循环
                                     continue;
                                 }
                                 Err(error) => {
-                                    error!("{}仓位清除下单异常 {}", position.symbol.clone(), error);
+                                    ts.on_after_send();
+                                    error!("{}仓位清除下单异常 {}, {}", position.symbol.clone(), error, ts.to_string());
                                     // 执行完当前币对  结束循环
                                     continue;
                                 }