diff --git a/source/common/logger/ur_logger.hpp b/source/common/logger/ur_logger.hpp index 1a79acf502..12adf6c7dc 100644 --- a/source/common/logger/ur_logger.hpp +++ b/source/common/logger/ur_logger.hpp @@ -11,31 +11,41 @@ #include "ur_util.hpp" namespace logger { -extern Logger logger; + +Logger create_logger(std::string logger_name); + +inline Logger &get_logger(std::string name = "common") { + static Logger logger = create_logger(name); + return logger; +} + +inline void init(std::string name) { + get_logger(name); +} template inline void debug(const char *format, Args &&...args) { - logger.log(logger::Level::DEBUG, format, std::forward(args)...); + get_logger().log(logger::Level::DEBUG, format, std::forward(args)...); } template inline void info(const char *format, Args &&...args) { - logger.log(logger::Level::INFO, format, std::forward(args)...); + get_logger().log(logger::Level::INFO, format, std::forward(args)...); } template inline void warning(const char *format, Args &&...args) { - logger.log(logger::Level::WARN, format, std::forward(args)...); + get_logger().log(logger::Level::WARN, format, std::forward(args)...); } template inline void error(const char *format, Args &&...args) { - logger.log(logger::Level::ERR, format, std::forward(args)...); + get_logger().log(logger::Level::ERR, format, std::forward(args)...); } -inline void setLevel(logger::Level level) { logger.setLevel(level); } +inline void setLevel(logger::Level level) { get_logger().setLevel(level); } -inline void setFlushLevel(logger::Level level) { logger.setFlushLevel(level); } +inline void setFlushLevel(logger::Level level) { get_logger().setFlushLevel(level); } /// @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, @@ -56,7 +66,7 @@ inline void setFlushLevel(logger::Level level) { logger.setFlushLevel(level); } /// - flush level: error, meaning that only error messages are guaranteed /// to be printed immediately as they occur /// - output: stderr -inline auto create_logger(std::string logger_name) { +inline Logger create_logger(std::string logger_name) { std::transform(logger_name.begin(), logger_name.end(), logger_name.begin(), ::toupper); std::stringstream env_var_name; @@ -70,7 +80,7 @@ inline auto create_logger(std::string logger_name) { env_var_name << "UR_LOG_" << logger_name; auto map = getenv_to_map(env_var_name.str().c_str()); if (!map.has_value()) { - return Logger(std::make_unique()); + return Logger(std::make_unique(logger_name)); } try { @@ -92,11 +102,11 @@ inline auto create_logger(std::string logger_name) { values = kv->second; } - sink = values.size() == 2 ? sink_from_str(values[0], values[1]) - : sink_from_str(values[0]); + sink = values.size() == 2 ? sink_from_str(logger_name, values[0], values[1]) + : sink_from_str(logger_name, values[0]); } catch (const std::invalid_argument &e) { std::cerr << "Error when creating a logger instance from environment variable" << e.what(); - return Logger(std::make_unique()); + return Logger(std::make_unique(logger_name)); } sink->setFlushLevel(flush_level); diff --git a/source/common/logger/ur_sinks.hpp b/source/common/logger/ur_sinks.hpp index 13f9c010e7..3caef4d1db 100644 --- a/source/common/logger/ur_sinks.hpp +++ b/source/common/logger/ur_sinks.hpp @@ -13,7 +13,8 @@ class Sink { public: template void log(logger::Level level, const char *fmt, Args &&...args) { - *ostream << "[" << level_to_str(level) << "]:"; + *ostream << "<" << logger_name << ">"; + *ostream << "[" << level_to_str(level) << "]: "; format(fmt, std::forward(args)...); *ostream << "\n"; if (level >= flush_level) { @@ -29,9 +30,11 @@ class Sink { std::ostream *ostream; logger::Level flush_level; - Sink() { flush_level = logger::Level::ERR; } + Sink(std::string logger_name) : logger_name(logger_name) { flush_level = logger::Level::ERR; } private: + std::string logger_name; + void format(const char *fmt) { while (*fmt != '\0') { while (*fmt != '{' && *fmt != '}' && *fmt != '\0') { @@ -112,9 +115,9 @@ class Sink { class StdoutSink : public Sink { public: - StdoutSink() { this->ostream = &std::cout; } + StdoutSink(std::string logger_name) : Sink(logger_name) { this->ostream = &std::cout; } - StdoutSink(Level flush_lvl) : StdoutSink() { + StdoutSink(std::string logger_name, Level flush_lvl) : StdoutSink(logger_name) { this->flush_level = flush_lvl; } @@ -123,9 +126,9 @@ class StdoutSink : public Sink { class StderrSink : public Sink { public: - StderrSink() { this->ostream = &std::cerr; } + StderrSink(std::string logger_name) : Sink(logger_name) { this->ostream = &std::cerr; } - StderrSink(Level flush_lvl) : StderrSink() { + StderrSink(std::string logger_name, Level flush_lvl) : StderrSink(logger_name) { this->flush_level = flush_lvl; } @@ -134,7 +137,7 @@ class StderrSink : public Sink { class FileSink : public Sink { public: - FileSink(std::string file_path) { + FileSink(std::string logger_name, std::string file_path) : Sink(logger_name) { ofstream = std::ofstream(file_path, std::ofstream::out); if (ofstream.rdstate() != std::ofstream::goodbit) { throw std::invalid_argument( @@ -144,7 +147,7 @@ class FileSink : public Sink { this->ostream = &ofstream; } - FileSink(std::string file_path, Level flush_lvl) : FileSink(file_path) { + FileSink(std::string logger_name, std::string file_path, Level flush_lvl) : FileSink(logger_name, file_path) { this->flush_level = flush_lvl; } @@ -152,13 +155,13 @@ class FileSink : public Sink { std::ofstream ofstream; }; -inline std::unique_ptr sink_from_str(std::string name, std::string file_path = "") { +inline std::unique_ptr sink_from_str(std::string logger_name, std::string name, std::string file_path = "") { if (name == "stdout") { - return std::make_unique(); + return std::make_unique(logger_name); } else if (name == "stderr") { - return std::make_unique(); + return std::make_unique(logger_name); } else if (name == "file" && !file_path.empty()) { - return std::make_unique(file_path.c_str()); + return std::make_unique(logger_name, file_path.c_str()); } throw std::invalid_argument( diff --git a/source/drivers/null/ur_null.cpp b/source/drivers/null/ur_null.cpp index 9ee1ed8155..6bc9aba417 100644 --- a/source/drivers/null/ur_null.cpp +++ b/source/drivers/null/ur_null.cpp @@ -8,11 +8,6 @@ * */ #include "ur_null.hpp" -#include "logger/ur_logger.hpp" - -namespace logger { -Logger logger = create_logger("null"); -} namespace driver { ////////////////////////////////////////////////////////////////////////// diff --git a/source/loader/ur_lib.cpp b/source/loader/ur_lib.cpp index 786058bb78..8a9834b4ed 100644 --- a/source/loader/ur_lib.cpp +++ b/source/loader/ur_lib.cpp @@ -17,10 +17,6 @@ #include "tracing/ur_tracing_layer.hpp" #endif -namespace logger { -Logger logger = create_logger("loader"); -} - namespace ur_lib { /////////////////////////////////////////////////////////////////////////////// context_t *context; @@ -34,6 +30,10 @@ context_t::~context_t() {} ////////////////////////////////////////////////////////////////////////// __urdlllocal ur_result_t context_t::Init(ur_device_init_flags_t device_flags) { ur_result_t result; + const char *logger_name = "loader"; + logger::init(logger_name); + logger::info("Logger {} initialized successfully!", logger_name); + result = loader::context->init(); if (UR_RESULT_SUCCESS == result) { diff --git a/test/unit/logger/logger.cpp b/test/unit/logger/logger.cpp index d7a3c18519..cdff29f451 100644 --- a/test/unit/logger/logger.cpp +++ b/test/unit/logger/logger.cpp @@ -10,10 +10,6 @@ #include "logger/ur_logger.hpp" #include "logger/ur_logger_details.hpp" -namespace logger { -Logger logger = create_logger("test_adapter"); -} - TEST(logger, NullSinkOneParam) { ASSERT_THROW(logger::Logger(nullptr), std::invalid_argument); } @@ -32,7 +28,8 @@ class CreateLoggerWithEnvVar : public ::testing::TestWithParam { env_var_value = GetParam(); ret = setenv("UR_LOG_TEST_ADAPTER", env_var_value.c_str(), 1); ASSERT_EQ(ret, 0); - logger::logger = logger::create_logger("test_adapter"); + logger::init("test_adapter"); + logger::info("{} initialized successfully!", "test_adapter"); } void TearDown() override { @@ -53,7 +50,8 @@ TEST_P(CreateLoggerWithEnvVar, EnvVarSetupStd) { class FileSink : public ::testing::Test { protected: std::string file_path = "ur_test_logger.log"; - std::string test_msg = ""; + std::string logger_name = "test"; + std::string test_msg = "<" + logger_name + ">"; void TearDown() override { auto test_log = std::ifstream(file_path, std::ios::in); @@ -69,71 +67,81 @@ class FileSink : public ::testing::Test { class FileSinkDefaultLevel : public FileSink { protected: + int ret = -1; + std::string env_var_value = "output:file," + file_path; + void SetUp() override { - logger::logger = - logger::Logger(std::make_unique(file_path)); + ret = setenv("UR_LOG_TEST_ADAPTER", env_var_value.c_str(), 1); + ASSERT_EQ(ret, 0); + logger::init("test_adapter"); + logger::info("{} initialized successfully!", "test_adapter"); + } + + void TearDown() override { + ret = unsetenv("UR_LOG_TEST_ADAPTER"); + ASSERT_EQ(ret, 0); } }; TEST_F(FileSink, MultipleLines) { logger::Level level = logger::Level::WARN; - logger::Logger logger(level, std::make_unique(file_path)); + logger::Logger logger(level, std::make_unique(logger_name, file_path)); logger.warning("Test message: {}", "success"); logger.debug("This should not be printed: {}", 42); logger.error("Test message: {}", "success"); - test_msg = "[WARNING]:Test message: success\n" - "[ERROR]:Test message: success\n"; + test_msg += "[WARNING]: Test message: success\n" + "[ERROR]: Test message: success\n"; } TEST_F(FileSink, ThreeParams) { logger::Level level = logger::Level::DEBUG; - logger::Logger logger(level, std::make_unique(file_path)); + logger::Logger logger(level, std::make_unique(logger_name, file_path)); logger.setFlushLevel(level); logger.debug("{} {}: {}", "Test", 42, 3.8); - test_msg = "[DEBUG]:Test 42: 3.8\n"; + test_msg += "[DEBUG]: Test 42: 3.8\n"; } TEST_F(FileSink, DoubleBraces) { logger::Logger logger(logger::Level::ERR, - std::make_unique(file_path)); + std::make_unique(logger_name, file_path)); logger.error("{{}} {}: {}", "Test", 42); - test_msg = "[ERROR]:{} Test: 42\n"; + test_msg += "[ERROR]: {} Test: 42\n"; } TEST_F(FileSink, DoubleBraces2) { logger::Logger logger(logger::Level::ERR, - std::make_unique(file_path)); + std::make_unique(logger_name, file_path)); logger.error("200 {{ {}: {{{}}} 3.8", "Test", 42); - test_msg = "[ERROR]:200 { Test: {42} 3.8\n"; + test_msg += "[ERROR]: 200 { Test: {42} 3.8\n"; } TEST_F(FileSink, DoubleBraces3) { logger::Logger logger(logger::Level::ERR, - std::make_unique(file_path)); + std::make_unique(logger_name, file_path)); logger.error("{{ {}:}} {}}}", "Test", 42); - test_msg = "[ERROR]:{ Test:} 42}\n"; + test_msg += "[ERROR]: { Test:} 42}\n"; } TEST_F(FileSink, NoBraces) { logger::Logger logger(logger::Level::ERR, - std::make_unique(file_path)); + std::make_unique(logger_name, file_path)); logger.error(" Test: 42"); - test_msg = "[ERROR]: Test: 42\n"; + test_msg += "[ERROR]: Test: 42\n"; } TEST_F(FileSink, SetFlushLevelDebugCtor) { auto level = logger::Level::DEBUG; - logger::Logger logger(level, std::make_unique(file_path, level)); + logger::Logger logger(level, std::make_unique(logger_name, file_path, level)); logger.debug("Test message: {}", "success"); - test_msg = "[DEBUG]:Test message: success\n"; + test_msg += "[DEBUG]: Test message: success\n"; } TEST_F(FileSinkDefaultLevel, DefaultLevelNoOutput) { @@ -146,7 +154,7 @@ TEST_F(FileSinkDefaultLevel, SetLevelDebug) { logger::setFlushLevel(level); logger::debug("Test message: {}", "success"); - test_msg = "[DEBUG]:Test message: success\n"; + test_msg += "[DEBUG]: Test message: success\n"; } TEST_F(FileSinkDefaultLevel, SetLevelInfo) { @@ -156,7 +164,7 @@ TEST_F(FileSinkDefaultLevel, SetLevelInfo) { logger::info("Test message: {}", "success"); logger::debug("This should not be printed: {}", 42); - test_msg = "[INFO]:Test message: success\n"; + test_msg += "[INFO]: Test message: success\n"; } TEST_F(FileSinkDefaultLevel, SetLevelWarning) { @@ -166,7 +174,7 @@ TEST_F(FileSinkDefaultLevel, SetLevelWarning) { logger::warning("Test message: {}", "success"); logger::info("This should not be printed: {}", 42); - test_msg = "[WARNING]:Test message: success\n"; + test_msg += "[WARNING]: Test message: success\n"; } TEST_F(FileSinkDefaultLevel, SetLevelError) { @@ -174,5 +182,5 @@ TEST_F(FileSinkDefaultLevel, SetLevelError) { logger::error("Test message: {}", "success"); logger::warning("This should not be printed: {}", 42); - test_msg = "[ERROR]:Test message: success\n"; + test_msg += "[ERROR]: Test message: success\n"; }