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;