Refactor logging system: Migrate log functionality to new 'logging' namespace

Seele-Official · Seele-Official · commit 3671d61d2cd1 · 2025-10-29T13:02:16.000+08:00
diff --git a/example/example.cpp b/example/example.cpp
@@ -1,5 +1,5 @@
-#include "log/log.h"
-#include "log/sink.h"
+#include "logging/log.h"
+#include "logging/sink.h"
 #include "web/env.h"
 #include "web/loop.h"
 #include "web/response.h"
@@ -33,8 +33,8 @@ int main(){
 
 
     // Configure the logging system
-    log::add_sink(
-        std::make_unique<log::sink::file>("app.log")
+    logging::add_sink(
+        std::make_unique<logging::sink::file>("app.log")
     );
 
 
diff --git a/src/concurrent/hp.cpp b/src/concurrent/hp.cpp
@@ -2,7 +2,7 @@
 #include <ranges>
 #include <algorithm>
 #include "concurrent/hp.h"
-#include "log/log.h"
+#include "logging/log.h"
 namespace concurrent {
 
 namespace detail {
@@ -60,7 +60,7 @@ void hazard_recorder::scan_retired(std::vector<retired_ptr_t>& retired_list){
                 deleter(ptr);
                 return true; // Remove from the list
             }
-            log::sync::error("retired pointer has no deleter.");
+            logging::sync::error("retired pointer has no deleter.");
             std::terminate();
         }
     );
@@ -73,10 +73,10 @@ hazard_recorder::~hazard_recorder() {
 
     this->scan_retired(g_retired);
     if (g_retired.size() > 0) {
-        log::sync::error("Hazard manager still has {} retired pointers after destruction.", g_retired.size());
+        logging::sync::error("Hazard manager still has {} retired pointers after destruction.", g_retired.size());
         for (const auto& [index, record] : std::views::enumerate(this->records)) {
             if (record.active.load(std::memory_order_acquire)) {
-                log::sync::error("Hazard record {} is still active.", index);
+                logging::sync::error("Hazard record {} is still active.", index);
             }
         }
 
diff --git a/src/io/ctx.cpp b/src/io/ctx.cpp
@@ -10,7 +10,7 @@
 
 #include "coro/thread.h"
 #include "io/ctx.h"
-#include "log/log.h"
+#include "logging/log.h"
 
 namespace io::detail {
     
@@ -34,9 +34,9 @@ void ctx::worker(std::stop_token st){
             if (submit_count >= submit_threshold) {
                 auto submit_ret = io_uring_submit(&ring);
                 if (submit_ret < 0) {
-                    log::async::error("io_uring_submit failed: {}", strerror(-submit_ret));
+                    logging::async::error("io_uring_submit failed: {}", strerror(-submit_ret));
                 } else {
-                    log::async::debug("Submitted {} requests to io_uring", submit_ret);
+                    logging::async::debug("Submitted {} requests to io_uring", submit_ret);
                     submit_count = 0;
                 }
             }
@@ -45,9 +45,9 @@ void ctx::worker(std::stop_token st){
                 this->pending_req_count.fetch_add(pending_req_count, std::memory_order_acq_rel);
                 auto submit_ret = io_uring_submit(&ring);
                 if (submit_ret < 0) {
-                    log::async::error("io_uring_submit failed: {}", strerror(-submit_ret));
+                    logging::async::error("io_uring_submit failed: {}", strerror(-submit_ret));
                 } else {
-                    log::async::debug("Submitted {} requests to io_uring", submit_ret);
+                    logging::async::debug("Submitted {} requests to io_uring", submit_ret);
                     submit_count = 0;
                     pending_req_count = 0;
                 }
@@ -84,15 +84,15 @@ void ctx::handle_cqes(io_uring_cqe* cqe) {
                         }
                     }
                 } else {
-                    log::async::error("Unknown user data type in cqe");
+                    logging::async::error("Unknown user data type in cqe");
                 }
             }
         );
         this->usr_data_pool.deallocate(data); // Clean up the user data
     }
     io_uring_cq_advance(&ring, count);
     this->pending_req_count.fetch_sub(processed_req, std::memory_order_acq_rel);
-    log::async::debug("Processed {} completed requests", count);      
+    logging::async::debug("Processed {} completed requests", count);      
 }
 
 
@@ -107,10 +107,10 @@ void ctx::start_listen(std::stop_token st){
         int ret = io_uring_wait_cqes(&ring, &cqe, 1, nullptr, &sigmask); 
 
         if (ret == -EINTR){
-            log::async::debug("io_uring_wait_cqes interrupted by signal, checking for stop request");
+            logging::async::debug("io_uring_wait_cqes interrupted by signal, checking for stop request");
             continue; // Interrupted by signal, continue waiting
         } else if (ret < 0) {
-            log::sync::error("io_uring_wait_cqes failed: {}", strerror(-ret));
+            logging::sync::error("io_uring_wait_cqes failed: {}", strerror(-ret));
             break;
         } else {
             this->handle_cqes(cqe);
@@ -135,9 +135,9 @@ void ctx::clean_up() {
     this->pending_req_count.fetch_add(pending_req_count, std::memory_order_acq_rel);
     auto submit_ret = io_uring_submit(&ring);
     if (submit_ret < 0) {
-        log::async::error("io_uring_submit failed: {}", strerror(-submit_ret));
+        logging::async::error("io_uring_submit failed: {}", strerror(-submit_ret));
     } else {
-        log::async::debug("Submitted {} requests to io_uring", submit_ret);
+        logging::async::debug("Submitted {} requests to io_uring", submit_ret);
     }
 
 
@@ -153,7 +153,7 @@ void ctx::clean_up() {
         if (ret == -ETIME){
             continue; // Timeout, continue waiting
         } else if (ret < 0) {
-            log::sync::error("io_uring_wait_cqes failed: {}", strerror(-ret));
+            logging::sync::error("io_uring_wait_cqes failed: {}", strerror(-ret));
             break;
         } else {
             this->handle_cqes(cqe);
diff --git a/src/logging/common.h b/src/logging/common.h
@@ -3,7 +3,7 @@
 #include <format>
 #include <source_location>
 #include <concepts>
-namespace log{
+namespace logging{
 
 enum class level{
     error,
diff --git a/src/logging/log.h b/src/logging/log.h
@@ -10,12 +10,12 @@
 #include <format>
 #include <vector>
 
-#include "log/sink.h"
-#include "log/common.h"
+#include "logging/sink.h"
+#include "logging/common.h"
 
 #include "concurrent/mpsc_ringbuffer.h"
 
-namespace log{
+namespace logging {
 
 namespace detail {
 
@@ -204,7 +204,7 @@ inline void add_sink(std::unique_ptr<sink::basic> s) {
 namespace sync {
 template<level lvl, typename... args_t>
 void log(format_string_wrapper<args_t...> fmt_w, args_t&&... args){
-    if constexpr (lvl <= log::max_level) {
+    if constexpr (lvl <= logging::max_level) {
         detail::logger::get_instance()->log(
             detail::packet::make<lvl>(system_clock::now(), fmt_w, std::forward<args_t>(args)...)
         );
@@ -242,7 +242,7 @@ namespace async{
 
 template<level lvl, typename... args_t>
 void log(format_string_wrapper<args_t...> fmt_w, args_t&&... args){
-    if constexpr (lvl <= log::max_level) {
+    if constexpr (lvl <= logging::max_level) {
         detail::tls().push(
             detail::packet::make<lvl>(system_clock::now(), fmt_w, std::forward<args_t>(args)...)
         );
diff --git a/src/logging/sink.h b/src/logging/sink.h
@@ -11,10 +11,10 @@
 #include <string_view>
 #include <utility>
 
-#include "common.h"
+#include "logging/common.h"
 #include "meta.h"
 
-namespace log::sink {
+namespace logging::sink {
 
 
 namespace detail {
@@ -138,7 +138,7 @@ class basic : public detail::fmt_ostream {
         }
     }
 private:
-    log::level level{max_level};
+    logging::level level{max_level};
     std::mutex mutex{};
 };
 
diff --git a/src/web/loop.cpp b/src/web/loop.cpp
@@ -3,7 +3,7 @@
 #include <system_error>
 #include <utility>
 #include <filesystem>
-#include "log/log.h"
+#include "logging/log.h"
 
 #include "web/loop.h"
 #include "web/mime.h"
@@ -35,7 +35,7 @@ coro::simple_task async_handle_connection(int fd, ip::v4 a) {
             };
 
             if (bytes_read <= 0) {
-                log::async::error("Failed to read from {}: {}", 
+                logging::async::error("Failed to read from {}: {}", 
                     client_addr.to_string(), io::error::msg
                 );
                 co_return;
@@ -66,7 +66,7 @@ coro::simple_task async_handle_connection(int fd, ip::v4 a) {
 
 
         } else {
-            log::async::error("Failed to parse request from {}", client_addr.to_string());
+            logging::async::error("Failed to parse request from {}", client_addr.to_string());
             co_await web::response::error(http::response::status_code::bad_request)
                         .settings({fd_w.get(), client_addr, timeout});
             co_return;
@@ -87,17 +87,17 @@ coro::simple_task server_loop(int32_t f) {
         switch (ret) {
             case io::error::SYS:
             case io::error::CTX_CLOSED:
-                log::async::error("Failed to accept connection: {}", io::error::msg);
+                logging::async::error("Failed to accept connection: {}", io::error::msg);
                 co_return;
             case io::error::TIMEOUT:
-                log::async::debug("Accept timed out, retrying...");
+                logging::async::debug("Accept timed out, retrying...");
                 continue;
             default:
                 break;
         
         }
         auto ipv4_addr = ip::v4::from_sockaddr_in(client_addr);
-        log::async::info("Fd[{}]: Accepted connection from {}", fd, ipv4_addr.to_string());
+        logging::async::info("Fd[{}]: Accepted connection from {}", fd, ipv4_addr.to_string());
         async_handle_connection(ret, ipv4_addr);
     }
 
@@ -161,7 +161,7 @@ void add_static_file_router(){
             }
 
             auto relative_path_str = std::format("/{}", full_path.lexically_relative(root).c_str());
-            log::sync::info("Adding file `{}` to router as `{}`", full_path.string(), relative_path_str);
+            logging::sync::info("Adding file `{}` to router as `{}`", full_path.string(), relative_path_str);
 
             routing::env::static_routers().push_back(
                 {
@@ -183,7 +183,7 @@ void add_static_file_router(){
 
     // Register static file routers
     for (auto& [head_router, router] : routing::env::static_routers()) {
-        log::sync::info("Adding file router: {}", router.name);
+        logging::sync::info("Adding file router: {}", router.name);
         routing::get(router.name, router);
         routing::head(head_router.name, head_router);
     }
diff --git a/src/web/reponse.cpp b/src/web/reponse.cpp
@@ -2,7 +2,7 @@
 #include <cstdint>
 #include <vector>
 
-#include "log/log.h"
+#include "logging/log.h"
 #include "web/response.h"
 #include "web/routing.h"
 
@@ -36,7 +36,7 @@ task msg(const http::response::msg& msg){
             timeout
         };
         if (res <= 0) {
-            log::async::error(
+            logging::async::error(
                 "Failed to send response for `{}`: `{}`", 
                 client_addr.to_string(), io::error::msg
             );
@@ -79,7 +79,7 @@ task error(http::response::status_code code){
             timeout
         };
         if (res <= 0) {
-            log::async::error(
+            logging::async::error(
                 "Failed to send response for `{}`: `{}`", 
                 client_addr.to_string(), io::error::msg
             );
@@ -144,7 +144,7 @@ task file(const std::string& content_type, std::span<std::byte> content){
     };
 
     if (res <= 0) {
-        log::async::error(
+        logging::async::error(
             "Failed to send response for {} : {}", 
             client_addr.to_string(), io::error::msg
         );
@@ -170,7 +170,7 @@ task file(const std::string& content_type, std::span<std::byte> content){
             };
 
             if (res <= 0) {
-                log::async::error(
+                logging::async::error(
                     "Failed to send response for {} : {}", 
                     client_addr.to_string(), io::error::msg
                 );
@@ -202,7 +202,7 @@ task file(const std::string& content_type, std::span<std::byte> content){
             };
             
             if (res <= 0) { 
-                log::async::error(
+                logging::async::error(
                     "Failed to send response for {} : {}", 
                     client_addr.to_string(), io::error::msg
                 );
diff --git a/src/web/response.h b/src/web/response.h
@@ -32,17 +32,17 @@ struct task {
         struct final_awaiter {
             bool await_ready() noexcept { return false; }
             void await_resume() noexcept {}
-            std::coroutine_handle<> await_suspend(std::coroutine_handle<promise_type> h){
+            std::coroutine_handle<> await_suspend(std::coroutine_handle<promise_type> h) noexcept {
                 return h.promise().previous;
             }
         };
         
         auto final_suspend() noexcept {
             return final_awaiter{};
         }
-        void unhandled_exception(){}
+        void unhandled_exception() noexcept {}
 
-        void return_value(int64_t v){
+        void return_value(int64_t v) noexcept {
             ret = v;
         }
 
diff --git a/test/log/log.cpp b/test/log/log.cpp
@@ -2,7 +2,7 @@
 #include <string>
 #include <system_error>
 
-#include "log/log.h"
+#include "logging/log.h"
 
 
 using namespace boost::ut;
@@ -15,7 +15,7 @@ suite<"Logging Sink Tests"> _ = [] {
         constexpr size_t times = 1000;
         
         {
-            log::sink::file file_sink(filename, 1024); // 1KB max size for testing
+            logging::sink::file file_sink(filename, 1024); // 1KB max size for testing
 
             for (auto _ : std::views::iota(0uz, times)) {
                 file_sink.fmt_to("{}", msg);

Original file line number	Diff line number	Diff line change
`@@ -32,17 +32,17 @@ struct task {`
`32`	`32`	`struct final_awaiter {`
`33`	`33`	`bool await_ready() noexcept { return false; }`
`34`	`34`	`void await_resume() noexcept {}`
`35`		`- std::coroutine_handle<> await_suspend(std::coroutine_handle<promise_type> h){`
	`35`	`+ std::coroutine_handle<> await_suspend(std::coroutine_handle<promise_type> h) noexcept {`
`36`	`36`	`return h.promise().previous;`
`37`	`37`	`}`
`38`	`38`	`};`
`39`	`39`
`40`	`40`	`auto final_suspend() noexcept {`
`41`	`41`	`return final_awaiter{};`
`42`	`42`	`}`
`43`		`- void unhandled_exception(){}`
	`43`	`+ void unhandled_exception() noexcept {}`
`44`	`44`
`45`		`- void return_value(int64_t v){`
	`45`	`+ void return_value(int64_t v) noexcept {`
`46`	`46`	`ret = v;`
`47`	`47`	`}`
`48`	`48`