Logging: wrap poco and simplify logging.

Centralize more logging functionality in Log.cpp, simplify and
wrap underlying logging APIs better.

Code is much more generic, and hides implementation details
much more thoroughly, while keeping the same API / wrappers.

To do this we have to sub-class Poco::Logger to get access to
its generic 'log' method instead of a mess of in-line wrappers,
this lets us avoid lots of code.

Change-Id: I541d3aef49f99ce582655c5102a0041bf84cd56a
Signed-off-by: Michael Meeks <michael.meeks@collabora.com>

14 files changed, 253 insertions, 201 deletions

diff --git a/common/Log.cpp b/common/Log.cpp
index 2d31b9687c..7efaafd1d3 100644
--- a/common/Log.cpp
+++ b/common/Log.cpp
@@ -30,6 +30,7 @@
 
 #include <Poco/AutoPtr.h>
 #include <Poco/FileChannel.h>
+#include <Poco/Logger.h>
 
 #include "Log.hpp"
 #include "Util.hpp"
@@ -49,6 +50,67 @@ constexpr int LOG_FILE_FD = STDERR_FILENO;
 
 } // namespace
 
+/// Wrapper to expose protected 'log' and genericise
+class GenericLogger : public Poco::Logger
+{
+public:
+    GenericLogger(const std::string& name,
+                  Poco::AutoPtr<Poco::Channel> chan, int lvl)
+        : Poco::Logger(name, chan, lvl)
+    {
+    }
+
+    static GenericLogger& create(const std::string& name,
+                                 Poco::AutoPtr<Poco::Channel> chan, int lvl)
+    {
+        // Expect no thread contention creating
+        // loggers and we can't access the internal mutex.
+        if (find(name))
+            throw Poco::ExistsException();
+        auto log = new GenericLogger(name, chan, lvl);
+        add(log);
+        return *log;
+    }
+
+    void doLog(Log::Level l, const std::string& text)
+    {
+        Poco::Message::Priority prio = Poco::Message::Priority::PRIO_TRACE;
+#define MAP(l,p) case Log::Level::l: prio = Poco::Message::Priority::p;break
+        switch (l) {
+            MAP(FTL, PRIO_FATAL);
+            MAP(CTL, PRIO_CRITICAL);
+            MAP(ERR, PRIO_ERROR);
+            MAP(WRN, PRIO_WARNING);
+            MAP(NTC, PRIO_NOTICE);
+            MAP(INF, PRIO_INFORMATION);
+            MAP(DBG, PRIO_DEBUG);
+            MAP(TRC, PRIO_TRACE);
+        default:
+            break;
+#undef MAP
+        }
+        log(text, prio);
+    }
+
+    static Log::Level mapToLevel(Poco::Message::Priority prio)
+    {
+#define MAP(l,p) case Poco::Message::Priority::p: return Log::Level::l;
+        switch (prio) {
+            MAP(FTL, PRIO_FATAL);
+            MAP(CTL, PRIO_CRITICAL);
+            MAP(ERR, PRIO_ERROR);
+            MAP(WRN, PRIO_WARNING);
+            MAP(NTC, PRIO_NOTICE);
+            MAP(INF, PRIO_INFORMATION);
+            MAP(DBG, PRIO_DEBUG);
+            MAP(TRC, PRIO_TRACE);
+        default:
+            return Log::Level::TRC;
+        }
+#undef MAP
+    }
+};
+
 namespace Log
 {
     using namespace Poco;
@@ -304,8 +366,8 @@ namespace Log
     static struct StaticHelper
     {
     private:
-        Poco::Logger* _logger;
-        static thread_local Poco::Logger* _threadLocalLogger;
+        GenericLogger* _logger;
+        static thread_local GenericLogger* _threadLocalLogger;
         std::string _name;
         std::string _logLevel;
         std::string _id;
@@ -335,9 +397,9 @@ namespace Log
 
         const std::string& getLevel() const { return _logLevel; }
 
-        void setLogger(Poco::Logger* logger) { _logger = logger; };
+        void setLogger(GenericLogger* logger) { _logger = logger; };
 
-        void setThreadLocalLogger(Poco::Logger* logger)
+        void setThreadLocalLogger(GenericLogger* logger)
         {
             // FIXME: What to do with the previous thread-local logger, if any? Will deleting it
             // destroy also its channel? That won't be good as we use the same channel for all
@@ -345,13 +407,13 @@ namespace Log
             _threadLocalLogger = logger;
         }
 
-        Poco::Logger* getLogger() const { return _logger; }
+        GenericLogger* getLogger() const { return _logger; }
 
-        Poco::Logger* getThreadLocalLogger() const { return _threadLocalLogger; }
+        GenericLogger* getThreadLocalLogger() const { return _threadLocalLogger; }
 
     } Static;
 
-    thread_local Poco::Logger* StaticHelper::_threadLocalLogger = nullptr;
+    thread_local GenericLogger* StaticHelper::_threadLocalLogger = nullptr;
 
     bool IsShutdown = false;
 
@@ -562,13 +624,13 @@ namespace Log
 
         try
         {
-            auto& logger = Poco::Logger::create(Static.getName(), channel, Poco::Message::PRIO_TRACE);
+            auto& logger = GenericLogger::create(Static.getName(), channel, Poco::Message::PRIO_TRACE);
             Static.setLogger(&logger);
         }
         catch (ExistsException&)
         {
-            auto& logger = Poco::Logger::get(Static.getName());
-            Static.setLogger(&logger);
+            auto logger = static_cast<GenericLogger *>(&Poco::Logger::get(Static.getName()));
+            Static.setLogger(logger);
         }
 
         auto logger = Static.getLogger();
@@ -584,15 +646,26 @@ namespace Log
                                 << ". Log level is [" << logger->getLevel() << ']');
     }
 
-    Poco::Logger& logger()
+    GenericLogger& logger()
     {
-        Poco::Logger* pLogger = Static.getThreadLocalLogger();
+        GenericLogger* pLogger = Static.getThreadLocalLogger();
         if (pLogger != nullptr)
             return *pLogger;
 
         pLogger = Static.getLogger();
         return pLogger ? *pLogger
-                       : Poco::Logger::get(Static.getInited() ? Static.getName() : std::string());
+            : *static_cast<GenericLogger *>(
+                &GenericLogger::get(Static.getInited() ? Static.getName() : std::string()));
+    }
+
+    bool isEnabled(Level l)
+    {
+        if (IsShutdown)
+            return false;
+
+        Log::Level logLevel = GenericLogger::mapToLevel(
+            static_cast<Poco::Message::Priority>(logger().getLevel()));
+        return logLevel >= static_cast<int>(l);
     }
 
     void shutdown()
@@ -603,7 +676,8 @@ namespace Log
             assert(ThreadLocalBufferCount <= 1 &&
                    "Unstopped threads may have unflushed buffered log entries");
 
-        IsShutdown = true;
+        // continue logging shutdown on mobile
+        IsShutdown = !Util::isMobileApp();
 
         Poco::Logger::shutdown();
 
@@ -625,16 +699,60 @@ namespace Log
         // The Poco loggers have to have names that are unique, but those aren't displayed anywhere.
         // So just use the name of the default logger for this process plus a counter.
         static int counter = 1;
-        auto& logger = Poco::Logger::create(Static.getName() + "." + std::to_string(counter++),
-                                            std::move(channel),
-                                            Poco::Logger::parseLevel(logLevel));
+        auto& logger = GenericLogger::create(Static.getName() + "." + std::to_string(counter++),
+                                             std::move(channel),
+                                             Poco::Logger::parseLevel(logLevel));
         Static.setThreadLocalLogger(&logger);
     }
 
-    const std::string& getLevel()
+    const std::string& getLevelName()
     {
         return Static.getLevel();
     }
-}
+
+    Level getLevel()
+    {
+        return GenericLogger::mapToLevel(
+            static_cast<Poco::Message::Priority>(
+                Log::logger().getLevel()));
+    }
+
+    void setLevel(const std::string &l)
+    {
+        Log::logger().setLevel(l);
+        // Update our public flags in the array now ...
+    }
+
+    void log(Level l, const std::string &text)
+    {
+        Log::logger().doLog(l, text);
+    }
+
+    const std::string levelList[] = {"none", "fatal", "critical", "error", "warning", "notice", "information", "debug", "trace"};
+
+    std::string getLogLevelName(const std::string &channel)
+    {
+        unsigned int wsdLogLevel =
+            Log::logger().get(channel).getLevel();
+        return levelList[wsdLogLevel];
+    }
+
+    void setLogLevelByName(const std::string &channel,
+                           const std::string &level)
+    {
+        // FIXME: seems redundant do we need that ?
+        std::string lvl = level;
+
+        // Get the list of channels..
+        std::vector<std::string> nameList;
+        Log::logger().names(nameList);
+
+        if (std::find(std::begin(levelList), std::end(levelList), level) == std::end(levelList))
+            lvl = "debug";
+
+        Log::logger().get(channel).setLevel(lvl);
+    }
+
+} // namespace Log
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/common/Log.hpp b/common/Log.hpp
index fe9262c717..933237de84 100644
--- a/common/Log.hpp
+++ b/common/Log.hpp
@@ -23,28 +23,27 @@
 #include <sstream>
 #include <string>
 
-#include <Poco/Logger.h>
-
 #ifdef __ANDROID__
 #include <android/log.h>
 #endif
 
 #include "Util.hpp"
 
-enum Level
-{
-    FTL = 1, // Fatal
-    CTL,     // Critical
-    ERR,     // Error
-    WRN,     // Warning
-    NTC,     // Notice
-    INF,     // Information
-    DBG,     // Debug
-    TRC      // Trace
-};
-
 namespace Log
 {
+    enum Level
+    {
+        FTL = 1, // Fatal
+        CTL,     // Critical
+        ERR,     // Error
+        WRN,     // Warning
+        NTC,     // Notice
+        INF,     // Information
+        DBG,     // Debug
+        TRC,     // Trace
+        MAX
+    };
+
     /// Initialize the logging system.
     void initialize(const std::string& name,
                     const std::string& logLevel,
@@ -52,19 +51,11 @@ namespace Log
                     const bool logToFile,
                     const std::map<std::string, std::string>& config);
 
-    /// Returns the underlying logging system. Return value is effectively thread-local.
-    Poco::Logger& logger();
-
     /// Shutdown and release the logging system.
     void shutdown();
 
     void setThreadLocalLogLevel(const std::string& logLevel);
 
-    extern bool IsShutdown;
-
-    /// Was static shutdown() called? If so, producing more logs should be avoided.
-    inline bool isShutdownCalled() { return IsShutdown && !Util::isMobileApp(); }
-
     /// Generates log entry prefix. Example follows (without the pipes).
     /// |wsd-07272-07298 2020-04-25 17:29:28.928697 -0400 [ websrv_poll ] TRC  |
     /// This is fully signal-safe. Buffer must be at least 128 bytes.
@@ -78,15 +69,6 @@ namespace Log
         return prefix(tv, buffer, level);
     }
 
-    inline bool traceEnabled() { return logger().trace(); }
-    inline bool debugEnabled() { return logger().debug(); }
-    inline bool infoEnabled() { return logger().information(); }
-    inline bool warnEnabled() { return logger().warning(); }
-    inline bool errorEnabled() { return logger().error(); }
-    inline bool fatalEnabled() { return logger().fatal(); }
-
-    const std::string& getLevel();
-
     /// The following is to write streaming logs.
     /// Log::info() << "Value: 0x" << std::hex << value
     ///             << ", pointer: " << this << Log::end;
@@ -134,6 +116,7 @@ namespace Log
         }
 
         std::ostringstream& getStream() { return _stream; }
+        static StreamLogger& getFor(Level l);
 
     private:
         std::ostringstream _stream;
@@ -142,47 +125,29 @@ namespace Log
         const bool _enabled;
     };
 
-    inline StreamLogger trace()
-    {
-        return traceEnabled()
-             ? StreamLogger([](const std::string& msg) { logger().trace(msg); }, "TRC")
-             : StreamLogger();
-    }
+    /// is a certain level of logging enabled ?
+    bool isEnabled(Level l);
 
-    inline StreamLogger debug()
+    inline bool traceEnabled()
     {
-        return debugEnabled()
-             ? StreamLogger([](const std::string& msg) { logger().debug(msg); }, "DBG")
-             : StreamLogger();
+        return isEnabled(Log::Level::TRC);
     }
 
-    inline StreamLogger info()
-    {
-        return infoEnabled()
-             ? StreamLogger([](const std::string& msg) { logger().information(msg); }, "INF")
-             : StreamLogger();
-    }
+    /// Main entry function for all logging
+    void log(Level l, const std::string &text);
 
-    inline StreamLogger warn()
-    {
-        return warnEnabled()
-             ? StreamLogger([](const std::string& msg) { logger().warning(msg); }, "WRN")
-             : StreamLogger();
-    }
+    /// Setting the logging level
+    void setLevel(const std::string &l);
 
-    inline StreamLogger error()
-    {
-        return errorEnabled()
-             ? StreamLogger([](const std::string& msg) { logger().error(msg); }, "ERR")
-             : StreamLogger();
-    }
+    /// Getting the logging level
+    Level getLevel();
 
-    inline StreamLogger fatal()
-    {
-        return fatalEnabled()
-             ? StreamLogger([](const std::string& msg) { logger().fatal(msg); }, "FTL")
-             : StreamLogger();
-    }
+    std::string getLogLevelName(const std::string &channel);
+    void setLogLevelByName(const std::string &channel,
+                           const std::string &level);
+
+    /// Getting the logging level as a string
+    const std::string& getLevelName();
 
     /// Dump the invalid id as 0, otherwise dump in hex.
     /// Note: std::thread::id defines operator<< which
@@ -272,14 +237,12 @@ static constexpr std::size_t skipPathPrefix(const char (&s)[N], std::size_t n =
 
 #ifdef __ANDROID__
 
-#define LOG_LOG(LOG, NAME, LVL, STR)                                     \
-    ((void)__android_log_print(ANDROID_LOG_DEBUG, "coolwsd", "%s %s", LVL, STR.c_str()))
-
+#define LOG_LOG(LVL, STR) \
+    ((void)__android_log_print(ANDROID_LOG_DEBUG, \
+                               "coolwsd", "%s %s", #LVL, STR.c_str()))
 #else
 
-#define LOG_LOG(LOG, NAME, LVL, STR)                                     \
-    LOG.log(Poco::Message(NAME, STR, static_cast<Poco::Message::Priority>(LVL)))
-
+#define LOG_LOG(LVL, STR)  Log::log(Log::LVL, STR)
 #endif
 
 #define LOG_END_NOFILE(LOG) (void)0
@@ -287,69 +250,57 @@ static constexpr std::size_t skipPathPrefix(const char (&s)[N], std::size_t n =
 #define LOG_END(LOG) LOG << "| " << LOG_FILE_NAME(__FILE__) << ":" STRING(__LINE__)
 
 /// Used to end multi-statement logging via Log::StreamLogger.
-#define LOG_END_FLUSH(LOG)                                                                         \
-    do                                                                                             \
-    {                                                                                              \
-        LOG_END(LOG);                                                                              \
-        LOG.flush();                                                                               \
+#define LOG_END_FLUSH(LOG) \
+    do                     \
+    {                      \
+        LOG_END(LOG);      \
+        LOG.flush();       \
     } while (false)
 
-#define LOG_MESSAGE_(LVL, X, TYPE, PREFIX, SUFFIX)                                                 \
-    do                                                                                             \
-    {                                                                                              \
-        auto& log_ = Log::logger();                                                                \
-        if (LOG_CONDITIONAL(log_, TYPE))                                                           \
-        {                                                                                          \
-            LOG_BODY_(log_, LVL, X, PREFIX, SUFFIX);                                               \
-        }                                                                                          \
+#define LOG_MESSAGE_(LVL, X, PREFIX, SUFFIX)    \
+    do                                          \
+    {                                           \
+        if (LOG_CONDITIONAL(LVL))               \
+        {                                       \
+            LOG_BODY_(LVL, X, PREFIX, SUFFIX);  \
+        }                                       \
     } while (false)
 
 
-#define LOG_BODY_(LOG, LVL, X, PREFIX, END)                        \
-    char b_[1024];                                                                                 \
-    std::ostringstream oss_(Log::prefix<sizeof(b_) - 1>(b_, #LVL), std::ostringstream::ate);       \
-    PREFIX(oss_);                                                                                  \
-    oss_ << std::boolalpha << X;                                                                   \
-    END(oss_);                                                                                     \
-    LOG_LOG(LOG, LOG.name(), LVL, oss_.str())
-
-#define LOG_ANY(X)                                                                                 \
-    char b_[1024];                                                                                 \
-    std::ostringstream oss_(Log::prefix<sizeof(b_) - 1>(b_, "INF"), std::ostringstream::ate);      \
-    logPrefix(oss_);                                                                               \
-    oss_ << std::boolalpha << X;                                                                   \
-    LOG_END(oss_);                                                                                 \
-    Poco::AutoPtr<Poco::Channel> channel = Log::logger().getChannel();                             \
-    channel->log(Poco::Message("", oss_.str(), Poco::Message::Priority::PRIO_INFORMATION))
+#define LOG_BODY_(LVL, X, PREFIX, END)          \
+    char b_[1024];                              \
+    std::ostringstream oss_(                    \
+        Log::prefix<sizeof(b_) - 1>(b_, #LVL),  \
+        std::ostringstream::ate);               \
+    PREFIX(oss_);                               \
+    oss_ << std::boolalpha << X;                \
+    END(oss_);                                  \
+    LOG_LOG(LVL, oss_.str())
+
+#define LOG_ANY(X)                              \
+    char b_[1024];                              \
+    std::ostringstream oss_(                    \
+        Log::prefix<sizeof(b_) - 1>(b_, "INF"), \
+        std::ostringstream::ate);               \
+    logPrefix(oss_);                            \
+    oss_ << std::boolalpha << X;                \
+    LOG_END(oss_);                              \
+    Log::log(Log::Level::INF, oss_.str());
 
 #if defined __GNUC__ || defined __clang__
-#  define LOG_CONDITIONAL(log,type)                                                                \
-    __builtin_expect((!Log::isShutdownCalled() && log.type()), 0)
+#  define LOG_CONDITIONAL(type)                 \
+    __builtin_expect(Log::isEnabled(Log::Level::type), 0)
 #else
-#  define LOG_CONDITIONAL(log,type)                                                                \
-    (!Log::isShutdownCalled() && log.type())
+#  define LOG_CONDITIONAL(type) Log::isEnabled(Log::Level::type)
 #endif
 
-#define LOG_TRC(X)                                                                                 \
-    LOG_MESSAGE_(TRC, X, trace, logPrefix, LOG_END)                                                \
-
-#define LOG_TRC_NOFILE(X)                                                                          \
-    LOG_MESSAGE_(TRC, X, trace, logPrefix, LOG_END_NOFILE)                                         \
-
-#define LOG_DBG(X)                                                                                 \
-    LOG_MESSAGE_(DBG, X, debug, logPrefix, LOG_END)                                                \
-
-#define LOG_INF(X)                                                                                 \
-    LOG_MESSAGE_(INF, X, information, logPrefix, LOG_END)                                          \
-
-#define LOG_INF_NOFILE(X)                                                                          \
-    LOG_MESSAGE_(INF, X, information, logPrefix, LOG_END_NOFILE)                                   \
-
-#define LOG_WRN(X)                                                                                 \
-    LOG_MESSAGE_(WRN, X, warning, logPrefix, LOG_END)                                              \
-
-#define LOG_ERR(X)                                                                                 \
-    LOG_MESSAGE_(ERR, X, error, logPrefix, LOG_END)                                                \
+#define LOG_TRC(X)        LOG_MESSAGE_(TRC, X, logPrefix, LOG_END)
+#define LOG_TRC_NOFILE(X) LOG_MESSAGE_(TRC, X, logPrefix, LOG_END_NOFILE)
+#define LOG_DBG(X)        LOG_MESSAGE_(DBG, X, logPrefix, LOG_END)
+#define LOG_INF(X)        LOG_MESSAGE_(INF, X, logPrefix, LOG_END)
+#define LOG_INF_NOFILE(X) LOG_MESSAGE_(INF, X, logPrefix, LOG_END_NOFILE)
+#define LOG_WRN(X)        LOG_MESSAGE_(WRN, X, logPrefix, LOG_END)
+#define LOG_ERR(X)        LOG_MESSAGE_(ERR, X, logPrefix, LOG_END)
 
 /// Log an ERR entry with the given errno appended.
 #define LOG_SYS_ERRNO(ERRNO, X)                                                                    \
@@ -368,10 +319,9 @@ static constexpr std::size_t skipPathPrefix(const char (&s)[N], std::size_t n =
     do                                                                                             \
     {                                                                                              \
         std::cerr << X << std::endl;                                                               \
-        auto& log_ = Log::logger();                                                                \
-        if (LOG_CONDITIONAL(log_, fatal))                                                          \
+        if (LOG_CONDITIONAL(FTL))                                                                  \
         {                                                                                          \
-            LOG_BODY_(log_, FTL, X, logPrefix, LOG_END);                                           \
+            LOG_BODY_(FTL, X, logPrefix, LOG_END);                                           \
         }                                                                                          \
     } while (false)
 
@@ -384,25 +334,12 @@ static constexpr std::size_t skipPathPrefix(const char (&s)[N], std::size_t n =
         LOG_FTL(X << " (" << Util::symbolicErrno(onrre) << ": " << std::strerror(onrre) << ')');   \
     } while (false)
 
-/// No-prefix version of LOG_TRC.
-#define LOG_TRC_S(X)                                                                               \
-    LOG_MESSAGE_(TRC, X, debug, (void), LOG_END)                                                   \
-
-/// No-prefix version of LOG_DBG.
-#define LOG_DBG_S(X)                                                                               \
-    LOG_MESSAGE_(DBG, X, debug, (void), LOG_END)                                                   \
-
-/// No-prefix version of LOG_INF.
-#define LOG_INF_S(X)                                                                               \
-    LOG_MESSAGE_(INF, X, error, (void), LOG_END)                                                   \
-
-/// No-prefix version of LOG_WRN.
-#define LOG_WRN_S(X)                                                                               \
-    LOG_MESSAGE_(WRN, X, error, (void), LOG_END)                                                   \
-
-/// No-prefix version of LOG_ERR.
-#define LOG_ERR_S(X)                                                                               \
-    LOG_MESSAGE_(ERR, X, error, (void), LOG_END)                                                   \
+/// No-prefix versions:
+#define LOG_TRC_S(X) LOG_MESSAGE_(TRC, X, (void), LOG_END)
+#define LOG_DBG_S(X) LOG_MESSAGE_(DBG, X, (void), LOG_END)
+#define LOG_INF_S(X) LOG_MESSAGE_(INF, X, (void), LOG_END)
+#define LOG_WRN_S(X) LOG_MESSAGE_(WRN, X, (void), LOG_END)
+#define LOG_ERR_S(X) LOG_MESSAGE_(ERR, X, (void), LOG_END)
 
 #define LOG_CHECK(X)                                                                               \
     do                                                                                             \
diff --git a/common/Unit.hpp b/common/Unit.hpp
index 90fea519ba..955bfbd1b4 100644
--- a/common/Unit.hpp
+++ b/common/Unit.hpp
@@ -17,6 +17,7 @@
 #include <common/StateEnum.hpp>
 #include "Util.hpp"
 #include "net/Socket.hpp"
+#include <Poco/Exception.h>
 
 #include <test/testlog.hpp>
 
diff --git a/common/Util-desktop.cpp b/common/Util-desktop.cpp
index f904d256bd..d0910fda0d 100644
--- a/common/Util-desktop.cpp
+++ b/common/Util-desktop.cpp
@@ -23,6 +23,7 @@
 #include <fstream>
 #include <iomanip>
 
+#include <Poco/Exception.h>
 #include "Log.hpp"
 
 namespace Util
diff --git a/kit/ChildSession.cpp b/kit/ChildSession.cpp
index ba9a08c253..d0dc126d2e 100644
--- a/kit/ChildSession.cpp
+++ b/kit/ChildSession.cpp
@@ -1447,7 +1447,7 @@ bool ChildSession::paste(const char* buffer, int length, const StringVector& tok
     {
         getLOKitDocument()->setView(_viewId);
 
-        if (Log::logger().trace())
+        if (Log::traceEnabled())
         {
             // Ensure 8 byte alignment for the start of the data, SpookyHash needs it.
             std::vector<char> toHash(data, data + size);
diff --git a/kit/ForKit.cpp b/kit/ForKit.cpp
index 9e2d4c44c2..8a1ac13985 100644
--- a/kit/ForKit.cpp
+++ b/kit/ForKit.cpp
@@ -156,7 +156,7 @@ protected:
         {
             // Set environment variable so that new children will also set their log levels accordingly.
             setenv("COOL_LOGLEVEL", tokens[1].c_str(), 1);
-            Log::logger().setLevel(tokens[1]);
+            Log::setLevel(tokens[1]);
         }
         else if (tokens.size() == 3 && tokens.equals(0, "setconfig"))
         {
@@ -784,7 +784,7 @@ int forkit_main(int argc, char** argv)
     if (LogLevel != LogLevelStartup)
     {
         LOG_INF("Forkit initialization complete: setting log-level to [" << LogLevel << "] as configured.");
-        Log::logger().setLevel(LogLevel);
+        Log::setLevel(LogLevel);
     }
 
     // The SocketPoll ctor which may, depending on COOL_WATCHDOG env variable,
diff --git a/kit/Kit.cpp b/kit/Kit.cpp
index 60aafa9f3e..841f1dacaf 100644
--- a/kit/Kit.cpp
+++ b/kit/Kit.cpp
@@ -3217,7 +3217,7 @@ void lokit_main(
         if (bTraceStartup && LogLevel != LogLevelStartup)
         {
             LOG_INF("Kit initialization complete: setting log-level to [" << LogLevel << "] as configured.");
-            Log::logger().setLevel(LogLevel);
+            Log::setLevel(LogLevel);
         }
 #endif
 
diff --git a/kit/KitWebSocket.cpp b/kit/KitWebSocket.cpp
index cbf647856b..d2b60c4ab6 100644
--- a/kit/KitWebSocket.cpp
+++ b/kit/KitWebSocket.cpp
@@ -148,7 +148,7 @@ void KitWebSocketHandler::handleMessage(const std::vector<char>& data)
     }
     else if (tokens.equals(0, "setloglevel"))
     {
-        Log::logger().setLevel(tokens[1]);
+        Log::setLevel(tokens[1]);
     }
     else
     {
diff --git a/wsd/Admin.cpp b/wsd/Admin.cpp
index fda7a585bf..5e479dfdf9 100644
--- a/wsd/Admin.cpp
+++ b/wsd/Admin.cpp
@@ -46,7 +46,6 @@ using Poco::Util::Application;
 
 const int Admin::MinStatsIntervalMs = 50;
 const int Admin::DefStatsIntervalMs = 1000;
-const std::string levelList[] = {"none", "fatal", "critical", "error", "warning", "notice", "information", "debug", "trace"};
 
 /// Process incoming websocket messages
 void AdminSocketHandler::handleMessage(const std::vector<char> &payload)
@@ -227,7 +226,7 @@ void AdminSocketHandler::handleMessage(const std::vector<char> &payload)
     else if (tokens.equals(0, "shutdown"))
     {
         LOG_INF("Setting ShutdownRequestFlag: Shutdown requested by admin.");
-        if (Admin::instance().logAdminAction() && Log::logger().getChannel())
+        if (Admin::instance().logAdminAction())
         {
             LOG_ANY("Shutdown requested by admin with source IPAddress [" << _clientIPAdress
                                                                           << ']');
@@ -785,10 +784,9 @@ unsigned Admin::getNetStatsInterval()
 
 std::string Admin::getChannelLogLevels()
 {
-    unsigned int wsdLogLevel = Log::logger().get("wsd").getLevel();
-    std::string result = "wsd=" + levelList[wsdLogLevel];
+    std::string result = "wsd=" + Log::getLogLevelName("wsd");
 
-    result += " kit=" + (_forkitLogLevel.empty() != true ? _forkitLogLevel: levelList[wsdLogLevel]);
+    result += " kit=" + (_forkitLogLevel.empty() != true ? _forkitLogLevel: Log::getLogLevelName("wsd"));
 
     return result;
 }
@@ -797,15 +795,9 @@ void Admin::setChannelLogLevel(const std::string& channelName, std::string level
 {
     ASSERT_CORRECT_THREAD();
 
-    // Get the list of channels..
-    std::vector<std::string> nameList;
-    Log::logger().names(nameList);
-
-    if (std::find(std::begin(levelList), std::end(levelList), level) == std::end(levelList))
-        level = "debug";
-
     if (channelName == "wsd")
-        Log::logger().get("wsd").setLevel(level);
+        Log::setLogLevelByName("wsd", level);
+
     else if (channelName == "kit")
     {
         COOLWSD::setLogLevelsOfKits(level); // For current kits.
diff --git a/wsd/COOLWSD.cpp b/wsd/COOLWSD.cpp
index 4e7f5faf6c..0ccc18cb83 100644
--- a/wsd/COOLWSD.cpp
+++ b/wsd/COOLWSD.cpp
@@ -4247,10 +4247,10 @@ int COOLWSD::innerMain()
     if (LogLevel != "trace")
     {
         LOG_INF("WSD initialization complete: setting log-level to [" << LogLevel << "] as configured.");
-        Log::logger().setLevel(LogLevel);
+        Log::setLevel(LogLevel);
     }
 
-    if (Log::logger().getLevel() >= Poco::Message::Priority::PRIO_INFORMATION)
+    if (Log::getLevel() >= Log::Level::INF)
         LOG_ERR("Log level is set very high to '" << LogLevel << "' this will have a "
                 "significant performance impact. Do not use this in production.");
 
diff --git a/wsd/ClientSession.cpp b/wsd/ClientSession.cpp
index 4b4c2d3ad3..c04d4fa9cc 100644
--- a/wsd/ClientSession.cpp
+++ b/wsd/ClientSession.cpp
@@ -974,7 +974,7 @@ bool ClientSession::_handleInput(const char *buffer, int length)
                 LOG_INF("Thread-local logging level being set to default ["
                         << Log::getLevel()
                         << "]");
-                Log::setThreadLocalLogLevel(Log::getLevel());
+                Log::setThreadLocalLogLevel(Log::getLevelName());
             }
             else
             {
diff --git a/wsd/wopi/CheckFileInfo.cpp b/wsd/wopi/CheckFileInfo.cpp
index 8d46829f51..3e4a2a6845 100644
--- a/wsd/wopi/CheckFileInfo.cpp
+++ b/wsd/wopi/CheckFileInfo.cpp
@@ -83,16 +83,17 @@ bool CheckFileInfo::checkFileInfo(int redirectLimit)
         std::string wopiResponse = httpResponse->getBody();
         const bool failed = (httpResponse->statusLine().statusCode() != http::StatusCode::OK);
 
-        Log::StreamLogger logRes = failed ? Log::error() : Log::trace();
-        if (logRes.enabled())
+        Log::Level level = failed ? Log::Level::ERR : Log::Level::TRC;
+        if (Log::isEnabled(level))
         {
-            logRes << "WOPI::CheckFileInfo " << (failed ? "failed" : "returned") << " for URI ["
-                   << uriAnonym << "]: " << httpResponse->statusLine().statusCode() << ' '
-                   << httpResponse->statusLine().reasonPhrase()
-                   << ". Headers: " << httpResponse->header()
-                   << (failed ? "\tBody: [" + wopiResponse + ']' : std::string());
-
-            LOG_END_FLUSH(logRes);
+            std::ostringstream oss;
+            oss << "WOPI::CheckFileInfo " << (failed ? "failed" : "returned") << " for URI ["
+                << uriAnonym << "]: " << httpResponse->statusLine().statusCode() << ' '
+                << httpResponse->statusLine().reasonPhrase()
+                << ". Headers: " << httpResponse->header()
+                << (failed ? "\tBody: [" + wopiResponse + ']' : std::string());
+            LOG_END_FLUSH(oss);
+            Log::log(level, oss.str());
         }
 
         if (failed)
@@ -195,4 +196,4 @@ CheckFileInfo::wopiFileInfo(const Poco::URI& uriPublic) const
     }
 
     return wopiFileInfo;
-}
\ No newline at end of file
+}
diff --git a/wsd/wopi/WopiProxy.cpp b/wsd/wopi/WopiProxy.cpp
index 0436cfa4cf..4788856a0e 100644
--- a/wsd/wopi/WopiProxy.cpp
+++ b/wsd/wopi/WopiProxy.cpp
@@ -266,16 +266,18 @@ void WopiProxy::download(const std::shared_ptr<TerminatingPoll>& poll, const std
         std::string wopiResponse = httpResponse->getBody();
         const bool failed = (httpResponse->statusLine().statusCode() != http::StatusCode::OK);
 
-        Log::StreamLogger logRes = failed ? Log::error() : Log::trace();
-        if (logRes.enabled())
+        Log::Level level = failed ? Log::Level::ERR : Log::Level::TRC;
+        if (Log::isEnabled(level))
         {
-            logRes << "WOPI::GetFile " << (failed ? "failed" : "returned") << " for URI ["
+            std::ostringstream oss;
+            oss << "WOPI::GetFile " << (failed ? "failed" : "returned") << " for URI ["
                    << uriAnonym << "]: " << httpResponse->statusLine().statusCode() << ' '
                    << httpResponse->statusLine().reasonPhrase()
                    << ". Headers: " << httpResponse->header()
                    << (failed ? "\tBody: [" + wopiResponse + ']' : std::string());
 
-            LOG_END_FLUSH(logRes);
+            LOG_END_FLUSH(oss);
+            Log::log(level, oss.str());
         }
 
         if (failed)
diff --git a/wsd/wopi/WopiStorage.cpp b/wsd/wopi/WopiStorage.cpp
index 5435f5a808..2e98dce911 100644
--- a/wsd/wopi/WopiStorage.cpp
+++ b/wsd/wopi/WopiStorage.cpp
@@ -805,7 +805,7 @@ WopiStorage::handleUploadToStorageResponse(const WopiUploadDetails& details,
                                       ? "WOPI::PutRelativeFile"
                                       : (details.isRename ? "WOPI::RenameFile" : "WOPI::PutFile"));
 
-        if (Log::infoEnabled())
+        if (Log::isEnabled(Log::Level::INF))
         {
             if (COOLWSD::AnonymizeUserData)
             {