akita 0.7.0

Akita - Mini orm for rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

/*
 *
 *  *
 *  *      Copyright (c) 2018-2025, SnackCloud All rights reserved.
 *  *
 *  *   Redistribution and use in source and binary forms, with or without
 *  *   modification, are permitted provided that the following conditions are met:
 *  *
 *  *   Redistributions of source code must retain the above copyright notice,
 *  *   this list of conditions and the following disclaimer.
 *  *   Redistributions in binary form must reproduce the above copyright
 *  *   notice, this list of conditions and the following disclaimer in the
 *  *   documentation and/or other materials provided with the distribution.
 *  *   Neither the name of the www.snackcloud.cn developer nor the names of its
 *  *   contributors may be used to endorse or promote products derived from
 *  *   this software without specific prior written permission.
 *  *   Author: SnackCloud
 *  *
 *
 */
use crate::comm::ExecuteContext;
use crate::errors::{AkitaError, Result};
use crate::interceptor::blocking::AkitaInterceptor;
use crate::interceptor::logging::LoggingInterceptor;
use crate::interceptor::{InterceptorType, LogLevel, OperationType};
use crate::prelude::ExecuteResult;
use tracing::{debug, enabled, error, info, trace, warn, Level};

impl AkitaInterceptor for LoggingInterceptor {
    fn before_execute(&self, ctx: &mut ExecuteContext) -> Result<()> {
        // Preparation logs are only recorded at DEBUG level and above
        if enabled!(target: "akita::sql", Level::DEBUG) {
            debug!(
                target: "akita::sql",
                sql = %ctx.final_sql(),
                params = ?ctx.final_params(),
                "Preparing SQL"
            );
        }

        // More context is recorded at the TRACE level
        if enabled!(target: "akita::sql", Level::TRACE) {
            trace!(
                target: "akita::sql",
                connection_id = ?ctx.connection_id(),
                "Start execution"
            );
        }

        Ok(())
    }

    fn after_execute(
        &self,
        ctx: &mut ExecuteContext,
        result: &mut Result<ExecuteResult>,
    ) -> Result<()> {
        let duration_ms = ctx.start_time().elapsed().as_millis();
        // Processing execution results
        match result {
            Err(err) => {
                // 错误日志（ERROR 级别）
                if enabled!(target: "akita::sql", Level::ERROR) {
                    error!(
                        target: "akita::sql",
                        error = %err,
                        sql = %ctx.final_sql(),
                        params = ?ctx.final_params(),
                        cost_ms = duration_ms as u64,
                        "SQL execution failed"
                    );
                }
                Ok(())
            }
            Ok(exec_result) => {
                // Gets the number of affected rows or query result rows
                let rows = if *ctx.operation_type() == OperationType::Select {
                    exec_result.len()
                } else {
                    ctx.metrics().rows_affected
                };

                // Slow Query warning (WARN level)
                if duration_ms > self.slow_query_threshold_ms as u128
                    && enabled!(target: "akita::sql", Level::WARN)
                {
                    warn!(
                        target: "akita::sql",
                        cost_ms = duration_ms as u64,
                        rows = rows,
                        sql = %ctx.final_sql(),
                        "Slow query detected"
                    );
                }

                // General success log (INFO level)
                if enabled!(target: "akita::sql", Level::INFO) {
                    info!(
                        target: "akita::sql",
                        cost_ms = duration_ms as u64,
                        rows = rows,
                        operation = ?ctx.operation_type(),
                        "SQL executed"
                    );
                }

                // Detailed tracking (TRACE level)
                if enabled!(target: "akita::sql", Level::TRACE) {
                    trace!(
                        target: "akita::sql",
                        cost_ms = duration_ms as u64,
                        rows = rows,
                        sql = %ctx.final_sql(),
                        params = ?ctx.final_params(),
                        "Execution finished"
                    );
                }
                Ok(())
            }
        }
    }
}