Logging

component/config.cpp

@@ -23,15 +23,21 @@ std::string Config::getFullJID() const {
     return getBareJID() + "/" + getResource();
 }
 
-gloox::LogLevel Config::getLogLevel() const {
-    std::string level = root["logLevel"].as<std::string>("warning");
+Logger::Level Config::getLogLevel() const {
+    std::string level = root["logLevel"].as<std::string>("info");
 
-    if (level == "debug")
-        return gloox::LogLevelDebug;
+    if (level == "trace")
+        return Logger::trace;
+    else if (level == "debug")
+        return Logger::debug;
+    else if (level == "info")
+        return Logger::info;
+    else if (level == "warn" || level == "warning")
+        return Logger::warning;
     else if (level == "error")
-        return gloox::LogLevelError;
+        return Logger::error;
     else
-        return gloox::LogLevelWarning;
+        return Logger::info;
 }
 
 gloox::TLSPolicy Config::getTLSPolicy() const {

component/config.h

@@ -10,6 +10,8 @@
 
 #include "yaml-cpp/yaml.h"
 
+#include "logger.h"
+
 class Config {
 public:
     struct Module {
@@ -31,7 +33,7 @@ public:
     std::string getPassword() const;
     std::string getResource() const;
     std::map<std::string, std::string> getActors() const;
-    gloox::LogLevel getLogLevel() const;
+    Logger::Level getLogLevel() const;
     gloox::TLSPolicy getTLSPolicy() const;
     Module getModuleConfig(const std::string& name) const;
 

component/core.cpp

@@ -6,5 +6,5 @@
 Core::Core(const std::string& configPath):
     config(configPath),
     router(),
-    logger()
+    logger(config.getLogLevel())
 {}

component/logger.cpp

@@ -7,15 +7,21 @@
 #include <chrono>
 
 static constexpr std::string_view logLevelMap[] = {
-    "DEBUG",    // 0
-    "WARNING",  // 1
-    "ERROR",    // 2
+    "TRACE",
+    "DEBUG",
+    "INFO",
+    "WARNING",
+    "ERROR",
+    "FATAL",
 };
 
 static constexpr std::string_view colorMap[] = {
-    "\033[32m",  // DEBUG (Green)
+    "\033[90m",  // TRACE (Gray)
+    "\033[34m",  // DEBUG (Blue)
+    "\033[32m",  // INFO (Green)
     "\033[33m",  // WARNING (Yellow)
     "\033[31m",  // ERROR (Red)
+    "\033[35m",  // FATAL (Magenta)
 };
 
 static constexpr std::string_view clear = "\033[0m";
@@ -33,11 +39,11 @@ void writeTimestamp() {
 }
 
 constexpr std::string_view getLogLevel(gloox::LogLevel level) {
-    return (level >= 0 && level < 3) ? logLevelMap[level] : "UNKNOWN";
+    return (level >= 0 && level < 3) ? logLevelMap[Logger::convert(level)] : "UNKNOWN";
 }
 
 constexpr std::string_view getColor(gloox::LogLevel level) {
-    return (level >= 0 && level < 3) ? colorMap[level] : "";
+    return (level >= 0 && level < 3) ? colorMap[Logger::convert(level)] : "";
 }
 
 void writeTags(gloox::LogArea area) {
@@ -78,14 +84,73 @@ void writeTags(gloox::LogArea area) {
         std::cout << '\t';
 }
 
-Logger::Logger()
+Logger::Level Logger::convert(gloox::LogLevel level) {
+    switch (level) {
+        case gloox::LogLevelDebug:
+            return trace;
+        case gloox::LogLevelError:
+            return error;
+        case gloox::LogLevelWarning:
+            return warning;
+    };
+
+    return warning;
+}
+
+gloox::LogLevel Logger::convert(Level level) {
+    switch (level) {
+        case trace:
+            return gloox::LogLevelDebug;
+        case debug:
+            return gloox::LogLevelWarning;
+        case info:
+            return gloox::LogLevelWarning;
+        case warning:
+            return gloox::LogLevelWarning;
+        case error:
+            return gloox::LogLevelError;
+        case fatal:
+            return gloox::LogLevelError;
+    }
+
+    return gloox::LogLevelWarning;
+}
+
+Logger::Logger(Level level):
+    level(level)
 {}
 
 Logger::~Logger() {}
 
 void Logger::handleLog(gloox::LogLevel level, gloox::LogArea area, const std::string& message) {
     writeTimestamp();
-    std::cout << getColor(level) << bold << "[" << getLogLevel(level) << "]" << clear << bold;
+    std::cout << getColor(level) << bold << '[' << getLogLevel(level) << ']' << clear << bold;
     writeTags(area);
     std::cout << clear << '\t' << message << clear << std::endl;
 }
+
+void Logger::log(Level lvl, const std::string& message, const std::vector<std::string>& domain) {
+    if (lvl < level)
+        return;
+
+    writeTimestamp();
+    std::cout << colorMap[lvl] << bold << '[' << logLevelMap[lvl] << ']' << clear;
+
+    if (!domain.empty()) {
+        std::cout << ' ' << bold << '[';
+
+        bool first = true;
+        for (const std::string& tag : domain) {
+            if (first)
+                first = false;
+            else
+                std::cout << ' ';
+
+            std::cout << tag;
+        }
+
+        std::cout << ']' << clear;
+    }
+    std::cout << '\t' << message << clear << std::endl;
+}
+

component/logger.h

@@ -3,13 +3,33 @@
 
 #pragma once
 
+#include <vector>
+
 #include <gloox/loghandler.h>
 #include <gloox/logsink.h>
 
 class Logger: public gloox::LogHandler {
 public:
-    Logger();
+    enum Level {
+        trace,
+        debug,
+        info,
+        warning,
+        error,
+        fatal
+    };
+
+public:
+    Logger(Level level = info);
     ~Logger();
 
     void handleLog(gloox::LogLevel level, gloox::LogArea area, const std::string& message) override;
+
+    void log(Level level, const std::string& message, const std::vector<std::string>& domain = {});
+
+    static gloox::LogLevel convert(Level level);
+    static Level convert(gloox::LogLevel level);
+
+private:
+    Level level;
 };