as-rust/global/src/trace_stack.rs

use std::fmt;
use std::fmt::{Formatter};
use chrono::Utc;
use rust_decimal::prelude::ToPrimitive;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TraceStack {
    pub before_network: i64,                // 官方数据生成时间
    pub after_network: i64,                 // 到达网络层时间

    pub before_unlock_quant: i64,           // 解锁quant之前的时间
    pub before_quant: i64,                  // quant层执行开始时间（也是通道+锁走完后的时间）
    pub after_quant: i64,                   // quant层执行结束时间

    pub before_format: i64,                 // 开始格式化时间
    pub after_format: i64,                  // 结束格式化时间

    pub before_strategy: i64,               // 计算层开始时间
    pub after_strategy: i64,                // 计算层结束时间

    pub before_send_thread: i64,            // 发送指令时时间（进入协程前）
    pub before_send: i64,                   // 发送指令时时间（进入协程后）
    pub after_send: i64,                    // 发送指令结束时间

    pub source: String,                     // 订单来源[depth|order]
    pub order_command: String               // 订单发送时的command
}

impl TraceStack {
    pub fn on_before_network(&mut self, before_network_millis: i64) {
        self.before_network = before_network_millis;
    }

    pub fn on_after_network(&mut self, after_network: i64) {
        self.after_network = after_network;
    }

    pub fn on_before_unlock_quant(&mut self) {
        self.before_unlock_quant = Utc::now().timestamp_micros();
    }

    pub fn on_before_quant(&mut self) {
        self.before_quant = Utc::now().timestamp_micros();
    }

    pub fn on_after_quant(&mut self) {
        self.after_quant = Utc::now().timestamp_micros();
    }

    pub fn on_before_format(&mut self) {
        self.before_format = Utc::now().timestamp_micros();
    }

    pub fn on_after_format(&mut self) {
        self.after_format = Utc::now().timestamp_micros();
    }

    pub fn on_before_strategy(&mut self) {
        self.before_strategy = Utc::now().timestamp_micros();
    }

    pub fn on_after_strategy(&mut self) {
        self.after_strategy = Utc::now().timestamp_micros();
    }

    pub fn on_before_send_thread(&mut self) {
        self.before_send_thread = Utc::now().timestamp_micros();
    }

    pub fn on_before_send(&mut self) {
        self.before_send = Utc::now().timestamp_micros();
    }

    pub fn on_after_send(&mut self) {
        self.after_send = Utc::now().timestamp_micros();
    }

    pub fn on_depth(&mut self) {
        self.source = "depth".to_string();
    }

    pub fn on_order(&mut self) {
        self.source = "order".to_string();
    }

    pub fn on_order_command(&mut self, command_str: String) {
        self.order_command = command_str;
    }

    pub fn on_special(mut self, event_str: String) -> Self {
        self.after_network = 1;
        self.source = event_str;

        self
    }
}

impl fmt::Display for TraceStack {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        let mut msg = String::new();

        if !self.source.is_empty() {
            msg.push_str(format!("订单来源：{} ", self.source).as_str());
        }

        if self.after_network != 0 && self.before_send != 0 {
            msg.push_str(format!("本地总耗时{}微秒  ", self.before_send - self.after_network).as_str());
        }

        if self.before_network != 0 && self.after_network != 0 {
            msg.push_str(format!("数据生成+到达rust耗时{}毫秒  ", (self.after_network - self.before_network).to_f64().unwrap() / 1000.0).as_str());
        }

        if self.before_unlock_quant != 0 && self.after_network != 0 {
            msg.push_str(format!("数据通道耗时{}微秒  ", self.before_unlock_quant - self.after_network).as_str());
        }

        if self.before_quant != 0 && self.before_unlock_quant != 0 {
            msg.push_str(format!("解锁quant{}微秒  ", self.before_quant - self.before_unlock_quant).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_quant != 0 && self.before_quant != 0 {
            msg.push_str(format!("quant执行耗时{}微秒  ", self.after_quant - self.before_quant).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.after_network != 0 && self.after_strategy != 0 {
            msg.push_str(format!("quant走完{}微秒  ", self.after_strategy - self.after_network).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)
    }
}

impl Default for TraceStack {
    fn default() -> Self {
        TraceStack {
            before_network: 0,
            after_network: 0,
            before_format: 0,
            after_format: 0,
            before_unlock_quant: 0,
            before_quant: 0,
            after_quant: 0,
            before_strategy: 0,
            after_strategy: 0,
            before_send_thread: 0,
            before_send: 0,
            after_send: 0,
            source: "".to_string(),
            order_command: "".to_string(),
        }
    }
}