TeaSpeak/spdlog
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Disable colors if terminal no attached and simplfy ansicolor_sink

Browse Source
This commit is contained in:
gabime 2017-05-21 01:36:03 +03:00
parent 1ab63ffdca
commit 98addad888
4 changed files with 335 additions and 354 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/spdlog/details/log_msg.h
View File

@ -19,7 +19,10 @@ namespace details
struct log_msg
{
log_msg() = default;
log_msg(const std::string *loggers_name, level::level_enum lvl) : logger_name(loggers_name), level(lvl)
log_msg(const std::string *loggers_name, level::level_enum lvl) :
logger_name(loggers_name),
level(lvl),
msg_id(0)
{
#ifndef SPDLOG_NO_DATETIME
time = os::now();
@ -42,7 +45,6 @@ struct log_msg
fmt::MemoryWriter raw;
fmt::MemoryWriter formatted;
size_t msg_id;
};
}
}

25
include/spdlog/details/os.h
View File

@ -29,7 +29,7 @@
#endif
#include <windows.h>
#include <process.h> // _get_pid support
#include <io.h> // _get_osfhandle support
#include <io.h> // _get_osfhandle and _isatty support
#ifdef __MINGW32__
#include <share.h>
@ -372,12 +372,10 @@ inline std::string errno_to_string(char [256], char* res)
inline std::string errno_to_string(char buf[256], int res)
{
if (res == 0)
{
if (res == 0) {
return std::string(buf);
}
else
{
else {
return "Unknown error";
}
}
@ -434,14 +432,12 @@ inline bool is_color_terminal()
};
const char *env_p = std::getenv("TERM");
if (env_p == nullptr)
{
if (env_p == nullptr) {
return false;
}
static const bool result = std::any_of(
std::begin(Terms), std::end(Terms), [&](const char* term)
{
std::begin(Terms), std::end(Terms), [&](const char* term) {
return std::strstr(env_p, term) != nullptr;
});
return result;
@ -449,6 +445,17 @@ inline bool is_color_terminal()
}
// Detrmine if the terminal attached
// Source: https://github.com/agauniyal/rang/
bool in_terminal(FILE* file)
{
#ifdef _WIN32
return _isatty(_fileno(file)) ? true : false;
#else
return isatty(fileno(file)) ? true : false;
#endif
}
} //os
} //details
} //spdlog

8
include/spdlog/details/spdlog_impl.h
View File

@ -137,25 +137,25 @@ inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_st(const std::string
inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt(const std::string& logger_name)
{
auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stdout_sink_mt::instance());
auto sink = std::make_shared<spdlog::sinks::ansicolor_stdout_sink_mt>();
return spdlog::details::registry::instance().create(logger_name, sink);
}
inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_st(const std::string& logger_name)
{
auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stdout_sink_st::instance());
auto sink = std::make_shared<spdlog::sinks::ansicolor_stdout_sink_st>();
return spdlog::details::registry::instance().create(logger_name, sink);
}
inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt(const std::string& logger_name)
{
auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stderr_sink_mt::instance());
auto sink = std::make_shared<spdlog::sinks::ansicolor_stderr_sink_mt>();
return spdlog::details::registry::instance().create(logger_name, sink);
}
inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_st(const std::string& logger_name)
{
auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stderr_sink_st::instance());
auto sink = std::make_shared<spdlog::sinks::ansicolor_stderr_sink_st>();
return spdlog::details::registry::instance().create(logger_name, sink);
}
#endif

158
include/spdlog/sinks/ansicolor_sink.h
View File

@ -10,7 +10,7 @@
#include <spdlog/details/os.h>
#include <string>
#include <map>
#include <unordered_map>
namespace spdlog
{
@ -22,106 +22,78 @@ namespace sinks
* the output with an ANSI escape sequence color code depending on the severity
* of the message.
*/
class ansicolor_sink SPDLOG_FINAL: public sink
template <class Mutex>
class ansicolor_sink SPDLOG_FINAL: public base_sink<Mutex>
{
public:
ansicolor_sink(sink_ptr wrapped_sink);
virtual ~ansicolor_sink();
ansicolor_sink(const ansicolor_sink& other) = delete;
ansicolor_sink& operator=(const ansicolor_sink& other) = delete;
virtual void log(const details::log_msg& msg) override;
virtual void flush() override;
void set_color(level::level_enum color_level, const std::string& color);
/// Formatting codes
const std::string reset = "\033[00m";
const std::string bold = "\033[1m";
const std::string dark = "\033[2m";
const std::string underline = "\033[4m";
const std::string blink = "\033[5m";
const std::string reverse = "\033[7m";
const std::string concealed = "\033[8m";
// Foreground colors
const std::string grey = "\033[30m";
const std::string red = "\033[31m";
const std::string green = "\033[32m";
const std::string yellow = "\033[33m";
const std::string blue = "\033[34m";
const std::string magenta = "\033[35m";
const std::string cyan = "\033[36m";
const std::string white = "\033[37m";
/// Background colors
const std::string on_grey = "\033[40m";
const std::string on_red = "\033[41m";
const std::string on_green = "\033[42m";
const std::string on_yellow = "\033[43m";
const std::string on_blue = "\033[44m";
const std::string on_magenta = "\033[45m";
const std::string on_cyan = "\033[46m";
const std::string on_white = "\033[47m";
protected:
bool is_color_terminal_;
sink_ptr sink_;
std::map<level::level_enum, std::string> colors_;
};
inline ansicolor_sink::ansicolor_sink(sink_ptr wrapped_sink): sink_(wrapped_sink)
ansicolor_sink(FILE* file): _target_file(file)
{
is_color_terminal_ = details::os::is_color_terminal();
colors_[level::trace] = cyan;
colors_[level::debug] = cyan;
colors_[level::info] = bold;
colors_[level::warn] = yellow + bold;
colors_[level::err] = red + bold;
colors_[level::critical] = bold + on_red;
colors_[level::off] = reset;
using namespace ansi_color_codes;
should_do_colors_ = details::os::in_terminal(file) && details::os::is_color_terminal();
colors_[level::trace] = "\033[36m"; // cyan;
colors_[level::debug] = "\033[36m"; // cyan;
colors_[level::info] = "\033[1m";// bold;
colors_[level::warn] = "\033[33m\033[1m"; // yellow_bold;
colors_[level::err] = "\033[31m\033[1m"; // red_bold;
colors_[level::critical] = "\033[1m\033[41m"; // bold_red_bg;
colors_[level::off] = "\033[00m"; //reset;
}
inline void ansicolor_sink::log(const details::log_msg& msg)
{
// Wrap the originally formatted message in color codes.
// If color is not supported in the terminal, log as is instead.
if (is_color_terminal_)
{
const std::string& prefix = colors_[msg.level];
const std::string& s = msg.formatted.str();
const std::string& suffix = reset;
details::log_msg m;
m.level = msg.level;
m.logger_name = msg.logger_name;
m.time = msg.time;
m.thread_id = msg.thread_id;
m.formatted << prefix << s << suffix;
sink_->log(m);
}
else
{
sink_->log(msg);
}
}
inline void ansicolor_sink::flush()
{
sink_->flush();
}
inline void ansicolor_sink::set_color(level::level_enum color_level, const std::string& color)
{
colors_[color_level] = color;
}
inline ansicolor_sink::~ansicolor_sink()
virtual ~ansicolor_sink()
{
flush();
}
void flush() override
{
fflush(_target_file);
}
protected:
virtual void _sink_it(const details::log_msg& msg) override
{
// Wrap the originally formatted message in color codes.
// If color is not supported in the terminal, log as is instead.
if (should_do_colors_)
{
const std::string& prefix = colors_[msg.level];
const std::string& suffix = ansi_color_codes::reset;
fwrite(prefix, sizeof(char), prefix.size(), _target_file);
fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), _target_file);
fwrite(suffix, sizeof(char), suffix.size(), _target_file);
}
else
{
fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), _target_file);
}
}
private:
bool should_do_colors_;
std::unordered_map<level::level_enum, std::string> colors_;
};
template<class Mutex>
class ansicolor_stdout_sink: public ansicolor_sink<Mutex>
{
public:
ansicolor_stdout_sink(): ansicolor_sink<Mutex>(stdout)
{}
};
template<class Mutex>
class ansicolor_stderr_sink: public ansicolor_sink<Mutex>
{
public:
ansicolor_stderr_sink(): ansicolor_sink<Mutex>(stderr)
{}
};
typedef ansicolor_stdout_sink<std::mutex> ansicolor_stdout_sink_mt;
typedef ansicolor_stdout_sink<details::null_mutex> ansicolor_stdout_sink_st;
typedef ansicolor_stderr_sink<std::mutex> ansicolor_stderr_sink_mt;
typedef ansicolor_stderr_sink<details::null_mutex> ansicolor_stderr_sink_st;
} // namespace sinks
} // namespace spdlog