Refactor MQTT-5.0 branch to semantic logging

README.md

@@ -2063,7 +2063,7 @@ The use of X.509 certificates for encrypted communication is demonstrated also.
 #include <express/legacy/in/WebApp.h>
 #include <express/tls/in/WebApp.h>
 #include <express/middleware/StaticMiddleware.h>
-#include <log/Logger.h>
+#include <SemanticLog.h>
 #include <utils/Config.h>
 int main(int argc, char* argv[]) {
     utils::Config::add_string_option("--web-root", "Root directory of the web site", "[path]");
@@ -2080,11 +2080,11 @@ int main(int argc, char* argv[]) {
 
     legacyApp.listen(8080, [](const LegacySocketAddress& socketAddress, int errnum) {
         if (errnum < 0) {
-            PLOG(ERROR) << "OnError";
+            snode::semantic::sysError(snode::semantic::appLog(), logger::LogLevel::Error, errno) << "OnError";
         } else if (errnum > 0) {
-            PLOG(ERROR) << "OnError: " << socketAddress.toString();
+            snode::semantic::sysError(snode::semantic::appLog(), logger::LogLevel::Error, errno) << "OnError: " << socketAddress.toString();
         } else {
-            VLOG(0) << "snode.c listening on " << socketAddress.toString();
+            snode::semantic::appLog().trace() << "snode.c listening on " << socketAddress.toString();
         }
     });
 
@@ -2102,11 +2102,11 @@ int main(int argc, char* argv[]) {
 
     tlsApp.listen(8088, [](const TLSSocketAddress& socketAddress, int errnum) {
         if (errnum < 0) {
-            PLOG(ERROR) << "OnError";
+            snode::semantic::sysError(snode::semantic::appLog(), logger::LogLevel::Error, errno) << "OnError";
         } else if (errnum > 0) {
-            PLOG(ERROR) << "OnError: " << socketAddress.toString();
+            snode::semantic::sysError(snode::semantic::appLog(), logger::LogLevel::Error, errno) << "OnError: " << socketAddress.toString();
         } else {
-            VLOG(0) << "snode.c listening on " << socketAddress.toString();
+            snode::semantic::appLog().trace() << "snode.c listening on " << socketAddress.toString();
         }
     });
 
@@ -2121,7 +2121,7 @@ The high-level web API provides the methods `get()`, `post()`, `put()`, etc like
 ``` cpp
 #include <express/legacy/in/WebApp.h>
 #include <express/tls/in/WebApp.h>
-#include <log/Logger.h>
+#include <SemanticLog.h>
 
 int main(int argc, char* argv[]) {
     express::WebApp::init(argc, argv);
@@ -2184,9 +2184,9 @@ int main(int argc, char* argv[]) {
 
     legacyApp.listen(8080, [](const LegacySocketAddress& socketAddress, int errnum) -> void {
         if (errnum != 0) {
-            PLOG(ERROR) << "OnError: " << socketAddress.toString();
+            snode::semantic::sysError(snode::semantic::appLog(), logger::LogLevel::Error, errno) << "OnError: " << socketAddress.toString();
         } else {
-            VLOG(0) << "LegacyWebApp listening on " << socketAddress.toString();
+            snode::semantic::appLog().trace() << "LegacyWebApp listening on " << socketAddress.toString();
         }
     });
 
@@ -2205,9 +2205,9 @@ int main(int argc, char* argv[]) {
 
     tlsApp.listen(8088, [](const TLSSocketAddress& socketAddress, int errnum) -> void {
         if (errnum != 0) {
-            PLOG(ERROR) << "OnError: " << socketAddress.toString();
+            snode::semantic::sysError(snode::semantic::appLog(), logger::LogLevel::Error, errno) << "OnError: " << socketAddress.toString();
         } else {
-            VLOG(0) << "TLSWebApp listening on " << socketAddress.toString();
+            snode::semantic::appLog().trace() << "TLSWebApp listening on " << socketAddress.toString();
         }
     });
 

src/SemanticLog.h

@@ -0,0 +1,141 @@
+/*
+ * snode.c - a slim toolkit for network communication
+ * Copyright (C) 2020, 2021, 2022, 2023 Volker Christian
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+#ifndef SNODEC_SEMANTICLOG_H
+#define SNODEC_SEMANTICLOG_H
+
+#include <log/Logger.h>
+
+#include <cerrno>
+#include <ostream>
+
+namespace logger {
+
+    enum class LogLevel {
+        Trace,
+        Debug,
+        Info,
+        Warning,
+        Error,
+        Critical,
+    };
+
+} // namespace logger
+
+namespace snode::semantic {
+
+    namespace detail {
+
+        inline el::Level backendLevel(logger::LogLevel level) {
+            switch (level) {
+                case logger::LogLevel::Trace:
+                    return el::Level::Trace;
+                case logger::LogLevel::Debug:
+                    return el::Level::Debug;
+                case logger::LogLevel::Info:
+                    return el::Level::Info;
+                case logger::LogLevel::Warning:
+                    return el::Level::Warning;
+                case logger::LogLevel::Error:
+                    return el::Level::Error;
+                case logger::LogLevel::Critical:
+                    return el::Level::Fatal;
+            }
+
+            return el::Level::Info;
+        }
+
+        inline el::Level captureSystemError(logger::LogLevel level, int errnum) {
+            errno = errnum;
+            return backendLevel(level);
+        }
+
+    } // namespace detail
+
+    class LogStream {
+    public:
+        explicit LogStream(logger::LogLevel level)
+            : writer(detail::backendLevel(level), "", 0, "") {
+            writer.construct(el::Loggers::getLogger("default"));
+        }
+
+        template <typename Value>
+        LogStream& operator<<(const Value& value) {
+            writer << value;
+            return *this;
+        }
+
+        LogStream& operator<<(std::ostream& (*manipulator)(std::ostream&)) {
+            writer << manipulator;
+            return *this;
+        }
+
+    private:
+        el::base::Writer writer;
+    };
+
+    class SystemErrorStream {
+    public:
+        SystemErrorStream(logger::LogLevel level, int errnum)
+            : writer(detail::captureSystemError(level, errnum), "", 0, "") {
+            writer.construct(el::Loggers::getLogger("default"));
+        }
+
+        template <typename Value>
+        SystemErrorStream& operator<<(const Value& value) {
+            writer << value;
+            return *this;
+        }
+
+        SystemErrorStream& operator<<(std::ostream& (*manipulator)(std::ostream&)) {
+            writer << manipulator;
+            return *this;
+        }
+
+    private:
+        el::base::PErrorWriter writer;
+    };
+
+    class AppLog {
+    public:
+        LogStream trace() const {
+            return LogStream(logger::LogLevel::Trace);
+        }
+
+        LogStream debug() const {
+            return LogStream(logger::LogLevel::Debug);
+        }
+
+        LogStream info() const {
+            return LogStream(logger::LogLevel::Info);
+        }
+
+        LogStream warn() const {
+            return LogStream(logger::LogLevel::Warning);
+        }
+
+        LogStream error() const {
+            return LogStream(logger::LogLevel::Error);
+        }
+
+        LogStream critical() const {
+            return LogStream(logger::LogLevel::Critical);
+        }
+    };
+
+    inline const AppLog& appLog() {
+        static const AppLog log;
+        return log;
+    }
+
+    inline SystemErrorStream sysError(const AppLog&, logger::LogLevel level, int errnum) {
+        return SystemErrorStream(level, errnum);
+    }
+
+} // namespace snode::semantic
+
+#endif // SNODEC_SEMANTICLOG_H

src/apps/configtest.cpp

@@ -1,3 +1,4 @@
+#include <SemanticLog.h>
 #include "log/Logger.h"
 
 #ifdef __GNUC__
@@ -31,7 +32,7 @@ int main(int argc, char* argv[]) {
     CLI::Option* filenameOpt = subApp->add_option("-f", filename, "A Filename");
     //    filenameOpt->default_val("Filenameeeeee");
 
-    VLOG(0) << "Filename: " << filename;
+    snode::semantic::appLog().trace() << "Filename: " << filename;
 
     //    app.needs(subApp);
     //    subApp->needs(filenameOpt);