int main(int, char* []) { namespace spd = spdlog; try { std::string filename = "logs/spdlog_example"; // Set log level to all loggers to DEBUG and above spd::set_level(spd::level::DEBUG); //Create console, multithreaded logger auto console = spd::stdout_logger_mt("console"); console->info("Welcome to spdlog!") ; console->info("An info message example", "...", 1, 2, 3.5); console->info() << "Streams are supported too " << std::setw(5) << std::setfill('0') << 1; //Create a file rotating logger with 5mb size max and 3 rotated files auto file_logger = spd::rotating_logger_mt("file_logger", filename, 1024 * 1024 * 5, 3); file_logger->info("Log file message number", 1); for (int i = 0; i < 100; ++i) { file_logger->info(i, "in hex is", "0x") << std::hex << std::uppercase << i; } spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***"); file_logger->info("This is another message with custom format"); spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function"); SPDLOG_TRACE(file_logger, "This is a trace message (only #ifdef _DEBUG)", 123); #ifdef __linux__ auto syslog_logger = spd::syslog_logger("syslog"); syslog_logger->warn("This is warning that will end up in syslog. This is Linux only!"); #endif } catch (const spd::spdlog_ex& ex) { std::cout << "Log failed: " << ex.what() << std::endl; } return 0; }
int main(int, char*[]) { namespace spd = spdlog; try { //Create console, multithreaded logger auto console = spd::stdout_logger_mt("console"); console->info("Welcome to spdlog!"); console->info("An info message example {}..", 1); console->info() << "Streams are supported too " << 1; //Formatting examples console->info("Easy padding in numbers like {:08d}", 12); console->info("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"); console->info("{:>30}", "right aligned"); console->info("{:^30}", "centered"); // // 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("Now it should.."); // // Create a file rotating logger with 5mb size max and 3 rotated files // auto file_logger = spd::rotating_logger_mt("file_logger", "logs/mylogfile", 1048576 * 5, 3); for (int i = 0; i < 10; ++i) file_logger->info("{} * {} equals {:>10}", i, i, i*i); // // Create a daily logger - a new file is created every day on 2:30am // auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily", 2, 30); // // Customize msg format for all messages // spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***"); file_logger->info("This is another message with custom format"); spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function"); // // Compile time debug or trace macros. // Enabled #ifdef SPDLOG_DEBUG_ON or #ifdef 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); // // Asynchronous logging is very fast.. // Just call spdlog::set_async_mode(q_size) and all created loggers from now on will be asynchronous.. // size_t q_size = 1048576; //queue size must be power of 2 spdlog::set_async_mode(q_size); auto async_file = spd::daily_logger_st("async_file_logger", "logs/async_log.txt"); async_file->info() << "This is async log.." << "Should be very fast!"; // // syslog example. linux only.. // #ifdef __linux__ std::string ident = "spdlog-example"; auto syslog_logger = spd::syslog_logger("syslog", ident, LOG_PID); syslog_logger->warn("This is warning that will end up in syslog. This is Linux only!"); #endif } catch (const spd::spdlog_ex& ex) { std::cout << "Log failed: " << ex.what() << std::endl; } }
int main(int, char*[]) { try { // Multithreaded color console auto console = spd::stdout_logger_mt("console", true); console->info("Welcome to spdlog!"); console->info("An info message example {}..", 1); // Formatting examples console->info("Easy padding in numbers like {:08d}", 12); console->info("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"); console->info("{:>30}", "right aligned"); console->info("{:^30}", "centered"); spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function"); // 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.."); // Create basic file logger (not rotated) auto my_logger = spd::basic_logger_mt("basic_logger", "logs/basic.txt"); my_logger->info("Some log message"); // Create a file rotating logger with 5mb size max and 3 rotated files auto rotating_logger = spd::rotating_logger_mt("some_logger_name", "logs/mylogfile", 1048576 * 5, 3); 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 auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily", 2, 30); 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"); // Compile time debug or trace macros. // Enabled #ifdef SPDLOG_DEBUG_ON or #ifdef 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); // Asynchronous logging is very fast.. // Just call spdlog::set_async_mode(q_size) and all created loggers from now on will be asynchronous.. async_example(); // syslog example. linux/osx only.. syslog_example(); // Release and close all loggers spdlog::drop_all(); } catch (const spd::spdlog_ex& ex) { std::cout << "Log failed: " << ex.what() << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; }
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; }
int main(int argc, char* argv[]) { gflags::SetUsageMessage("[options] full_path_to_urdf_or_sdf_file"); gflags::ParseCommandLineFlags(&argc, &argv, true); if (argc < 2) { gflags::ShowUsageWithFlags(argv[0]); return 1; } logging::HandleSpdlogGflags(); // todo: consider moving this logic into the RigidBodySystem class so it can // be reused FloatingBaseType floating_base_type = kQuaternion; if (FLAGS_base == "kFixed") { floating_base_type = kFixed; } else if (FLAGS_base == "RPY") { floating_base_type = kRollPitchYaw; } else if (FLAGS_base == "QUAT") { floating_base_type = kQuaternion; } else { throw std::runtime_error(string("Unknown base type") + FLAGS_base + "; must be kFixed, RPY, or QUAT"); } auto rigid_body_sys = make_shared<RigidBodySystem>(); rigid_body_sys->AddModelInstanceFromFile(argv[argc - 1], floating_base_type); auto const& tree = rigid_body_sys->getRigidBodyTree(); if (FLAGS_add_flat_terrain) { SPDLOG_TRACE(drake::log(), "adding flat terrain"); double box_width = 1000; double box_depth = 10; DrakeShapes::Box geom(Vector3d(box_width, box_width, box_depth)); Isometry3d T_element_to_link = Isometry3d::Identity(); T_element_to_link.translation() << 0, 0, -box_depth / 2; // top of the box is at z=0 RigidBody<double>& world = tree->world(); Vector4d color; color << 0.9297, 0.7930, 0.6758, 1; // was hex2dec({'ee','cb','ad'})'/256 in matlab world.AddVisualElement( DrakeShapes::VisualElement(geom, T_element_to_link, color)); tree->addCollisionElement( DrakeCollision::Element(geom, T_element_to_link, &world), world, "terrain"); tree->compile(); } shared_ptr<lcm::LCM> lcm = make_shared<lcm::LCM>(); auto visualizer = make_shared<BotVisualizer<RigidBodySystem::StateVector>>(lcm, tree); auto sys = cascade(rigid_body_sys, visualizer); SimulationOptions options; options.realtime_factor = 1.0; options.timeout_seconds = std::numeric_limits<double>::infinity(); options.initial_step_size = 5e-3; runLCM(sys, lcm, 0, std::numeric_limits<double>::infinity(), getInitialState(*sys), options); // simulate(*sys, 0, std::numeric_limits<double>::max(), // getInitialState(*sys), options); return 0; }
int_fast8_t shared::init(const string_t cf) { ///init log try { //Create console, multithreaded logger c_logger_ = spd::stdout_logger_mt("console"); c_logger_->info("Welcome to spdlog!"); c_logger_->info("An info message example {}..", 1); c_logger_->info() << "Streams are supported too " << 1; //Formatting examples c_logger_->info("Easy padding in numbers like {:08d}", 12); c_logger_->info("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); c_logger_->info("Support for floats {:03.2f}", 1.23456); c_logger_->info("Positional args are {1} {0}..", "too", "supported"); c_logger_->info("{:<30}", "left aligned"); c_logger_->info("{:>30}", "right aligned"); c_logger_->info("{:^30}", "centered"); // // Runtime log levels // spd::set_level(spd::level::debug); //Set global log level to info c_logger_->debug("This message shold not be displayed!"); c_logger_->set_level(spd::level::debug); // Set specific logger's log level c_logger_->debug("Now it should.."); spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***"); SPDLOG_TRACE(c_logger_, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);SPDLOG_DEBUG(c_logger_, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23); af_logger_ = spd::daily_logger_st("async_file_logger", "async_log.txt"); af_logger_->set_level(spd::level::debug); af_logger_->info() << "This is async log.." << "Should be very fast!"; } catch (const spd::spdlog_ex& ex) { std::cout << "Log failed: " << ex.what() << std::endl; return -1; } /** * get conf info . * */ //json json_obj; std::ifstream file(cf); //file >> json_obj; //LOGGER()->debug("read conf, the client count is {:d}!\n", json_obj.count("client_info")); //af_logger_->flush(); web::json::value v = web::json::value::parse(file); LOGGER()->debug("json size: %d\n", v.size()); //rs_addr_ = ; // for (auto x : json_obj) // { // LOGGER()->debug(x.dump()); // auto cid = x["client_id"]; // LOGGER()->debug(cid); // auto base_contracts = x["base_contracts"]; // LOGGER()->debug(base_contracts.dump()); // for (auto y : base_contracts) // { // LOGGER()->debug(y.dump()); // string_t tmp = y["id"]; // client_infos_[cid].base_contracts_[hash_str(tmp.c_str())].max_bid_posi_ = y["max_bid_posi"]; // } // // auto arbi_contracts = x["arbi_contracts"]; // for (auto y : arbi_contracts) // { // LOGGER()->debug(y.dump()); // string_t tmp = y[0]; // client_infos_[cid].arbi_contracts_[hash_str(tmp.c_str())].max_bid_posi_ = 1; // } // // } ///start rest service // Build our listener's URI from the configured address ///and the hard-coded path "blackjack/dealer" rs_ptr_ = std::unique_ptr<rest_service>(new rest_service(rs_addr_)); rs_ptr_->open().wait(); return ne_.open(); }