[#184] 로거를 env_logger로 교체

Author: myyrakle

Cargo.toml

@@ -38,6 +38,8 @@ itertools = "0.10.5"
 anyhow = "1.0.86"
 mockall = "0.12.1"
 bitcode = "0.6.3"
+env_logger = "0.11.8"
+log = "0.4.28"
 
 [target.'cfg(windows)'.dependencies]
 winreg = "0.10.1"
@@ -57,4 +59,4 @@ rrdb = ["cli"]
 cli = ["atty", "structopt"]
 
 [lints.clippy]
-to_string_trait_impl = "allow"
+to_string_trait_impl = "allow"

src/engine/lexer/tokenizer.rs

@@ -1,7 +1,6 @@
-use crate::errors::predule::LexingError;
-use crate::errors::RRDBError;
 use crate::engine::lexer::predule::{OperatorToken, Token};
-use crate::logger::predule::Logger;
+use crate::errors::RRDBError;
+use crate::errors::predule::LexingError;
 
 #[derive(Debug)]
 pub struct Tokenizer {
@@ -12,7 +11,7 @@ pub struct Tokenizer {
 
 impl Tokenizer {
     pub fn new(text: String) -> Self {
-        Logger::info(format!("SQL echo: {:?}", text));
+        log::info!("SQL echo: {:?}", text);
         Self {
             last_char: ' ',
             buffer: text.chars().collect(),
@@ -207,7 +206,7 @@ impl Tokenizer {
                         return Err(LexingError::wrap(format!(
                             "invalid floating point number format: {}",
                             number_string
-                        )))
+                        )));
                     }
                 }
             } else {
@@ -219,7 +218,7 @@ impl Tokenizer {
                         return Err(LexingError::wrap(format!(
                             "invalid integer number format: {}",
                             number_string
-                        )))
+                        )));
                     }
                 }
             }
@@ -328,7 +327,7 @@ impl Tokenizer {
                     return Err(LexingError::wrap(format!(
                         "unexpected operator: {:?}",
                         self.last_char
-                    )))
+                    )));
                 }
             }
         }

src/engine/mod.rs

@@ -31,7 +31,6 @@ use crate::engine::wal::endec::implements::bitcode::BitcodeEncoder;
 use crate::engine::wal::manager::WALManager;
 use crate::errors::RRDBError;
 use crate::errors::execute_error::ExecuteError;
-use crate::logger::predule::Logger;
 
 pub struct DBEngine {
     pub(crate) config: Arc<LaunchConfig>,
@@ -55,7 +54,7 @@ impl DBEngine {
         _wal_manager: Arc<WALManager<BitcodeEncoder>>,
         _connection_id: String,
     ) -> Result<ExecuteResult, RRDBError> {
-        Logger::info(format!("AST echo: {:?}", statement));
+        log::info!("AST echo: {:?}", statement);
 
         // 쿼리 실행
         let result = match statement {

src/engine/server/mod.rs

@@ -13,7 +13,6 @@ use crate::engine::wal::endec::implements::bitcode::{BitcodeDecoder, BitcodeEnco
 use crate::engine::wal::manager::builder::WALBuilder;
 use crate::errors::RRDBError;
 use crate::errors::execute_error::ExecuteError;
-use crate::logger::predule::Logger;
 use crate::pgwire::predule::Connection;
 
 use futures::future::join_all;
@@ -74,15 +73,15 @@ impl Server {
                                 .response_sender
                                 .send(ChannelResponse { result: Ok(result) })
                             {
-                                Logger::error("channel send failed");
+                                log::error!("channel send failed");
                             }
                         }
                         Err(error) => {
                             let error = error.to_string();
                             if let Err(_response) = request.response_sender.send(ChannelResponse {
                                 result: Err(ExecuteError::wrap(error)),
                             }) {
-                                Logger::error("channel send failed");
+                                log::error!("channel send failed");
                             }
                         }
                     }
@@ -104,7 +103,7 @@ impl Server {
                 let (stream, address) = match accepted {
                     Ok((stream, address)) => (stream, address),
                     Err(error) => {
-                        Logger::error(format!("socket error {:?}", error));
+                        log::error!("socket error {:?}", error);
                         continue;
                     }
                 };
@@ -124,16 +123,17 @@ impl Server {
                 tokio::spawn(async move {
                     let mut conn = Connection::new(shared_state, config);
                     if let Err(error) = conn.run(stream).await {
-                        Logger::error(format!("connection error {:?}", error));
+                        log::error!("connection error {:?}", error);
                     }
                 });
             }
         });
 
-        Logger::info(format!(
+        log::info!(
             "Server is running on {}:{}",
-            self.config.host, self.config.port
-        ));
+            self.config.host,
+            self.config.port
+        );
 
         join_all(vec![connection_task, background_task]).await;
 

src/logger/logger.rs

@@ -4,7 +4,6 @@ pub mod config;
 pub mod constants;
 pub mod engine;
 pub mod errors;
-pub mod logger;
 pub mod pgwire;
 pub mod utils;
 

src/logger/mod.rs

@@ -12,7 +12,6 @@ use crate::engine::lexer::predule::Tokenizer;
 use crate::engine::parser::context::ParserContext;
 use crate::engine::parser::predule::Parser;
 use crate::engine::server::shared_state::SharedState;
-use crate::logger::predule::Logger;
 use crate::pgwire::connection::{BoundPortal, ConnectionError, ConnectionState, PreparedStatement};
 use crate::pgwire::engine::{Engine, Portal, RRDBEngine};
 use crate::pgwire::protocol::backend::{
@@ -120,12 +119,12 @@ impl Connection {
                                         self.engine.shared_state.client_info.database =
                                             database_name.to_owned();
 
-                                        Logger::info(format!(
+                                        log::info!(
                                             "New Connection=> UUID:{} IP:{} DATABASE:{}",
                                             self.engine.shared_state.client_info.connection_id,
                                             self.engine.shared_state.client_info.ip,
                                             self.engine.shared_state.client_info.database
-                                        ));
+                                        );
                                     } else {
                                         return Err(ErrorResponse::fatal(
                                             SqlState::CONNECTION_EXCEPTION,