Skip to content

Commit 22c6e96

Browse files
pbalcerpbalcer
authored
Merge pull request #341 from PatKamin/logger-singleton
[ur] Replace extern logger object with a singleton
2 parents 9317646 + 54edea0 commit 22c6e96

File tree

5 files changed

+76
-60
lines changed

5 files changed

+76
-60
lines changed

‎source/common/logger/ur_logger.hpp‎

Lines changed: 22 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -11,31 +11,41 @@
1111
#include "ur_util.hpp"
1212

1313
namespace logger {
14-
extern Logger logger;
14+
15+
Logger create_logger(std::string logger_name);
16+
17+
inline Logger &get_logger(std::string name = "common") {
18+
static Logger logger = create_logger(name);
19+
return logger;
20+
}
21+
22+
inline void init(std::string name) {
23+
get_logger(name);
24+
}
1525

1626
template <typename... Args>
1727
inline void debug(const char *format, Args &&...args) {
18-
logger.log(logger::Level::DEBUG, format, std::forward<Args>(args)...);
28+
get_logger().log(logger::Level::DEBUG, format, std::forward<Args>(args)...);
1929
}
2030

2131
template <typename... Args>
2232
inline void info(const char *format, Args &&...args) {
23-
logger.log(logger::Level::INFO, format, std::forward<Args>(args)...);
33+
get_logger().log(logger::Level::INFO, format, std::forward<Args>(args)...);
2434
}
2535

2636
template <typename... Args>
2737
inline void warning(const char *format, Args &&...args) {
28-
logger.log(logger::Level::WARN, format, std::forward<Args>(args)...);
38+
get_logger().log(logger::Level::WARN, format, std::forward<Args>(args)...);
2939
}
3040

3141
template <typename... Args>
3242
inline void error(const char *format, Args &&...args) {
33-
logger.log(logger::Level::ERR, format, std::forward<Args>(args)...);
43+
get_logger().log(logger::Level::ERR, format, std::forward<Args>(args)...);
3444
}
3545

36-
inline void setLevel(logger::Level level) { logger.setLevel(level); }
46+
inline void setLevel(logger::Level level) { get_logger().setLevel(level); }
3747

38-
inline void setFlushLevel(logger::Level level) { logger.setFlushLevel(level); }
48+
inline void setFlushLevel(logger::Level level) { get_logger().setFlushLevel(level); }
3949

4050
/// @brief Create an instance of the logger with parameters obtained from the respective
4151
/// 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); }
5666
/// - flush level: error, meaning that only error messages are guaranteed
5767
/// to be printed immediately as they occur
5868
/// - output: stderr
59-
inline auto create_logger(std::string logger_name) {
69+
inline Logger create_logger(std::string logger_name) {
6070
std::transform(logger_name.begin(), logger_name.end(), logger_name.begin(),
6171
::toupper);
6272
std::stringstream env_var_name;
@@ -70,7 +80,7 @@ inline auto create_logger(std::string logger_name) {
7080
env_var_name << "UR_LOG_" << logger_name;
7181
auto map = getenv_to_map(env_var_name.str().c_str());
7282
if (!map.has_value()) {
73-
return Logger(std::make_unique<logger::StderrSink>());
83+
return Logger(std::make_unique<logger::StderrSink>(logger_name));
7484
}
7585

7686
try {
@@ -92,11 +102,11 @@ inline auto create_logger(std::string logger_name) {
92102
values = kv->second;
93103
}
94104

95-
sink = values.size() == 2 ? sink_from_str(values[0], values[1])
96-
: sink_from_str(values[0]);
105+
sink = values.size() == 2 ? sink_from_str(logger_name, values[0], values[1])
106+
: sink_from_str(logger_name, values[0]);
97107
} catch (const std::invalid_argument &e) {
98108
std::cerr << "Error when creating a logger instance from environment variable" << e.what();
99-
return Logger(std::make_unique<logger::StderrSink>());
109+
return Logger(std::make_unique<logger::StderrSink>(logger_name));
100110
}
101111
sink->setFlushLevel(flush_level);
102112

‎source/common/logger/ur_sinks.hpp‎

Lines changed: 15 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,8 @@ class Sink {
1313
public:
1414
template <typename... Args>
1515
void log(logger::Level level, const char *fmt, Args &&...args) {
16-
*ostream << "[" << level_to_str(level) << "]:";
16+
*ostream << "<" << logger_name << ">";
17+
*ostream << "[" << level_to_str(level) << "]: ";
1718
format(fmt, std::forward<Args &&>(args)...);
1819
*ostream << "\n";
1920
if (level >= flush_level) {
@@ -29,9 +30,11 @@ class Sink {
2930
std::ostream *ostream;
3031
logger::Level flush_level;
3132

32-
Sink() { flush_level = logger::Level::ERR; }
33+
Sink(std::string logger_name) : logger_name(logger_name) { flush_level = logger::Level::ERR; }
3334

3435
private:
36+
std::string logger_name;
37+
3538
void format(const char *fmt) {
3639
while (*fmt != '\0') {
3740
while (*fmt != '{' && *fmt != '}' && *fmt != '\0') {
@@ -112,9 +115,9 @@ class Sink {
112115

113116
class StdoutSink : public Sink {
114117
public:
115-
StdoutSink() { this->ostream = &std::cout; }
118+
StdoutSink(std::string logger_name) : Sink(logger_name) { this->ostream = &std::cout; }
116119

117-
StdoutSink(Level flush_lvl) : StdoutSink() {
120+
StdoutSink(std::string logger_name, Level flush_lvl) : StdoutSink(logger_name) {
118121
this->flush_level = flush_lvl;
119122
}
120123

@@ -123,9 +126,9 @@ class StdoutSink : public Sink {
123126

124127
class StderrSink : public Sink {
125128
public:
126-
StderrSink() { this->ostream = &std::cerr; }
129+
StderrSink(std::string logger_name) : Sink(logger_name) { this->ostream = &std::cerr; }
127130

128-
StderrSink(Level flush_lvl) : StderrSink() {
131+
StderrSink(std::string logger_name, Level flush_lvl) : StderrSink(logger_name) {
129132
this->flush_level = flush_lvl;
130133
}
131134

@@ -134,7 +137,7 @@ class StderrSink : public Sink {
134137

135138
class FileSink : public Sink {
136139
public:
137-
FileSink(std::string file_path) {
140+
FileSink(std::string logger_name, std::string file_path) : Sink(logger_name) {
138141
ofstream = std::ofstream(file_path, std::ofstream::out);
139142
if (ofstream.rdstate() != std::ofstream::goodbit) {
140143
throw std::invalid_argument(
@@ -144,21 +147,21 @@ class FileSink : public Sink {
144147
this->ostream = &ofstream;
145148
}
146149

147-
FileSink(std::string file_path, Level flush_lvl) : FileSink(file_path) {
150+
FileSink(std::string logger_name, std::string file_path, Level flush_lvl) : FileSink(logger_name, file_path) {
148151
this->flush_level = flush_lvl;
149152
}
150153

151154
private:
152155
std::ofstream ofstream;
153156
};
154157

155-
inline std::unique_ptr<Sink> sink_from_str(std::string name, std::string file_path = "") {
158+
inline std::unique_ptr<Sink> sink_from_str(std::string logger_name, std::string name, std::string file_path = "") {
156159
if (name == "stdout") {
157-
return std::make_unique<logger::StdoutSink>();
160+
return std::make_unique<logger::StdoutSink>(logger_name);
158161
} else if (name == "stderr") {
159-
return std::make_unique<logger::StderrSink>();
162+
return std::make_unique<logger::StderrSink>(logger_name);
160163
} else if (name == "file" && !file_path.empty()) {
161-
return std::make_unique<logger::FileSink>(file_path.c_str());
164+
return std::make_unique<logger::FileSink>(logger_name, file_path.c_str());
162165
}
163166

164167
throw std::invalid_argument(

‎source/drivers/null/ur_null.cpp‎

Lines changed: 0 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -8,11 +8,6 @@
88
*
99
*/
1010
#include "ur_null.hpp"
11-
#include "logger/ur_logger.hpp"
12-
13-
namespace logger {
14-
Logger logger = create_logger("null");
15-
}
1611

1712
namespace driver {
1813
//////////////////////////////////////////////////////////////////////////

‎source/loader/ur_lib.cpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -17,10 +17,6 @@
1717
#include "tracing/ur_tracing_layer.hpp"
1818
#endif
1919

20-
namespace logger {
21-
Logger logger = create_logger("loader");
22-
}
23-
2420
namespace ur_lib {
2521
///////////////////////////////////////////////////////////////////////////////
2622
context_t *context;
@@ -34,6 +30,10 @@ context_t::~context_t() {}
3430
//////////////////////////////////////////////////////////////////////////
3531
__urdlllocal ur_result_t context_t::Init(ur_device_init_flags_t device_flags) {
3632
ur_result_t result;
33+
const char *logger_name = "loader";
34+
logger::init(logger_name);
35+
logger::info("Logger {} initialized successfully!", logger_name);
36+
3737
result = loader::context->init();
3838

3939
if (UR_RESULT_SUCCESS == result) {

‎test/unit/logger/logger.cpp‎

Lines changed: 35 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -10,10 +10,6 @@
1010
#include "logger/ur_logger.hpp"
1111
#include "logger/ur_logger_details.hpp"
1212

13-
namespace logger {
14-
Logger logger = create_logger("test_adapter");
15-
}
16-
1713
TEST(logger, NullSinkOneParam) {
1814
ASSERT_THROW(logger::Logger(nullptr), std::invalid_argument);
1915
}
@@ -32,7 +28,8 @@ class CreateLoggerWithEnvVar : public ::testing::TestWithParam<std::string> {
3228
env_var_value = GetParam();
3329
ret = setenv("UR_LOG_TEST_ADAPTER", env_var_value.c_str(), 1);
3430
ASSERT_EQ(ret, 0);
35-
logger::logger = logger::create_logger("test_adapter");
31+
logger::init("test_adapter");
32+
logger::info("{} initialized successfully!", "test_adapter");
3633
}
3734

3835
void TearDown() override {
@@ -53,7 +50,8 @@ TEST_P(CreateLoggerWithEnvVar, EnvVarSetupStd) {
5350
class FileSink : public ::testing::Test {
5451
protected:
5552
std::string file_path = "ur_test_logger.log";
56-
std::string test_msg = "";
53+
std::string logger_name = "test";
54+
std::string test_msg = "<" + logger_name + ">";
5755

5856
void TearDown() override {
5957
auto test_log = std::ifstream(file_path, std::ios::in);
@@ -69,71 +67,81 @@ class FileSink : public ::testing::Test {
6967

7068
class FileSinkDefaultLevel : public FileSink {
7169
protected:
70+
int ret = -1;
71+
std::string env_var_value = "output:file," + file_path;
72+
7273
void SetUp() override {
73-
logger::logger =
74-
logger::Logger(std::make_unique<logger::FileSink>(file_path));
74+
ret = setenv("UR_LOG_TEST_ADAPTER", env_var_value.c_str(), 1);
75+
ASSERT_EQ(ret, 0);
76+
logger::init("test_adapter");
77+
logger::info("{} initialized successfully!", "test_adapter");
78+
}
79+
80+
void TearDown() override {
81+
ret = unsetenv("UR_LOG_TEST_ADAPTER");
82+
ASSERT_EQ(ret, 0);
7583
}
7684
};
7785

7886
TEST_F(FileSink, MultipleLines) {
7987
logger::Level level = logger::Level::WARN;
80-
logger::Logger logger(level, std::make_unique<logger::FileSink>(file_path));
88+
logger::Logger logger(level, std::make_unique<logger::FileSink>(logger_name, file_path));
8189

8290
logger.warning("Test message: {}", "success");
8391
logger.debug("This should not be printed: {}", 42);
8492
logger.error("Test message: {}", "success");
8593

86-
test_msg = "[WARNING]:Test message: success\n"
87-
"[ERROR]:Test message: success\n";
94+
test_msg += "[WARNING]: Test message: success\n"
95+
"<test>[ERROR]: Test message: success\n";
8896
}
8997

9098
TEST_F(FileSink, ThreeParams) {
9199
logger::Level level = logger::Level::DEBUG;
92-
logger::Logger logger(level, std::make_unique<logger::FileSink>(file_path));
100+
logger::Logger logger(level, std::make_unique<logger::FileSink>(logger_name, file_path));
93101

94102
logger.setFlushLevel(level);
95103
logger.debug("{} {}: {}", "Test", 42, 3.8);
96-
test_msg = "[DEBUG]:Test 42: 3.8\n";
104+
test_msg += "[DEBUG]: Test 42: 3.8\n";
97105
}
98106

99107
TEST_F(FileSink, DoubleBraces) {
100108
logger::Logger logger(logger::Level::ERR,
101-
std::make_unique<logger::FileSink>(file_path));
109+
std::make_unique<logger::FileSink>(logger_name, file_path));
102110

103111
logger.error("{{}} {}: {}", "Test", 42);
104-
test_msg = "[ERROR]:{} Test: 42\n";
112+
test_msg += "[ERROR]: {} Test: 42\n";
105113
}
106114

107115
TEST_F(FileSink, DoubleBraces2) {
108116
logger::Logger logger(logger::Level::ERR,
109-
std::make_unique<logger::FileSink>(file_path));
117+
std::make_unique<logger::FileSink>(logger_name, file_path));
110118

111119
logger.error("200 {{ {}: {{{}}} 3.8", "Test", 42);
112-
test_msg = "[ERROR]:200 { Test: {42} 3.8\n";
120+
test_msg += "[ERROR]: 200 { Test: {42} 3.8\n";
113121
}
114122

115123
TEST_F(FileSink, DoubleBraces3) {
116124
logger::Logger logger(logger::Level::ERR,
117-
std::make_unique<logger::FileSink>(file_path));
125+
std::make_unique<logger::FileSink>(logger_name, file_path));
118126

119127
logger.error("{{ {}:}} {}}}", "Test", 42);
120-
test_msg = "[ERROR]:{ Test:} 42}\n";
128+
test_msg += "[ERROR]: { Test:} 42}\n";
121129
}
122130

123131
TEST_F(FileSink, NoBraces) {
124132
logger::Logger logger(logger::Level::ERR,
125-
std::make_unique<logger::FileSink>(file_path));
133+
std::make_unique<logger::FileSink>(logger_name, file_path));
126134

127135
logger.error(" Test: 42");
128-
test_msg = "[ERROR]: Test: 42\n";
136+
test_msg += "[ERROR]: Test: 42\n";
129137
}
130138

131139
TEST_F(FileSink, SetFlushLevelDebugCtor) {
132140
auto level = logger::Level::DEBUG;
133-
logger::Logger logger(level, std::make_unique<logger::FileSink>(file_path, level));
141+
logger::Logger logger(level, std::make_unique<logger::FileSink>(logger_name, file_path, level));
134142

135143
logger.debug("Test message: {}", "success");
136-
test_msg = "[DEBUG]:Test message: success\n";
144+
test_msg += "[DEBUG]: Test message: success\n";
137145
}
138146

139147
TEST_F(FileSinkDefaultLevel, DefaultLevelNoOutput) {
@@ -146,7 +154,7 @@ TEST_F(FileSinkDefaultLevel, SetLevelDebug) {
146154
logger::setFlushLevel(level);
147155
logger::debug("Test message: {}", "success");
148156

149-
test_msg = "[DEBUG]:Test message: success\n";
157+
test_msg += "[DEBUG]: Test message: success\n";
150158
}
151159

152160
TEST_F(FileSinkDefaultLevel, SetLevelInfo) {
@@ -156,7 +164,7 @@ TEST_F(FileSinkDefaultLevel, SetLevelInfo) {
156164
logger::info("Test message: {}", "success");
157165
logger::debug("This should not be printed: {}", 42);
158166

159-
test_msg = "[INFO]:Test message: success\n";
167+
test_msg += "[INFO]: Test message: success\n";
160168
}
161169

162170
TEST_F(FileSinkDefaultLevel, SetLevelWarning) {
@@ -166,13 +174,13 @@ TEST_F(FileSinkDefaultLevel, SetLevelWarning) {
166174
logger::warning("Test message: {}", "success");
167175
logger::info("This should not be printed: {}", 42);
168176

169-
test_msg = "[WARNING]:Test message: success\n";
177+
test_msg += "[WARNING]: Test message: success\n";
170178
}
171179

172180
TEST_F(FileSinkDefaultLevel, SetLevelError) {
173181
logger::setLevel(logger::Level::ERR);
174182
logger::error("Test message: {}", "success");
175183
logger::warning("This should not be printed: {}", 42);
176184

177-
test_msg = "[ERROR]:Test message: success\n";
185+
test_msg += "[ERROR]: Test message: success\n";
178186
}

0 commit comments

Comments
 (0)