feat: add macros for logging and debugging

Author: iboukhss

.clang-format

@@ -9,11 +9,25 @@ SpaceAfterCStyleCast: true
 IndentAccessModifiers: false
 AccessModifierOffset: -4
 
-#AllowShortCaseLabelsOnASingleLine: true
 AllowShortFunctionsOnASingleLine: InlineOnly
 BreakConstructorInitializers: BeforeColon
 PackConstructorInitializers: Never
 
+AllowShortCaseLabelsOnASingleLine: true
+AlignConsecutiveShortCaseStatements:
+  Enabled: true
+  
+# Fails on ubuntu-latest
+#AlignEscapedNewlines: LeftWithLastLine
+
+AlignEscapedNewlines: DontAlign
+AlignConsecutiveMacros:
+  Enabled: true
+
+# Fails on ubuntu-latest
+#BreakTemplateDeclarations: Yes
+AlwaysBreakTemplateDeclarations: true
+
 SortIncludes: true
 IncludeBlocks: Regroup
 IncludeCategories:

Makefile

@@ -32,6 +32,8 @@ SRCS      = $(addprefix $(SRC_DIR)/, \
             http/http_response.hpp \
             router/router.cpp \
             router/router.hpp \
+            util/log_message.cpp \
+            util/log_message.hpp \
             util/str_split.cpp \
             util/str_trim.cpp \
             util/string.hpp \

src/core/client.cpp

@@ -1,5 +1,6 @@
 #include "core/client.hpp"
 
+#include "util/log_message.hpp"
 #include "util/syscall_error.hpp"
 
 #include <fcntl.h>
@@ -14,7 +15,7 @@ Client::Client(uint64_t id, int fd, const sockaddr_in& addr)
       handler_(NULL)
 {
     set_nonblocking();
-    std::cout << "Client constructor called" << std::endl;
+    LOG(DEBUG) << "Client constructor called";
 }
 
 Client::~Client()
@@ -25,7 +26,7 @@ Client::~Client()
     if (handler_) {
         delete handler_;
     }
-    std::cout << "Client destructor called" << std::endl;
+    LOG(DEBUG) << "Client destructor called";
 }
 
 void Client::set_nonblocking()

src/core/server.cpp

@@ -4,6 +4,7 @@
 #include "core/signals.hpp"
 #include "http/http_parser.hpp"
 #include "router/router.hpp"
+#include "util/log_message.hpp"
 #include "util/syscall_error.hpp"
 
 #include <errno.h>
@@ -85,7 +86,7 @@ void Server::close_connection(Client& conn)
 
     std::map<uint64_t, Client*>::iterator it = clients_.find(client_id);
     if (it == clients_.end()) {
-        std::cerr << "[WARNING] Attempted to remove inexistant client id" << std::endl;
+        LOG(WARN) << "Attempted to remove inexistand client id";
         return;
     }
 
@@ -97,7 +98,7 @@ Client& Server::get_client(uint64_t id)
 {
     std::map<uint64_t, Client*>::iterator it = clients_.find(id);
     if (it == clients_.end()) {
-        throw std::runtime_error("[FATAL] Attempted to retrieve inexistant client id");
+        throw std::runtime_error("Attempted to retrieve inexistant client id");
     }
     return *(it->second);
 }
@@ -121,7 +122,7 @@ void Server::accept_connection()
     ev.data.u64 = client_id;
     epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, client_fd, &ev);
 
-    std::cout << "* Connection established, client_id = " << client_id << std::endl;
+    LOG(INFO) << "Client #" << client_id << " connected";
 }
 
 void Server::run()
@@ -135,8 +136,7 @@ void Server::run()
                 // nothing happened.
                 n_events = 0;
                 break;
-            default:
-                throw UnrecoverableError("epoll_wait", errno);
+            default: throw UnrecoverableError("epoll_wait", errno);
             }
         }
 
@@ -193,7 +193,7 @@ void Server::handle_events(Client& conn, uint32_t events)
             return;
         }
 
-        std::cout << "* Received data from socket" << std::endl;
+        LOG(DEBUG) << "Received " << bytes_received << " bytes from socket";
         print_raw_data(tmp);
 
         // Feed data to the parser

src/core/server_defaults.hpp

@@ -1,8 +1,8 @@
 #ifndef SERVER_DEFAULTS_HPP_
 #define SERVER_DEFAULTS_HPP_
 
-#define WEBSERV_DEFAULT_PORT 8080
-#define WEBSERV_DEFAULT_BACKLOG 128
+#define WEBSERV_DEFAULT_PORT          8080
+#define WEBSERV_DEFAULT_BACKLOG       128
 #define WEBSERV_DEFAULT_MAX_BODY_SIZE (1 << 20) // 1MB
 
 #endif // SERVER_DEFAULTS_HPP_

src/handler/static_file_handler.cpp

@@ -1,6 +1,7 @@
 #include "handler/static_file_handler.hpp"
 
 #include "http/http_response.hpp"
+#include "util/log_message.hpp"
 #include "util/syscall_error.hpp"
 
 #include <errno.h>
@@ -22,7 +23,7 @@ StaticFileHandler::StaticFileHandler(const std::string& path)
     HttpResponse res;
     res.http_version = "HTTP/1.1";
 
-    std::cout << "[DEBUG] Trying to open file: " << path << std::endl;
+    LOG(DEBUG) << "Trying to open file: " << path;
 
     if (stat(path.c_str(), &file_stat) != 0 || !S_ISREG(file_stat.st_mode)) {
         res.code = HttpResponse::kNotFound;

src/http/http_response.cpp

@@ -2,20 +2,17 @@
 
 #include <sstream>
 
-const char* HttpResponse::reason_phrase(Status code) const
+const char* HttpResponse::reason_phrase(HttpResponse::Status code) const
 {
-    /* clang-format off */
     switch (code) {
-    case kOk: return "OK";
-    case kBadRequest: return "Bad Request";
-    case kForbidden: return "Forbidden";
-    case kNotFound: return "Not Found";
-    case kMethodNotAllowed: return "Method Not Allowed";
+    case kOk:                  return "OK";
+    case kBadRequest:          return "Bad Request";
+    case kForbidden:           return "Forbidden";
+    case kNotFound:            return "Not Found";
+    case kMethodNotAllowed:    return "Method Not Allowed";
     case kInternalServerError: return "Internal Server Error";
-    case kNotImplemented: return "Not Implemented";
-    default: return "Unknown";
+    case kNotImplemented:      return "Not Implemented";
     }
-    /* clang-format on */
 }
 
 std::string HttpResponse::to_string() const

src/http/http_response.hpp

@@ -17,14 +17,14 @@ struct HttpResponse {
     };
 
     std::string http_version;
-    Status code;
+    HttpResponse::Status code;
     std::map<std::string, std::string> headers;
     std::string body;
 
     std::string to_string() const;
 
 private:
-    const char* reason_phrase(Status code) const;
+    const char* reason_phrase(HttpResponse::Status code) const;
 };
 
 #endif // HTTP_HTTP_RESPONSE_HPP_

src/router/router.cpp

@@ -3,6 +3,7 @@
 #include "config/server_config.hpp"
 #include "handler/static_file_handler.hpp"
 #include "http/http_request.hpp"
+#include "util/log_message.hpp"
 
 #include <sys/stat.h>
 
@@ -58,7 +59,6 @@ std::string Router::build_request_path(const HttpRequest& request, const Locatio
 {
     std::string full_path = config_.root;
     std::string folder = static_cast<std::string>(best_match->path);
-    // std::cout << "root = " << full_path << std::endl;
     std::string file =
         request.path.substr(best_match->path.size(), request.path.size() - best_match->path.size());
     if (full_path[full_path.size() - 1] != '/')

src/util/log_message.cpp

@@ -0,0 +1,70 @@
+#include "util/log_message.hpp"
+
+#include <cstdio>
+#include <cstdlib>
+
+LogMessage::LogMessage(LogMessage::Level level)
+    : level_(level)
+{
+}
+
+LogMessage::~LogMessage()
+{
+    print_message();
+
+    if (level_ == kLevelFatal)
+        std::abort();
+}
+
+void LogMessage::print_message()
+{
+    /* clang-format off */
+    fprintf(stderr, "%s[%s]%s %s\n",
+			color_string(get_color()),
+			level_string(level_),
+            color_string(kColorReset),
+			stream_.str().c_str());
+    /* clang-format on */
+}
+
+LogMessage::Color LogMessage::get_color() const
+{
+    switch (level_) {
+    case kLevelDebug:   return kColorBlue;
+    case kLevelInfo:    return kColorReset;
+    case kLevelWarning: return kColorYellow;
+    case kLevelError:   return kColorRed;
+    case kLevelFatal:   return kColorRed;
+    }
+
+    NOTREACHED();
+    return kColorReset;
+}
+
+const char* LogMessage::level_string(LogMessage::Level level)
+{
+    switch (level) {
+    case kLevelDebug:   return "DEBUG";
+    case kLevelInfo:    return "INFO";
+    case kLevelWarning: return "WARN";
+    case kLevelError:   return "ERROR";
+    case kLevelFatal:   return "FATAL";
+    }
+
+    NOTREACHED();
+    return "UNKNOWN";
+}
+
+const char* LogMessage::color_string(LogMessage::Color color)
+{
+    switch (color) {
+    case kColorReset:  return "\033[0m";
+    case kColorRed:    return "\033[31m";
+    case kColorGreen:  return "\033[32m";
+    case kColorYellow: return "\033[33m";
+    case kColorBlue:   return "\033[34m";
+    }
+
+    NOTREACHED();
+    return "";
+}