From fb07a39947308cb24e730eb6ff5f980dced60a3d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Plewa?= <lukasz.plewa@intel.com>
Date: Thu, 8 Feb 2024 15:51:04 +0100
Subject: [PATCH] Add Legacy Compatibility to Logger

Switching to the new logger changes API and log format,
and requires changes in user code. To make the transition easier,
this PR adds an option in the new logger to print logs in the old
format.
---
 source/common/logger/ur_logger.hpp         | 32 +++++++++++++
 source/common/logger/ur_logger_details.hpp | 54 ++++++++++++++++++++--
 source/common/logger/ur_sinks.hpp          | 15 +++---
 3 files changed, 92 insertions(+), 9 deletions(-)

diff --git a/source/common/logger/ur_logger.hpp b/source/common/logger/ur_logger.hpp
index 27fcca4274..9735d0d814 100644
--- a/source/common/logger/ur_logger.hpp
+++ b/source/common/logger/ur_logger.hpp
@@ -48,12 +48,44 @@ inline void always(const char *format, Args &&...args) {
     get_logger().always(format, std::forward<Args>(args)...);
 }
 
+template <typename... Args>
+inline void debug(const logger::LegacyMessage &p, const char *format,
+                  Args &&...args) {
+    get_logger().log(p, logger::Level::DEBUG, format,
+                     std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+inline void info(logger::LegacyMessage p, const char *format, Args &&...args) {
+    get_logger().log(p, logger::Level::INFO, format,
+                     std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+inline void warning(logger::LegacyMessage p, const char *format,
+                    Args &&...args) {
+    get_logger().log(p, logger::Level::WARN, format,
+                     std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+inline void error(logger::LegacyMessage p, const char *format, Args &&...args) {
+    get_logger().log(p, logger::Level::ERR, format,
+                     std::forward<Args>(args)...);
+}
+
 inline void setLevel(logger::Level level) { get_logger().setLevel(level); }
 
 inline void setFlushLevel(logger::Level level) {
     get_logger().setFlushLevel(level);
 }
 
+template <typename T> inline std::string toHex(T t) {
+    std::stringstream s;
+    s << std::hex << t;
+    return s.str();
+}
+
 /// @brief Create an instance of the logger with parameters obtained from the respective
 ///        environment variable or with default configuration if the env var is empty,
 ///        not set, or has the wrong format.
diff --git a/source/common/logger/ur_logger_details.hpp b/source/common/logger/ur_logger_details.hpp
index 6ff279ad1a..5324f4083f 100644
--- a/source/common/logger/ur_logger_details.hpp
+++ b/source/common/logger/ur_logger_details.hpp
@@ -11,6 +11,11 @@
 
 namespace logger {
 
+struct LegacyMessage {
+    LegacyMessage(const char *p) : message(p){};
+    const char *message;
+};
+
 class Logger {
   public:
     Logger(std::unique_ptr<logger::Sink> sink) : sink(std::move(sink)) {
@@ -59,20 +64,63 @@ class Logger {
         }
     }
 
+    template <typename... Args>
+    void debug(const logger::LegacyMessage &p, const char *format,
+               Args &&...args) {
+        log(p, logger::Level::DEBUG, format, std::forward<Args>(args)...);
+    }
+
+    template <typename... Args>
+    void info(const logger::LegacyMessage &p, const char *format,
+              Args &&...args) {
+        log(p, logger::Level::INFO, format, std::forward<Args>(args)...);
+    }
+
+    template <typename... Args>
+    void warning(const logger::LegacyMessage &p, const char *format,
+                 Args &&...args) {
+        log(p, logger::Level::WARN, format, std::forward<Args>(args)...);
+    }
+
+    template <typename... Args>
+    void error(const logger::LegacyMessage &p, const char *format,
+               Args &&...args) {
+        log(p, logger::Level::ERR, format, std::forward<Args>(args)...);
+    }
+
     template <typename... Args>
     void log(logger::Level level, const char *format, Args &&...args) {
-        if (level < this->level) {
+        log(logger::LegacyMessage(format), level, format,
+            std::forward<Args>(args)...);
+    }
+
+    template <typename... Args>
+    void log(const logger::LegacyMessage &p, logger::Level level,
+             const char *format, Args &&...args) {
+        if (!sink) {
             return;
         }
 
-        if (sink) {
-            sink->log(level, format, std::forward<Args>(args)...);
+        if (isLegacySink) {
+            sink->log(level, p.message, std::forward<Args>(args)...);
+            return;
         }
+        if (level < this->level) {
+            return;
+        }
+
+        sink->log(level, format, std::forward<Args>(args)...);
+    }
+
+    void setLegacySink(std::unique_ptr<logger::Sink> legacySink) {
+        this->isLegacySink = true;
+        this->sink = std::move(legacySink);
     }
 
   private:
     logger::Level level;
     std::unique_ptr<logger::Sink> sink;
+    bool isLegacySink = false;
 };
 
 } // namespace logger
diff --git a/source/common/logger/ur_sinks.hpp b/source/common/logger/ur_sinks.hpp
index db30f3c8ed..97c87d3cb4 100644
--- a/source/common/logger/ur_sinks.hpp
+++ b/source/common/logger/ur_sinks.hpp
@@ -28,12 +28,7 @@ class Sink {
         }
 
         format(buffer, fmt, std::forward<Args &&>(args)...);
-
-        std::scoped_lock<std::mutex> lock(output_mutex);
-        *ostream << buffer.str();
-        if (level >= flush_level) {
-            ostream->flush();
-        }
+        print(level, buffer.str());
     }
 
     void setFlushLevel(logger::Level level) { this->flush_level = level; }
@@ -50,6 +45,14 @@ class Sink {
         flush_level = logger::Level::ERR;
     }
 
+    virtual void print(logger::Level level, const std::string &msg) {
+        std::scoped_lock<std::mutex> lock(output_mutex);
+        *ostream << msg;
+        if (level >= flush_level) {
+            ostream->flush();
+        }
+    }
+
   private:
     std::string logger_name;
     bool skip_prefix;