commit f637c3cee687aced8508787f7066a94698708f15 Author: Dominik Meyer Date: Thu Aug 19 17:03:04 2021 +0200 Squashed 'libs/loguru/' content from commit 9c2fea0d git-subtree-dir: libs/loguru git-subtree-split: 9c2fea0d4530657f23259be4132f8101c98b579e diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d79bdb2 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +build +*.sublime-workspace diff --git a/README.md b/README.md new file mode 100644 index 0000000..6f133f3 --- /dev/null +++ b/README.md @@ -0,0 +1,232 @@ +# Loguru: a lightweight and flexible C++ logging library. + +[![Build status](https://ci.appveyor.com/api/projects/status/hret4rx3xakjs7j4?svg=true)](https://ci.appveyor.com/project/emilk/loguru) + +## At a glance + +![Loguru terminal output](docs/terminal_colors.png) + +## Documentation +Documentation can be found at https://emilk.github.io/loguru/index.html. + +## License +This software is in the public domain. Where that dedication is not recognized, you are granted a perpetual, irrevocable license to copy, modify and distribute it as you see fit. + +That being said, I would appreciate credit! +If you find Loguru useful, tweet me at @ernerfeldt mail me at emil.ernerfeldt@gmail.com. + +## Why another logging library? +I have yet to come across a nice, light-weight logging library for C++ that does everything I want. So I made one! + +In particular, I want logging that produces logs that are both human-readable and easily grep:ed. I also want to be able to hook into the logging process to print some of the more severe messages on-screen in my app (for dev-purposes). + +## Features: +* Simple integration + * Just two files: `loguru.hpp` and `loguru.cpp`. + * Either build and link `loguru.cpp` or just `#include ` in one of your own .cpp files. +* Small, simple library. + * Small header with no `#include`s for **fast compile times** (see separate heading). + * No dependencies. + * Cross-platform +* Flexible: + * User can install callbacks for logging (e.g. to draw log messages on screen in a game). + * User can install callbacks for fatal error (e.g. to pause an attached debugger or throw an exception). +* Support multiple file outputs, either trunc or append: + * e.g. a logfile with just the latest run at low verbosity (high readability). + * e.g. a full logfile at highest verbosity which is appended to on every run. +* Full featured: + * Verbosity levels. + * Supports assertions: `CHECK_F(fp != nullptr, "Failed to open '%s'", filename)` + * Supports abort: `ABORT_F("Something went wrong, debug value is %d", value)`. +* Stack traces printed on abort. + * Stack traces are cleaned up somewhat. + * Before cleanup: `some_function_name(std::__1::vector, std::__1::allocator >, std::__1::allocator, std::__1::allocator > > > const&)` + * After cleanup: `some_function_name(std::vector const&)` + * Stack traces are printed [the right way](http://yellerapp.com/posts/2015-01-22-upside-down-stacktraces.html): + * Chronological order with the most relevant at the end. +* (most) signals writes stack traces. +* Fast: + - When configured in unbuffered mode (loguru::g_flush_interval_ms = 0): + + 6-8 us when logging to stderr + file (rMBP + SSD + Clang). + + About 25%-75% faster than GLOG on my MacBook Pro (Clang). + + About the same as GLOG on my Linux Desktop (GCC). + - With loguru::g_flush_interval_ms set to ~100 ms: + + 3-5 us when logging to stderr + file (rMBP + SSD + Clang). + + About twice as fast as GLOG. +* Drop-in replacement for most of GLOG (except for setup code). +* Choose between using printf-style or std::cout-style formatting. +* Compile-time checked printf-formating (on supported compilers). +* Support for [fmtlib](https://github.com/fmtlib/fmt) formatting. + * Add `#define LOGURU_USE_FMTLIB 1`, before including `loguru.hpp` + * You also need to set up the `fmtlib` include directory for building as well as linking against `fmtlib`, alternatively use the `FMT_HEADER_ONLY` preprocessor definition. +* Assertion failures are marked with `noreturn` for the benefit of the static analyzer and optimizer. +* All logging also written to stderr. + * With colors on supported terminals. +* Thread-safe. +* Can be configured to either: + * Flush every `loguru::g_flush_interval_ms` in a background thread + * Flushes output on each call so you won't miss anything even on hard crashes (and still faster than buffered GLOG!). +* Prefixes each log line with: + * Date and time to millisecond precision. + * Application uptime to millisecond precision. + * Thread name or id (you can set the name with `loguru::set_thread_name`). + * File and line. + * Log level. + * Indentation (see *Scopes*). +* Error context: + * Catch the values of local variables and print them only on a crash (see *Error context*). +* Scopes (see *Scopes*). +* grep:able logs: + * Each line has all the info you need (e.g. date). + * You can easily filter out high verbosity levels after the fact. + +## Compiling + +Just include where you want to use Loguru. +Then either compile and link with `loguru.cpp` or in one .cpp file: `#include ` +Make sure you compile with `-std=c++11 -lpthread -ldl` on relevant environments. + +## Usage + +``` C++ +#include + +… + +// Optional, but useful to time-stamp the start of the log. +// Will also detect verbosity level on command line as -v. +loguru::init(argc, argv); + +// Put every log message in "everything.log": +loguru::add_file("everything.log", loguru::Append, loguru::Verbosity_MAX); + +// Only log INFO, WARNING, ERROR and FATAL to "latest_readable.log": +loguru::add_file("latest_readable.log", loguru::Truncate, loguru::Verbosity_INFO); + +// Only show most relevant things on stderr: +loguru::g_stderr_verbosity = 1; + +LOG_SCOPE_F(INFO, "Will indent all log messages within this scope."); +LOG_F(INFO, "I'm hungry for some %.3f!", 3.14159); +LOG_F(2, "Will only show if verbosity is 2 or higher"); +VLOG_F(get_log_level(), "Use vlog for dynamic log level (integer in the range 0-9, inclusive)"); +LOG_IF_F(ERROR, badness, "Will only show if badness happens"); +auto fp = fopen(filename, "r"); +CHECK_F(fp != nullptr, "Failed to open file '%s'", filename); +CHECK_GT_F(length, 0); // Will print the value of `length` on failure. +CHECK_EQ_F(a, b, "You can also supply a custom message, like to print something: %d", a + b); + +// Each function also comes with a version prefixed with D for Debug: +DCHECK_F(expensive_check(x)); // Only checked #if !NDEBUG +DLOG_F(INFO, "Only written in debug-builds"); + +// Turn off writing to stderr: +loguru::g_stderr_verbosity = loguru::Verbosity_OFF; + +// Turn off writing err/warn in red: +loguru::g_colorlogtostderr = false; + +// Throw exceptions instead of aborting on CHECK fails: +loguru::set_fatal_handler([](const loguru::Message& message){ + throw std::runtime_error(std::string(message.prefix) + message.message); +}); +``` + +If you prefer logging with streams: + +``` C++ +#define LOGURU_WITH_STREAMS 1 +#include +... +LOG_S(INFO) << "Look at my custom object: " << a.cross(b); +CHECK_EQ_S(pi, 3.14) << "Maybe it is closer to " << M_PI; +``` + +For more info, see [the official documentation](https://emilk.github.io/loguru/index.html). + +## Grep:able logs +``` bash +# Only show warnings, errors and fatal messages: +cat logfile.txt | egrep "[^0-9]\|" + +# Ignore verbosity-levels 4 and above: +cat logfile.txt | egrep "[^4-9]\|" + +# Only show verbosity-level 6: +cat logfile.txt | egrep "6\|" + +# Only show messages from the main thread: +cat logfile.txt | egrep "\[main thread \]" +``` + +## No includes in loguru.hpp +I abhor logging libraries that `#include`'s everything from `iostream` to `windows.h` into every compilation unit in your project. Logging should be frequent in your source code, and thus as lightweight as possible. Loguru's header has *no #includes*. This means it will not slow down the compilation of your project. + +In a test of a medium-sized project, including `loguru.hpp` instead of `glog/logging.hpp` everywhere gave about 10% speedup in compilation times. + +Note, however, that this gives you the bare-bones version of Loguru with printf-style logging. If you want `std::ostream` style logging (or GLOG functionality) you need to `#define LOGURU_WITH_STREAMS 1` before `#include `, and that will make `loguru.hpp` include ``. No away around it! + +## Scopes +The library supports scopes for indenting the log-file. Here's an example: + +``` C++ +int main(int argc, char* argv[]) +{ + loguru::init(argc, argv); + LOG_SCOPE_FUNCTION(INFO); + LOG_F(INFO, "Doing some stuff..."); + for (int i=0; i<2; ++i) { + VLOG_SCOPE_F(1, "Iteration %d", i); + auto result = some_expensive_operation(); + LOG_IF_F(WARNING, result == BAD, "Bad result"); + } + LOG_F(INFO, "Time to go!"); + return 0; +} +``` + + +This will output: + +``` + loguru.cpp:184 0| arguments: ./loguru_test test -v1 + loguru.cpp:185 0| Verbosity level: 1 + loguru.cpp:186 0| ----------------------------------- + loguru_test.cpp:108 0| { int main_test(int, char **) + loguru_test.cpp:109 0| . Doing some stuff... + loguru_test.cpp:111 1| . { Iteration 0 + loguru_test.cpp:111 1| . } 0.133 s: Iteration 0 + loguru_test.cpp:111 1| . { Iteration 1 + loguru_test.cpp:113 0| . . Bad result + loguru_test.cpp:111 1| . } 0.134 s: Iteration 1 + loguru_test.cpp:115 0| . Time to go! + loguru_test.cpp:108 0| } 0.267 s: int main_test(int, char **) +``` + + +# `ERROR_CONTEXT` +You can also optionally log things ONLY if there is a crash. This is a very useful feature: + +``` + void process_file(const char* filename) + { + ERROR_CONTEXT("filename", filename); + parse_file(filename); // Only if this crashes will filename be logged. + } +``` + + +## Streams vs printf +Some logging libraries only supports stream style logging, not printf-style. This means that what in Loguru is: + +``` C++ +LOG_F(INFO, "Some float: %+05.3f", number); +``` + +in Glog becomes something along the lines of: + +``` C++ +LOG(INFO) << "Some float: " << std::setfill('0') << std::setw(5) << std::setprecision(3) << number; +``` + +Loguru allows you to use whatever style you prefer. diff --git a/appveyor.yml b/appveyor.yml new file mode 100644 index 0000000..5c5ce85 --- /dev/null +++ b/appveyor.yml @@ -0,0 +1,12 @@ +version: 0.1.{build}-{branch} +pull_requests: + do_not_increment_build_number: true + +image: + - Ubuntu + - Visual Studio 2017 + +# loguru is header-only +build: off + +test_script: cmake -P test/appveyor.cmake diff --git a/docs/index.html b/docs/index.html new file mode 100644 index 0000000..166ff28 --- /dev/null +++ b/docs/index.html @@ -0,0 +1,679 @@ + + +# Loguru +This document contains the official documentation of Loguru, a lightweight and flexible C++ logging library. This documentations is not 100% complete. Read the `loguru.hpp` for more details. + +The official project homepage of Loguru is at https://github.com/emilk/loguru. + +Loguru provides a set of functions and macros to aid logging to one or several files and/or to `stderr`. It prefixes each log line with useful information such as time. + +# Getting started +Download `loguru.hpp` and `loguru.cpp` from https://github.com/emilk/loguru. To use Loguru in any file, simply `#include `. Then either compile and link with `loguru.cpp` or add `#include ` to one of your `.cpp` files. + +Loguru uses C++11, so make sure you compile with `-std=c++11`. On Linux you also need the following linker flags: `-lpthread -ldl`. + +Now you are ready to use Loguru! Here is a simple example: + +``` C++ + #include + + int main_test(int argc, char* argv[]) + { + loguru::init(argc, argv); + loguru::add_file("everything.log", loguru::Append, loguru::Verbosity_MAX); + LOG_F(INFO, "Hello log file!"); + return 0; + } +``` + +## A slightly more advanced example +`main.cpp`: + +``` C++ + #include + #include + + #include + + void sleep_ms(int ms) + { + VLOG_F(2, "Sleeping for %d ms", ms); + std::this_thread::sleep_for(std::chrono::milliseconds(ms)); + } + + void complex_calculation() + { + LOG_SCOPE_F(INFO, "complex_calculation"); + LOG_F(INFO, "Starting time machine..."); + sleep_ms(200); + LOG_F(WARNING, "The flux capacitor is not getting enough power!"); + sleep_ms(400); + LOG_F(INFO, "Lighting strike!"); + VLOG_F(1, "Found 1.21 gigawatts..."); + sleep_ms(400); + std::thread([](){ + loguru::set_thread_name("the past"); + LOG_F(ERROR, "We ended up in 1985!"); + }).join(); + } + + int main(int argc, char* argv[]) + { + loguru::init(argc, argv); + LOG_F(INFO, "Hello from main.cpp!"); + complex_calculation(); + LOG_F(INFO, "main function about to end!"); + } +``` + +``` bash + g++ -std=c++11 main.cpp -o loguru_example + ./loguru_example -v 1 +``` + +Output: +![Notice how the color matches the verbosity level (`0 = INFO`)](terminal_colors.png) + + +## Older versions +Before Loguru 2.0 was released in 2018, Loguru consisted of a single `loguru.hpp` header. If you are still using that version (and for some reason don't want to upgrade), this is how you use it: + +In ONE `.cpp` file you need to add this: + +``` C++ + #define LOGURU_IMPLEMENTATION + #include +``` + +That's it! Most of this documentation will still apply the same. + + +# How Loguru works +## Outputs and verbosity +Loguru has several outputs. By default, Loguru logs everything to `stderr` and nowhere else. You can add files to write to using `loguru::add_file`. Each output (`stderr` and files) has a *verbosity level* attached to it. Each time you log something, you also pick a verbosity level, for instance `INFO` or `ERROR`. This way you can have one log file where only the most important messages go (e.g. `WARNING`s and `ERROR`s) and another where all logging goes. You can control the verbosity level of `stderr` either from code (with `loguru::g_stderr_verbosity`) or from the command line arguments with the `-v` flags. + + +************************************************************* +* .---------. * +* | LOG_F +->+ .-------. * +* '---------' | +->| stderr | * +* | | '-------' * +* .---------. | | .------------------. * +* | CHECK_F +->+ _________ +->| optional callback | * +* '---------' | / / | '------------------' * +* +->-++ Loguru ++---+ .-------. * +* .---------. | /________/ +->| file 1 | * +* | ABORT_F +->+ | '-------' * +* '---------' | | .---------. * +* | +->| file 2 … | * +* .---------. | '---------' * +* | Crash +->+ * +* '---------' * +************************************************************* + + +# Logging +## Verbosity levels +Loguru has a hierarchy of verbosity levels: + +* FATAL (caused by failed checks, signals or calls to ABORT_F) +* ERROR (= -2) +* WARNING (= -1) +* INFO (= 0) +* 1-9 + +When calling a log function you must pick one of the above log levels (except FATAL). Loguru will then only process it (write to `stderr`, a file, or your custom callbacks) if the verbosity is below the cutoff for that output. For instance, by default only INFO, WARNING and ERROR is written to `stderr`. + +A common approach is to print only high-verbosity things to `stderr`, but write everything to a logfile. + +## Log functions + +### `LOG_F(verbosity_name, fmt, ...)` +The first and foremost logging function is `LOG_F` which looks like this. + +``` C++ + LOG_F(INFO, "Warming up %d lasers", 3); + LOG_F(WARNING, "%s is an old code, but it checks out", code_id); + LOG_F(ERROR, "The hyperdrive doesn't work"); +``` + +You can pass any number of arguments to `LOG_F` just like with `printf`. On modern compilers you will get compile-time checking of the argument number and types. + +Those are the named verbosity levels, and those you will most often use. However, sometimes you may want to log some details that you may very seldom be interested in. For this you can pick an integer verbosity level in the range 0-9 (inclusive). `0` is identical with `INFO`. A higher number means "more verbose", e.g. "more likely to be irrelevant". Example: + +``` C++ + LOG_F(1, "This may be important, but probably not"); + LOG_F(9, "Nobody will ever care about this."); +``` + +If you want to pick verbosity level dynamically, use the `VLOG_F` function. + +### `VLOG_F(verbosity, fmt, ...)` +This is for when you want a dynamic verbosity, i.e. an verbosity derived from a function call: +``` C++ + VLOG_F(is_vip(guest) ? 0 : 9, "%s has entered the room", guest); + + loguru::Verbosity verbosity = 5; // Higher = less likely to be printed + VLOG_F(verbosity, "..."); + + verbosity = loguru::Verbosity_WARNING; + VLOG_F(verbosity, "..."); +``` + +### `LOG_IF_F(verbosity_name, condition, fmt, ...)` +Conditionally log something. +``` C++ + LOG_IF_F(WARNING, value == invalid, "Invalid value: %d", value); + + // Equivalent to: + if (value == invalid) { + LOG_F(WARNING, "Invalid value: %d", value); + } +``` + +### `RAW_LOG_F(verbosity_name, fmt, ...)` +Log something without the usual prefix of date, time, file etc. + + +### All logging functions +There are also combinations of the `RAW`, `IF`, and `V` versions. Here is the complete list: + +``` C++ + LOG_F(verbosity_name, fmt, ...) + VLOG_F(verbosity, fmt, ...) + LOG_IF_F(verbosity_name, cond, fmt, ...) + VLOG_IF_F(verbosity, cond, fmt, ...) + RAW_LOG_F(verbosity_name, fmt, ...) + RAW_VLOG_F(verbosity, fmt, ...) +``` + +### Debug-only logging: +In addition, there are variants who only log in debug builds (and/or when `LOGURU_DEBUG_LOGGING=1`): + +``` C++ + DLOG_F(verbosity_name, fmt, ...) + DVLOG_F(verbosity, fmt, ...) + DLOG_IF_F(verbosity_name, cond, fmt, ...) + DVLOG_IF_F(verbosity, cond, fmt, ...) + DRAW_LOG_F(verbosity_name, fmt, ...) + DRAW_VLOG_F(verbosity, fmt, ...) +``` + +## Log scopes +Loguru has the concept of *log scopes*. This is a way to indent you logging to make them more readable. This is great for readability of your log files. Here's an example: + +``` C++ + int main(int argc, char* argv[]) + { + loguru::init(argc, argv); + LOG_SCOPE_FUNCTION(INFO); + LOG_F(INFO, "Doing some stuff..."); + for (int i=0; i<2; ++i) { + VLOG_SCOPE_F(1, "Iteration %d", i); + auto result = some_expensive_operation(); + LOG_IF_F(WARNING, result == BAD, "Bad result"); + } + LOG_F(INFO, "Time to go!"); + return 0; + } +``` + +This will output: + +``` + loguru.cpp:184 0| arguments: ./loguru_test test -v1 + loguru.cpp:185 0| Verbosity level: 1 + loguru.cpp:186 0| ----------------------------------- + loguru_test.cpp:108 0| { int main_test(int, char **) + loguru_test.cpp:109 0| . Doing some stuff... + loguru_test.cpp:111 1| . { Iteration 0 + loguru_test.cpp:111 1| . } 0.133 s: Iteration 0 + loguru_test.cpp:111 1| . { Iteration 1 + loguru_test.cpp:113 0| . . Bad result + loguru_test.cpp:111 1| . } 0.134 s: Iteration 1 + loguru_test.cpp:115 0| . Time to go! + loguru_test.cpp:108 0| } 0.267 s: int main_test(int, char **) +``` + + +Here are the LOG_SCOPE family of functions: +``` C++ + LOG_SCOPE_F(verbosity_name, fmt, ...) + VLOG_SCOPE_F(name, fmt, ...) + LOG_SCOPE_FUNCTION(verbosity_name) // Logs the name of the current function. +``` + +Scopes affects logging on all threads. + + +## Logging with streams +By default, Loguru will only let you log with `printf`-style formatting. If you prefer to use C++-style stream logging you need to define `LOGURU_WITH_STREAMS=1` (e.g. set `#define LOGURU_WITH_STREAMS 1` before including `loguru.hpp` or pass `-DLOGURU_WITH_STREAMS=1` to your compiler). + +This will enable new logging functions with `_S` suffixes: + +``` + LOG_S(INFO) << "Look at my custom object: " << a.cross(b); + CHECK_EQ_S(pi, 3.14) << "Maybe it is closer to " << M_PI; +``` + +Here are all the stream logging functions: + +``` C++ + VLOG_IF_S(verbosity, cond) << ... + LOG_IF_S(verbosity_name, cond) << ... + VLOG_S(verbosity) << ... + LOG_S(verbosity_name) << ... + DVLOG_IF_S(verbosity, cond) << ... + DLOG_IF_S(verbosity_name, cond) << ... + DVLOG_S(verbosity) << ... + DLOG_S(verbosity_name) << ... +``` + +## Notes + * Any arguments to LOG functions or LOG_SCOPE are only evaluated iff the verbosity test passes. + * Any arguments to LOG_IF functions are only evaluated if the test passes. + + +# Logging crashes +One of the most important parts of any logging library is to log things when they go horribly wrong. In Loguru, we call this *FATAL* logging. This can be caused by CHECK fails, signals or manual aborts. + +When they happen, Loguru will: + +* Print the cause of the fatality +* Print the error context (see separate chapter) +* Print a stack trace +* Call any installed fatal handler (see `set_fatal_handler`). +* Abort your program (unless your fatal handler chose to instead throw an exception). + +Let's examine all the causes for FATALs: + +## CHECKS +Loguru can also do runtime checks which are similar to [`assert`](http://en.cppreference.com/w/cpp/error/assert) but far more powerful. In particular, by default Loguru will run the checks in release builds as well as debug builds, and helpful and descriptive errors will be logged when a check fails. Here is a simple example of some checks: + +``` C++ + CHECK_F(list.empty(), "Expected empty list, but list has %lu elements in it", list.size()); + CHECK_NOTNULL_F(some_pointer); + CHECK_GT_F(number, 0, "Expected a positive integer"); +``` + +### Variants +``` C++ + CHECK_F(test, ...) + CHECK_NOTNULL_F(x, ...) + CHECK_EQ_F(a, b, ...) + CHECK_NE_F(a, b, ...) + CHECK_LT_F(a, b, ...) + CHECK_LE_F(a, b, ...) + CHECK_GT_F(a, b, ...) + CHECK_GE_F(a, b, ...) +``` + +You also have debug-versions of these: +``` C++ + DCHECK_F(test, ...) + DCHECK_NOTNULL_F(x, ...) + DCHECK_EQ_F(a, b, ...) + DCHECK_NE_F(a, b, ...) + DCHECK_LT_F(a, b, ...) + DCHECK_LE_F(a, b, ...) + DCHECK_GT_F(a, b, ...) + DCHECK_GE_F(a, b, ...) +``` + +These can be used to run a check ONLY in debug build (or when `LOGURU_DEBUG_CHECKS` is defined). + +### Format string +The format string to CHECK:s are optional. All these work: + +``` C++ + CHECK_F(exists(filename)); + CHECK_F(exists(filename), "File does not exist"); + CHECK_F(exists(filename), "File does not exist: '%s'", filename); +``` + +Arguments to CHECK:s are only evaluated once. + +## `ABORT_F` +You can also call `ABORT_F` to abort your program with a message written to the log: `ABORT_F("Something went wrong wile processing '%s'", filename);` + +## Signals +By calling `loguru::init` Loguru will also catch signals such as segmentation errors and divisions by zero. Here is the full list of signals caught by Loguru: + +* `SIGABRT` (can be turned off with LOGURU_CATCH_SIGABRT=0) +* `SIGBUS` +* `SIGFPE` +* `SIGILL` +* `SIGINT` +* `SIGSEGV` +* `SIGTERM` + +## Error context +A stack trace gives you the names of the function at the point of a crash. With `ERROR_CONTEXT`, you can also get the values of select local variables. `ERROR_CONTEXT` is in effect a logging that only occurs if there is a crash. + +Usage: + +``` C++ +void process_customers(const std::string& filename) +{ + ERROR_CONTEXT("Processing file", filename.c_str()); + for (size_t i = 0; i < num_customers; ++i) { + ERROR_CONTEXT("Customer index", i); + if (i == 42) { crashy_code(); } + } +} +``` + +The context extends to the containing scope of the `ERROR_CONTEXT` macro. + +Example output (in case of crash): + +``` + ------------------------------------------------ + [ErrorContext] main.cpp:416 Processing file: "customers.json" + [ErrorContext] main.cpp:417 Customer index: 42 + ------------------------------------------------ +``` + +Error contexts are printed automatically on crashes. Note that values captured by `ERROR_CONTEXT` are **only printed on a crash**. They do not litter the log file otherwise. They also have an almost negligible performance hit (about 12 nanoseconds per `ERROR_CONTEXT` on my MacBook Pro, compared to about 4-7 milliseconds a line in the logfile). + +`ERROR_CONTEXT` works with built-in types (`float`, `int`, `char` etc) as well as `const char*`. You can also add support for your own types by overloading `loguru::ec_to_text` (see [`loguru.hpp`](https://github.com/emilk/loguru/blob/master/loguru.hpp) for details). + +The `ERROR_CONTEXT` feature of Loguru is actually orthogonal to the logging. If you want to, you can use Loguru just for its `ERROR_CONTEXT` (and use some other library for logging). You can print the error context stack at any time like this: + +``` + auto text = loguru::get_error_context(); + printf("%s", text.c_str()); + some_stream << text.c_str(); // Or like this +``` + + +# Functions +## `void init(int& argc, char* argv[], const Options& options = {})` + +Should be called from the main thread. +You don't *need* to call this, but if you do you get: + * Signal handlers installed + * Program arguments logged + * Working dir logged + * Optional `-v` verbosity flag parsed + * Main thread name set to "main thread" + * Explanation of the preamble (date, threanmae etc) logged + +`loguru::init()` will look for arguments meant for loguru and remove them. +Loguru currently only looks for the `-v` argument: +``` + -v n Set loguru::g_stderr_verbosity level. Examples: + -v 3 Show verbosity level 3 and lower. + -v 0 Only show INFO, WARNING, ERROR, FATAL (default). + -v INFO Only show INFO, WARNING, ERROR, FATAL (default). + -v WARNING Only show WARNING, ERROR, FATAL. + -v ERROR Only show ERROR, FATAL. + -v FATAL Only show FATAL. + -v OFF Turn off logging to stderr. +``` + +Tip: You can set `g_stderr_verbosity` before calling `loguru::init`. +That way you can set the default but have the user override it with the `-v` flag. +Note that `-v` does not affect file logging (see `loguru::add_file`). + +You can you something other than the `-v` flag by setting the `verbosity_flag` option. + +``` C++ +// Runtime options passed to loguru::init +struct Options +{ + // This allows you to use something else instead of "-v" via verbosity_flag. + // Set to nullptr to if you don't want Loguru to parse verbosity from the args.' + const char* verbosity_flag = "-v"; + + // loguru::init will set the name of the calling thread to this. + // If you don't want Loguru to set the name of the main thread, + // set this to nullptr. + // NOTE: on SOME platforms loguru::init will only overwrite the thread name + // if a thread name has not already been set. + // To always set a thread name, use loguru::set_thread_name instead. + const char+ main_thread_name = "main thread"; + + // Make Loguru try to do unsafe but useful things, + // like printing a stack trace, when catching signals. + // This may lead to bad things like deadlocks in certain situations. + bool unsafe_signal_handler = true; +}; +``` + +## `void shutdown()` +Will call `loguru::remove_all_callbacks()`, thus stopping all logging except to `stderr`. + +You generally don't need to call this. + +## `bool add_file(const char* path, FileMode mode, Verbosity verbosity)` + +Will log to a file at the given path. Any logging message with a verbosity lower or equal to the given verbosity will be included. The function will create all directories in 'path' if needed (like `mkdir -p`). + +If the path starts with a `~`, it will be replaced with your home path. +To stop the file logging, just call `loguru::remove_callback(path)` with the same path. + +Examples: + +``` C++ + // Put every log message in "everything.log": + loguru::add_file("everything.log", loguru::Append, loguru::Verbosity_MAX); + + // Only log INFO, WARNING, ERROR and FATAL to "latest_readable.log": + loguru::add_file("latest_readable.log", loguru::Truncate, loguru::Verbosity_INFO); + + char log_path[PATH_MAX]; + loguru::suggest_log_path("~/loguru/", log_path, sizeof(log_path)); + loguru::add_file(log_path, loguru::FileMode::Truncate, loguru::Verbosity_MAX); + +``` + +## `void suggest_log_path(const char* prefix, char* buff, unsigned buff_size)` +Given a prefix of e.g. `"~/loguru/"` this might return: + + `"/home/your_username/loguru/app_name/20151017_161503.123.log"` + +where "app_name" is a sanitized version of `argv[0]`. + +## `void set_thread_name(const char* name)` +Thread names can be set for the benefit of readable logs. +If you do not set the thread name, a hex id will be shown instead. +These thread names may or may not be the same as the system thread names, +depending on the system. +Try to limit the thread name to 15 characters or less. +`loguru::init` will set the name of the calling thread to `"main thread"`. + +## `Text stacktrace(int skip = 1)` +Generates a readable stacktrace as a string. 'skip' specifies how many stack frames to skip. For instance, the default skip means: don't include the function loguru::stacktrace in the stack trace. + +`Text` here is just a simple wrapper type. You can print its content with `.c_str()` just like you would with an `std::string`. + +## `Text errno_as_text();` +A thread-safe version `strerror`. + + +# Callbacks +## Logging callbacks +Say you want to send your log messages over a network, or print them to the screen in your game. What you want then is a callback from Loguru each time a logging function is called. This is what `loguru::add_callback` is for. Here is an example how to do this: + +``` C++ + struct MyNetworkLogger{...}; + + // Note: this function should be thread safe, + // as logging can be done from any thread at any time. + void log_to_network(void* user_data, const loguru::Message& message) + { + MyNetworkLogger* logger = reinterpret_cast(user_data); + logger->log("%s%s", message.prefix, message.message); + } + + int main(int argc, char* argv[]) { + MyNetworkLogger network_logger{...}; + loguru::add_callback("network_logger", + log_to_network, &network_logger, loguru::Verbosity_INFO); + loguru::init(argc, argv); + ... +} +``` + +Here's the relevant excerpt from `Loguru.hpp`: +``` C++ + struct Message + { + // You would generally print a Message by just concating the buffers without spacing. + // Optionally, ignore preamble and indentation. + Verbosity verbosity; // Already part of preamble + const char* filename; // Already part of preamble + unsigned line; // Already part of preamble + const char* preamble; // Date, time, uptime, thread, file:line, verbosity. + const char* indentation; // Just a bunch of spacing. + const char* prefix; // Assertion failure info goes here (or ""). + const char* message; // User message goes here. + }; + + // May not throw! + typedef void (*log_handler_t)(void* user_data, const Message& message); + typedef void (*close_handler_t)(void* user_data); + typedef void (*flush_handler_t)(void* user_data); + + /* Will be called on each log messages with a verbosity less or equal to the given one. + Useful for displaying messages on-screen in a game, for example. + The given on_close is also expected to flush (if desired). + */ + void add_callback( + const char* id, + log_handler_t callback, + void* user_data, + Verbosity verbosity, + close_handler_t on_close = nullptr, + flush_handler_t on_flush = nullptr); + + // Returns true iff the callback was found (and removed). + bool remove_callback(const char* id); +``` + +## Fatal handler +You can install a callback to be called when your program is about to crash (a CHECK failed, a signal was caught, or somebody called `ABORT_F`). + +Example: + +``` C+++ + // Throw exceptions instead of aborting: + loguru::set_fatal_handler([](const loguru::Message& message){ + throw std::runtime_error(std::string(message.prefix) + message.message); + }); +``` + + +# Options +## Run-time option: +There are some options you can set via global variables in the `loguru::` namespace: + +``` C++ + // Only write warnings, errors and crashes to stderr: + loguru::g_stderr_verbosity = loguru::Verbosity_WARNING; + + // Turn off writing err/warn in red: + loguru::g_colorlogtostderr = false; +``` + +Generally you would do the above once before calling `loguru::init`. + + +### `loguru::g_stderr_verbosity` +Everything with a verbosity equal or greater than g_stderr_verbosity will be +written to stderr. You can set this in code or via the -v argument. +Set to loguru::Verbosity_OFF to write nothing to stderr. +Default is 0, i.e. only log ERROR, WARNING and INFO are written to stderr. + +### `loguru::g_flush_interval_ms`: +If set to zero Loguru will flush on every line (unbuffered mode). +Else Loguru will flush outputs every `g_flush_interval_ms` milliseconds (buffered mode). The default is `g_flush_interval_ms=0`, i.e. unbuffered mode. + +### List +Here is the full list: + +``` C++ + Verbosity g_stderr_verbosity = 0; // 0 (INFO) by default. + bool g_colorlogtostderr = true; // If you don't want color in your terminal. + unsigned g_flush_interval_ms = 0; // Unbuffered (0) by default. + bool g_preamble = true; // Prefix each log line with date, time etc? + + // Turn off individual parts of the preamble + bool g_preamble_date = true; // The date field + bool g_preamble_time = true; // The time of the current day + bool g_preamble_uptime = true; // The time since init call + bool g_preamble_thread = true; // The logging thread + bool g_preamble_file = true; // The file from which the log originates from + bool g_preamble_verbose = true; // The verbosity field + bool g_preamble_pipe = true; // The pipe symbol right before the message +``` + + +## Compile-time options +Loguru let's you tweak many aspects of how it works via macros that you can set either manually with `#define LOGURU_FOO 1` or with a compilation flag as `-DLOGURU_FOO=1`. + +Here follows a list of flags and their default values: + +### `LOGURU_EXPORT` +Define to your project's export declaration if needed for use in a shared library. + +### `LOGURU_DEBUG_LOGGING` (defaults to the opposite of `NDEBUG`): +Enables debug versions of logging statements (`DLOG_F` etc). + +### `LOGURU_DEBUG_CHECKS` (defaults to the opposite of `NDEBUG`): +Enables debug versions of checks (`DCHECK_F` etc). + +### `LOGURU_SCOPE_TEXT_SIZE = 196` +Maximum length of text that can be printed by a `LOG_SCOPE`. This should be long enough to get most things, but short enough not to clutter the stack. + +### `LOGURU_CATCH_SIGABRT = 1` +Should Loguru catch SIGABRT to print stack trace etc? + +### `LOGURU_REDEFINE_ASSERT = 0` +Redefine "assert" to call Loguru version (!NDEBUG only). + +### `LOGURU_WITH_STREAMS = 0` +Add support for _S versions for all LOG and CHECK functions: +``` C++ + LOG_S(INFO) << "My vec3: " << x.cross(y); + CHECK_EQ_S(a, b) << "I expected a and b to be the same!"; +``` +This is off by default to keep down compilation times. + +### `LOGURU_REPLACE_GLOG = 0` +Make Loguru mimic GLOG as close as possible, including #defining `LOG`, `CHECK`, `VLOG_IS_ON` etc. Great if you plan to migrate from GLOG to Loguru and don't want to add _S suffixes to all your logging functions (see `LOGURU_WITH_STREAMS`). `LOGURU_REPLACE_GLOG` implies `LOGURU_WITH_STREAMS`. + +### `LOGURU_USE_FMTLIB = 0` +Use fmtlib formatting. See https://github.com/fmtlib/fmt +This will make `loguru.hpp` depend on `<fmt/format.h>` +You will need to link against `fmtlib` or use the `FMT_HEADER_ONLY` preprocessor definition. +Feature by kolis (https://github.com/emilk/loguru/pull/22) + +### `LOGURU_WITH_FILEABS = 0` +When `LOGURU_WITH_FILEABS` is turned on, a check of file change will be performed on every call to file_log. +If the file is moved, or inode changes, file is reopened using the same FileMode as is done by add_file. +Such a scheme is useful if you have a daemon program that moves the log file every 24 hours and expects new file to be created. +Feature by scinart (https://github.com/emilk/loguru/pull/23). + +### `LOGURU_STACKTRACES` (default 1 on supported platforms) +Print stack traces on abort. + +### `LOGURU_RTTI` +Set to 0 if your platform does not support runtime type information (-fno-rtti). + +### Flags for controlling output formats: +#### `LOGURU_FILENAME_WIDTH = 23` +Width of the column containing the file name + +#### `LOGURU_THREADNAME_WIDTH = 16` +Width of the column containing the thread name. + +#### `LOGURU_VERBOSE_SCOPE_ENDINGS = 1` +Show milliseconds and scope name at end of scope. + +#### `LOGURU_SCOPE_TIME_PRECISION = 3` +Resolution of scope timers. 3=ms, 6=us, 9=ns + + + diff --git a/docs/terminal_colors.png b/docs/terminal_colors.png new file mode 100644 index 0000000..fc91ebb Binary files /dev/null and b/docs/terminal_colors.png differ diff --git a/glog_bench/CMakeLists.txt b/glog_bench/CMakeLists.txt new file mode 100644 index 0000000..6512d3f --- /dev/null +++ b/glog_bench/CMakeLists.txt @@ -0,0 +1,71 @@ +cmake_minimum_required(VERSION 2.8) + +project(glog_bench) + +if(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE "Release" CACHE STRING + "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE) +endif(NOT CMAKE_BUILD_TYPE) + +MESSAGE(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}") + +add_compile_options(-std=c++11 -Werror -Wall -Wextra) + +file(GLOB source + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +# ------------------------------------------------------ +# GFLAGS +find_library(GFLAGS_LIB NAMES "gflags" PATHS + ${GFLAGS_ROOT}/lib + ${GFLAGS_ROOT}/Lib) + +if (MSVC) + find_path(GFLAGS_INCLUDE_DIR gflags/gflags.h PATHS ${GFLAGS_ROOT}/Include) + set(GFLAGS_LIB_DIR ${GFLAGS_ROOT}/Lib) +else() + find_path(GFLAGS_INCLUDE_DIR gflags/gflags.h PATHS + ${GFLAGS_ROOT}/include) + set(GFLAGS_LIB_DIR ${GFLAGS_ROOT}/lib) +endif() +mark_as_advanced( + GFLAGS_INCLUDE_DIR + GFLAGS_LIB +) + +# ------------------------------------------------------ +# GLOG + +find_library(GLOG_LIB NAMES "glog" libglog PATHS + ${GLOG_ROOT}) + +if (MSVC) + find_path(GLOG_INCLUDE_DIR glog/logging.h PATHS ${GLOG_ROOT}) + set(GLOG_LIB_DIR ${GLOG_ROOT}) + add_definitions(-DUSE_OWN_CHECK) +else() + find_path(GLOG_INCLUDE_DIR glog/logging.h PATHS + ${GLOG_ROOT}/include) + set(GLOG_LIB_DIR ${GLOG_ROOT}/lib) +endif() +add_definitions(-DGLOG_NO_ABBREVIATED_SEVERITIES=1) + +mark_as_advanced( + GLOG_INCLUDE_DIR + GLOG_LIB +) + +# ------------------------------------------------------ + +add_executable(glog_bench ${source}) + +include_directories( + ${GFLAGS_INCLUDE_DIR} + ${GLOG_INCLUDE_DIR} +) + +target_link_libraries(glog_bench + ${GFLAGS_LIB} + ${GLOG_LIB} +) diff --git a/glog_bench/build_and_run.sh b/glog_bench/build_and_run.sh new file mode 100755 index 0000000..d1600b6 --- /dev/null +++ b/glog_bench/build_and_run.sh @@ -0,0 +1,12 @@ +#!/bin/bash +set -e # Fail on error + +ROOT_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd) + +cd "$ROOT_DIR" +mkdir -p build +cd build +cmake .. +make + +./glog_bench $@ 2>/dev/null diff --git a/glog_bench/glog_bench.cpp b/glog_bench/glog_bench.cpp new file mode 100644 index 0000000..f5564ae --- /dev/null +++ b/glog_bench/glog_bench.cpp @@ -0,0 +1,93 @@ +#include +#include +#include +#include + +#include +#include + +const size_t kNumIterations = 50 * 1000; +const size_t kNumRuns = 10; +const double kPi = 3.1415926535897932384626433; + +static long long now_ns() +{ + using namespace std::chrono; + return duration_cast(high_resolution_clock::now().time_since_epoch()).count(); +} + +template +double time_sec(const Function& function) +{ + auto start_ns = now_ns(); + function(); + return (now_ns() - start_ns) * 1e-9; +} + +template +void bench(const std::string& name, const Function& function) +{ + function(); // Warm-up + + printf("%-30s ", name.c_str()); + fflush(stdout); + std::vector times; + double sum = 0; + for (size_t i = 0; i < kNumRuns; ++i) + { + times.push_back(time_sec(function) / kNumIterations); + sum += times.back(); + } + + double mean = sum / kNumRuns; + double std_dev_sum = 0; + + for (double time : times) { + std_dev_sum += (time - mean) * (time - mean); + } + + double variance = std::sqrt(std_dev_sum / kNumRuns); + + printf("%6.3f +- %.3f us per call\n", mean * 1e6, variance * 1e6); + fflush(stdout); +} + +// ---------------------------------------------------------------------------- + +void stream_strings() +{ + for (size_t i = 0; i < kNumIterations; ++i) { + LOG(WARNING) << "Some long, complex message."; + } + google::FlushLogFiles(google::GLOG_INFO); +} + +void stream_float() +{ + for (size_t i = 0; i < kNumIterations; ++i) { + LOG(WARNING) << std::setfill('0') << std::setw(6) << std::setprecision(3) << kPi; + } + google::FlushLogFiles(google::GLOG_INFO); +} + +void raw_string_float() +{ + for (size_t i = 0; i < kNumIterations; ++i) { + RAW_LOG(WARNING, "Some long, complex message."); + } + google::FlushLogFiles(google::GLOG_INFO); +} + +int main(int argc, char* argv[]) +{ + FLAGS_alsologtostderr = true; + google::ParseCommandLineFlags(&argc, &argv, true); + google::InitGoogleLogging(argv[0]); + + bench("LOG(WARNING) << string (buffered):", stream_strings); + bench("LOG(WARNING) << float (buffered):", stream_float); + + FLAGS_logbufsecs = 0; // Flush all output in realtime + bench("LOG(WARNING) << string (unbuffered):", stream_strings); + bench("LOG(WARNING) << float (unbuffered):", stream_float); +} diff --git a/glog_example/CMakeLists.txt b/glog_example/CMakeLists.txt new file mode 100644 index 0000000..efe3fa2 --- /dev/null +++ b/glog_example/CMakeLists.txt @@ -0,0 +1,71 @@ +cmake_minimum_required(VERSION 2.8) + +project(glog_example) + +if(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE "Release" CACHE STRING + "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE) +endif(NOT CMAKE_BUILD_TYPE) + +MESSAGE(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}") + +add_compile_options(-std=c++11 -Werror -Wall -Wextra) + +file(GLOB source + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +# ------------------------------------------------------ +# GFLAGS +find_library(GFLAGS_LIB NAMES "gflags" PATHS + ${GFLAGS_ROOT}/lib + ${GFLAGS_ROOT}/Lib) + +if (MSVC) + find_path(GFLAGS_INCLUDE_DIR gflags/gflags.h PATHS ${GFLAGS_ROOT}/Include) + set(GFLAGS_LIB_DIR ${GFLAGS_ROOT}/Lib) +else() + find_path(GFLAGS_INCLUDE_DIR gflags/gflags.h PATHS + ${GFLAGS_ROOT}/include) + set(GFLAGS_LIB_DIR ${GFLAGS_ROOT}/lib) +endif() +mark_as_advanced( + GFLAGS_INCLUDE_DIR + GFLAGS_LIB +) + +# ------------------------------------------------------ +# GLOG + +find_library(GLOG_LIB NAMES "glog" libglog PATHS + ${GLOG_ROOT}) + +if (MSVC) + find_path(GLOG_INCLUDE_DIR glog/logging.h PATHS ${GLOG_ROOT}) + set(GLOG_LIB_DIR ${GLOG_ROOT}) + add_definitions(-DUSE_OWN_CHECK) +else() + find_path(GLOG_INCLUDE_DIR glog/logging.h PATHS + ${GLOG_ROOT}/include) + set(GLOG_LIB_DIR ${GLOG_ROOT}/lib) +endif() +add_definitions(-DGLOG_NO_ABBREVIATED_SEVERITIES=1) + +mark_as_advanced( + GLOG_INCLUDE_DIR + GLOG_LIB +) + +# ------------------------------------------------------ + +add_executable(glog_example ${source}) + +include_directories( + ${GFLAGS_INCLUDE_DIR} + ${GLOG_INCLUDE_DIR} +) + +target_link_libraries(glog_example + ${GFLAGS_LIB} + ${GLOG_LIB} +) diff --git a/glog_example/build_and_run.sh b/glog_example/build_and_run.sh new file mode 100755 index 0000000..0b1e18e --- /dev/null +++ b/glog_example/build_and_run.sh @@ -0,0 +1,12 @@ +#!/bin/bash +set -e # Fail on error + +ROOT_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd) + +cd "$ROOT_DIR" +mkdir -p build +cd build +cmake .. +make + +./glog_example $@ diff --git a/glog_example/glog_example.hpp b/glog_example/glog_example.hpp new file mode 100644 index 0000000..434468b --- /dev/null +++ b/glog_example/glog_example.hpp @@ -0,0 +1,26 @@ +#include +#include + +#include + +inline void sleep_ms(int ms) +{ + VLOG(2) << "Sleeping for " << ms << " ms"; + std::this_thread::sleep_for(std::chrono::milliseconds(ms)); +} + +inline void complex_calculation() +{ + LOG(INFO) << "complex_calculation started"; + LOG(INFO) << "Starting time machine..."; + sleep_ms(200); + LOG(WARNING) << "The flux capacitor is not getting enough power!"; + sleep_ms(400); + LOG(INFO) << "Lighting strike!"; + VLOG(1) << "Found 1.21 gigawatts..."; + sleep_ms(400); + std::thread([](){ + LOG(ERROR) << "We ended up in 1985!"; + }).join(); + LOG(INFO) << "complex_calculation stopped"; +} diff --git a/glog_example/main.cpp b/glog_example/main.cpp new file mode 100644 index 0000000..17fa819 --- /dev/null +++ b/glog_example/main.cpp @@ -0,0 +1,13 @@ +#include +#include "glog_example.hpp" + +int main(int argc, char* argv[]) +{ + FLAGS_alsologtostderr = true; + FLAGS_colorlogtostderr = true; + google::ParseCommandLineFlags(&argc, &argv, true); + google::InitGoogleLogging(argv[0]); + LOG(INFO) << "Hello from main.cpp!"; + complex_calculation(); + LOG(INFO) << "main function about to end!"; +} diff --git a/loguru.cpp b/loguru.cpp new file mode 100644 index 0000000..468675d --- /dev/null +++ b/loguru.cpp @@ -0,0 +1,1849 @@ +#ifndef _WIN32 +// Disable all warnings from gcc/clang: +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wpragmas" + +#pragma GCC diagnostic ignored "-Wc++98-compat" +#pragma GCC diagnostic ignored "-Wc++98-compat-pedantic" +#pragma GCC diagnostic ignored "-Wexit-time-destructors" +#pragma GCC diagnostic ignored "-Wformat-nonliteral" +#pragma GCC diagnostic ignored "-Wglobal-constructors" +#pragma GCC diagnostic ignored "-Wgnu-zero-variadic-macro-arguments" +#pragma GCC diagnostic ignored "-Wmissing-prototypes" +#pragma GCC diagnostic ignored "-Wpadded" +#pragma GCC diagnostic ignored "-Wsign-compare" +#pragma GCC diagnostic ignored "-Wsign-conversion" +#pragma GCC diagnostic ignored "-Wunknown-pragmas" +#pragma GCC diagnostic ignored "-Wunused-macros" +#pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant" +#else +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable:4018) +#endif // _MSC_VER +#endif + +#include "loguru.hpp" + +#ifndef LOGURU_HAS_BEEN_IMPLEMENTED +#define LOGURU_HAS_BEEN_IMPLEMENTED + +#define LOGURU_PREAMBLE_WIDTH (53 + LOGURU_THREADNAME_WIDTH + LOGURU_FILENAME_WIDTH) + +#undef min +#undef max + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef _WIN32 + #include + + #define localtime_r(a, b) localtime_s(b, a) // No localtime_r with MSVC, but arguments are swapped for localtime_s +#else + #include + #include // mkdir + #include // STDERR_FILENO +#endif + +#ifdef __linux__ + #include // PATH_MAX +#elif !defined(_WIN32) + #include // PATH_MAX +#endif + +#ifndef PATH_MAX + #define PATH_MAX 1024 +#endif + +#ifdef __APPLE__ + #include "TargetConditionals.h" +#endif + +// TODO: use defined(_POSIX_VERSION) for some of these things? + +#if defined(_WIN32) || defined(__CYGWIN__) + #define LOGURU_PTHREADS 0 + #define LOGURU_WINTHREADS 1 + #ifndef LOGURU_STACKTRACES + #define LOGURU_STACKTRACES 0 + #endif +#elif defined(__rtems__) || defined(__ANDROID__) + #define LOGURU_PTHREADS 1 + #define LOGURU_WINTHREADS 0 + #ifndef LOGURU_STACKTRACES + #define LOGURU_STACKTRACES 0 + #endif +#else + #define LOGURU_PTHREADS 1 + #define LOGURU_WINTHREADS 0 + #ifndef LOGURU_STACKTRACES + #define LOGURU_STACKTRACES 1 + #endif +#endif + +#if LOGURU_STACKTRACES + #include // for __cxa_demangle + #include // for dladdr + #include // for backtrace +#endif // LOGURU_STACKTRACES + +#if LOGURU_PTHREADS + #include + #if defined(__FreeBSD__) + #include + #include + #elif defined(__OpenBSD__) + #include + #endif + + #ifdef __linux__ + /* On Linux, the default thread name is the same as the name of the binary. + Additionally, all new threads inherit the name of the thread it got forked from. + For this reason, Loguru use the pthread Thread Local Storage + for storing thread names on Linux. */ + #define LOGURU_PTLS_NAMES 1 + #endif +#endif + +#if LOGURU_WINTHREADS + #ifndef _WIN32_WINNT + #define _WIN32_WINNT 0x0502 + #endif + #define WIN32_LEAN_AND_MEAN + #define NOMINMAX + #include +#endif + +#ifndef LOGURU_PTLS_NAMES + #define LOGURU_PTLS_NAMES 0 +#endif + + +namespace loguru +{ + using namespace std::chrono; + +#if LOGURU_WITH_FILEABS + struct FileAbs + { + char path[PATH_MAX]; + char mode_str[4]; + Verbosity verbosity; + struct stat st; + FILE* fp; + bool is_reopening = false; // to prevent recursive call in file_reopen. + decltype(steady_clock::now()) last_check_time = steady_clock::now(); + }; +#else + typedef FILE* FileAbs; +#endif + + struct Callback + { + std::string id; + log_handler_t callback; + void* user_data; + Verbosity verbosity; // Does not change! + close_handler_t close; + flush_handler_t flush; + unsigned indentation; + }; + + using CallbackVec = std::vector; + + using StringPair = std::pair; + using StringPairList = std::vector; + + const auto s_start_time = steady_clock::now(); + + Verbosity g_stderr_verbosity = Verbosity_0; + bool g_colorlogtostderr = true; + unsigned g_flush_interval_ms = 0; + bool g_preamble = true; + + Verbosity g_internal_verbosity = Verbosity_0; + + // Preamble details + bool g_preamble_date = true; + bool g_preamble_time = true; + bool g_preamble_uptime = true; + bool g_preamble_thread = true; + bool g_preamble_file = true; + bool g_preamble_verbose = true; + bool g_preamble_pipe = true; + + static std::recursive_mutex s_mutex; + static Verbosity s_max_out_verbosity = Verbosity_OFF; + static std::string s_argv0_filename; + static std::string s_arguments; + static char s_current_dir[PATH_MAX]; + static CallbackVec s_callbacks; + static fatal_handler_t s_fatal_handler = nullptr; + static verbosity_to_name_t s_verbosity_to_name_callback = nullptr; + static name_to_verbosity_t s_name_to_verbosity_callback = nullptr; + static StringPairList s_user_stack_cleanups; + static bool s_strip_file_path = true; + static std::atomic s_stderr_indentation { 0 }; + + // For periodic flushing: + static std::thread* s_flush_thread = nullptr; + static bool s_needs_flushing = false; + + static const bool s_terminal_has_color = [](){ + #ifdef _WIN32 + #ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING + #define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004 + #endif + + HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); + if (hOut != INVALID_HANDLE_VALUE) { + DWORD dwMode = 0; + GetConsoleMode(hOut, &dwMode); + dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING; + return SetConsoleMode(hOut, dwMode) != 0; + } + return false; + #else + if (const char* term = getenv("TERM")) { + return 0 == strcmp(term, "cygwin") + || 0 == strcmp(term, "linux") + || 0 == strcmp(term, "rxvt-unicode-256color") + || 0 == strcmp(term, "screen") + || 0 == strcmp(term, "screen-256color") + || 0 == strcmp(term, "screen.xterm-256color") + || 0 == strcmp(term, "tmux-256color") + || 0 == strcmp(term, "xterm") + || 0 == strcmp(term, "xterm-256color") + || 0 == strcmp(term, "xterm-termite") + || 0 == strcmp(term, "xterm-color"); + } else { + return false; + } + #endif + }(); + + static void print_preamble_header(char* out_buff, size_t out_buff_size); + + #if LOGURU_PTLS_NAMES + static pthread_once_t s_pthread_key_once = PTHREAD_ONCE_INIT; + static pthread_key_t s_pthread_key_name; + + void make_pthread_key_name() + { + (void)pthread_key_create(&s_pthread_key_name, free); + } + #endif + + // ------------------------------------------------------------------------------ + // Colors + + bool terminal_has_color() { return s_terminal_has_color; } + + // Colors + +#ifdef _WIN32 +#define VTSEQ(ID) ("\x1b[1;" #ID "m") +#else +#define VTSEQ(ID) ("\x1b[" #ID "m") +#endif + + const char* terminal_black() { return s_terminal_has_color ? VTSEQ(30) : ""; } + const char* terminal_red() { return s_terminal_has_color ? VTSEQ(31) : ""; } + const char* terminal_green() { return s_terminal_has_color ? VTSEQ(32) : ""; } + const char* terminal_yellow() { return s_terminal_has_color ? VTSEQ(33) : ""; } + const char* terminal_blue() { return s_terminal_has_color ? VTSEQ(34) : ""; } + const char* terminal_purple() { return s_terminal_has_color ? VTSEQ(35) : ""; } + const char* terminal_cyan() { return s_terminal_has_color ? VTSEQ(36) : ""; } + const char* terminal_light_gray() { return s_terminal_has_color ? VTSEQ(37) : ""; } + const char* terminal_white() { return s_terminal_has_color ? VTSEQ(37) : ""; } + const char* terminal_light_red() { return s_terminal_has_color ? VTSEQ(91) : ""; } + const char* terminal_dim() { return s_terminal_has_color ? VTSEQ(2) : ""; } + + // Formating + const char* terminal_bold() { return s_terminal_has_color ? VTSEQ(1) : ""; } + const char* terminal_underline() { return s_terminal_has_color ? VTSEQ(4) : ""; } + + // You should end each line with this! + const char* terminal_reset() { return s_terminal_has_color ? VTSEQ(0) : ""; } + + // ------------------------------------------------------------------------------ +#if LOGURU_WITH_FILEABS + void file_reopen(void* user_data); + inline FILE* to_file(void* user_data) { return reinterpret_cast(user_data)->fp; } +#else + inline FILE* to_file(void* user_data) { return reinterpret_cast(user_data); } +#endif + + void file_log(void* user_data, const Message& message) + { +#if LOGURU_WITH_FILEABS + FileAbs* file_abs = reinterpret_cast(user_data); + if (file_abs->is_reopening) { + return; + } + // It is better checking file change every minute/hour/day, + // instead of doing this every time we log. + // Here check_interval is set to zero to enable checking every time; + const auto check_interval = seconds(0); + if (duration_cast(steady_clock::now() - file_abs->last_check_time) > check_interval) { + file_abs->last_check_time = steady_clock::now(); + file_reopen(user_data); + } + FILE* file = to_file(user_data); + if (!file) { + return; + } +#else + FILE* file = to_file(user_data); +#endif + fprintf(file, "%s%s%s%s\n", + message.preamble, message.indentation, message.prefix, message.message); + if (g_flush_interval_ms == 0) { + fflush(file); + } + } + + void file_close(void* user_data) + { + FILE* file = to_file(user_data); + if (file) { + fclose(file); + } +#if LOGURU_WITH_FILEABS + delete reinterpret_cast(user_data); +#endif + } + + void file_flush(void* user_data) + { + FILE* file = to_file(user_data); + fflush(file); + } + +#if LOGURU_WITH_FILEABS + void file_reopen(void* user_data) + { + FileAbs * file_abs = reinterpret_cast(user_data); + struct stat st; + int ret; + if (!file_abs->fp || (ret = stat(file_abs->path, &st)) == -1 || (st.st_ino != file_abs->st.st_ino)) { + file_abs->is_reopening = true; + if (file_abs->fp) { + fclose(file_abs->fp); + } + if (!file_abs->fp) { + VLOG_F(g_internal_verbosity, "Reopening file '" LOGURU_FMT(s) "' due to previous error", file_abs->path); + } + else if (ret < 0) { + const auto why = errno_as_text(); + VLOG_F(g_internal_verbosity, "Reopening file '" LOGURU_FMT(s) "' due to '" LOGURU_FMT(s) "'", file_abs->path, why.c_str()); + } else { + VLOG_F(g_internal_verbosity, "Reopening file '" LOGURU_FMT(s) "' due to file changed", file_abs->path); + } + // try reopen current file. + if (!create_directories(file_abs->path)) { + LOG_F(ERROR, "Failed to create directories to '" LOGURU_FMT(s) "'", file_abs->path); + } + file_abs->fp = fopen(file_abs->path, file_abs->mode_str); + if (!file_abs->fp) { + LOG_F(ERROR, "Failed to open '" LOGURU_FMT(s) "'", file_abs->path); + } else { + stat(file_abs->path, &file_abs->st); + } + file_abs->is_reopening = false; + } + } +#endif + // ------------------------------------------------------------------------------ + + // Helpers: + + Text::~Text() { free(_str); } + +#if LOGURU_USE_FMTLIB + Text vtextprintf(const char* format, fmt::format_args args) + { + return Text(STRDUP(fmt::vformat(format, args).c_str())); + } +#else + LOGURU_PRINTF_LIKE(1, 0) + static Text vtextprintf(const char* format, va_list vlist) + { +#ifdef _WIN32 + int bytes_needed = _vscprintf(format, vlist); + CHECK_F(bytes_needed >= 0, "Bad string format: '%s'", format); + char* buff = (char*)malloc(bytes_needed+1); + vsnprintf(buff, bytes_needed+1, format, vlist); + return Text(buff); +#else + char* buff = nullptr; + int result = vasprintf(&buff, format, vlist); + CHECK_F(result >= 0, "Bad string format: '" LOGURU_FMT(s) "'", format); + return Text(buff); +#endif + } + + Text textprintf(const char* format, ...) + { + va_list vlist; + va_start(vlist, format); + auto result = vtextprintf(format, vlist); + va_end(vlist); + return result; + } +#endif + + // Overloaded for variadic template matching. + Text textprintf() + { + return Text(static_cast(calloc(1, 1))); + } + + static const char* indentation(unsigned depth) + { + static const char buff[] = + ". . . . . . . . . . " ". . . . . . . . . . " + ". . . . . . . . . . " ". . . . . . . . . . " + ". . . . . . . . . . " ". . . . . . . . . . " + ". . . . . . . . . . " ". . . . . . . . . . " + ". . . . . . . . . . " ". . . . . . . . . . "; + static const size_t INDENTATION_WIDTH = 4; + static const size_t NUM_INDENTATIONS = (sizeof(buff) - 1) / INDENTATION_WIDTH; + depth = std::min(depth, NUM_INDENTATIONS); + return buff + INDENTATION_WIDTH * (NUM_INDENTATIONS - depth); + } + + static void parse_args(int& argc, char* argv[], const char* verbosity_flag) + { + int arg_dest = 1; + int out_argc = argc; + + for (int arg_it = 1; arg_it < argc; ++arg_it) { + auto cmd = argv[arg_it]; + auto arg_len = strlen(verbosity_flag); + if (strncmp(cmd, verbosity_flag, arg_len) == 0 && !std::isalpha(cmd[arg_len], std::locale(""))) { + out_argc -= 1; + auto value_str = cmd + arg_len; + if (value_str[0] == '\0') { + // Value in separate argument + arg_it += 1; + CHECK_LT_F(arg_it, argc, "Missing verbosiy level after " LOGURU_FMT(s) "", verbosity_flag); + value_str = argv[arg_it]; + out_argc -= 1; + } + if (*value_str == '=') { value_str += 1; } + + auto req_verbosity = get_verbosity_from_name(value_str); + if (req_verbosity != Verbosity_INVALID) { + g_stderr_verbosity = req_verbosity; + } else { + char* end = 0; + g_stderr_verbosity = static_cast(strtol(value_str, &end, 10)); + CHECK_F(end && *end == '\0', + "Invalid verbosity. Expected integer, INFO, WARNING, ERROR or OFF, got '" LOGURU_FMT(s) "'", value_str); + } + } else { + argv[arg_dest++] = argv[arg_it]; + } + } + + argc = out_argc; + argv[argc] = nullptr; + } + + static long long now_ns() + { + return duration_cast(high_resolution_clock::now().time_since_epoch()).count(); + } + + // Returns the part of the path after the last / or \ (if any). + const char* filename(const char* path) + { + for (auto ptr = path; *ptr; ++ptr) { + if (*ptr == '/' || *ptr == '\\') { + path = ptr + 1; + } + } + return path; + } + + // ------------------------------------------------------------------------------ + + static void on_atexit() + { + VLOG_F(g_internal_verbosity, "atexit"); + flush(); + } + + static void install_signal_handlers(bool unsafe_signal_handler); + + static void write_hex_digit(std::string& out, unsigned num) + { + DCHECK_LT_F(num, 16u); + if (num < 10u) { out.push_back(char('0' + num)); } + else { out.push_back(char('A' + num - 10)); } + } + + static void write_hex_byte(std::string& out, uint8_t n) + { + write_hex_digit(out, n >> 4u); + write_hex_digit(out, n & 0x0f); + } + + static void escape(std::string& out, const std::string& str) + { + for (char c : str) { + /**/ if (c == '\a') { out += "\\a"; } + else if (c == '\b') { out += "\\b"; } + else if (c == '\f') { out += "\\f"; } + else if (c == '\n') { out += "\\n"; } + else if (c == '\r') { out += "\\r"; } + else if (c == '\t') { out += "\\t"; } + else if (c == '\v') { out += "\\v"; } + else if (c == '\\') { out += "\\\\"; } + else if (c == '\'') { out += "\\\'"; } + else if (c == '\"') { out += "\\\""; } + else if (c == ' ') { out += "\\ "; } + else if (0 <= c && c < 0x20) { // ASCI control character: + // else if (c < 0x20 || c != (c & 127)) { // ASCII control character or UTF-8: + out += "\\x"; + write_hex_byte(out, static_cast(c)); + } else { out += c; } + } + } + + Text errno_as_text() + { + char buff[256]; + #if defined(__GLIBC__) && defined(_GNU_SOURCE) + // GNU Version + return Text(STRDUP(strerror_r(errno, buff, sizeof(buff)))); + #elif defined(__APPLE__) || _POSIX_C_SOURCE >= 200112L + // XSI Version + strerror_r(errno, buff, sizeof(buff)); + return Text(strdup(buff)); + #elif defined(_WIN32) + strerror_s(buff, sizeof(buff), errno); + return Text(STRDUP(buff)); + #else + // Not thread-safe. + return Text(STRDUP(strerror(errno))); + #endif + } + + void init(int& argc, char* argv[], const Options& options) + { + CHECK_GT_F(argc, 0, "Expected proper argc/argv"); + CHECK_EQ_F(argv[argc], nullptr, "Expected proper argc/argv"); + + s_argv0_filename = filename(argv[0]); + + #ifdef _WIN32 + #define getcwd _getcwd + #endif + + if (!getcwd(s_current_dir, sizeof(s_current_dir))) { + const auto error_text = errno_as_text(); + LOG_F(WARNING, "Failed to get current working directory: " LOGURU_FMT(s) "", error_text.c_str()); + } + + s_arguments = ""; + for (int i = 0; i < argc; ++i) { + escape(s_arguments, argv[i]); + if (i + 1 < argc) { + s_arguments += " "; + } + } + + if (options.verbosity_flag) { + parse_args(argc, argv, options.verbosity_flag); + } + + if (const auto main_thread_name = options.main_thread_name) { + #if LOGURU_PTLS_NAMES || LOGURU_WINTHREADS + set_thread_name(main_thread_name); + #elif LOGURU_PTHREADS + char old_thread_name[16] = {0}; + auto this_thread = pthread_self(); + #if defined(__APPLE__) || defined(__linux__) + pthread_getname_np(this_thread, old_thread_name, sizeof(old_thread_name)); + #endif + if (old_thread_name[0] == 0) { + #ifdef __APPLE__ + pthread_setname_np(main_thread_name); + #elif defined(__FreeBSD__) || defined(__OpenBSD__) + pthread_set_name_np(this_thread, main_thread_name); + #elif defined(__linux__) + pthread_setname_np(this_thread, main_thread_name); + #endif + } + #endif // LOGURU_PTHREADS + } + + if (g_stderr_verbosity >= Verbosity_INFO) { + if (g_preamble) { + char preamble_explain[LOGURU_PREAMBLE_WIDTH]; + print_preamble_header(preamble_explain, sizeof(preamble_explain)); + if (g_colorlogtostderr && s_terminal_has_color) { + fprintf(stderr, "%s%s%s\n", terminal_reset(), terminal_dim(), preamble_explain); + } else { + fprintf(stderr, "%s\n", preamble_explain); + } + } + fflush(stderr); + } + VLOG_F(g_internal_verbosity, "arguments: " LOGURU_FMT(s) "", s_arguments.c_str()); + if (strlen(s_current_dir) != 0) + { + VLOG_F(g_internal_verbosity, "Current dir: " LOGURU_FMT(s) "", s_current_dir); + } + VLOG_F(g_internal_verbosity, "stderr verbosity: " LOGURU_FMT(d) "", g_stderr_verbosity); + VLOG_F(g_internal_verbosity, "-----------------------------------"); + + install_signal_handlers(options.unsafe_signal_handler); + + atexit(on_atexit); + } + + void shutdown() + { + VLOG_F(g_internal_verbosity, "loguru::shutdown()"); + remove_all_callbacks(); + set_fatal_handler(nullptr); + set_verbosity_to_name_callback(nullptr); + set_name_to_verbosity_callback(nullptr); + } + + void write_date_time(char* buff, size_t buff_size) + { + auto now = system_clock::now(); + long long ms_since_epoch = duration_cast(now.time_since_epoch()).count(); + time_t sec_since_epoch = time_t(ms_since_epoch / 1000); + tm time_info; + localtime_r(&sec_since_epoch, &time_info); + snprintf(buff, buff_size, "%04d%02d%02d_%02d%02d%02d.%03lld", + 1900 + time_info.tm_year, 1 + time_info.tm_mon, time_info.tm_mday, + time_info.tm_hour, time_info.tm_min, time_info.tm_sec, ms_since_epoch % 1000); + } + + const char* argv0_filename() + { + return s_argv0_filename.c_str(); + } + + const char* arguments() + { + return s_arguments.c_str(); + } + + const char* current_dir() + { + return s_current_dir; + } + + const char* home_dir() + { + #ifdef _WIN32 + auto user_profile = getenv("USERPROFILE"); + CHECK_F(user_profile != nullptr, "Missing USERPROFILE"); + return user_profile; + #else // _WIN32 + auto home = getenv("HOME"); + CHECK_F(home != nullptr, "Missing HOME"); + return home; + #endif // _WIN32 + } + + void suggest_log_path(const char* prefix, char* buff, unsigned buff_size) + { + if (prefix[0] == '~') { + snprintf(buff, buff_size - 1, "%s%s", home_dir(), prefix + 1); + } else { + snprintf(buff, buff_size - 1, "%s", prefix); + } + + // Check for terminating / + size_t n = strlen(buff); + if (n != 0) { + if (buff[n - 1] != '/') { + CHECK_F(n + 2 < buff_size, "Filename buffer too small"); + buff[n] = '/'; + buff[n + 1] = '\0'; + } + } + + strncat(buff, s_argv0_filename.c_str(), buff_size - strlen(buff) - 1); + strncat(buff, "/", buff_size - strlen(buff) - 1); + write_date_time(buff + strlen(buff), buff_size - strlen(buff)); + strncat(buff, ".log", buff_size - strlen(buff) - 1); + } + + bool create_directories(const char* file_path_const) + { + CHECK_F(file_path_const && *file_path_const); + char* file_path = STRDUP(file_path_const); + for (char* p = strchr(file_path + 1, '/'); p; p = strchr(p + 1, '/')) { + *p = '\0'; + + #ifdef _WIN32 + if (_mkdir(file_path) == -1) { + #else + if (mkdir(file_path, 0755) == -1) { + #endif + if (errno != EEXIST) { + LOG_F(ERROR, "Failed to create directory '" LOGURU_FMT(s) "'", file_path); + LOG_IF_F(ERROR, errno == EACCES, "EACCES"); + LOG_IF_F(ERROR, errno == ENAMETOOLONG, "ENAMETOOLONG"); + LOG_IF_F(ERROR, errno == ENOENT, "ENOENT"); + LOG_IF_F(ERROR, errno == ENOTDIR, "ENOTDIR"); + LOG_IF_F(ERROR, errno == ELOOP, "ELOOP"); + + *p = '/'; + free(file_path); + return false; + } + } + *p = '/'; + } + free(file_path); + return true; + } + bool add_file(const char* path_in, FileMode mode, Verbosity verbosity) + { + char path[PATH_MAX]; + if (path_in[0] == '~') { + snprintf(path, sizeof(path) - 1, "%s%s", home_dir(), path_in + 1); + } else { + snprintf(path, sizeof(path) - 1, "%s", path_in); + } + + if (!create_directories(path)) { + LOG_F(ERROR, "Failed to create directories to '" LOGURU_FMT(s) "'", path); + } + + const char* mode_str = (mode == FileMode::Truncate ? "w" : "a"); + auto file = fopen(path, mode_str); + if (!file) { + LOG_F(ERROR, "Failed to open '" LOGURU_FMT(s) "'", path); + return false; + } +#if LOGURU_WITH_FILEABS + FileAbs* file_abs = new FileAbs(); // this is deleted in file_close; + snprintf(file_abs->path, sizeof(file_abs->path) - 1, "%s", path); + snprintf(file_abs->mode_str, sizeof(file_abs->mode_str) - 1, "%s", mode_str); + stat(file_abs->path, &file_abs->st); + file_abs->fp = file; + file_abs->verbosity = verbosity; + add_callback(path_in, file_log, file_abs, verbosity, file_close, file_flush); +#else + add_callback(path_in, file_log, file, verbosity, file_close, file_flush); +#endif + + if (mode == FileMode::Append) { + fprintf(file, "\n\n\n\n\n"); + } + if (!s_arguments.empty()) { + fprintf(file, "arguments: %s\n", s_arguments.c_str()); + } + if (strlen(s_current_dir) != 0) { + fprintf(file, "Current dir: %s\n", s_current_dir); + } + fprintf(file, "File verbosity level: %d\n", verbosity); + if (g_preamble) { + char preamble_explain[LOGURU_PREAMBLE_WIDTH]; + print_preamble_header(preamble_explain, sizeof(preamble_explain)); + fprintf(file, "%s\n", preamble_explain); + } + fflush(file); + + VLOG_F(g_internal_verbosity, "Logging to '" LOGURU_FMT(s) "', mode: '" LOGURU_FMT(s) "', verbosity: " LOGURU_FMT(d) "", path, mode_str, verbosity); + return true; + } + + // Will be called right before abort(). + void set_fatal_handler(fatal_handler_t handler) + { + s_fatal_handler = handler; + } + + fatal_handler_t get_fatal_handler() + { + return s_fatal_handler; + } + + void set_verbosity_to_name_callback(verbosity_to_name_t callback) + { + s_verbosity_to_name_callback = callback; + } + + void set_name_to_verbosity_callback(name_to_verbosity_t callback) + { + s_name_to_verbosity_callback = callback; + } + + void add_stack_cleanup(const char* find_this, const char* replace_with_this) + { + if (strlen(find_this) <= strlen(replace_with_this)) { + LOG_F(WARNING, "add_stack_cleanup: the replacement should be shorter than the pattern!"); + return; + } + + s_user_stack_cleanups.push_back(StringPair(find_this, replace_with_this)); + } + + static void on_callback_change() + { + s_max_out_verbosity = Verbosity_OFF; + for (const auto& callback : s_callbacks) { + s_max_out_verbosity = std::max(s_max_out_verbosity, callback.verbosity); + } + } + + void add_callback( + const char* id, + log_handler_t callback, + void* user_data, + Verbosity verbosity, + close_handler_t on_close, + flush_handler_t on_flush) + { + std::lock_guard lock(s_mutex); + s_callbacks.push_back(Callback{id, callback, user_data, verbosity, on_close, on_flush, 0}); + on_callback_change(); + } + + // Returns a custom verbosity name if one is available, or nullptr. + // See also set_verbosity_to_name_callback. + const char* get_verbosity_name(Verbosity verbosity) + { + auto name = s_verbosity_to_name_callback + ? (*s_verbosity_to_name_callback)(verbosity) + : nullptr; + + // Use standard replacements if callback fails: + if (!name) + { + if (verbosity <= Verbosity_FATAL) { + name = "FATL"; + } else if (verbosity == Verbosity_ERROR) { + name = "ERR"; + } else if (verbosity == Verbosity_WARNING) { + name = "WARN"; + } else if (verbosity == Verbosity_INFO) { + name = "INFO"; + } + } + + return name; + } + + // Returns Verbosity_INVALID if the name is not found. + // See also set_name_to_verbosity_callback. + Verbosity get_verbosity_from_name(const char* name) + { + auto verbosity = s_name_to_verbosity_callback + ? (*s_name_to_verbosity_callback)(name) + : Verbosity_INVALID; + + // Use standard replacements if callback fails: + if (verbosity == Verbosity_INVALID) { + if (strcmp(name, "OFF") == 0) { + verbosity = Verbosity_OFF; + } else if (strcmp(name, "INFO") == 0) { + verbosity = Verbosity_INFO; + } else if (strcmp(name, "WARNING") == 0) { + verbosity = Verbosity_WARNING; + } else if (strcmp(name, "ERROR") == 0) { + verbosity = Verbosity_ERROR; + } else if (strcmp(name, "FATAL") == 0) { + verbosity = Verbosity_FATAL; + } + } + + return verbosity; + } + + bool remove_callback(const char* id) + { + std::lock_guard lock(s_mutex); + auto it = std::find_if(begin(s_callbacks), end(s_callbacks), [&](const Callback& c) { return c.id == id; }); + if (it != s_callbacks.end()) { + if (it->close) { it->close(it->user_data); } + s_callbacks.erase(it); + on_callback_change(); + return true; + } else { + LOG_F(ERROR, "Failed to locate callback with id '" LOGURU_FMT(s) "'", id); + return false; + } + } + + void remove_all_callbacks() + { + std::lock_guard lock(s_mutex); + for (auto& callback : s_callbacks) { + if (callback.close) { + callback.close(callback.user_data); + } + } + s_callbacks.clear(); + on_callback_change(); + } + + // Returns the maximum of g_stderr_verbosity and all file/custom outputs. + Verbosity current_verbosity_cutoff() + { + return g_stderr_verbosity > s_max_out_verbosity ? + g_stderr_verbosity : s_max_out_verbosity; + } + +#if LOGURU_WINTHREADS + char* get_thread_name_win32() + { + __declspec( thread ) static char thread_name[LOGURU_THREADNAME_WIDTH + 1] = {0}; + return &thread_name[0]; + } +#endif // LOGURU_WINTHREADS + + void set_thread_name(const char* name) + { + #if LOGURU_PTLS_NAMES + (void)pthread_once(&s_pthread_key_once, make_pthread_key_name); + (void)pthread_setspecific(s_pthread_key_name, STRDUP(name)); + + #elif LOGURU_PTHREADS + #ifdef __APPLE__ + pthread_setname_np(name); + #elif defined(__FreeBSD__) || defined(__OpenBSD__) + pthread_set_name_np(pthread_self(), name); + #elif defined(__linux__) + pthread_setname_np(pthread_self(), name); + #endif + #elif LOGURU_WINTHREADS + strncpy_s(get_thread_name_win32(), LOGURU_THREADNAME_WIDTH + 1, name, _TRUNCATE); + #else // LOGURU_PTHREADS + (void)name; + #endif // LOGURU_PTHREADS + } + +#if LOGURU_PTLS_NAMES + const char* get_thread_name_ptls() + { + (void)pthread_once(&s_pthread_key_once, make_pthread_key_name); + return static_cast(pthread_getspecific(s_pthread_key_name)); + } +#endif // LOGURU_PTLS_NAMES + + void get_thread_name(char* buffer, unsigned long long length, bool right_align_hext_id) + { +#ifdef _WIN32 + (void)right_align_hext_id; +#endif + CHECK_NE_F(length, 0u, "Zero length buffer in get_thread_name"); + CHECK_NOTNULL_F(buffer, "nullptr in get_thread_name"); +#if LOGURU_PTHREADS + auto thread = pthread_self(); + #if LOGURU_PTLS_NAMES + if (const char* name = get_thread_name_ptls()) { + snprintf(buffer, length, "%s", name); + } else { + buffer[0] = 0; + } + #elif defined(__APPLE__) || defined(__linux__) + pthread_getname_np(thread, buffer, length); + #else + buffer[0] = 0; + #endif + + if (buffer[0] == 0) { + #ifdef __APPLE__ + uint64_t thread_id; + pthread_threadid_np(thread, &thread_id); + #elif defined(__FreeBSD__) + long thread_id; + (void)thr_self(&thread_id); + #elif defined(__OpenBSD__) + unsigned thread_id = -1; + #else + uint64_t thread_id = thread; + #endif + if (right_align_hext_id) { + snprintf(buffer, length, "%*X", static_cast(length - 1), static_cast(thread_id)); + } else { + snprintf(buffer, length, "%X", static_cast(thread_id)); + } + } +#elif LOGURU_WINTHREADS + if (const char* name = get_thread_name_win32()) { + snprintf(buffer, (size_t)length, "%s", name); + } else { + buffer[0] = 0; + } +#else // !LOGURU_WINTHREADS && !LOGURU_WINTHREADS + buffer[0] = 0; +#endif + + } + + // ------------------------------------------------------------------------ + // Stack traces + +#if LOGURU_STACKTRACES + Text demangle(const char* name) + { + int status = -1; + char* demangled = abi::__cxa_demangle(name, 0, 0, &status); + Text result{status == 0 ? demangled : STRDUP(name)}; + return result; + } + + #if LOGURU_RTTI + template + std::string type_name() + { + auto demangled = demangle(typeid(T).name()); + return demangled.c_str(); + } + #endif // LOGURU_RTTI + + static const StringPairList REPLACE_LIST = { + #if LOGURU_RTTI + { type_name(), "std::string" }, + { type_name(), "std::wstring" }, + { type_name(), "std::u16string" }, + { type_name(), "std::u32string" }, + #endif // LOGURU_RTTI + { "std::__1::", "std::" }, + { "__thiscall ", "" }, + { "__cdecl ", "" }, + }; + + void do_replacements(const StringPairList& replacements, std::string& str) + { + for (auto&& p : replacements) { + if (p.first.size() <= p.second.size()) { + // On gcc, "type_name()" is "std::string" + continue; + } + + size_t it; + while ((it=str.find(p.first)) != std::string::npos) { + str.replace(it, p.first.size(), p.second); + } + } + } + + std::string prettify_stacktrace(const std::string& input) + { + std::string output = input; + + do_replacements(s_user_stack_cleanups, output); + do_replacements(REPLACE_LIST, output); + + try { + std::regex std_allocator_re(R"(,\s*std::allocator<[^<>]+>)"); + output = std::regex_replace(output, std_allocator_re, std::string("")); + + std::regex template_spaces_re(R"(<\s*([^<> ]+)\s*>)"); + output = std::regex_replace(output, template_spaces_re, std::string("<$1>")); + } catch (std::regex_error&) { + // Probably old GCC. + } + + return output; + } + + std::string stacktrace_as_stdstring(int skip) + { + // From https://gist.github.com/fmela/591333 + void* callstack[128]; + const auto max_frames = sizeof(callstack) / sizeof(callstack[0]); + int num_frames = backtrace(callstack, max_frames); + char** symbols = backtrace_symbols(callstack, num_frames); + + std::string result; + // Print stack traces so the most relevant ones are written last + // Rationale: http://yellerapp.com/posts/2015-01-22-upside-down-stacktraces.html + for (int i = num_frames - 1; i >= skip; --i) { + char buf[1024]; + Dl_info info; + if (dladdr(callstack[i], &info) && info.dli_sname) { + char* demangled = NULL; + int status = -1; + if (info.dli_sname[0] == '_') { + demangled = abi::__cxa_demangle(info.dli_sname, 0, 0, &status); + } + snprintf(buf, sizeof(buf), "%-3d %*p %s + %zd\n", + i - skip, int(2 + sizeof(void*) * 2), callstack[i], + status == 0 ? demangled : + info.dli_sname == 0 ? symbols[i] : info.dli_sname, + static_cast(callstack[i]) - static_cast(info.dli_saddr)); + free(demangled); + } else { + snprintf(buf, sizeof(buf), "%-3d %*p %s\n", + i - skip, int(2 + sizeof(void*) * 2), callstack[i], symbols[i]); + } + result += buf; + } + free(symbols); + + if (num_frames == max_frames) { + result = "[truncated]\n" + result; + } + + if (!result.empty() && result[result.size() - 1] == '\n') { + result.resize(result.size() - 1); + } + + return prettify_stacktrace(result); + } + +#else // LOGURU_STACKTRACES + Text demangle(const char* name) + { + return Text(STRDUP(name)); + } + + std::string stacktrace_as_stdstring(int) + { + // No stacktraces available on this platform" + return ""; + } + +#endif // LOGURU_STACKTRACES + + Text stacktrace(int skip) + { + auto str = stacktrace_as_stdstring(skip + 1); + return Text(STRDUP(str.c_str())); + } + + // ------------------------------------------------------------------------ + + static void print_preamble_header(char* out_buff, size_t out_buff_size) + { + if (out_buff_size == 0) { return; } + out_buff[0] = '\0'; + long pos = 0; + if (g_preamble_date && pos < out_buff_size) { + pos += snprintf(out_buff + pos, out_buff_size - pos, "date "); + } + if (g_preamble_time && pos < out_buff_size) { + pos += snprintf(out_buff + pos, out_buff_size - pos, "time "); + } + if (g_preamble_uptime && pos < out_buff_size) { + pos += snprintf(out_buff + pos, out_buff_size - pos, "( uptime ) "); + } + if (g_preamble_thread && pos < out_buff_size) { + pos += snprintf(out_buff + pos, out_buff_size - pos, "[%-*s]", LOGURU_THREADNAME_WIDTH, " thread name/id"); + } + if (g_preamble_file && pos < out_buff_size) { + pos += snprintf(out_buff + pos, out_buff_size - pos, "%*s:line ", LOGURU_FILENAME_WIDTH, "file"); + } + if (g_preamble_verbose && pos < out_buff_size) { + pos += snprintf(out_buff + pos, out_buff_size - pos, " v"); + } + if (g_preamble_pipe && pos < out_buff_size) { + pos += snprintf(out_buff + pos, out_buff_size - pos, "| "); + } + } + + static void print_preamble(char* out_buff, size_t out_buff_size, Verbosity verbosity, const char* file, unsigned line) + { + if (out_buff_size == 0) { return; } + out_buff[0] = '\0'; + if (!g_preamble) { return; } + long long ms_since_epoch = duration_cast(system_clock::now().time_since_epoch()).count(); + time_t sec_since_epoch = time_t(ms_since_epoch / 1000); + tm time_info; + localtime_r(&sec_since_epoch, &time_info); + + auto uptime_ms = duration_cast(steady_clock::now() - s_start_time).count(); + auto uptime_sec = uptime_ms / 1000.0; + + char thread_name[LOGURU_THREADNAME_WIDTH + 1] = {0}; + get_thread_name(thread_name, LOGURU_THREADNAME_WIDTH + 1, true); + + if (s_strip_file_path) { + file = filename(file); + } + + char level_buff[6]; + const char* custom_level_name = get_verbosity_name(verbosity); + if (custom_level_name) { + snprintf(level_buff, sizeof(level_buff) - 1, "%s", custom_level_name); + } else { + snprintf(level_buff, sizeof(level_buff) - 1, "% 4d", verbosity); + } + + long pos = 0; + + if (g_preamble_date && pos < out_buff_size) { + pos += snprintf(out_buff + pos, out_buff_size - pos, "%04d-%02d-%02d ", + 1900 + time_info.tm_year, 1 + time_info.tm_mon, time_info.tm_mday); + } + if (g_preamble_time && pos < out_buff_size) { + pos += snprintf(out_buff + pos, out_buff_size - pos, "%02d:%02d:%02d.%03lld ", + time_info.tm_hour, time_info.tm_min, time_info.tm_sec, ms_since_epoch % 1000); + } + if (g_preamble_uptime && pos < out_buff_size) { + pos += snprintf(out_buff + pos, out_buff_size - pos, "(%8.3fs) ", + uptime_sec); + } + if (g_preamble_thread && pos < out_buff_size) { + pos += snprintf(out_buff + pos, out_buff_size - pos, "[%-*s]", + LOGURU_THREADNAME_WIDTH, thread_name); + } + if (g_preamble_file && pos < out_buff_size) { + char shortened_filename[LOGURU_FILENAME_WIDTH + 1]; + snprintf(shortened_filename, LOGURU_FILENAME_WIDTH + 1, "%s", file); + pos += snprintf(out_buff + pos, out_buff_size - pos, "%*s:%-5u ", + LOGURU_FILENAME_WIDTH, shortened_filename, line); + } + if (g_preamble_verbose && pos < out_buff_size) { + pos += snprintf(out_buff + pos, out_buff_size - pos, "%4s", + level_buff); + } + if (g_preamble_pipe && pos < out_buff_size) { + pos += snprintf(out_buff + pos, out_buff_size - pos, "| "); + } + } + + // stack_trace_skip is just if verbosity == FATAL. + static void log_message(int stack_trace_skip, Message& message, bool with_indentation, bool abort_if_fatal) + { + const auto verbosity = message.verbosity; + std::lock_guard lock(s_mutex); + + if (message.verbosity == Verbosity_FATAL) { + auto st = loguru::stacktrace(stack_trace_skip + 2); + if (!st.empty()) { + RAW_LOG_F(ERROR, "Stack trace:\n" LOGURU_FMT(s) "", st.c_str()); + } + + auto ec = loguru::get_error_context(); + if (!ec.empty()) { + RAW_LOG_F(ERROR, "" LOGURU_FMT(s) "", ec.c_str()); + } + } + + if (with_indentation) { + message.indentation = indentation(s_stderr_indentation); + } + + if (verbosity <= g_stderr_verbosity) { + if (g_colorlogtostderr && s_terminal_has_color) { + if (verbosity > Verbosity_WARNING) { + fprintf(stderr, "%s%s%s%s%s%s%s%s\n", + terminal_reset(), + terminal_dim(), + message.preamble, + message.indentation, + verbosity == Verbosity_INFO ? terminal_reset() : "", // un-dim for info + message.prefix, + message.message, + terminal_reset()); + } else { + fprintf(stderr, "%s%s%s%s%s%s%s\n", + terminal_reset(), + verbosity == Verbosity_WARNING ? terminal_yellow() : terminal_red(), + message.preamble, + message.indentation, + message.prefix, + message.message, + terminal_reset()); + } + } else { + fprintf(stderr, "%s%s%s%s\n", + message.preamble, message.indentation, message.prefix, message.message); + } + + if (g_flush_interval_ms == 0) { + fflush(stderr); + } else { + s_needs_flushing = true; + } + } + + for (auto& p : s_callbacks) { + if (verbosity <= p.verbosity) { + if (with_indentation) { + message.indentation = indentation(p.indentation); + } + p.callback(p.user_data, message); + if (g_flush_interval_ms == 0) { + if (p.flush) { p.flush(p.user_data); } + } else { + s_needs_flushing = true; + } + } + } + + if (g_flush_interval_ms > 0 && !s_flush_thread) { + s_flush_thread = new std::thread([](){ + for (;;) { + if (s_needs_flushing) { + flush(); + } + std::this_thread::sleep_for(std::chrono::milliseconds(g_flush_interval_ms)); + } + }); + } + + if (message.verbosity == Verbosity_FATAL) { + flush(); + + if (s_fatal_handler) { + s_fatal_handler(message); + flush(); + } + + if (abort_if_fatal) { +#if LOGURU_CATCH_SIGABRT && !defined(_WIN32) + // Make sure we don't catch our own abort: + signal(SIGABRT, SIG_DFL); +#endif + abort(); + } + } + } + + // stack_trace_skip is just if verbosity == FATAL. + void log_to_everywhere(int stack_trace_skip, Verbosity verbosity, + const char* file, unsigned line, + const char* prefix, const char* buff) + { + char preamble_buff[LOGURU_PREAMBLE_WIDTH]; + print_preamble(preamble_buff, sizeof(preamble_buff), verbosity, file, line); + auto message = Message{verbosity, file, line, preamble_buff, "", prefix, buff}; + log_message(stack_trace_skip + 1, message, true, true); + } + +#if LOGURU_USE_FMTLIB + void vlog(Verbosity verbosity, const char* file, unsigned line, const char* format, fmt::format_args args) + { + auto formatted = fmt::vformat(format, args); + log_to_everywhere(1, verbosity, file, line, "", formatted.c_str()); + } + + void raw_vlog(Verbosity verbosity, const char* file, unsigned line, const char* format, fmt::format_args args) + { + auto formatted = fmt::vformat(format, args); + auto message = Message{verbosity, file, line, "", "", "", formatted.c_str()}; + log_message(1, message, false, true); + } +#else + void log(Verbosity verbosity, const char* file, unsigned line, const char* format, ...) + { + va_list vlist; + va_start(vlist, format); + auto buff = vtextprintf(format, vlist); + log_to_everywhere(1, verbosity, file, line, "", buff.c_str()); + va_end(vlist); + } + + void raw_log(Verbosity verbosity, const char* file, unsigned line, const char* format, ...) + { + va_list vlist; + va_start(vlist, format); + auto buff = vtextprintf(format, vlist); + auto message = Message{verbosity, file, line, "", "", "", buff.c_str()}; + log_message(1, message, false, true); + va_end(vlist); + } +#endif + + void flush() + { + std::lock_guard lock(s_mutex); + fflush(stderr); + for (const auto& callback : s_callbacks) + { + if (callback.flush) { + callback.flush(callback.user_data); + } + } + s_needs_flushing = false; + } + + LogScopeRAII::LogScopeRAII(Verbosity verbosity, const char* file, unsigned line, const char* format, ...) + : _verbosity(verbosity), _file(file), _line(line) + { + if (verbosity <= current_verbosity_cutoff()) { + std::lock_guard lock(s_mutex); + _indent_stderr = (verbosity <= g_stderr_verbosity); + _start_time_ns = now_ns(); + va_list vlist; + va_start(vlist, format); + vsnprintf(_name, sizeof(_name), format, vlist); + log_to_everywhere(1, _verbosity, file, line, "{ ", _name); + va_end(vlist); + + if (_indent_stderr) { + ++s_stderr_indentation; + } + + for (auto& p : s_callbacks) { + if (verbosity <= p.verbosity) { + ++p.indentation; + } + } + } else { + _file = nullptr; + } + } + + LogScopeRAII::~LogScopeRAII() + { + if (_file) { + std::lock_guard lock(s_mutex); + if (_indent_stderr && s_stderr_indentation > 0) { + --s_stderr_indentation; + } + for (auto& p : s_callbacks) { + // Note: Callback indentation cannot change! + if (_verbosity <= p.verbosity) { + // in unlikely case this callback is new + if (p.indentation > 0) { + --p.indentation; + } + } + } +#if LOGURU_VERBOSE_SCOPE_ENDINGS + auto duration_sec = (now_ns() - _start_time_ns) / 1e9; +#if LOGURU_USE_FMTLIB + auto buff = textprintf("{:.{}f} s: {:s}", duration_sec, LOGURU_SCOPE_TIME_PRECISION, _name); +#else + auto buff = textprintf("%.*f s: %s", LOGURU_SCOPE_TIME_PRECISION, duration_sec, _name); +#endif + log_to_everywhere(1, _verbosity, _file, _line, "} ", buff.c_str()); +#else + log_to_everywhere(1, _verbosity, _file, _line, "}", ""); +#endif + } + } + +#if LOGURU_USE_FMTLIB + void vlog_and_abort(int stack_trace_skip, const char* expr, const char* file, unsigned line, const char* format, fmt::format_args args) + { + auto formatted = fmt::vformat(format, args); + log_to_everywhere(stack_trace_skip + 1, Verbosity_FATAL, file, line, expr, formatted.c_str()); + abort(); // log_to_everywhere already does this, but this makes the analyzer happy. + } +#else + void log_and_abort(int stack_trace_skip, const char* expr, const char* file, unsigned line, const char* format, ...) + { + va_list vlist; + va_start(vlist, format); + auto buff = vtextprintf(format, vlist); + log_to_everywhere(stack_trace_skip + 1, Verbosity_FATAL, file, line, expr, buff.c_str()); + va_end(vlist); + abort(); // log_to_everywhere already does this, but this makes the analyzer happy. + } +#endif + + void log_and_abort(int stack_trace_skip, const char* expr, const char* file, unsigned line) + { + log_and_abort(stack_trace_skip + 1, expr, file, line, " "); + } + + // ---------------------------------------------------------------------------- + // Streams: + +#if LOGURU_USE_FMTLIB + template + std::string vstrprintf(const char* format, const Args&... args) + { + auto text = textprintf(format, args...); + std::string result = text.c_str(); + return result; + } + + template + std::string strprintf(const char* format, const Args&... args) + { + return vstrprintf(format, args...); + } +#else + std::string vstrprintf(const char* format, va_list vlist) + { + auto text = vtextprintf(format, vlist); + std::string result = text.c_str(); + return result; + } + + std::string strprintf(const char* format, ...) + { + va_list vlist; + va_start(vlist, format); + auto result = vstrprintf(format, vlist); + va_end(vlist); + return result; + } +#endif + + #if LOGURU_WITH_STREAMS + + StreamLogger::~StreamLogger() noexcept(false) + { + auto message = _ss.str(); + log(_verbosity, _file, _line, LOGURU_FMT(s), message.c_str()); + } + + AbortLogger::~AbortLogger() noexcept(false) + { + auto message = _ss.str(); + loguru::log_and_abort(1, _expr, _file, _line, LOGURU_FMT(s), message.c_str()); + } + + #endif // LOGURU_WITH_STREAMS + + // ---------------------------------------------------------------------------- + // 888888 88""Yb 88""Yb dP"Yb 88""Yb dP""b8 dP"Yb 88b 88 888888 888888 Yb dP 888888 + // 88__ 88__dP 88__dP dP Yb 88__dP dP `" dP Yb 88Yb88 88 88__ YbdP 88 + // 88"" 88"Yb 88"Yb Yb dP 88"Yb Yb Yb dP 88 Y88 88 88"" dPYb 88 + // 888888 88 Yb 88 Yb YbodP 88 Yb YboodP YbodP 88 Y8 88 888888 dP Yb 88 + // ---------------------------------------------------------------------------- + + struct StringStream + { + std::string str; + }; + + // Use this in your EcPrinter implementations. + void stream_print(StringStream& out_string_stream, const char* text) + { + out_string_stream.str += text; + } + + // ---------------------------------------------------------------------------- + + using ECPtr = EcEntryBase*; + +#if defined(_WIN32) || (defined(__APPLE__) && !TARGET_OS_IPHONE) + #ifdef __APPLE__ + #define LOGURU_THREAD_LOCAL __thread + #else + #define LOGURU_THREAD_LOCAL thread_local + #endif + static LOGURU_THREAD_LOCAL ECPtr thread_ec_ptr = nullptr; + + ECPtr& get_thread_ec_head_ref() + { + return thread_ec_ptr; + } +#else // !thread_local + static pthread_once_t s_ec_pthread_once = PTHREAD_ONCE_INIT; + static pthread_key_t s_ec_pthread_key; + + void free_ec_head_ref(void* io_error_context) + { + delete reinterpret_cast(io_error_context); + } + + void ec_make_pthread_key() + { + (void)pthread_key_create(&s_ec_pthread_key, free_ec_head_ref); + } + + ECPtr& get_thread_ec_head_ref() + { + (void)pthread_once(&s_ec_pthread_once, ec_make_pthread_key); + auto ec = reinterpret_cast(pthread_getspecific(s_ec_pthread_key)); + if (ec == nullptr) { + ec = new ECPtr(nullptr); + (void)pthread_setspecific(s_ec_pthread_key, ec); + } + return *ec; + } +#endif // !thread_local + + // ---------------------------------------------------------------------------- + + EcHandle get_thread_ec_handle() + { + return get_thread_ec_head_ref(); + } + + Text get_error_context() + { + return get_error_context_for(get_thread_ec_head_ref()); + } + + Text get_error_context_for(const EcEntryBase* ec_head) + { + std::vector stack; + while (ec_head) { + stack.push_back(ec_head); + ec_head = ec_head->_previous; + } + std::reverse(stack.begin(), stack.end()); + + StringStream result; + if (!stack.empty()) { + result.str += "------------------------------------------------\n"; + for (auto entry : stack) { + const auto description = std::string(entry->_descr) + ":"; +#if LOGURU_USE_FMTLIB + auto prefix = textprintf("[ErrorContext] {.{}s}:{:-5u} {:-20s} ", + filename(entry->_file), LOGURU_FILENAME_WIDTH, entry->_line, description.c_str()); +#else + auto prefix = textprintf("[ErrorContext] %*s:%-5u %-20s ", + LOGURU_FILENAME_WIDTH, filename(entry->_file), entry->_line, description.c_str()); +#endif + result.str += prefix.c_str(); + entry->print_value(result); + result.str += "\n"; + } + result.str += "------------------------------------------------"; + } + return Text(STRDUP(result.str.c_str())); + } + + EcEntryBase::EcEntryBase(const char* file, unsigned line, const char* descr) + : _file(file), _line(line), _descr(descr) + { + EcEntryBase*& ec_head = get_thread_ec_head_ref(); + _previous = ec_head; + ec_head = this; + } + + EcEntryBase::~EcEntryBase() + { + get_thread_ec_head_ref() = _previous; + } + + // ------------------------------------------------------------------------ + + Text ec_to_text(const char* value) + { + // Add quotes around the string to make it obvious where it begin and ends. + // This is great for detecting erroneous leading or trailing spaces in e.g. an identifier. + auto str = "\"" + std::string(value) + "\""; + return Text{STRDUP(str.c_str())}; + } + + Text ec_to_text(char c) + { + // Add quotes around the character to make it obvious where it begin and ends. + std::string str = "'"; + + auto write_hex_digit = [&](unsigned num) + { + if (num < 10u) { str += char('0' + num); } + else { str += char('a' + num - 10); } + }; + + auto write_hex_16 = [&](uint16_t n) + { + write_hex_digit((n >> 12u) & 0x0f); + write_hex_digit((n >> 8u) & 0x0f); + write_hex_digit((n >> 4u) & 0x0f); + write_hex_digit((n >> 0u) & 0x0f); + }; + + if (c == '\\') { str += "\\\\"; } + else if (c == '\"') { str += "\\\""; } + else if (c == '\'') { str += "\\\'"; } + else if (c == '\0') { str += "\\0"; } + else if (c == '\b') { str += "\\b"; } + else if (c == '\f') { str += "\\f"; } + else if (c == '\n') { str += "\\n"; } + else if (c == '\r') { str += "\\r"; } + else if (c == '\t') { str += "\\t"; } + else if (0 <= c && c < 0x20) { + str += "\\u"; + write_hex_16(static_cast(c)); + } else { str += c; } + + str += "'"; + + return Text{STRDUP(str.c_str())}; + } + + #define DEFINE_EC(Type) \ + Text ec_to_text(Type value) \ + { \ + auto str = std::to_string(value); \ + return Text{STRDUP(str.c_str())}; \ + } + + DEFINE_EC(int) + DEFINE_EC(unsigned int) + DEFINE_EC(long) + DEFINE_EC(unsigned long) + DEFINE_EC(long long) + DEFINE_EC(unsigned long long) + DEFINE_EC(float) + DEFINE_EC(double) + DEFINE_EC(long double) + + #undef DEFINE_EC + + Text ec_to_text(EcHandle ec_handle) + { + Text parent_ec = get_error_context_for(ec_handle); + char* with_newline = reinterpret_cast(malloc(strlen(parent_ec.c_str()) + 2)); + with_newline[0] = '\n'; + strcpy(with_newline + 1, parent_ec.c_str()); + return Text(with_newline); + } + + // ---------------------------------------------------------------------------- + +} // namespace loguru + +// ---------------------------------------------------------------------------- +// .dP"Y8 88 dP""b8 88b 88 db 88 .dP"Y8 +// `Ybo." 88 dP `" 88Yb88 dPYb 88 `Ybo." +// o.`Y8b 88 Yb "88 88 Y88 dP__Yb 88 .o o.`Y8b +// 8bodP' 88 YboodP 88 Y8 dP""""Yb 88ood8 8bodP' +// ---------------------------------------------------------------------------- + +#ifdef _WIN32 +namespace loguru { + void install_signal_handlers(bool unsafe_signal_handler) + { + (void)unsafe_signal_handler; + // TODO: implement signal handlers on windows + } +} // namespace loguru + +#else // _WIN32 + +namespace loguru +{ + struct Signal + { + int number; + const char* name; + }; + const Signal ALL_SIGNALS[] = { +#if LOGURU_CATCH_SIGABRT + { SIGABRT, "SIGABRT" }, +#endif + { SIGBUS, "SIGBUS" }, + { SIGFPE, "SIGFPE" }, + { SIGILL, "SIGILL" }, + { SIGINT, "SIGINT" }, + { SIGSEGV, "SIGSEGV" }, + { SIGTERM, "SIGTERM" }, + }; + + void write_to_stderr(const char* data, size_t size) + { + auto result = write(STDERR_FILENO, data, size); + (void)result; // Ignore errors. + } + + void write_to_stderr(const char* data) + { + write_to_stderr(data, strlen(data)); + } + + void call_default_signal_handler(int signal_number) + { + struct sigaction sig_action; + memset(&sig_action, 0, sizeof(sig_action)); + sigemptyset(&sig_action.sa_mask); + sig_action.sa_handler = SIG_DFL; + sigaction(signal_number, &sig_action, NULL); + kill(getpid(), signal_number); + } + + static bool s_unsafe_signal_handler = false; + + void signal_handler(int signal_number, siginfo_t*, void*) + { + const char* signal_name = "UNKNOWN SIGNAL"; + + for (const auto& s : ALL_SIGNALS) { + if (s.number == signal_number) { + signal_name = s.name; + break; + } + } + + // -------------------------------------------------------------------- + /* There are few things that are safe to do in a signal handler, + but writing to stderr is one of them. + So we first print out what happened to stderr so we're sure that gets out, + then we do the unsafe things, like logging the stack trace. + */ + + if (g_colorlogtostderr && s_terminal_has_color) { + write_to_stderr(terminal_reset()); + write_to_stderr(terminal_bold()); + write_to_stderr(terminal_light_red()); + } + write_to_stderr("\n"); + write_to_stderr("Loguru caught a signal: "); + write_to_stderr(signal_name); + write_to_stderr("\n"); + if (g_colorlogtostderr && s_terminal_has_color) { + write_to_stderr(terminal_reset()); + } + + // -------------------------------------------------------------------- + + if (s_unsafe_signal_handler) { + // -------------------------------------------------------------------- + /* Now we do unsafe things. This can for example lead to deadlocks if + the signal was triggered from the system's memory management functions + and the code below tries to do allocations. + */ + + flush(); + char preamble_buff[LOGURU_PREAMBLE_WIDTH]; + print_preamble(preamble_buff, sizeof(preamble_buff), Verbosity_FATAL, "", 0); + auto message = Message{Verbosity_FATAL, "", 0, preamble_buff, "", "Signal: ", signal_name}; + try { + log_message(1, message, false, false); + } catch (...) { + // This can happed due to s_fatal_handler. + write_to_stderr("Exception caught and ignored by Loguru signal handler.\n"); + } + flush(); + + // -------------------------------------------------------------------- + } + + call_default_signal_handler(signal_number); + } + + void install_signal_handlers(bool unsafe_signal_handler) + { + s_unsafe_signal_handler = unsafe_signal_handler; + + struct sigaction sig_action; + memset(&sig_action, 0, sizeof(sig_action)); + sigemptyset(&sig_action.sa_mask); + sig_action.sa_flags |= SA_SIGINFO; + sig_action.sa_sigaction = &signal_handler; + for (const auto& s : ALL_SIGNALS) { + CHECK_F(sigaction(s.number, &sig_action, NULL) != -1, + "Failed to install handler for " LOGURU_FMT(s) "", s.name); + } + } +} // namespace loguru + +#endif // _WIN32 + +#ifdef _WIN32 +#ifdef _MSC_VER +#pragma warning(pop) +#endif // _MSC_VER +#endif // _WIN32 + +#endif // LOGURU_IMPLEMENTATION diff --git a/loguru.hpp b/loguru.hpp new file mode 100644 index 0000000..05b4e98 --- /dev/null +++ b/loguru.hpp @@ -0,0 +1,1388 @@ +/* +Loguru logging library for C++, by Emil Ernerfeldt. +www.github.com/emilk/loguru +If you find Loguru useful, please let me know on twitter or in a mail! +Twitter: @ernerfeldt +Mail: emil.ernerfeldt@gmail.com +Website: www.ilikebigbits.com + +# License + This software is in the public domain. Where that dedication is not + recognized, you are granted a perpetual, irrevocable license to + copy, modify and distribute it as you see fit. + +# Inspiration + Much of Loguru was inspired by GLOG, https://code.google.com/p/google-glog/. + The choice of public domain is fully due Sean T. Barrett + and his wonderful stb libraries at https://github.com/nothings/stb. + +# Version history + * Version 0.1.0 - 2015-03-22 - Works great on Mac. + * Version 0.2.0 - 2015-09-17 - Removed the only dependency. + * Version 0.3.0 - 2015-10-02 - Drop-in replacement for most of GLOG + * Version 0.4.0 - 2015-10-07 - Single-file! + * Version 0.5.0 - 2015-10-17 - Improved file logging + * Version 0.6.0 - 2015-10-24 - Add stack traces + * Version 0.7.0 - 2015-10-27 - Signals + * Version 0.8.0 - 2015-10-30 - Color logging. + * Version 0.9.0 - 2015-11-26 - ABORT_S and proper handling of FATAL + * Version 1.0.0 - 2016-02-14 - ERROR_CONTEXT + * Version 1.1.0 - 2016-02-19 - -v OFF, -v INFO etc + * Version 1.1.1 - 2016-02-20 - textprintf vs strprintf + * Version 1.1.2 - 2016-02-22 - Remove g_alsologtostderr + * Version 1.1.3 - 2016-02-29 - ERROR_CONTEXT as linked list + * Version 1.2.0 - 2016-03-19 - Add get_thread_name() + * Version 1.2.1 - 2016-03-20 - Minor fixes + * Version 1.2.2 - 2016-03-29 - Fix issues with set_fatal_handler throwing an exception + * Version 1.2.3 - 2016-05-16 - Log current working directory in loguru::init(). + * Version 1.2.4 - 2016-05-18 - Custom replacement for -v in loguru::init() by bjoernpollex + * Version 1.2.5 - 2016-05-18 - Add ability to print ERROR_CONTEXT of parent thread. + * Version 1.2.6 - 2016-05-19 - Bug fix regarding VLOG verbosity argument lacking (). + * Version 1.2.7 - 2016-05-23 - Fix PATH_MAX problem. + * Version 1.2.8 - 2016-05-26 - Add shutdown() and remove_all_callbacks() + * Version 1.2.9 - 2016-06-09 - Use a monotonic clock for uptime. + * Version 1.3.0 - 2016-07-20 - Fix issues with callback flush/close not being called. + * Version 1.3.1 - 2016-07-20 - Add LOGURU_UNSAFE_SIGNAL_HANDLER to toggle stacktrace on signals. + * Version 1.3.2 - 2016-07-20 - Add loguru::arguments() + * Version 1.4.0 - 2016-09-15 - Semantic versioning + add loguru::create_directories + * Version 1.4.1 - 2016-09-29 - Customize formating with LOGURU_FILENAME_WIDTH + * Version 1.5.0 - 2016-12-22 - LOGURU_USE_FMTLIB by kolis and LOGURU_WITH_FILEABS by scinart + * Version 1.5.1 - 2017-08-08 - Terminal colors on Windows 10 thanks to looki + * Version 1.6.0 - 2018-01-03 - Add LOGURU_RTTI and LOGURU_STACKTRACES settings + * Version 1.7.0 - 2018-01-03 - Add ability to turn off the preamble with loguru::g_preamble + * Version 1.7.1 - 2018-04-05 - Add function get_fatal_handler + * Version 1.7.2 - 2018-04-22 - Fix a bug where large file names could cause stack corruption (thanks @ccamporesi) + * Version 1.8.0 - 2018-04-23 - Shorten long file names to keep preamble fixed width + * Version 1.9.0 - 2018-09-22 - Adjust terminal colors, add LOGURU_VERBOSE_SCOPE_ENDINGS, add LOGURU_SCOPE_TIME_PRECISION, add named log levels + * Version 2.0.0 - 2018-09-22 - Split loguru.hpp into loguru.hpp and loguru.cpp + * Version 2.1.0 - 2019-09-23 - Update fmtlib + add option to loguru::init to NOT set main thread name. + +# Compiling + Just include where you want to use Loguru. + Then, in one .cpp file #include + Make sure you compile with -std=c++11 -lstdc++ -lpthread -ldl + +# Usage + For details, please see the official documentation at emilk.github.io/loguru + + #include + + int main(int argc, char* argv[]) { + loguru::init(argc, argv); + + // Put every log message in "everything.log": + loguru::add_file("everything.log", loguru::Append, loguru::Verbosity_MAX); + + LOG_F(INFO, "The magic number is %d", 42); + } + +*/ + +#if defined(LOGURU_IMPLEMENTATION) + #error "You are defining LOGURU_IMPLEMENTATION. This is for older versions of Loguru. You should now instead include loguru.cpp (or build it and link with it)" +#endif + +// Disable all warnings from gcc/clang: +#if defined(__clang__) + #pragma clang system_header +#elif defined(__GNUC__) + #pragma GCC system_header +#endif + +#ifndef LOGURU_HAS_DECLARED_FORMAT_HEADER +#define LOGURU_HAS_DECLARED_FORMAT_HEADER + +// Semantic versioning. Loguru version can be printed with printf("%d.%d.%d", LOGURU_VERSION_MAJOR, LOGURU_VERSION_MINOR, LOGURU_VERSION_PATCH); +#define LOGURU_VERSION_MAJOR 2 +#define LOGURU_VERSION_MINOR 1 +#define LOGURU_VERSION_PATCH 0 + +#if defined(_MSC_VER) +#include // Needed for _In_z_ etc annotations +#endif + +// ---------------------------------------------------------------------------- + +#ifndef LOGURU_EXPORT + // Define to your project's export declaration if needed for use in a shared library. + #define LOGURU_EXPORT +#endif + +#ifndef LOGURU_SCOPE_TEXT_SIZE + // Maximum length of text that can be printed by a LOG_SCOPE. + // This should be long enough to get most things, but short enough not to clutter the stack. + #define LOGURU_SCOPE_TEXT_SIZE 196 +#endif + +#ifndef LOGURU_FILENAME_WIDTH + // Width of the column containing the file name + #define LOGURU_FILENAME_WIDTH 23 +#endif + +#ifndef LOGURU_THREADNAME_WIDTH + // Width of the column containing the thread name + #define LOGURU_THREADNAME_WIDTH 16 +#endif + +#ifndef LOGURU_SCOPE_TIME_PRECISION + // Resolution of scope timers. 3=ms, 6=us, 9=ns + #define LOGURU_SCOPE_TIME_PRECISION 3 +#endif + +#ifndef LOGURU_CATCH_SIGABRT + // Should Loguru catch SIGABRT to print stack trace etc? + #define LOGURU_CATCH_SIGABRT 1 +#endif + +#ifndef LOGURU_VERBOSE_SCOPE_ENDINGS + // Show milliseconds and scope name at end of scope. + #define LOGURU_VERBOSE_SCOPE_ENDINGS 1 +#endif + +#ifndef LOGURU_REDEFINE_ASSERT + #define LOGURU_REDEFINE_ASSERT 0 +#endif + +#ifndef LOGURU_WITH_STREAMS + #define LOGURU_WITH_STREAMS 0 +#endif + +#ifndef LOGURU_REPLACE_GLOG + #define LOGURU_REPLACE_GLOG 0 +#endif + +#if LOGURU_REPLACE_GLOG + #undef LOGURU_WITH_STREAMS + #define LOGURU_WITH_STREAMS 1 +#endif + +#if defined(LOGURU_UNSAFE_SIGNAL_HANDLER) + #error "You are defining LOGURU_UNSAFE_SIGNAL_HANDLER. This is for older versions of Loguru. You should now instead set the unsafe_signal_handler option when you call loguru::init." +#endif + +#if LOGURU_IMPLEMENTATION + #undef LOGURU_WITH_STREAMS + #define LOGURU_WITH_STREAMS 1 +#endif + +#ifndef LOGURU_USE_FMTLIB + #define LOGURU_USE_FMTLIB 0 +#endif + +#ifndef LOGURU_WITH_FILEABS + #define LOGURU_WITH_FILEABS 0 +#endif + +#ifndef LOGURU_RTTI +#if defined(__clang__) + #if __has_feature(cxx_rtti) + #define LOGURU_RTTI 1 + #endif +#elif defined(__GNUG__) + #if defined(__GXX_RTTI) + #define LOGURU_RTTI 1 + #endif +#elif defined(_MSC_VER) + #if defined(_CPPRTTI) + #define LOGURU_RTTI 1 + #endif +#endif +#endif + +// -------------------------------------------------------------------- +// Utility macros + +#define LOGURU_CONCATENATE_IMPL(s1, s2) s1 ## s2 +#define LOGURU_CONCATENATE(s1, s2) LOGURU_CONCATENATE_IMPL(s1, s2) + +#ifdef __COUNTER__ +# define LOGURU_ANONYMOUS_VARIABLE(str) LOGURU_CONCATENATE(str, __COUNTER__) +#else +# define LOGURU_ANONYMOUS_VARIABLE(str) LOGURU_CONCATENATE(str, __LINE__) +#endif + +#if defined(__clang__) || defined(__GNUC__) + // Helper macro for declaring functions as having similar signature to printf. + // This allows the compiler to catch format errors at compile-time. + #define LOGURU_PRINTF_LIKE(fmtarg, firstvararg) __attribute__((__format__ (__printf__, fmtarg, firstvararg))) + #define LOGURU_FORMAT_STRING_TYPE const char* +#elif defined(_MSC_VER) + #define LOGURU_PRINTF_LIKE(fmtarg, firstvararg) + #define LOGURU_FORMAT_STRING_TYPE _In_z_ _Printf_format_string_ const char* +#else + #define LOGURU_PRINTF_LIKE(fmtarg, firstvararg) + #define LOGURU_FORMAT_STRING_TYPE const char* +#endif + +// Used to mark log_and_abort for the benefit of the static analyzer and optimizer. +#if defined(_MSC_VER) +#define LOGURU_NORETURN __declspec(noreturn) +#else +#define LOGURU_NORETURN __attribute__((noreturn)) +#endif + +#if defined(_MSC_VER) +#define LOGURU_PREDICT_FALSE(x) (x) +#define LOGURU_PREDICT_TRUE(x) (x) +#else +#define LOGURU_PREDICT_FALSE(x) (__builtin_expect(x, 0)) +#define LOGURU_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1)) +#endif + +#if LOGURU_USE_FMTLIB + #include + #define LOGURU_FMT(x) "{:" #x "}" +#else + #define LOGURU_FMT(x) "%" #x +#endif + +#ifdef _WIN32 + #define STRDUP(str) _strdup(str) +#else + #define STRDUP(str) strdup(str) +#endif + +// -------------------------------------------------------------------- + +namespace loguru +{ + // Simple RAII ownership of a char*. + class LOGURU_EXPORT Text + { + public: + explicit Text(char* owned_str) : _str(owned_str) {} + ~Text(); + Text(Text&& t) + { + _str = t._str; + t._str = nullptr; + } + Text(Text& t) = delete; + Text& operator=(Text& t) = delete; + void operator=(Text&& t) = delete; + + const char* c_str() const { return _str; } + bool empty() const { return _str == nullptr || *_str == '\0'; } + + char* release() + { + auto result = _str; + _str = nullptr; + return result; + } + + private: + char* _str; + }; + + // Like printf, but returns the formated text. +#if LOGURU_USE_FMTLIB + LOGURU_EXPORT + Text vtextprintf(const char* format, fmt::format_args args); + + template + LOGURU_EXPORT + Text textprintf(LOGURU_FORMAT_STRING_TYPE format, const Args&... args) { + return vtextprintf(format, fmt::make_format_args(args...)); + } +#else + LOGURU_EXPORT + Text textprintf(LOGURU_FORMAT_STRING_TYPE format, ...) LOGURU_PRINTF_LIKE(1, 2); +#endif + + // Overloaded for variadic template matching. + LOGURU_EXPORT + Text textprintf(); + + using Verbosity = int; + +#undef FATAL +#undef ERROR +#undef WARNING +#undef INFO +#undef MAX + + enum NamedVerbosity : Verbosity + { + // Used to mark an invalid verbosity. Do not log to this level. + Verbosity_INVALID = -10, // Never do LOG_F(INVALID) + + // You may use Verbosity_OFF on g_stderr_verbosity, but for nothing else! + Verbosity_OFF = -9, // Never do LOG_F(OFF) + + // Prefer to use ABORT_F or ABORT_S over LOG_F(FATAL) or LOG_S(FATAL). + Verbosity_FATAL = -3, + Verbosity_ERROR = -2, + Verbosity_WARNING = -1, + + // Normal messages. By default written to stderr. + Verbosity_INFO = 0, + + // Same as Verbosity_INFO in every way. + Verbosity_0 = 0, + + // Verbosity levels 1-9 are generally not written to stderr, but are written to file. + Verbosity_1 = +1, + Verbosity_2 = +2, + Verbosity_3 = +3, + Verbosity_4 = +4, + Verbosity_5 = +5, + Verbosity_6 = +6, + Verbosity_7 = +7, + Verbosity_8 = +8, + Verbosity_9 = +9, + + // Don not use higher verbosity levels, as that will make grepping log files harder. + Verbosity_MAX = +9, + }; + + struct Message + { + // You would generally print a Message by just concating the buffers without spacing. + // Optionally, ignore preamble and indentation. + Verbosity verbosity; // Already part of preamble + const char* filename; // Already part of preamble + unsigned line; // Already part of preamble + const char* preamble; // Date, time, uptime, thread, file:line, verbosity. + const char* indentation; // Just a bunch of spacing. + const char* prefix; // Assertion failure info goes here (or ""). + const char* message; // User message goes here. + }; + + /* Everything with a verbosity equal or greater than g_stderr_verbosity will be + written to stderr. You can set this in code or via the -v argument. + Set to loguru::Verbosity_OFF to write nothing to stderr. + Default is 0, i.e. only log ERROR, WARNING and INFO are written to stderr. + */ + LOGURU_EXPORT extern Verbosity g_stderr_verbosity; + LOGURU_EXPORT extern bool g_colorlogtostderr; // True by default. + LOGURU_EXPORT extern unsigned g_flush_interval_ms; // 0 (unbuffered) by default. + LOGURU_EXPORT extern bool g_preamble; // Prefix each log line with date, time etc? True by default. + + /* Specify the verbosity used by loguru to log its info messages including the header + logged when logged::init() is called or on exit. Default is 0 (INFO). + */ + LOGURU_EXPORT extern Verbosity g_internal_verbosity; + + // Turn off individual parts of the preamble + LOGURU_EXPORT extern bool g_preamble_date; // The date field + LOGURU_EXPORT extern bool g_preamble_time; // The time of the current day + LOGURU_EXPORT extern bool g_preamble_uptime; // The time since init call + LOGURU_EXPORT extern bool g_preamble_thread; // The logging thread + LOGURU_EXPORT extern bool g_preamble_file; // The file from which the log originates from + LOGURU_EXPORT extern bool g_preamble_verbose; // The verbosity field + LOGURU_EXPORT extern bool g_preamble_pipe; // The pipe symbol right before the message + + // May not throw! + typedef void (*log_handler_t)(void* user_data, const Message& message); + typedef void (*close_handler_t)(void* user_data); + typedef void (*flush_handler_t)(void* user_data); + + // May throw if that's how you'd like to handle your errors. + typedef void (*fatal_handler_t)(const Message& message); + + // Given a verbosity level, return the level's name or nullptr. + typedef const char* (*verbosity_to_name_t)(Verbosity verbosity); + + // Given a verbosity level name, return the verbosity level or + // Verbosity_INVALID if name is not recognized. + typedef Verbosity (*name_to_verbosity_t)(const char* name); + + // Runtime options passed to loguru::init + struct Options + { + // This allows you to use something else instead of "-v" via verbosity_flag. + // Set to nullptr to if you don't want Loguru to parse verbosity from the args.' + const char* verbosity_flag = "-v"; + + // loguru::init will set the name of the calling thread to this. + // If you don't want Loguru to set the name of the main thread, + // set this to nullptr. + // NOTE: on SOME platforms loguru::init will only overwrite the thread name + // if a thread name has not already been set. + // To always set a thread name, use loguru::set_thread_name instead. + const char* main_thread_name = "main thread"; + + // Make Loguru try to do unsafe but useful things, + // like printing a stack trace, when catching signals. + // This may lead to bad things like deadlocks in certain situations. + bool unsafe_signal_handler = true; + }; + + /* Should be called from the main thread. + You don't *need* to call this, but if you do you get: + * Signal handlers installed + * Program arguments logged + * Working dir logged + * Optional -v verbosity flag parsed + * Main thread name set to "main thread" + * Explanation of the preamble (date, threanmae etc) logged + + loguru::init() will look for arguments meant for loguru and remove them. + Arguments meant for loguru are: + -v n Set loguru::g_stderr_verbosity level. Examples: + -v 3 Show verbosity level 3 and lower. + -v 0 Only show INFO, WARNING, ERROR, FATAL (default). + -v INFO Only show INFO, WARNING, ERROR, FATAL (default). + -v WARNING Only show WARNING, ERROR, FATAL. + -v ERROR Only show ERROR, FATAL. + -v FATAL Only show FATAL. + -v OFF Turn off logging to stderr. + + Tip: You can set g_stderr_verbosity before calling loguru::init. + That way you can set the default but have the user override it with the -v flag. + Note that -v does not affect file logging (see loguru::add_file). + + You can you something other than the -v flag by setting the verbosity_flag option. + */ + LOGURU_EXPORT + void init(int& argc, char* argv[], const Options& options = {}); + + // Will call remove_all_callbacks(). After calling this, logging will still go to stderr. + // You generally don't need to call this. + LOGURU_EXPORT + void shutdown(); + + // What ~ will be replaced with, e.g. "/home/your_user_name/" + LOGURU_EXPORT + const char* home_dir(); + + /* Returns the name of the app as given in argv[0] but without leading path. + That is, if argv[0] is "../foo/app" this will return "app". + */ + LOGURU_EXPORT + const char* argv0_filename(); + + // Returns all arguments given to loguru::init(), but escaped with a single space as separator. + LOGURU_EXPORT + const char* arguments(); + + // Returns the path to the current working dir when loguru::init() was called. + LOGURU_EXPORT + const char* current_dir(); + + // Returns the part of the path after the last / or \ (if any). + LOGURU_EXPORT + const char* filename(const char* path); + + // e.g. "foo/bar/baz.ext" will create the directories "foo/" and "foo/bar/" + LOGURU_EXPORT + bool create_directories(const char* file_path_const); + + // Writes date and time with millisecond precision, e.g. "20151017_161503.123" + LOGURU_EXPORT + void write_date_time(char* buff, unsigned buff_size); + + // Helper: thread-safe version strerror + LOGURU_EXPORT + Text errno_as_text(); + + /* Given a prefix of e.g. "~/loguru/" this might return + "/home/your_username/loguru/app_name/20151017_161503.123.log" + + where "app_name" is a sanitized version of argv[0]. + */ + LOGURU_EXPORT + void suggest_log_path(const char* prefix, char* buff, unsigned buff_size); + + enum FileMode { Truncate, Append }; + + /* Will log to a file at the given path. + Any logging message with a verbosity lower or equal to + the given verbosity will be included. + The function will create all directories in 'path' if needed. + If path starts with a ~, it will be replaced with loguru::home_dir() + To stop the file logging, just call loguru::remove_callback(path) with the same path. + */ + LOGURU_EXPORT + bool add_file(const char* path, FileMode mode, Verbosity verbosity); + + /* Will be called right before abort(). + You can for instance use this to print custom error messages, or throw an exception. + Feel free to call LOG:ing function from this, but not FATAL ones! */ + LOGURU_EXPORT + void set_fatal_handler(fatal_handler_t handler); + + // Get the current fatal handler, if any. Default value is nullptr. + LOGURU_EXPORT + fatal_handler_t get_fatal_handler(); + + /* Will be called on each log messages with a verbosity less or equal to the given one. + Useful for displaying messages on-screen in a game, for example. + The given on_close is also expected to flush (if desired). + */ + LOGURU_EXPORT + void add_callback( + const char* id, + log_handler_t callback, + void* user_data, + Verbosity verbosity, + close_handler_t on_close = nullptr, + flush_handler_t on_flush = nullptr); + + /* Set a callback that returns custom verbosity level names. If callback + is nullptr or returns nullptr, default log names will be used. + */ + LOGURU_EXPORT + void set_verbosity_to_name_callback(verbosity_to_name_t callback); + + /* Set a callback that returns the verbosity level matching a name. The + callback should return Verbosity_INVALID if the name is not + recognized. + */ + LOGURU_EXPORT + void set_name_to_verbosity_callback(name_to_verbosity_t callback); + + /* Get a custom name for a specific verbosity, if one exists, or nullptr. */ + LOGURU_EXPORT + const char* get_verbosity_name(Verbosity verbosity); + + /* Get the verbosity enum value from a custom 4-character level name, if one exists. + If the name does not match a custom level name, Verbosity_INVALID is returned. + */ + LOGURU_EXPORT + Verbosity get_verbosity_from_name(const char* name); + + // Returns true iff the callback was found (and removed). + LOGURU_EXPORT + bool remove_callback(const char* id); + + // Shut down all file logging and any other callback hooks installed. + LOGURU_EXPORT + void remove_all_callbacks(); + + // Returns the maximum of g_stderr_verbosity and all file/custom outputs. + LOGURU_EXPORT + Verbosity current_verbosity_cutoff(); + +#if LOGURU_USE_FMTLIB + // Internal functions + void vlog(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, fmt::format_args args); + void raw_vlog(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, fmt::format_args args); + + // Actual logging function. Use the LOG macro instead of calling this directly. + template + LOGURU_EXPORT + void log(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, const Args &... args) { + vlog(verbosity, file, line, format, fmt::make_format_args(args...)); + } + + // Log without any preamble or indentation. + template + LOGURU_EXPORT + void raw_log(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, const Args &... args) { + raw_vlog(verbosity, file, line, format, fmt::make_format_args(args...)); + } +#else // LOGURU_USE_FMTLIB? + // Actual logging function. Use the LOG macro instead of calling this directly. + LOGURU_EXPORT + void log(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, ...) LOGURU_PRINTF_LIKE(4, 5); + + // Log without any preamble or indentation. + LOGURU_EXPORT + void raw_log(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, ...) LOGURU_PRINTF_LIKE(4, 5); +#endif // !LOGURU_USE_FMTLIB + + // Helper class for LOG_SCOPE_F + class LOGURU_EXPORT LogScopeRAII + { + public: + LogScopeRAII() : _file(nullptr) {} // No logging + LogScopeRAII(Verbosity verbosity, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, ...) LOGURU_PRINTF_LIKE(5, 6); + ~LogScopeRAII(); + +#if defined(_MSC_VER) && _MSC_VER > 1800 + // older MSVC default move ctors close the scope on move. See + // issue #43 + LogScopeRAII(LogScopeRAII&& other) + : _verbosity(other._verbosity) + , _file(other._file) + , _line(other._line) + , _indent_stderr(other._indent_stderr) + , _start_time_ns(other._start_time_ns) + { + // Make sure the tmp object's destruction doesn't close the scope: + other._file = nullptr; + + for (unsigned int i = 0; i < LOGURU_SCOPE_TEXT_SIZE; ++i) { + _name[i] = other._name[i]; + } + } +#else + LogScopeRAII(LogScopeRAII&&) = default; +#endif + + private: + LogScopeRAII(const LogScopeRAII&) = delete; + LogScopeRAII& operator=(const LogScopeRAII&) = delete; + void operator=(LogScopeRAII&&) = delete; + + Verbosity _verbosity; + const char* _file; // Set to null if we are disabled due to verbosity + unsigned _line; + bool _indent_stderr; // Did we? + long long _start_time_ns; + char _name[LOGURU_SCOPE_TEXT_SIZE]; + }; + + // Marked as 'noreturn' for the benefit of the static analyzer and optimizer. + // stack_trace_skip is the number of extrace stack frames to skip above log_and_abort. +#if LOGURU_USE_FMTLIB + LOGURU_EXPORT + LOGURU_NORETURN void vlog_and_abort(int stack_trace_skip, const char* expr, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, fmt::format_args); + template + LOGURU_EXPORT + LOGURU_NORETURN void log_and_abort(int stack_trace_skip, const char* expr, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, const Args&... args) { + vlog_and_abort(stack_trace_skip, expr, file, line, format, fmt::make_format_args(args...)); + } +#else + LOGURU_EXPORT + LOGURU_NORETURN void log_and_abort(int stack_trace_skip, const char* expr, const char* file, unsigned line, LOGURU_FORMAT_STRING_TYPE format, ...) LOGURU_PRINTF_LIKE(5, 6); +#endif + LOGURU_EXPORT + LOGURU_NORETURN void log_and_abort(int stack_trace_skip, const char* expr, const char* file, unsigned line); + + // Flush output to stderr and files. + // If g_flush_interval_ms is set to non-zero, this will be called automatically this often. + // If not set, you do not need to call this at all. + LOGURU_EXPORT + void flush(); + + template inline Text format_value(const T&) { return textprintf("N/A"); } + template<> inline Text format_value(const char& v) { return textprintf(LOGURU_FMT(c), v); } + template<> inline Text format_value(const int& v) { return textprintf(LOGURU_FMT(d), v); } + template<> inline Text format_value(const unsigned int& v) { return textprintf(LOGURU_FMT(u), v); } + template<> inline Text format_value(const long& v) { return textprintf(LOGURU_FMT(lu), v); } + template<> inline Text format_value(const unsigned long& v) { return textprintf(LOGURU_FMT(ld), v); } + template<> inline Text format_value(const long long& v) { return textprintf(LOGURU_FMT(llu), v); } + template<> inline Text format_value(const unsigned long long& v) { return textprintf(LOGURU_FMT(lld), v); } + template<> inline Text format_value(const float& v) { return textprintf(LOGURU_FMT(f), v); } + template<> inline Text format_value(const double& v) { return textprintf(LOGURU_FMT(f), v); } + + /* Thread names can be set for the benefit of readable logs. + If you do not set the thread name, a hex id will be shown instead. + These thread names may or may not be the same as the system thread names, + depending on the system. + Try to limit the thread name to 15 characters or less. */ + LOGURU_EXPORT + void set_thread_name(const char* name); + + /* Returns the thread name for this thread. + On OSX this will return the system thread name (settable from both within and without Loguru). + On other systems it will return whatever you set in set_thread_name(); + If no thread name is set, this will return a hexadecimal thread id. + length should be the number of bytes available in the buffer. + 17 is a good number for length. + right_align_hext_id means any hexadecimal thread id will be written to the end of buffer. + */ + LOGURU_EXPORT + void get_thread_name(char* buffer, unsigned long long length, bool right_align_hext_id); + + /* Generates a readable stacktrace as a string. + 'skip' specifies how many stack frames to skip. + For instance, the default skip (1) means: + don't include the call to loguru::stacktrace in the stack trace. */ + LOGURU_EXPORT + Text stacktrace(int skip = 1); + + /* Add a string to be replaced with something else in the stack output. + + For instance, instead of having a stack trace look like this: + 0x41f541 some_function(std::basic_ofstream >&) + You can clean it up with: + auto verbose_type_name = loguru::demangle(typeid(std::ofstream).name()); + loguru::add_stack_cleanup(verbose_type_name.c_str(); "std::ofstream"); + So the next time you will instead see: + 0x41f541 some_function(std::ofstream&) + + `replace_with_this` must be shorter than `find_this`. + */ + LOGURU_EXPORT + void add_stack_cleanup(const char* find_this, const char* replace_with_this); + + // Example: demangle(typeid(std::ofstream).name()) -> "std::basic_ofstream >" + LOGURU_EXPORT + Text demangle(const char* name); + + // ------------------------------------------------------------------------ + /* + Not all terminals support colors, but if they do, and g_colorlogtostderr + is set, Loguru will write them to stderr to make errors in red, etc. + + You also have the option to manually use them, via the function below. + + Note, however, that if you do, the color codes could end up in your logfile! + + This means if you intend to use them functions you should either: + * Use them on the stderr/stdout directly (bypass Loguru). + * Don't add file outputs to Loguru. + * Expect some \e[1m things in your logfile. + + Usage: + printf("%sRed%sGreen%sBold green%sClear again\n", + loguru::terminal_red(), loguru::terminal_green(), + loguru::terminal_bold(), loguru::terminal_reset()); + + If the terminal at hand does not support colors the above output + will just not have funky \e[1m things showing. + */ + + // Do the output terminal support colors? + LOGURU_EXPORT + bool terminal_has_color(); + + // Colors + LOGURU_EXPORT const char* terminal_black(); + LOGURU_EXPORT const char* terminal_red(); + LOGURU_EXPORT const char* terminal_green(); + LOGURU_EXPORT const char* terminal_yellow(); + LOGURU_EXPORT const char* terminal_blue(); + LOGURU_EXPORT const char* terminal_purple(); + LOGURU_EXPORT const char* terminal_cyan(); + LOGURU_EXPORT const char* terminal_light_gray(); + LOGURU_EXPORT const char* terminal_light_red(); + LOGURU_EXPORT const char* terminal_white(); + + // Formating + LOGURU_EXPORT const char* terminal_bold(); + LOGURU_EXPORT const char* terminal_underline(); + + // You should end each line with this! + LOGURU_EXPORT const char* terminal_reset(); + + // -------------------------------------------------------------------- + // Error context related: + + struct StringStream; + + // Use this in your EcEntryBase::print_value overload. + LOGURU_EXPORT + void stream_print(StringStream& out_string_stream, const char* text); + + class LOGURU_EXPORT EcEntryBase + { + public: + EcEntryBase(const char* file, unsigned line, const char* descr); + ~EcEntryBase(); + EcEntryBase(const EcEntryBase&) = delete; + EcEntryBase(EcEntryBase&&) = delete; + EcEntryBase& operator=(const EcEntryBase&) = delete; + EcEntryBase& operator=(EcEntryBase&&) = delete; + + virtual void print_value(StringStream& out_string_stream) const = 0; + + EcEntryBase* previous() const { return _previous; } + + // private: + const char* _file; + unsigned _line; + const char* _descr; + EcEntryBase* _previous; + }; + + template + class EcEntryData : public EcEntryBase + { + public: + using Printer = Text(*)(T data); + + EcEntryData(const char* file, unsigned line, const char* descr, T data, Printer&& printer) + : EcEntryBase(file, line, descr), _data(data), _printer(printer) {} + + virtual void print_value(StringStream& out_string_stream) const override + { + const auto str = _printer(_data); + stream_print(out_string_stream, str.c_str()); + } + + private: + T _data; + Printer _printer; + }; + + // template + // class EcEntryLambda : public EcEntryBase + // { + // public: + // EcEntryLambda(const char* file, unsigned line, const char* descr, Printer&& printer) + // : EcEntryBase(file, line, descr), _printer(std::move(printer)) {} + + // virtual void print_value(StringStream& out_string_stream) const override + // { + // const auto str = _printer(); + // stream_print(out_string_stream, str.c_str()); + // } + + // private: + // Printer _printer; + // }; + + // template + // EcEntryLambda make_ec_entry_lambda(const char* file, unsigned line, const char* descr, Printer&& printer) + // { + // return {file, line, descr, std::move(printer)}; + // } + + template + struct decay_char_array { using type = T; }; + + template + struct decay_char_array { using type = const char*; }; + + template + struct make_const_ptr { using type = T; }; + + template + struct make_const_ptr { using type = const T*; }; + + template + struct make_ec_type { using type = typename make_const_ptr::type>::type; }; + + /* A stack trace gives you the names of the function at the point of a crash. + With ERROR_CONTEXT, you can also get the values of select local variables. + Usage: + + void process_customers(const std::string& filename) + { + ERROR_CONTEXT("Processing file", filename.c_str()); + for (int customer_index : ...) + { + ERROR_CONTEXT("Customer index", customer_index); + ... + } + } + + The context is in effect during the scope of the ERROR_CONTEXT. + Use loguru::get_error_context() to get the contents of the active error contexts. + + Example result: + + ------------------------------------------------ + [ErrorContext] main.cpp:416 Processing file: "customers.json" + [ErrorContext] main.cpp:417 Customer index: 42 + ------------------------------------------------ + + Error contexts are printed automatically on crashes, and only on crashes. + This makes them much faster than logging the value of a variable. + */ + #define ERROR_CONTEXT(descr, data) \ + const loguru::EcEntryData::type> \ + LOGURU_ANONYMOUS_VARIABLE(error_context_scope_)( \ + __FILE__, __LINE__, descr, data, \ + static_cast::type>::Printer>(loguru::ec_to_text) ) // For better error messages + +/* + #define ERROR_CONTEXT(descr, data) \ + const auto LOGURU_ANONYMOUS_VARIABLE(error_context_scope_)( \ + loguru::make_ec_entry_lambda(__FILE__, __LINE__, descr, \ + [=](){ return loguru::ec_to_text(data); })) +*/ + + using EcHandle = const EcEntryBase*; + + /* + Get a light-weight handle to the error context stack on this thread. + The handle is valid as long as the current thread has no changes to its error context stack. + You can pass the handle to loguru::get_error_context on another thread. + This can be very useful for when you have a parent thread spawning several working threads, + and you want the error context of the parent thread to get printed (too) when there is an + error on the child thread. You can accomplish this thusly: + + void foo(const char* parameter) + { + ERROR_CONTEXT("parameter", parameter) + const auto parent_ec_handle = loguru::get_thread_ec_handle(); + + std::thread([=]{ + loguru::set_thread_name("child thread"); + ERROR_CONTEXT("parent context", parent_ec_handle); + dangerous_code(); + }.join(); + } + + */ + LOGURU_EXPORT + EcHandle get_thread_ec_handle(); + + // Get a string describing the current stack of error context. Empty string if there is none. + LOGURU_EXPORT + Text get_error_context(); + + // Get a string describing the error context of the given thread handle. + LOGURU_EXPORT + Text get_error_context_for(EcHandle ec_handle); + + // ------------------------------------------------------------------------ + + LOGURU_EXPORT Text ec_to_text(const char* data); + LOGURU_EXPORT Text ec_to_text(char data); + LOGURU_EXPORT Text ec_to_text(int data); + LOGURU_EXPORT Text ec_to_text(unsigned int data); + LOGURU_EXPORT Text ec_to_text(long data); + LOGURU_EXPORT Text ec_to_text(unsigned long data); + LOGURU_EXPORT Text ec_to_text(long long data); + LOGURU_EXPORT Text ec_to_text(unsigned long long data); + LOGURU_EXPORT Text ec_to_text(float data); + LOGURU_EXPORT Text ec_to_text(double data); + LOGURU_EXPORT Text ec_to_text(long double data); + LOGURU_EXPORT Text ec_to_text(EcHandle); + + /* + You can add ERROR_CONTEXT support for your own types by overloading ec_to_text. Here's how: + + some.hpp: + namespace loguru { + Text ec_to_text(MySmallType data) + Text ec_to_text(const MyBigType* data) + } // namespace loguru + + some.cpp: + namespace loguru { + Text ec_to_text(MySmallType small_value) + { + // Called only when needed, i.e. on a crash. + std::string str = small_value.as_string(); // Format 'small_value' here somehow. + return Text{STRDUP(str.c_str())}; + } + + Text ec_to_text(const MyBigType* big_value) + { + // Called only when needed, i.e. on a crash. + std::string str = big_value->as_string(); // Format 'big_value' here somehow. + return Text{STRDUP(str.c_str())}; + } + } // namespace loguru + + Any file that include some.hpp: + void foo(MySmallType small, const MyBigType& big) + { + ERROR_CONTEXT("Small", small); // Copy ´small` by value. + ERROR_CONTEXT("Big", &big); // `big` should not change during this scope! + .... + } + */ +} // namespace loguru + +// -------------------------------------------------------------------- +// Logging macros + +// LOG_F(2, "Only logged if verbosity is 2 or higher: %d", some_number); +#define VLOG_F(verbosity, ...) \ + ((verbosity) > loguru::current_verbosity_cutoff()) ? (void)0 \ + : loguru::log(verbosity, __FILE__, __LINE__, __VA_ARGS__) + +// LOG_F(INFO, "Foo: %d", some_number); +#define LOG_F(verbosity_name, ...) VLOG_F(loguru::Verbosity_ ## verbosity_name, __VA_ARGS__) + +#define VLOG_IF_F(verbosity, cond, ...) \ + ((verbosity) > loguru::current_verbosity_cutoff() || (cond) == false) \ + ? (void)0 \ + : loguru::log(verbosity, __FILE__, __LINE__, __VA_ARGS__) + +#define LOG_IF_F(verbosity_name, cond, ...) \ + VLOG_IF_F(loguru::Verbosity_ ## verbosity_name, cond, __VA_ARGS__) + +#define VLOG_SCOPE_F(verbosity, ...) \ + loguru::LogScopeRAII LOGURU_ANONYMOUS_VARIABLE(error_context_RAII_) = \ + ((verbosity) > loguru::current_verbosity_cutoff()) ? loguru::LogScopeRAII() : \ + loguru::LogScopeRAII(verbosity, __FILE__, __LINE__, __VA_ARGS__) + +// Raw logging - no preamble, no indentation. Slightly faster than full logging. +#define RAW_VLOG_F(verbosity, ...) \ + ((verbosity) > loguru::current_verbosity_cutoff()) ? (void)0 \ + : loguru::raw_log(verbosity, __FILE__, __LINE__, __VA_ARGS__) + +#define RAW_LOG_F(verbosity_name, ...) RAW_VLOG_F(loguru::Verbosity_ ## verbosity_name, __VA_ARGS__) + +// Use to book-end a scope. Affects logging on all threads. +#define LOG_SCOPE_F(verbosity_name, ...) \ + VLOG_SCOPE_F(loguru::Verbosity_ ## verbosity_name, __VA_ARGS__) + +#define LOG_SCOPE_FUNCTION(verbosity_name) LOG_SCOPE_F(verbosity_name, __func__) + +// ----------------------------------------------- +// ABORT_F macro. Usage: ABORT_F("Cause of error: %s", error_str); + +// Message is optional +#define ABORT_F(...) loguru::log_and_abort(0, "ABORT: ", __FILE__, __LINE__, __VA_ARGS__) + +// -------------------------------------------------------------------- +// CHECK_F macros: + +#define CHECK_WITH_INFO_F(test, info, ...) \ + LOGURU_PREDICT_TRUE((test) == true) ? (void)0 : loguru::log_and_abort(0, "CHECK FAILED: " info " ", __FILE__, \ + __LINE__, ##__VA_ARGS__) + +/* Checked at runtime too. Will print error, then call fatal_handler (if any), then 'abort'. + Note that the test must be boolean. + CHECK_F(ptr); will not compile, but CHECK_F(ptr != nullptr); will. */ +#define CHECK_F(test, ...) CHECK_WITH_INFO_F(test, #test, ##__VA_ARGS__) + +#define CHECK_NOTNULL_F(x, ...) CHECK_WITH_INFO_F((x) != nullptr, #x " != nullptr", ##__VA_ARGS__) + +#define CHECK_OP_F(expr_left, expr_right, op, ...) \ + do \ + { \ + auto val_left = expr_left; \ + auto val_right = expr_right; \ + if (! LOGURU_PREDICT_TRUE(val_left op val_right)) \ + { \ + auto str_left = loguru::format_value(val_left); \ + auto str_right = loguru::format_value(val_right); \ + auto fail_info = loguru::textprintf("CHECK FAILED: " LOGURU_FMT(s) " " LOGURU_FMT(s) " " LOGURU_FMT(s) " (" LOGURU_FMT(s) " " LOGURU_FMT(s) " " LOGURU_FMT(s) ") ", \ + #expr_left, #op, #expr_right, str_left.c_str(), #op, str_right.c_str()); \ + auto user_msg = loguru::textprintf(__VA_ARGS__); \ + loguru::log_and_abort(0, fail_info.c_str(), __FILE__, __LINE__, \ + LOGURU_FMT(s), user_msg.c_str()); \ + } \ + } while (false) + +#ifndef LOGURU_DEBUG_LOGGING + #ifndef NDEBUG + #define LOGURU_DEBUG_LOGGING 1 + #else + #define LOGURU_DEBUG_LOGGING 0 + #endif +#endif + +#if LOGURU_DEBUG_LOGGING + // Debug logging enabled: + #define DLOG_F(verbosity_name, ...) LOG_F(verbosity_name, __VA_ARGS__) + #define DVLOG_F(verbosity, ...) VLOG_F(verbosity, __VA_ARGS__) + #define DLOG_IF_F(verbosity_name, ...) LOG_IF_F(verbosity_name, __VA_ARGS__) + #define DVLOG_IF_F(verbosity, ...) VLOG_IF_F(verbosity, __VA_ARGS__) + #define DRAW_LOG_F(verbosity_name, ...) RAW_LOG_F(verbosity_name, __VA_ARGS__) + #define DRAW_VLOG_F(verbosity, ...) RAW_VLOG_F(verbosity, __VA_ARGS__) +#else + // Debug logging disabled: + #define DLOG_F(verbosity_name, ...) + #define DVLOG_F(verbosity, ...) + #define DLOG_IF_F(verbosity_name, ...) + #define DVLOG_IF_F(verbosity, ...) + #define DRAW_LOG_F(verbosity_name, ...) + #define DRAW_VLOG_F(verbosity, ...) +#endif + +#define CHECK_EQ_F(a, b, ...) CHECK_OP_F(a, b, ==, ##__VA_ARGS__) +#define CHECK_NE_F(a, b, ...) CHECK_OP_F(a, b, !=, ##__VA_ARGS__) +#define CHECK_LT_F(a, b, ...) CHECK_OP_F(a, b, < , ##__VA_ARGS__) +#define CHECK_GT_F(a, b, ...) CHECK_OP_F(a, b, > , ##__VA_ARGS__) +#define CHECK_LE_F(a, b, ...) CHECK_OP_F(a, b, <=, ##__VA_ARGS__) +#define CHECK_GE_F(a, b, ...) CHECK_OP_F(a, b, >=, ##__VA_ARGS__) + +#ifndef LOGURU_DEBUG_CHECKS + #ifndef NDEBUG + #define LOGURU_DEBUG_CHECKS 1 + #else + #define LOGURU_DEBUG_CHECKS 0 + #endif +#endif + +#if LOGURU_DEBUG_CHECKS + // Debug checks enabled: + #define DCHECK_F(test, ...) CHECK_F(test, ##__VA_ARGS__) + #define DCHECK_NOTNULL_F(x, ...) CHECK_NOTNULL_F(x, ##__VA_ARGS__) + #define DCHECK_EQ_F(a, b, ...) CHECK_EQ_F(a, b, ##__VA_ARGS__) + #define DCHECK_NE_F(a, b, ...) CHECK_NE_F(a, b, ##__VA_ARGS__) + #define DCHECK_LT_F(a, b, ...) CHECK_LT_F(a, b, ##__VA_ARGS__) + #define DCHECK_LE_F(a, b, ...) CHECK_LE_F(a, b, ##__VA_ARGS__) + #define DCHECK_GT_F(a, b, ...) CHECK_GT_F(a, b, ##__VA_ARGS__) + #define DCHECK_GE_F(a, b, ...) CHECK_GE_F(a, b, ##__VA_ARGS__) +#else + // Debug checks disabled: + #define DCHECK_F(test, ...) + #define DCHECK_NOTNULL_F(x, ...) + #define DCHECK_EQ_F(a, b, ...) + #define DCHECK_NE_F(a, b, ...) + #define DCHECK_LT_F(a, b, ...) + #define DCHECK_LE_F(a, b, ...) + #define DCHECK_GT_F(a, b, ...) + #define DCHECK_GE_F(a, b, ...) +#endif // NDEBUG + + +#if LOGURU_REDEFINE_ASSERT + #undef assert + #ifndef NDEBUG + // Debug: + #define assert(test) CHECK_WITH_INFO_F(!!(test), #test) // HACK + #else + #define assert(test) + #endif +#endif // LOGURU_REDEFINE_ASSERT + +#endif // LOGURU_HAS_DECLARED_FORMAT_HEADER + +// ---------------------------------------------------------------------------- +// .dP"Y8 888888 88""Yb 888888 db 8b d8 .dP"Y8 +// `Ybo." 88 88__dP 88__ dPYb 88b d88 `Ybo." +// o.`Y8b 88 88"Yb 88"" dP__Yb 88YbdP88 o.`Y8b +// 8bodP' 88 88 Yb 888888 dP""""Yb 88 YY 88 8bodP' + +#if LOGURU_WITH_STREAMS +#ifndef LOGURU_HAS_DECLARED_STREAMS_HEADER +#define LOGURU_HAS_DECLARED_STREAMS_HEADER + +/* This file extends loguru to enable std::stream-style logging, a la Glog. + It's an optional feature behind the LOGURU_WITH_STREAMS settings + because including it everywhere will slow down compilation times. +*/ + +#include +#include // Adds about 38 kLoC on clang. +#include + +namespace loguru +{ + // Like sprintf, but returns the formated text. + LOGURU_EXPORT + std::string strprintf(LOGURU_FORMAT_STRING_TYPE format, ...) LOGURU_PRINTF_LIKE(1, 2); + + // Like vsprintf, but returns the formated text. + LOGURU_EXPORT + std::string vstrprintf(LOGURU_FORMAT_STRING_TYPE format, va_list) LOGURU_PRINTF_LIKE(1, 0); + + class LOGURU_EXPORT StreamLogger + { + public: + StreamLogger(Verbosity verbosity, const char* file, unsigned line) : _verbosity(verbosity), _file(file), _line(line) {} + ~StreamLogger() noexcept(false); + + template + StreamLogger& operator<<(const T& t) + { + _ss << t; + return *this; + } + + // std::endl and other iomanip:s. + StreamLogger& operator<<(std::ostream&(*f)(std::ostream&)) + { + f(_ss); + return *this; + } + + private: + Verbosity _verbosity; + const char* _file; + unsigned _line; + std::ostringstream _ss; + }; + + class LOGURU_EXPORT AbortLogger + { + public: + AbortLogger(const char* expr, const char* file, unsigned line) : _expr(expr), _file(file), _line(line) { } + LOGURU_NORETURN ~AbortLogger() noexcept(false); + + template + AbortLogger& operator<<(const T& t) + { + _ss << t; + return *this; + } + + // std::endl and other iomanip:s. + AbortLogger& operator<<(std::ostream&(*f)(std::ostream&)) + { + f(_ss); + return *this; + } + + private: + const char* _expr; + const char* _file; + unsigned _line; + std::ostringstream _ss; + }; + + class LOGURU_EXPORT Voidify + { + public: + Voidify() {} + // This has to be an operator with a precedence lower than << but higher than ?: + void operator&(const StreamLogger&) { } + void operator&(const AbortLogger&) { } + }; + + /* Helper functions for CHECK_OP_S macro. + GLOG trick: The (int, int) specialization works around the issue that the compiler + will not instantiate the template version of the function on values of unnamed enum type. */ + #define DEFINE_CHECK_OP_IMPL(name, op) \ + template \ + inline std::string* name(const char* expr, const T1& v1, const char* op_str, const T2& v2) \ + { \ + if (LOGURU_PREDICT_TRUE(v1 op v2)) { return NULL; } \ + std::ostringstream ss; \ + ss << "CHECK FAILED: " << expr << " (" << v1 << " " << op_str << " " << v2 << ") "; \ + return new std::string(ss.str()); \ + } \ + inline std::string* name(const char* expr, int v1, const char* op_str, int v2) \ + { \ + return name(expr, v1, op_str, v2); \ + } + + DEFINE_CHECK_OP_IMPL(check_EQ_impl, ==) + DEFINE_CHECK_OP_IMPL(check_NE_impl, !=) + DEFINE_CHECK_OP_IMPL(check_LE_impl, <=) + DEFINE_CHECK_OP_IMPL(check_LT_impl, < ) + DEFINE_CHECK_OP_IMPL(check_GE_impl, >=) + DEFINE_CHECK_OP_IMPL(check_GT_impl, > ) + #undef DEFINE_CHECK_OP_IMPL + + /* GLOG trick: Function is overloaded for integral types to allow static const integrals + declared in classes and not defined to be used as arguments to CHECK* macros. */ + template + inline const T& referenceable_value(const T& t) { return t; } + inline char referenceable_value(char t) { return t; } + inline unsigned char referenceable_value(unsigned char t) { return t; } + inline signed char referenceable_value(signed char t) { return t; } + inline short referenceable_value(short t) { return t; } + inline unsigned short referenceable_value(unsigned short t) { return t; } + inline int referenceable_value(int t) { return t; } + inline unsigned int referenceable_value(unsigned int t) { return t; } + inline long referenceable_value(long t) { return t; } + inline unsigned long referenceable_value(unsigned long t) { return t; } + inline long long referenceable_value(long long t) { return t; } + inline unsigned long long referenceable_value(unsigned long long t) { return t; } +} // namespace loguru + +// ----------------------------------------------- +// Logging macros: + +// usage: LOG_STREAM(INFO) << "Foo " << std::setprecision(10) << some_value; +#define VLOG_IF_S(verbosity, cond) \ + ((verbosity) > loguru::current_verbosity_cutoff() || (cond) == false) \ + ? (void)0 \ + : loguru::Voidify() & loguru::StreamLogger(verbosity, __FILE__, __LINE__) +#define LOG_IF_S(verbosity_name, cond) VLOG_IF_S(loguru::Verbosity_ ## verbosity_name, cond) +#define VLOG_S(verbosity) VLOG_IF_S(verbosity, true) +#define LOG_S(verbosity_name) VLOG_S(loguru::Verbosity_ ## verbosity_name) + +// ----------------------------------------------- +// ABORT_S macro. Usage: ABORT_S() << "Causo of error: " << details; + +#define ABORT_S() loguru::Voidify() & loguru::AbortLogger("ABORT: ", __FILE__, __LINE__) + +// ----------------------------------------------- +// CHECK_S macros: + +#define CHECK_WITH_INFO_S(cond, info) \ + LOGURU_PREDICT_TRUE((cond) == true) \ + ? (void)0 \ + : loguru::Voidify() & loguru::AbortLogger("CHECK FAILED: " info " ", __FILE__, __LINE__) + +#define CHECK_S(cond) CHECK_WITH_INFO_S(cond, #cond) +#define CHECK_NOTNULL_S(x) CHECK_WITH_INFO_S((x) != nullptr, #x " != nullptr") + +#define CHECK_OP_S(function_name, expr1, op, expr2) \ + while (auto error_string = loguru::function_name(#expr1 " " #op " " #expr2, \ + loguru::referenceable_value(expr1), #op, \ + loguru::referenceable_value(expr2))) \ + loguru::AbortLogger(error_string->c_str(), __FILE__, __LINE__) + +#define CHECK_EQ_S(expr1, expr2) CHECK_OP_S(check_EQ_impl, expr1, ==, expr2) +#define CHECK_NE_S(expr1, expr2) CHECK_OP_S(check_NE_impl, expr1, !=, expr2) +#define CHECK_LE_S(expr1, expr2) CHECK_OP_S(check_LE_impl, expr1, <=, expr2) +#define CHECK_LT_S(expr1, expr2) CHECK_OP_S(check_LT_impl, expr1, < , expr2) +#define CHECK_GE_S(expr1, expr2) CHECK_OP_S(check_GE_impl, expr1, >=, expr2) +#define CHECK_GT_S(expr1, expr2) CHECK_OP_S(check_GT_impl, expr1, > , expr2) + +#if LOGURU_DEBUG_LOGGING + // Debug logging enabled: + #define DVLOG_IF_S(verbosity, cond) VLOG_IF_S(verbosity, cond) + #define DLOG_IF_S(verbosity_name, cond) LOG_IF_S(verbosity_name, cond) + #define DVLOG_S(verbosity) VLOG_S(verbosity) + #define DLOG_S(verbosity_name) LOG_S(verbosity_name) +#else + // Debug logging disabled: + #define DVLOG_IF_S(verbosity, cond) \ + (true || (verbosity) > loguru::current_verbosity_cutoff() || (cond) == false) \ + ? (void)0 \ + : loguru::Voidify() & loguru::StreamLogger(verbosity, __FILE__, __LINE__) + + #define DLOG_IF_S(verbosity_name, cond) DVLOG_IF_S(loguru::Verbosity_ ## verbosity_name, cond) + #define DVLOG_S(verbosity) DVLOG_IF_S(verbosity, true) + #define DLOG_S(verbosity_name) DVLOG_S(loguru::Verbosity_ ## verbosity_name) +#endif + +#if LOGURU_DEBUG_CHECKS + // Debug checks enabled: + #define DCHECK_S(cond) CHECK_S(cond) + #define DCHECK_NOTNULL_S(x) CHECK_NOTNULL_S(x) + #define DCHECK_EQ_S(a, b) CHECK_EQ_S(a, b) + #define DCHECK_NE_S(a, b) CHECK_NE_S(a, b) + #define DCHECK_LT_S(a, b) CHECK_LT_S(a, b) + #define DCHECK_LE_S(a, b) CHECK_LE_S(a, b) + #define DCHECK_GT_S(a, b) CHECK_GT_S(a, b) + #define DCHECK_GE_S(a, b) CHECK_GE_S(a, b) +#else +// Debug checks disabled: + #define DCHECK_S(cond) CHECK_S(true || (cond)) + #define DCHECK_NOTNULL_S(x) CHECK_S(true || (x) != nullptr) + #define DCHECK_EQ_S(a, b) CHECK_S(true || (a) == (b)) + #define DCHECK_NE_S(a, b) CHECK_S(true || (a) != (b)) + #define DCHECK_LT_S(a, b) CHECK_S(true || (a) < (b)) + #define DCHECK_LE_S(a, b) CHECK_S(true || (a) <= (b)) + #define DCHECK_GT_S(a, b) CHECK_S(true || (a) > (b)) + #define DCHECK_GE_S(a, b) CHECK_S(true || (a) >= (b)) +#endif + +#if LOGURU_REPLACE_GLOG + #undef LOG + #undef VLOG + #undef LOG_IF + #undef VLOG_IF + #undef CHECK + #undef CHECK_NOTNULL + #undef CHECK_EQ + #undef CHECK_NE + #undef CHECK_LT + #undef CHECK_LE + #undef CHECK_GT + #undef CHECK_GE + #undef DLOG + #undef DVLOG + #undef DLOG_IF + #undef DVLOG_IF + #undef DCHECK + #undef DCHECK_NOTNULL + #undef DCHECK_EQ + #undef DCHECK_NE + #undef DCHECK_LT + #undef DCHECK_LE + #undef DCHECK_GT + #undef DCHECK_GE + #undef VLOG_IS_ON + + #define LOG LOG_S + #define VLOG VLOG_S + #define LOG_IF LOG_IF_S + #define VLOG_IF VLOG_IF_S + #define CHECK(cond) CHECK_S(!!(cond)) + #define CHECK_NOTNULL CHECK_NOTNULL_S + #define CHECK_EQ CHECK_EQ_S + #define CHECK_NE CHECK_NE_S + #define CHECK_LT CHECK_LT_S + #define CHECK_LE CHECK_LE_S + #define CHECK_GT CHECK_GT_S + #define CHECK_GE CHECK_GE_S + #define DLOG DLOG_S + #define DVLOG DVLOG_S + #define DLOG_IF DLOG_IF_S + #define DVLOG_IF DVLOG_IF_S + #define DCHECK DCHECK_S + #define DCHECK_NOTNULL DCHECK_NOTNULL_S + #define DCHECK_EQ DCHECK_EQ_S + #define DCHECK_NE DCHECK_NE_S + #define DCHECK_LT DCHECK_LT_S + #define DCHECK_LE DCHECK_LE_S + #define DCHECK_GT DCHECK_GT_S + #define DCHECK_GE DCHECK_GE_S + #define VLOG_IS_ON(verbosity) ((verbosity) <= loguru::current_verbosity_cutoff()) + +#endif // LOGURU_REPLACE_GLOG + +#endif // LOGURU_WITH_STREAMS + +#endif // LOGURU_HAS_DECLARED_STREAMS_HEADER diff --git a/loguru_bench/CMakeLists.txt b/loguru_bench/CMakeLists.txt new file mode 100644 index 0000000..9604abc --- /dev/null +++ b/loguru_bench/CMakeLists.txt @@ -0,0 +1,22 @@ +cmake_minimum_required(VERSION 2.8) + +project(loguru_bench) + +if(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE "Release" CACHE STRING + "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE) +endif(NOT CMAKE_BUILD_TYPE) + +MESSAGE(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}") + +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Werror -Wall -Wextra") + +file(GLOB source + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +add_executable(loguru_bench ${source}) + +find_package(Threads) +target_link_libraries(loguru_bench ${CMAKE_THREAD_LIBS_INIT}) # For pthreads +target_link_libraries(loguru_bench dl) # For ldl diff --git a/loguru_bench/build_and_run.sh b/loguru_bench/build_and_run.sh new file mode 100755 index 0000000..038426e --- /dev/null +++ b/loguru_bench/build_and_run.sh @@ -0,0 +1,12 @@ +#!/bin/bash +set -e # Fail on error + +ROOT_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd) + +cd "$ROOT_DIR" +mkdir -p build +cd build +cmake .. +make + +./loguru_bench $@ 2>/dev/null diff --git a/loguru_bench/loguru_bench.cpp b/loguru_bench/loguru_bench.cpp new file mode 100644 index 0000000..14cb0d8 --- /dev/null +++ b/loguru_bench/loguru_bench.cpp @@ -0,0 +1,121 @@ +#include +#include +#include +#include +#include + +#define LOGURU_WITH_STREAMS 1 +#define LOGURU_REDEFINE_ASSERT 1 +#include "../loguru.cpp" + +const size_t kNumRuns = 10; +const double kPi = 3.1415926535897932384626433; + +static long long now_ns() +{ + using namespace std::chrono; + return duration_cast(high_resolution_clock::now().time_since_epoch()).count(); +} + +template +void bench(const std::string& name, const Function& function, size_t num_iterations) +{ + function(num_iterations); // Warm-up. + + printf("%-30s ", name.c_str()); + fflush(stdout); + std::vector times; + double sum = 0; + for (size_t i = 0; i < kNumRuns; ++i) { + auto start_ns = now_ns(); + function(num_iterations); + double total_time_sec = (now_ns() - start_ns) * 1e-9; + times.push_back(total_time_sec / num_iterations); + sum += times.back(); + } + + double mean = sum / kNumRuns; + double std_dev_sum = 0; + + for (double time : times) { + std_dev_sum += (time - mean) * (time - mean); + } + + double variance = std::sqrt(std_dev_sum / kNumRuns); + + printf("%6.3f ± %.3f μs per call\n", mean * 1e6, variance * 1e6); + fflush(stdout); +} + +// ---------------------------------------------------------------------------- + +void format_strings(size_t num_iterations) +{ + for (size_t i = 0; i < num_iterations; ++i) { + LOG_F(WARNING, "Some long, complex message."); + } + loguru::flush(); +} + +void format_float(size_t num_iterations) +{ + for (size_t i = 0; i < num_iterations; ++i) { + LOG_F(WARNING, "%+05.3f", kPi); + } + loguru::flush(); +} + +void stream_strings(size_t num_iterations) +{ + for (size_t i = 0; i < num_iterations; ++i) { + LOG_S(WARNING) << "Some long, complex message."; + } + loguru::flush(); +} + +void stream_float(size_t num_iterations) +{ + for (size_t i = 0; i < num_iterations; ++i) { + LOG_S(WARNING) << std::setfill('0') << std::setw(5) << std::setprecision(3) << kPi; + } + loguru::flush(); +} + +void raw_string_float(size_t num_iterations) +{ + for (size_t i = 0; i < num_iterations; ++i) { + RAW_LOG_F(WARNING, "Some long, complex message."); + } + loguru::flush(); +} + +void error_context(size_t num_iterations) +{ + for (size_t i = 0; i < num_iterations; ++i) { + ERROR_CONTEXT("key", "value"); + } +} + +int main(int argc, char* argv[]) +{ + const size_t kNumIterations = 50 * 1000; + + loguru::init(argc, argv); + loguru::add_file("loguru_bench.log", loguru::Truncate, loguru::Verbosity_INFO); + + bench("ERROR_CONTEXT", error_context, kNumIterations * 100); + + loguru::g_flush_interval_ms = 200; + bench("LOG_F string (buffered):", format_strings, kNumIterations); + bench("LOG_F float (buffered):", format_float, kNumIterations); + bench("LOG_S string (buffered):", stream_strings, kNumIterations); + bench("LOG_S float (buffered):", stream_float, kNumIterations); + bench("RAW_LOG_F (buffered):", raw_string_float, kNumIterations); + + loguru::g_flush_interval_ms = 0; + bench("LOG_F string (unbuffered):", format_strings, kNumIterations); + bench("LOG_F float (unbuffered):", format_float, kNumIterations); + bench("LOG_S string (unbuffered):", stream_strings, kNumIterations); + bench("LOG_S float (unbuffered):", stream_float, kNumIterations); + bench("RAW_LOG_F (unbuffered):", raw_string_float, kNumIterations); +} diff --git a/loguru_example/CMakeLists.txt b/loguru_example/CMakeLists.txt new file mode 100644 index 0000000..b70441e --- /dev/null +++ b/loguru_example/CMakeLists.txt @@ -0,0 +1,38 @@ +cmake_minimum_required(VERSION 2.8) + +project(loguru_example) + +if(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE "Debug" CACHE STRING + "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE) +endif(NOT CMAKE_BUILD_TYPE) + +MESSAGE(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}") + +if(MSVC) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Wall") +else() + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Werror -Wall -Wextra -pedantic") +endif() + +if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Weverything") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-c++98-compat") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-c++98-compat-pedantic") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-noreturn") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-prototypes") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-gnu-zero-variadic-macro-arguments") +endif() # Clang + +file(GLOB source + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" + # "${CMAKE_CURRENT_SOURCE_DIR}/../*.cpp" +) + +add_executable(loguru_example ${source}) + +find_package(Threads) +target_link_libraries(loguru_example ${CMAKE_THREAD_LIBS_INIT}) # For pthreads +if(NOT WIN32) + target_link_libraries(loguru_example dl) # For ldl +endif() diff --git a/loguru_example/build_and_run.sh b/loguru_example/build_and_run.sh new file mode 100755 index 0000000..6219da4 --- /dev/null +++ b/loguru_example/build_and_run.sh @@ -0,0 +1,12 @@ +#!/bin/bash +set -e # Fail on error + +ROOT_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd) + +cd "$ROOT_DIR" +mkdir -p build +cd build +cmake .. +make + +./loguru_example $@ diff --git a/loguru_example/loguru_example.hpp b/loguru_example/loguru_example.hpp new file mode 100644 index 0000000..e743d7c --- /dev/null +++ b/loguru_example/loguru_example.hpp @@ -0,0 +1,26 @@ +#include +#include + +#include "../loguru.hpp" + +inline void sleep_ms(int ms) +{ + VLOG_F(2, "Sleeping for %d ms", ms); + std::this_thread::sleep_for(std::chrono::milliseconds(ms)); +} + +inline void complex_calculation() +{ + LOG_SCOPE_F(INFO, "complex_calculation"); + LOG_F(INFO, "Starting time machine..."); + sleep_ms(200); + LOG_F(WARNING, "The flux capacitor is not getting enough power!"); + sleep_ms(400); + LOG_F(INFO, "Lighting strike!"); + VLOG_F(1, "Found 1.21 gigawatts..."); + sleep_ms(400); + std::thread([](){ + loguru::set_thread_name("the past"); + LOG_F(ERROR, "We ended up in 1985!"); + }).join(); +} diff --git a/loguru_example/main.cpp b/loguru_example/main.cpp new file mode 100644 index 0000000..8e9a14b --- /dev/null +++ b/loguru_example/main.cpp @@ -0,0 +1,13 @@ +#include + +#include "loguru_example.hpp" + +#include "../loguru.cpp" + +int main(int argc, char* argv[]) +{ + loguru::init(argc, argv); + LOG_F(INFO, "Hello from main.cpp!"); + complex_calculation(); + LOG_F(INFO, "main function about to end!"); +} diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt new file mode 100644 index 0000000..6ace470 --- /dev/null +++ b/test/CMakeLists.txt @@ -0,0 +1,80 @@ +cmake_minimum_required(VERSION 2.8) + +project(loguru_test) + +if(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE "Debug" CACHE STRING + "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE) +endif(NOT CMAKE_BUILD_TYPE) + +MESSAGE(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}") + +if(MSVC) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Wall") +else() + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Werror -Wall -Wextra -pedantic -fsanitize=address -fno-omit-frame-pointer") +endif() + +if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Weverything") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-c++98-compat") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-c++98-compat-pedantic") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-noreturn") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-prototypes") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-gnu-zero-variadic-macro-arguments") +endif() # Clang + +add_executable(loguru_test loguru_test.cpp) + +find_package(Threads) +target_link_libraries(loguru_test ${CMAKE_THREAD_LIBS_INIT}) # For pthreads +if(NOT WIN32) + target_link_libraries(loguru_test dl) # For ldl +endif() + +enable_testing() + +if(NOT WIN32) +# Sadly, Windows doesn't allow us to safely run the following tests + list(APPEND ExtraFailureTests + SIGSEGV + throw_on_signal) +endif() + +if(CMAKE_BUILD_TYPE STREQUAL "Debug") + list(APPEND ExtraFailureTests + assert) +endif() + +# Failure Tests +foreach(Test + ABORT_F + ABORT_S + LOG_F_FATAL + LOG_S_FATAL + CHECK_NOTNULL_F + CHECK_F + CHECK_EQ_F_int + CHECK_EQ_F_unsigned + CHECK_EQ_F_size_t + CHECK_EQ_F + CHECK_EQ_F_message + CHECK_EQ_S + CHECK_LT_S + CHECK_LT_S_message + deep_abort + abort + error_context + throw_on_fatal + ${ExtraFailureTests} +) + add_test(NAME loguru_test_${Test} + COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_LIST_DIR}/fail_test_wrapper.cmake + $ ${Test}) +endforeach() + +# Success Tests +foreach(Test + callback) + add_test(loguru_test_${Test} loguru_test ${Test}) +endforeach() diff --git a/test/appveyor.cmake b/test/appveyor.cmake new file mode 100644 index 0000000..f603b48 --- /dev/null +++ b/test/appveyor.cmake @@ -0,0 +1,50 @@ +#!/usr/bin/env cmake -P +# Group AppVeyor builds to use fewer VM instances and upload useful artifacts from each. +find_program(AppVeyor appveyor) +if(NOT AppVeyor) + message(FATAL_ERROR "script specific to appveyor only") +endif() + +function(message type) # overriding CMake built-in message function for AppVeyor + set(msg "${ARGV}") + if(type STREQUAL FATAL_ERROR OR type STREQUAL SEND_ERROR) + set(msg "${ARGN}") + set(options -Category Error) + elseif(type STREQUAL WARNING OR type STREQUAL AUTHOR_WARNING) + set(msg "${ARGN}") + set(options -Category Warning) + elseif(type STREQUAL STATUS) + set(msg "${ARGN}") + set(options -Category Information) + endif() + execute_process(COMMAND ${AppVeyor} AddMessage "${msg}" ${options}) + + _message(${ARGV}) # the built-in functionality +endfunction() + +function(BuildAndRun) + if(DEFINED Generator) + string(REPLACE " " "" gen "${Generator}/") # Remove spaces from generator + endif() + set(BUILD_DIR "${CMAKE_CURRENT_LIST_DIR}/build/${gen}${Configuration}") + message("Building ${gen}${Configuration}") + include(${CMAKE_CURRENT_LIST_DIR}/build_and_run.cmake) + message("Built ${gen}${Configuration}") + execute_process(COMMAND ${CMAKE_COMMAND} -E tar czf "${BUILD_DIR}/Testing.zip" "${BUILD_DIR}/Testing") + execute_process(COMMAND ${AppVeyor} PushArtifact "${BUILD_DIR}/Testing.zip" -FileName "${gen}${Configuration}.zip") +endfunction() + +foreach(Configuration "Debug" "Release") + if(WIN32) + foreach(Generator + "Visual Studio 14 2015" + "Visual Studio 14 2015 Win64" + "Visual Studio 15 2017" + "Visual Studio 15 2017 Win64" + ) + BuildAndRun() + endforeach() + elseif(UNIX) + BuildAndRun() + endif() +endforeach() diff --git a/test/build.sh b/test/build.sh new file mode 100755 index 0000000..9c0de1a --- /dev/null +++ b/test/build.sh @@ -0,0 +1,21 @@ +#!/bin/bash +set -e # Fail on error + +ROOT_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd) + +cd "$ROOT_DIR" +mkdir -p build +cd build + +cmake .. + +# Use GCC: +# cmake -DCMAKE_C_COMPILER=/usr/bin/gcc -DCMAKE_CXX_COMPILER=/usr/bin/g++ .. + +# Use GCC5: +# cmake -DCMAKE_C_COMPILER=/usr/bin/gcc-5 -DCMAKE_CXX_COMPILER=/usr/bin/g++-5 .. + +# Use clang-3.7: +# cmake -DCMAKE_C_COMPILER=/usr/bin/clang-3.7 -DCMAKE_CXX_COMPILER=/usr/bin/clang++-3.7 .. + +make diff --git a/test/build_and_run.cmake b/test/build_and_run.cmake new file mode 100644 index 0000000..e7aa137 --- /dev/null +++ b/test/build_and_run.cmake @@ -0,0 +1,45 @@ +#!/usr/bin/env cmake -P + +# for lack of an equivalent of `set -e` in bash +macro(EXEC_CMD_CHECK) + message("running ${ARGN}") + execute_process(COMMAND ${ARGN} RESULT_VARIABLE CMD_RESULT) + if(CMD_RESULT) + message(FATAL_ERROR "Error running ${ARGN}") + endif() +endmacro() + +# Read the configuration from the environement +if(NOT DEFINED Configuration AND DEFINED ENV{Configuration}) + set(Configuration $ENV{Configuration}) +endif() +# to override the default configuration: ex. -DConfiguration=Release +if(DEFINED Configuration) + list(APPEND CMAKE_EXTRA_ARGS "-DCMAKE_BUILD_TYPE=${Configuration}") + set(CMAKE_BUILD_EXTRA_ARGS --config ${Configuration}) + set(CTEST_EXTRA_ARGS -C ${Configuration}) +endif() + +# The generator also, if we have an entry in the envirnoment +if(NOT DEFINED Generator AND DEFINED ENV{Generator}) + set(Generator $ENV{Generator}) +endif() +# to override the default generator: ex. -DGenerator=Ninja +if(DEFINED Generator) + list(APPEND CMAKE_EXTRA_ARGS "-G${Generator}") +endif() + +if(NOT DEFINED BUILD_DIR) + set(BUILD_DIR ${CMAKE_CURRENT_LIST_DIR}/build) +endif() +file(MAKE_DIRECTORY ${BUILD_DIR}) + +# cd build && cmake .. && cd - +EXEC_CMD_CHECK(${CMAKE_COMMAND} ${CMAKE_EXTRA_ARGS} ${CMAKE_CURRENT_LIST_DIR} + WORKING_DIRECTORY ${BUILD_DIR}) + +# platform-independent equivalent of `make` +EXEC_CMD_CHECK(${CMAKE_COMMAND} --build ${BUILD_DIR} ${CMAKE_BUILD_EXTRA_ARGS}) + +EXEC_CMD_CHECK(${CMAKE_CTEST_COMMAND} ${CTEST_EXTRA_ARGS} --output-on-failure + WORKING_DIRECTORY ${BUILD_DIR}) diff --git a/test/build_and_run.sh b/test/build_and_run.sh new file mode 100755 index 0000000..0383aee --- /dev/null +++ b/test/build_and_run.sh @@ -0,0 +1,57 @@ +#!/bin/bash +set -e # Fail on error + +ROOT_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd) + +$ROOT_DIR/build.sh + +cd $ROOT_DIR/build/ + +function test_failure +{ + echo "" + ./loguru_test $1 && echo "Expected command to fail!" && exit 1 + echo "" + echo "" +} + +function test_success +{ + echo "" + ./loguru_test $1 || echo "Expected command to succeed!" + echo "" + echo "" +} + +echo "---------------------------------------------------------" +echo "Testing failures..." +echo "---------------------------------------------------------" +test_failure "ABORT_F" +test_failure "ABORT_S" +test_failure "assert" +test_failure "LOG_F_FATAL" +test_failure "LOG_S_FATAL" +test_failure "CHECK_NOTNULL_F" +test_failure "CHECK_F" +test_failure "CHECK_EQ_F_int" +test_failure "CHECK_EQ_F_unsigned" +test_failure "CHECK_EQ_F_size_t" +test_failure "CHECK_EQ_F" +test_failure "CHECK_EQ_F_message" +test_failure "CHECK_EQ_S" +test_failure "CHECK_LT_S" +test_failure "CHECK_LT_S_message" +test_failure "deep_abort" +test_failure "SIGSEGV" +test_failure "abort" +test_failure "error_context" +test_failure "throw_on_fatal" +test_failure "throw_on_signal" +test_success "callback" +echo "---------------------------------------------------------" +echo "ALL TESTS PASSED!" +echo "---------------------------------------------------------" + +./loguru_test $@ + +./loguru_test hang diff --git a/test/fail_test_wrapper.cmake b/test/fail_test_wrapper.cmake new file mode 100644 index 0000000..82efe76 --- /dev/null +++ b/test/fail_test_wrapper.cmake @@ -0,0 +1,24 @@ +#!/usr/bin/env cmake -P +cmake_minimum_required(VERSION 2.8.7) + +get_filename_component(CurrentFile ${CMAKE_CURRENT_LIST_FILE} NAME) + +# The script is invoked as cmake -P