SNodeC · VolkerChristian · Aug 31, 2026
diff --git a/README.md b/README.md
diff --git a/src/SemanticLog.h b/src/SemanticLog.h
@@ -0,0 +1,85 @@
+#ifndef SNODEC_SEMANTICLOG_H
+#define SNODEC_SEMANTICLOG_H
+
+#include "log/Logger.h"
+
+#include <cerrno>
+
+namespace logger {
+
+    enum class LogLevel {
+        Trace,
+        Debug,
+        Info,
+        Warning,
+        Error,
+        Critical,
+    };
+
+} // namespace logger
+
+namespace snode::semantic {
+
+    namespace detail {
+
+        inline logger::Level backendLevel(logger::LogLevel level) {
+            switch (level) {
+                case logger::LogLevel::Trace:
+                    return logger::Level::TRACE;
+                case logger::LogLevel::Debug:
+                    return logger::Level::DEBUG;
+                case logger::LogLevel::Info:
+                    return logger::Level::INFO;
+                case logger::LogLevel::Warning:
+                    return logger::Level::WARNING;
+                case logger::LogLevel::Error:
+                    return logger::Level::ERROR;
+                case logger::LogLevel::Critical:
+                    return logger::Level::FATAL;
+            }
+
+            return logger::Level::INFO;
+        }
+
+    } // namespace detail
+
+    class AppLog {
+    public:
+        logger::LogMessage trace() const {
+            return logger::LogMessage(logger::Level::TRACE);
+        }
+
+        logger::LogMessage debug() const {
+            return logger::LogMessage(logger::Level::DEBUG);
+        }
+
+        logger::LogMessage info() const {
+            return logger::LogMessage(logger::Level::INFO);
+        }
+
+        logger::LogMessage warn() const {
+            return logger::LogMessage(logger::Level::WARNING);
+        }
+
+        logger::LogMessage error() const {
+            return logger::LogMessage(logger::Level::ERROR);
+        }
+
+        logger::LogMessage critical() const {
+            return logger::LogMessage(logger::Level::FATAL);
+        }
+    };
+
+    inline const AppLog& appLog() {
+        static const AppLog log;
+        return log;
+    }
+
+    inline logger::LogMessage sysError(const AppLog&, logger::LogLevel level, int errnum) {
+        errno = errnum;
+        return logger::LogMessage(detail::backendLevel(level), -1, true);
+    }
+
+} // namespace snode::semantic
+
+#endif // SNODEC_SEMANTICLOG_H
diff --git a/src/apps/configtest.cpp b/src/apps/configtest.cpp
@@ -1,3 +1,4 @@
+#include <SemanticLog.h>
 /*
  * SNode.C - A Slim Toolkit for Network Communication
  * Copyright (C) Volker Christian <me@vchrist.at>
@@ -82,7 +83,7 @@ int main(int argc, char* argv[]) {
     CLI::Option* filenameOpt = subApp->add_option("-f", filename, "A Filename");
     //    filenameOpt->default_val("Filenameeeeee");
 
-    VLOG(1) << "Filename: " << filename;
+    snode::semantic::appLog().trace() << "Filename: " << filename;
 
     //    app.needs(subApp);
     //    subApp->needs(filenameOpt);

diff --git a/src/apps/database/testmariadb.cpp b/src/apps/database/testmariadb.cpp
diff --git a/src/apps/echo/echoclient.cpp b/src/apps/echo/echoclient.cpp
@@ -1,3 +1,4 @@
+#include <SemanticLog.h>
 /*
  * SNode.C - A Slim Toolkit for Network Communication
  * Copyright (C) Volker Christian <me@vchrist.at>
@@ -59,33 +60,33 @@ int main(int argc, char* argv[]) {
         [instanceName = client.getConfig()->getInstanceName()](const SocketAddress& socketAddress, const core::socket::State& state) {
             switch (state) {
                 case core::socket::State::OK:
-                    VLOG(1) << instanceName << ": connected to '" << socketAddress.toString() << "'";
+                    snode::semantic::appLog().trace() << instanceName << ": connected to '" << socketAddress.toString() << "'";
                     break;
                 case core::socket::State::DISABLED:
-                    VLOG(1) << instanceName << ": disabled";
+                    snode::semantic::appLog().trace() << instanceName << ": disabled";
                     break;
                 case core::socket::State::ERROR:
-                    LOG(ERROR) << instanceName << ": " << socketAddress.toString() << ": " << state.what();
+                    snode::semantic::appLog().error() << instanceName << ": " << socketAddress.toString() << ": " << state.what();
                     break;
                 case core::socket::State::FATAL:
-                    LOG(FATAL) << instanceName << ": " << socketAddress.toString() << ": " << state.what();
+                    snode::semantic::appLog().critical() << instanceName << ": " << socketAddress.toString() << ": " << state.what();
                     break;
             }
         });
     /*
         client.connect([](const SocketAddress& socketAddress, const core::socket::State& state) {
             switch (state) {
                 case core::socket::State::OK:
-                    VLOG(1) << "echoclient: connected to '" << socketAddress.toString() << "'" << "'";
+                    snode::semantic::appLog().trace() << "echoclient: connected to '" << socketAddress.toString() << "'" << "'";
                     break;
                 case core::socket::State::DISABLED:
-                    VLOG(1) << "echoclient: disabled";
+                    snode::semantic::appLog().trace() << "echoclient: disabled";
                     break;
                 case core::socket::State::ERROR:
-                    VLOG(1) << "echoclientt: error occurred";
+                    snode::semantic::appLog().trace() << "echoclientt: error occurred";
                     break;
                 case core::socket::State::FATAL:
-                    VLOG(1) << "echoclient: fatal error occurred";
+                    snode::semantic::appLog().trace() << "echoclient: fatal error occurred";
                     break;
             }
         });
@@ -121,12 +122,12 @@ int main(int argc, char* argv[]) {
 #endif
 
     if (errnum < 0) {
-        PLOG(ERROR) << "OnError";
+        snode::semantic::sysError(snode::semantic::appLog(), logger::LogLevel::Error, errno) << "OnError";
     } else if (errnum > 0) {
         errno = errnum;
-        PLOG(ERROR) << "OnError: " << socketAddress.toString();
+        snode::semantic::sysError(snode::semantic::appLog(), logger::LogLevel::Error, errno) << "OnError: " << socketAddress.toString();
     } else {
-        VLOG(1) << "snode.c connecting to " << socketAddress.toString();
+        snode::semantic::appLog().trace() << "snode.c connecting to " << socketAddress.toString();
     }
 
 #ifdef NET_TYPE

diff --git a/src/apps/echo/echoserver.cpp b/src/apps/echo/echoserver.cpp
@@ -1,3 +1,4 @@
+#include <SemanticLog.h>
 /*
  * SNode.C - A Slim Toolkit for Network Communication
  * Copyright (C) Volker Christian <me@vchrist.at>
@@ -83,16 +84,16 @@ int main(int argc, char* argv[]) {
                                                                          const core::socket::State& state) {
         switch (state) {
             case core::socket::State::OK:
-                VLOG(1) << instanceName << ": listening on '" << socketAddress.toString() << "'";
+                snode::semantic::appLog().trace() << instanceName << ": listening on '" << socketAddress.toString() << "'";
                 break;
             case core::socket::State::DISABLED:
-                VLOG(1) << instanceName << ": disabled";
+                snode::semantic::appLog().trace() << instanceName << ": disabled";
                 break;
             case core::socket::State::ERROR:
-                LOG(ERROR) << instanceName << ": " << socketAddress.toString() << ": " << state.what();
+                snode::semantic::appLog().error() << instanceName << ": " << socketAddress.toString() << ": " << state.what();
                 break;
             case core::socket::State::FATAL:
-                LOG(FATAL) << instanceName << ": " << socketAddress.toString() << ": " << state.what();
+                snode::semantic::appLog().critical() << instanceName << ": " << socketAddress.toString() << ": " << state.what();
                 break;
         }
     });
@@ -127,9 +128,9 @@ int main(int argc, char* argv[]) {
      server.listen("/tmp/testme", 5, [](const SocketServer::Socket& socket, int errnum) { // titan
 #endif
         if (errnum != 0) {
-            PLOG(FATAL) << "listen";
+            snode::semantic::sysError(snode::semantic::appLog(), logger::LogLevel::Critical, errno) << "listen";
         } else {
-            VLOG(1) << "snode.c listening on " << socket.getBindAddress().toString();
+            snode::semantic::appLog().trace() << "snode.c listening on " << socket.getBindAddress().toString();
         }
 
 #ifdef NET_TYPE

diff --git a/src/apps/echo/model/EchoSocketContext.cpp b/src/apps/echo/model/EchoSocketContext.cpp
@@ -1,3 +1,4 @@
+#include <SemanticLog.h>
 /*
  * SNode.C - A Slim Toolkit for Network Communication
  * Copyright (C) Volker Christian <me@vchrist.at>
@@ -57,15 +58,15 @@ namespace apps::echo::model {
     }
 
     void EchoSocketContext::onConnected() {
-        VLOG(1) << "Echo connected";
+        snode::semantic::appLog().trace() << "Echo connected";
 
         if (role == Role::CLIENT) {
             sendToPeer("Hello peer! Nice to see you!!!");
         }
     }
 
     void EchoSocketContext::onDisconnected() {
-        VLOG(1) << "Echo disconnected";
+        snode::semantic::appLog().trace() << "Echo disconnected";
     }
 
     bool EchoSocketContext::onSignal([[maybe_unused]] int signum) {
@@ -78,7 +79,7 @@ namespace apps::echo::model {
         const std::size_t chunklen = readFromPeer(chunk, 4096);
 
         if (chunklen > 0) {
-            VLOG(1) << "Data to reflect: " << std::string(chunk, chunklen);
+            snode::semantic::appLog().trace() << "Data to reflect: " << std::string(chunk, chunklen);
             sendToPeer(chunk, chunklen);
         }
 

diff --git a/src/apps/echo/model/clients.h b/src/apps/echo/model/clients.h
@@ -1,3 +1,4 @@
+#include <SemanticLog.h>
 /*
  * SNode.C - A Slim Toolkit for Network Communication
  * Copyright (C) Volker Christian <me@vchrist.at>
@@ -90,10 +91,10 @@ namespace apps::echo::model::tls {
         EchoSocketClient client("echoclient");
 
         client.setOnConnect([&client](SocketConnection* socketConnection) { // onConnect
-            VLOG(1) << "OnConnect " << client.getConfig()->getInstanceName();
+            snode::semantic::appLog().trace() << "OnConnect " << client.getConfig()->getInstanceName();
 
-            VLOG(1) << "\tLocal: " << socketConnection->getLocalAddress().toString();
-            VLOG(1) << "\tPeer:  " << socketConnection->getRemoteAddress().toString();
+            snode::semantic::appLog().trace() << "\tLocal: " << socketConnection->getLocalAddress().toString();
+            snode::semantic::appLog().trace() << "\tPeer:  " << socketConnection->getRemoteAddress().toString();
 
             /* Enable automatic hostname checks */
             // X509_VERIFY_PARAM* param = SSL_get0_param(socketConnection->getSSL());
@@ -106,21 +107,21 @@ namespace apps::echo::model::tls {
         });
 
         client.setOnConnected([&client](SocketConnection* socketConnection) { // onConnected
-            VLOG(1) << "OnConnected " << client.getConfig()->getInstanceName();
+            snode::semantic::appLog().trace() << "OnConnected " << client.getConfig()->getInstanceName();
 
             X509* server_cert = SSL_get_peer_certificate(socketConnection->getSSL());
             if (server_cert != nullptr) {
                 const long verifyErr = SSL_get_verify_result(socketConnection->getSSL());
 
-                VLOG(1) << "\tPeer certificate verifyErr = " + std::to_string(verifyErr) + ": " +
+                snode::semantic::appLog().trace() << "\tPeer certificate verifyErr = " + std::to_string(verifyErr) + ": " +
                                std::string(X509_verify_cert_error_string(verifyErr));
 
                 char* str = X509_NAME_oneline(X509_get_subject_name(server_cert), nullptr, 0);
-                VLOG(1) << "\t   Subject: " + std::string(str);
+                snode::semantic::appLog().trace() << "\t   Subject: " + std::string(str);
                 OPENSSL_free(str);
 
                 str = X509_NAME_oneline(X509_get_issuer_name(server_cert), nullptr, 0);
-                VLOG(1) << "\t   Issuer: " + std::string(str);
+                snode::semantic::appLog().trace() << "\t   Issuer: " + std::string(str);
                 OPENSSL_free(str);
 
                 // We could do all sorts of certificate verification stuff here before deallocating the certificate.
@@ -130,37 +131,37 @@ namespace apps::echo::model::tls {
 
                 const int32_t altNameCount = sk_GENERAL_NAME_num(subjectAltNames);
 
-                VLOG(1) << "\t   Subject alternative name count: " << altNameCount;
+                snode::semantic::appLog().trace() << "\t   Subject alternative name count: " << altNameCount;
                 for (int32_t i = 0; i < altNameCount; ++i) {
                     GENERAL_NAME* generalName = sk_GENERAL_NAME_value(subjectAltNames, i);
                     if (generalName->type == GEN_URI) {
                         const std::string subjectAltName =
                             std::string(reinterpret_cast<const char*>(ASN1_STRING_get0_data(generalName->d.uniformResourceIdentifier)),
                                         static_cast<std::size_t>(ASN1_STRING_length(generalName->d.uniformResourceIdentifier)));
-                        VLOG(1) << "\t      SAN (URI): '" + subjectAltName;
+                        snode::semantic::appLog().trace() << "\t      SAN (URI): '" + subjectAltName;
                     } else if (generalName->type == GEN_DNS) {
                         const std::string subjectAltName =
                             std::string(reinterpret_cast<const char*>(ASN1_STRING_get0_data(generalName->d.dNSName)),
                                         static_cast<std::size_t>(ASN1_STRING_length(generalName->d.dNSName)));
-                        VLOG(1) << "\t      SAN (DNS): '" + subjectAltName;
+                        snode::semantic::appLog().trace() << "\t      SAN (DNS): '" + subjectAltName;
                     } else {
-                        VLOG(1) << "\t      SAN (Type): '" + std::to_string(generalName->type);
+                        snode::semantic::appLog().trace() << "\t      SAN (Type): '" + std::to_string(generalName->type);
                     }
                 }
 
                 sk_GENERAL_NAME_pop_free(subjectAltNames, GENERAL_NAME_free);
 
                 X509_free(server_cert);
             } else {
-                VLOG(1) << "\tPeer certificate: no certificate";
+                snode::semantic::appLog().trace() << "\tPeer certificate: no certificate";
             }
         });
 
         client.setOnDisconnect([&client](SocketConnection* socketConnection) { // onDisconnect
-            VLOG(1) << "OnDisconnect " << client.getConfig()->getInstanceName();
+            snode::semantic::appLog().trace() << "OnDisconnect " << client.getConfig()->getInstanceName();
 
-            VLOG(1) << "\tLocal: " << socketConnection->getLocalAddress().toString();
-            VLOG(1) << "\tPeer:  " << socketConnection->getRemoteAddress().toString();
+            snode::semantic::appLog().trace() << "\tLocal: " << socketConnection->getLocalAddress().toString();
+            snode::semantic::appLog().trace() << "\tPeer:  " << socketConnection->getRemoteAddress().toString();
         });
 
         return client;