LoggerPtr
LogRegistry::getOrCreateLogger(const std::string &logger_name) {
// If logger already exists, return a copy of it
auto spd_logger = spdlog::get(logger_name);
if (!spd_logger) {
// Bummer, it didn't exist. We'll create one from scratch.
try {
spd_logger = spdlog::details::registry::instance().create(
logger_name, begin(sinks_), end(sinks_));
spd_logger->set_pattern(DEFAULT_PATTERN);
/// @todo should this level be different than other levels?
spd_logger->set_level(convertToLevelEnum(minLevel_));
spd_logger->flush_on(
convertToLevelEnum(DEFAULT_FLUSH_LEVEL));
} catch (const std::exception &e) {
generalPurposeLog_->error()
<< "Caught exception attempting to create logger: "
<< e.what();
generalPurposeLog_->error() << "Error creating logger. "
"Will only log to the "
"console.";
} catch (...) {
generalPurposeLog_->error() << "Error creating logger. "
"Will only log to the "
"console.";
}
}
return Logger::makeFromExistingImplementation(logger_name,
spd_logger);
}
void run(unsigned thread_id, std::string filename, Address ip,
std::vector<Address> routing_addresses) {
std::string log_file = "log_user.txt";
std::string logger_name = "user_log";
auto logger = spdlog::basic_logger_mt(logger_name, log_file, true);
logger->flush_on(spdlog::level::info);
std::hash<std::string> hasher;
unsigned seed = time(NULL);
seed += hasher(ip);
seed += thread_id;
logger->info("Random seed is {}.", seed);
// mapping from key to a set of worker addresses
std::unordered_map<Key, std::unordered_set<Address>> key_address_cache;
UserThread ut = UserThread(ip, thread_id);
int timeout = 10000;
zmq::context_t context(1);
SocketCache pushers(&context, ZMQ_PUSH);
// responsible for pulling response
zmq::socket_t response_puller(context, ZMQ_PULL);
response_puller.setsockopt(ZMQ_RCVTIMEO, &timeout, sizeof(timeout));
response_puller.bind(ut.get_request_pulling_bind_addr());
// responsible for receiving key address responses
zmq::socket_t key_address_puller(context, ZMQ_PULL);
key_address_puller.setsockopt(ZMQ_RCVTIMEO, &timeout, sizeof(timeout));
key_address_puller.bind(ut.get_key_address_bind_addr());
unsigned rid = 0;
std::string input;
unsigned trial = 1;
if (filename == "") {
while (true) {
std::cout << "kvs> ";
getline(std::cin, input);
handle_request(input, pushers, routing_addresses, key_address_cache, seed,
logger, ut, response_puller, key_address_puller, ip,
thread_id, rid, trial);
}
} else {
std::ifstream infile(filename);
while (getline(infile, input)) {
handle_request(input, pushers, routing_addresses, key_address_cache, seed,
logger, ut, response_puller, key_address_puller, ip,
thread_id, rid, trial);
}
}
}
LoggerPtr Logger::makeWithSink(std::string const &name,
spdlog::sink_ptr sink) {
if (!sink) {
// bad sink!
std::cerr << "WARNING: Logger::makeWithSink(\"" << name
<< "\", sink) called with a null sink! Will result "
"in a fallback logger!"
<< std::endl;
return makeFallback(name);
}
auto spd_logger = std::make_shared<spdlog::logger>(name, sink);
spd_logger->set_pattern(DEFAULT_PATTERN);
spd_logger->flush_on(convertToLevelEnum(DEFAULT_FLUSH_LEVEL));
return makeLogger(name, spd_logger);
}
LoggerPtr Logger::makeWithSinks(std::string const &name,
spdlog::sinks_init_list sinks) {
for (auto &sink : sinks) {
if (!sink) {
std::cerr << "WARNING: "
"Logger::makeWithSinks(\""
<< name << "\", sinks) called "
"with at least one null sink! Will "
"result in a fallback logger!"
<< std::endl;
// got a bad sink
/// @todo should we be making a fallback logger here, just
/// hoping spdlog will deal with a bad sink pointer without
/// issue, or filtering the init list to a non-nullptr
/// vector?
return makeFallback(name);
}
}
auto spd_logger = std::make_shared<spdlog::logger>(name, sinks);
spd_logger->set_pattern(DEFAULT_PATTERN);
spd_logger->flush_on(convertToLevelEnum(DEFAULT_FLUSH_LEVEL));
return makeLogger(name, spd_logger);
}
int test_spdlog_console()
{
try {
// Console logger with color
auto console = spd::stdout_color_mt("console");
console->info("Welcome to spdlog!");
console->error("Some error message with arg{}..", 1);
// Conditional logging example
console->info_if(true, "Welcome to spdlog conditional logging!");
// Formatting examples
console->warn("Easy padding in numbers like {:08d}", 12);
console->critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42);
console->info("Support for floats {:03.2f}", 1.23456);
console->info("Positional args are {1} {0}..", "too", "supported");
console->info("{:<30}", "left aligned");
SPDLOG_DEBUG_IF(console, true, "This is a debug log");
spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function");
// Create basic file logger (not rotated)
#ifdef __linux__
auto my_logger = spd::basic_logger_mt("basic_logger", "testdata/basic_log");
#else
auto my_logger = spd::basic_logger_mt("basic_logger", "E:/GitCode/Messy_Test/testdata/basic_log");
#endif
my_logger->info("Some log message");
// Create a file rotating logger with 5mb size max and 3 rotated files
#ifdef __linux__
auto rotating_logger = spd::rotating_logger_mt("some_logger_name", "testdata/mylogfile_log", 1048576 * 5, 3);
#else
auto rotating_logger = spd::rotating_logger_mt("some_logger_name", "E:/GitCode/Messy_Test/testdata/mylogfile_log", 1048576 * 5, 3);
#endif
for (int i = 0; i < 10; ++i)
rotating_logger->info("{} * {} equals {:>10}", i, i, i*i);
// Create a daily logger - a new file is created every day on 2:30am
#ifdef __linux__
auto daily_logger = spd::daily_logger_mt("daily_logger", "testdata/daily_log", 2, 30);
#else
auto daily_logger = spd::daily_logger_mt("daily_logger", "E:/GitCode/Messy_Test/testdata/daily_log", 2, 30);
#endif
// trigger flush if the log severity is error or higher
daily_logger->flush_on(spd::level::err);
daily_logger->info(123.44);
// Customize msg format for all messages
spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***");
rotating_logger->info("This is another message with custom format");
// Runtime log levels
spd::set_level(spd::level::info); //Set global log level to info
console->debug("This message shold not be displayed!");
console->set_level(spd::level::debug); // Set specific logger's log level
console->debug("This message shold be displayed..");
// Compile time log levels
// define SPDLOG_DEBUG_ON or SPDLOG_TRACE_ON
SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
SPDLOG_DEBUG_IF(console, true, "This is a debug log");
// Apply a function on all registered loggers
spd::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });
// Release and close all loggers
spdlog::drop_all();
}
// Exceptions will only be thrown upon failed logger or sink construction (not during logging)
catch (const spd::spdlog_ex& ex) {
std::cout << "Log init failed: " << ex.what() << std::endl;
return -1;
}
return 0;
}
