Skip to content

[ur] Replace extern logger object with a singleton #341

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Mar 13, 2023
Merged

[ur] Replace extern logger object with a singleton #341

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
34 changes: 22 additions & 12 deletions source/common/logger/ur_logger.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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 <typename... Args>
inline void debug(const char *format, Args &&...args) {
logger.log(logger::Level::DEBUG, format, std::forward<Args>(args)...);
get_logger().log(logger::Level::DEBUG, format, std::forward<Args>(args)...);
}

template <typename... Args>
inline void info(const char *format, Args &&...args) {
logger.log(logger::Level::INFO, format, std::forward<Args>(args)...);
get_logger().log(logger::Level::INFO, format, std::forward<Args>(args)...);
}

template <typename... Args>
inline void warning(const char *format, Args &&...args) {
logger.log(logger::Level::WARN, format, std::forward<Args>(args)...);
get_logger().log(logger::Level::WARN, format, std::forward<Args>(args)...);
}

template <typename... Args>
inline void error(const char *format, Args &&...args) {
logger.log(logger::Level::ERR, format, std::forward<Args>(args)...);
get_logger().log(logger::Level::ERR, format, std::forward<Args>(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,
Expand All @@ -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;
Expand All @@ -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<logger::StderrSink>());
return Logger(std::make_unique<logger::StderrSink>(logger_name));
}

try {
Expand All @@ -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<logger::StderrSink>());
return Logger(std::make_unique<logger::StderrSink>(logger_name));
}
sink->setFlushLevel(flush_level);

Expand Down
27 changes: 15 additions & 12 deletions source/common/logger/ur_sinks.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,8 @@ class Sink {
public:
template <typename... Args>
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 &&>(args)...);
*ostream << "\n";
if (level >= flush_level) {
Expand All @@ -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') {
Expand Down Expand Up @@ -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;
}

Expand All @@ -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;
}

Expand All @@ -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(
Expand All @@ -144,21 +147,21 @@ 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;
}

private:
std::ofstream ofstream;
};

inline std::unique_ptr<Sink> sink_from_str(std::string name, std::string file_path = "") {
inline std::unique_ptr<Sink> sink_from_str(std::string logger_name, std::string name, std::string file_path = "") {
if (name == "stdout") {
return std::make_unique<logger::StdoutSink>();
return std::make_unique<logger::StdoutSink>(logger_name);
} else if (name == "stderr") {
return std::make_unique<logger::StderrSink>();
return std::make_unique<logger::StderrSink>(logger_name);
} else if (name == "file" && !file_path.empty()) {
return std::make_unique<logger::FileSink>(file_path.c_str());
return std::make_unique<logger::FileSink>(logger_name, file_path.c_str());
}

throw std::invalid_argument(
Expand Down
5 changes: 0 additions & 5 deletions source/drivers/null/ur_null.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,11 +8,6 @@
*
*/
#include "ur_null.hpp"
#include "logger/ur_logger.hpp"

namespace logger {
Logger logger = create_logger("null");
}

namespace driver {
//////////////////////////////////////////////////////////////////////////
Expand Down
8 changes: 4 additions & 4 deletions source/loader/ur_lib.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,10 +17,6 @@
#include "tracing/ur_tracing_layer.hpp"
#endif

namespace logger {
Logger logger = create_logger("loader");
}

namespace ur_lib {
///////////////////////////////////////////////////////////////////////////////
context_t *context;
Expand All @@ -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) {
Expand Down
62 changes: 35 additions & 27 deletions test/unit/logger/logger.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
}
Expand All @@ -32,7 +28,8 @@ class CreateLoggerWithEnvVar : public ::testing::TestWithParam<std::string> {
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 {
Expand All @@ -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);
Expand All @@ -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<logger::FileSink>(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<logger::FileSink>(file_path));
logger::Logger logger(level, std::make_unique<logger::FileSink>(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"
"<test>[ERROR]: Test message: success\n";
}

TEST_F(FileSink, ThreeParams) {
logger::Level level = logger::Level::DEBUG;
logger::Logger logger(level, std::make_unique<logger::FileSink>(file_path));
logger::Logger logger(level, std::make_unique<logger::FileSink>(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<logger::FileSink>(file_path));
std::make_unique<logger::FileSink>(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<logger::FileSink>(file_path));
std::make_unique<logger::FileSink>(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<logger::FileSink>(file_path));
std::make_unique<logger::FileSink>(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<logger::FileSink>(file_path));
std::make_unique<logger::FileSink>(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<logger::FileSink>(file_path, level));
logger::Logger logger(level, std::make_unique<logger::FileSink>(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) {
Expand All @@ -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) {
Expand All @@ -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) {
Expand All @@ -166,13 +174,13 @@ 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) {
logger::setLevel(logger::Level::ERR);
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";
}