SNodeC · dependabot · Aug 12, 2026 · Aug 31, 2026 · Aug 31, 2026
diff --git a/README.md b/README.md
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -216,3 +216,9 @@ install(
     DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/snodec
     COMPONENT "core"
 )
+
+install(
+    FILES "${CMAKE_CURRENT_SOURCE_DIR}/SemanticLog.h"
+    DESTINATION include/snode.c
+    COMPONENT "logger"
+)
diff --git a/src/apps/oauth2/client_app/vue-frontend-oauth2-client/package-lock.json b/src/apps/oauth2/client_app/vue-frontend-oauth2-client/package-lock.json
diff --git a/src/express/express-compat-suite/snodec/0001-add-express-compat-server.patch b/src/express/express-compat-suite/snodec/0001-add-express-compat-server.patch
@@ -27,7 +27,7 @@ new file mode 100644
 +#include "express/Response.h"
 +#include "express/Router.h"
 +#include "express/legacy/in/WebApp.h"
-+#include "log/Logger.h"
++#include "SemanticLog.h"
 +
 +#include <nlohmann/json.hpp>
 +
@@ -263,16 +263,16 @@ new file mode 100644
 +        [](const express::legacy::in::WebApp::SocketAddress& socketAddress, const core::socket::State& state) {
 +            switch (state) {
 +                case core::socket::State::OK:
-+                    VLOG(1) << "express-compat listening on '" << socketAddress.toString() << "'";
++                    snode::semantic::appLog().info() << "express-compat listening on '" << socketAddress.toString() << "'";
 +                    break;
 +                case core::socket::State::DISABLED:
-+                    VLOG(1) << "express-compat disabled";
++                    snode::semantic::appLog().info() << "express-compat disabled";
 +                    break;
 +                case core::socket::State::ERROR:
-+                    LOG(ERROR) << "express-compat " << socketAddress.toString() << ": " << state.what();
++                    snode::semantic::appLog().error() << "express-compat " << socketAddress.toString() << ": " << state.what();
 +                    break;
 +                case core::socket::State::FATAL:
-+                    LOG(FATAL) << "express-compat " << socketAddress.toString() << ": " << state.what();
++                    snode::semantic::appLog().critical() << "express-compat " << socketAddress.toString() << ": " << state.what();
 +                    break;
 +            }
 +        });

diff --git a/src/log/Logger.cpp b/src/log/Logger.cpp
@@ -46,7 +46,6 @@
 #include "log/SemanticLogger.h"
 #include "log/detail/SpdlogBackend.h"
 
-#include <cerrno>
 #include <utility>
 
 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
@@ -127,24 +126,6 @@ namespace logger {
 
     bool Logger::disableColorLog = false;
 
-    LogMessage::LogMessage(const Level level, const int verboseLevel, const bool withErrno)
-        : level(level)
-        , verboseLevel(verboseLevel)
-        , withErrno(withErrno)
-        , enabled(true)
-        , errnoValue(errno) {
-    }
-
-    LogMessage::~LogMessage() {
-        if (enabled) {
-            backend.emitLegacy(level, message.str(), withErrno, errnoValue);
-        }
-    }
-
-    std::ostringstream& LogMessage::stream() {
-        return message;
-    }
-
 } // namespace logger
 
 std::ostream& Color::operator<<(std::ostream& os, const Code& code) {

diff --git a/src/log/Logger.h b/src/log/Logger.h
@@ -49,7 +49,6 @@
 #include <functional>
 #include <memory>
 #include <ostream> // IWYU pragma: export
-#include <sstream>
 #include <string>
 
 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
@@ -122,54 +121,6 @@ namespace logger {
         friend std::string Color::operator+(const Color::Code& code, const std::string& string);
     };
 
-    class LogMessage {
-    public:
-        LogMessage(Level level, int verboseLevel = -1, bool withErrno = false);
-        ~LogMessage();
-
-        std::ostringstream& stream();
-
-    private:
-        Level level;
-        int verboseLevel;
-        bool withErrno;
-        bool enabled;
-        int errnoValue;
-        std::ostringstream message;
-    };
-
 } // namespace logger
 
-#ifdef SNODEC_DISABLE_LOGLEVEL_LOGGING
-#define LOG(level)                                                                                                                         \
-    if (true) {                                                                                                                            \
-    } else                                                                                                                                 \
-        ::logger::LogMessage(::logger::Level::level).stream()
-#define PLOG(level)                                                                                                                        \
-    if (true) {                                                                                                                            \
-    } else                                                                                                                                 \
-        ::logger::LogMessage(::logger::Level::level, -1, true).stream()
-#else
-#define LOG(level)                                                                                                                         \
-    if (!::logger::Logger::shouldLog(::logger::Level::level)) {                                                                            \
-    } else                                                                                                                                 \
-        ::logger::LogMessage(::logger::Level::level).stream()
-#define PLOG(level)                                                                                                                        \
-    if (!::logger::Logger::shouldLog(::logger::Level::level)) {                                                                            \
-    } else                                                                                                                                 \
-        ::logger::LogMessage(::logger::Level::level, -1, true).stream()
-#endif
-
-#ifdef SNODEC_DISABLE_VERBOSE_LOGGING
-#define VLOG(level)                                                                                                                        \
-    if (true) {                                                                                                                            \
-    } else                                                                                                                                 \
-        ::logger::LogMessage(::logger::Level::VERBOSE, level).stream()
-#else
-#define VLOG(level)                                                                                                                        \
-    if (!::logger::Logger::shouldVerbose(level)) {                                                                                         \
-    } else                                                                                                                                 \
-        ::logger::LogMessage(::logger::Level::VERBOSE, level).stream()
-#endif
-
 #endif // LOGGER_LOGGER_H
diff --git a/tests/unit/log/CMakeLists.txt b/tests/unit/log/CMakeLists.txt
@@ -25,10 +25,6 @@ snodec_add_log_test(SemanticLoggerFilteringTest)
 target_link_libraries(SemanticLoggerFilteringTest PRIVATE snodec-test-support snodec::net snodec::core-socket-stream)
 set_property(TEST SemanticLoggerFilteringTest APPEND PROPERTY LABELS "filter")
 
-snodec_add_log_test(SemanticLoggerCompatibilityTest)
-target_link_libraries(SemanticLoggerCompatibilityTest PRIVATE snodec-test-support snodec::logger)
-set_property(TEST SemanticLoggerCompatibilityTest APPEND PROPERTY LABELS "compatibility;legacy")
-
 snodec_add_log_test(SemanticLoggerDisabledPathTest)
 target_link_libraries(SemanticLoggerDisabledPathTest PRIVATE snodec-test-support snodec::net snodec::core-socket-stream)
 set_property(TEST SemanticLoggerDisabledPathTest APPEND PROPERTY LABELS "overhead")

diff --git a/tests/unit/log/SemanticEndToEndOutputTest.cpp b/tests/unit/log/SemanticEndToEndOutputTest.cpp
@@ -132,23 +132,23 @@ int main() {
         }
     }
 
-    const auto legacyPath = tempLogPath("snodec-semantic-e2e-legacy.log");
+    const auto helperPath = tempLogPath("snodec-semantic-e2e-helper.log");
     {
-        LoggerStateGuard guard(legacyPath);
-        LOG(INFO) << "legacy info still works";
-        errno = EACCES;
-        PLOG(ERROR) << "legacy plog still works";
+        LoggerStateGuard guard(helperPath);
+        snode::semantic::appLog().info() << "semantic info works";
+        snode::semantic::sysError(snode::semantic::appLog(), logger::LogLevel::Error, EACCES)
+            << "semantic system error works";
     }
-    const auto legacyLines = readLines(legacyPath);
-    std::ostringstream legacyLog;
-    for (const auto& line : legacyLines) {
-        legacyLog << line << '\n';
+    const auto helperLines = readLines(helperPath);
+    std::ostringstream helperLog;
+    for (const auto& line : helperLines) {
+        helperLog << line << '\n';
     }
-    result.expectTrue(contains(legacyLog.str(), "INFO") && contains(legacyLog.str(), "legacy info still works"),
-                      "legacy LOG still emits through the legacy path");
-    result.expectTrue(contains(legacyLog.str(), "ERROR") && contains(legacyLog.str(), "legacy plog still works") &&
-                          contains(legacyLog.str(), "Permission denied"),
-                      "legacy PLOG still appends errno text through the legacy path");
+    result.expectTrue(contains(helperLog.str(), "INFO") && contains(helperLog.str(), "semantic info works"),
+                      "semantic application helper emits through the backend");
+    result.expectTrue(contains(helperLog.str(), "ERROR") && contains(helperLog.str(), "semantic system error works") &&
+                          contains(helperLog.str(), "Permission denied"),
+                      "semantic sysError appends explicit error text");
 
     std::vector<logger::LogRecord> identityRecords;
     auto identityLog = snode::semantic::coreSocketLog(

diff --git a/tests/unit/log/SemanticLoggerBackendTest.cpp b/tests/unit/log/SemanticLoggerBackendTest.cpp
@@ -1,3 +1,4 @@
+#include "SemanticLog.h"
 #include "core/socket/SocketAddress.h"
 #include "core/socket/stream/SocketConnection.h"
 #include "core/socket/stream/SocketContext.h"
@@ -166,14 +167,15 @@ int main() {
         LoggerStateGuard guard(semanticPath.string());
         logger::Logger::emitSemantic(record(logger::LogLevel::Info, "semantic info emitted"));
         logger::Logger::emitSemantic(record(logger::LogLevel::Off, "semantic off hidden"));
-        LOG(INFO) << "legacy macro emitted";
+        snode::semantic::appLog().info() << "semantic helper emitted";
     }
     const auto semanticLog = readFile(semanticPath);
     result.expectTrue(semanticLog.find("INFO") != std::string::npos, "semantic info maps to legacy INFO label");
     result.expectTrue(semanticLog.find("semantic info emitted") != std::string::npos, "semantic info emits through file backend");
     result.expectTrue(semanticLog.find("semantic off hidden") == std::string::npos, "semantic off emits nothing");
     result.expectTrue(semanticLog.find("BACKENDTICK000") != std::string::npos, "semantic emission uses legacy tick resolver pattern");
-    result.expectTrue(semanticLog.find("legacy macro emitted") != std::string::npos, "legacy LOG macro still emits through backend");
+    result.expectTrue(semanticLog.find("semantic helper emitted") != std::string::npos,
+                      "semantic application helper emits through backend");
 
     const auto filteredPath = tempLogPath("snodec-backend-filtered.log");
     {

diff --git a/tests/unit/log/SemanticLoggerCompatibilityTest.cpp b/tests/unit/log/SemanticLoggerCompatibilityTest.cpp
diff --git a/tests/unit/log/SemanticLoggerFilteringTest.cpp b/tests/unit/log/SemanticLoggerFilteringTest.cpp
@@ -178,17 +178,11 @@ int main() {
         logger::Logger::setLogLevel(3);
         logger::Logger::emitSemantic(record(logger::LogLevel::Info, "backend info hidden"));
         logger::Logger::emitSemantic(record(logger::LogLevel::Warn, "backend warn visible"));
-        LOG(INFO) << "legacy info hidden";
-        LOG(WARNING) << "legacy warning visible";
     }
     const auto gateLog = readFile(gatePath);
     result.expectTrue(gateLog.find("backend info hidden") != std::string::npos,
                       "semantic records accepted by LogManager are not double-gated by Logger::setLogLevel");
     result.expectTrue(gateLog.find("backend warn visible") != std::string::npos, "semantic warning still emits after semantic filtering");
-    result.expectTrue(gateLog.find("legacy info hidden") == std::string::npos &&
-                          gateLog.find("legacy warning visible") != std::string::npos,
-                      "legacy LOG macro behavior remains unchanged");
-
     const auto jsonPath = tempLogPath("snodec-filtering-json-format.log");
     {
         LoggerStateGuard guard(jsonPath.string());