Logger Class Reference

#include <Logger.h>

Collaboration diagram for Logger:

Classes
class	LineToLoggerBuf
struct	LogEntry
class	OstreamRedirect

Public Types
enum class	Level : uint8_t {   Trace , Debug , Info , Warn ,   Error , Success }
using	Sink = std::function<void(const std::string& channel, const LogEntry& e)>

Public Member Functions
void	log (const std::string &channel, const std::string &line)
void	log (const std::string &channel, Level lvl, const std::string &line)
std::vector< LogEntry >	getChannel (const std::string &channel)
std::vector< std::string >	channels () const
void	clearChannel (const std::string &channel)
void	setChannelCapacity (size_t cap)
int	addSink (const Sink &s)
void	removeSink (int id)
void	clearSinks ()
void	installStdCapture ()
void	uninstallStdCapture ()

Static Public Member Functions
static Logger &	instance ()
static std::string	formatTs (uint64_t ms)

Private Member Functions
	Logger ()=default
void	ensureSeed_ ()
void	commit_ (const std::string &channel, LogEntry e)

Static Private Member Functions
static uint64_t	nowMs_ ()
static Level	autoDetect_ (const std::string &s)

Private Attributes
std::mutex	m_
size_t	capacity_ = 4000
std::unordered_map< std::string, std::deque< LogEntry > >	channels_
int	nextSinkId_ = 0
std::vector< std::pair< int, Sink > >	sinks_
bool	seeded_ = false
std::unique_ptr< OstreamRedirect >	coutRedirect_
std::unique_ptr< OstreamRedirect >	cerrRedirect_

Detailed Description

Definition at line 15 of file Logger.h.

Member Typedef Documentation

Sink

using Logger::Sink = std::function<void(const std::string& channel, const LogEntry& e)>

Definition at line 37 of file Logger.h.

Member Enumeration Documentation

Level

enum class Logger::Level : uint8_t

strong

Enumerator
Trace
Debug
Info
Warn
Error
Success

Definition at line 18 of file Logger.h.

    {
        Trace,
        Debug,
        Info,
        Warn,
        Error,
        Success
    };

Constructor & Destructor Documentation

Logger()

Logger::Logger ( )

privatedefault

Member Function Documentation

addSink()

int Logger::addSink ( const Sink & s )

inline

Definition at line 96 of file Logger.h.

    {
        std::lock_guard<std::mutex> lk(m_);
        int id = ++nextSinkId_;
        sinks_.emplace_back(id, s);
        return id;
    }

autoDetect_()

static Level Logger::autoDetect_ ( const std::string & s )

inlinestaticprivate

Definition at line 268 of file Logger.h.

    {
        // very small heuristics (case-insensitive): [error], error:, fail, warn, etc.
        auto has = [&](const char* needle)
        {
            auto it = std::search(
                s.begin(), s.end(),
                needle, needle + std::strlen(needle),
                [](char a, char b)
                { return std::tolower((unsigned char)a) == std::tolower((unsigned char)b); });
            return it != s.end();
        };
        if (has("[error]") || has(" error") || has("failed") || has("exception"))
            return Level::Error;
        if (has("[warn]") || has(" warning"))
            return Level::Warn;
        // If you wish, detect [debug] → Debug, [trace] → Trace
        if (has("[debug]"))
            return Level::Debug;
        if (has("[trace]"))
            return Level::Trace;
        return Level::Info;
    }

Here is the caller graph for this function:

channels()

std::vector< std::string > Logger::channels ( ) const

inline

Definition at line 73 of file Logger.h.

    {
        std::lock_guard<std::mutex> lk(m_);
        std::vector<std::string> names;
        names.reserve(channels_.size());
        for (auto& kv : channels_)
            names.push_back(kv.first);
        return names;
    }

Here is the caller graph for this function:

clearChannel()

void Logger::clearChannel ( const std::string & channel )

inline

Definition at line 83 of file Logger.h.

    {
        std::lock_guard<std::mutex> lk(m_);
        channels_[channel].clear();
    }

Here is the caller graph for this function:

clearSinks()

void Logger::clearSinks ( )

inline

Definition at line 111 of file Logger.h.

    {
        std::lock_guard<std::mutex> lk(m_);
        sinks_.clear();
    }

commit_()

void Logger::commit_ ( const std::string & channel, LogEntry e )

inlineprivate

Definition at line 292 of file Logger.h.

    {
        std::lock_guard<std::mutex> lk(m_);
        auto& q = channels_[channel];
        q.emplace_back(std::move(e));
        while (q.size() > capacity_)
            q.pop_front();
        // fan-out sinks
        auto& back = q.back();
        for (auto& [id, s] : sinks_)
            s(channel, back);
    }

Here is the caller graph for this function:

ensureSeed_()

void Logger::ensureSeed_ ( )

inlineprivate

Definition at line 252 of file Logger.h.

    {
        if (!seeded_)
        {
            channels_["main"];
            channels_["localtunnel"];
            seeded_ = true;
        }
    }

Here is the caller graph for this function:

formatTs()

static std::string Logger::formatTs ( uint64_t ms )

inlinestatic

Definition at line 135 of file Logger.h.

    {
        using namespace std::chrono;
        auto tp = time_point<system_clock, milliseconds>(milliseconds(ms));
        auto t = system_clock::to_time_t(tp);
        auto ms_part = (int)(ms % 1000);
        struct tm bt;
#if defined(_WIN32)
        localtime_s(&bt, &t);
#else
        localtime_r(&t, &bt);
#endif
        char buf[32];
        std::snprintf(buf, sizeof(buf), "%02d:%02d:%02d.%03d", bt.tm_hour, bt.tm_min, bt.tm_sec, ms_part);
        return std::string(buf);
    }

Here is the caller graph for this function:

getChannel()

std::vector< LogEntry > Logger::getChannel ( const std::string & channel )

inline

Definition at line 64 of file Logger.h.

    {
        std::lock_guard<std::mutex> lk(m_);
        auto it = channels_.find(channel);
        if (it == channels_.end())
            return {};
        return {it->second.begin(), it->second.end()};
    }

Here is the caller graph for this function:

installStdCapture()

void Logger::installStdCapture ( )

inline

Definition at line 118 of file Logger.h.

    {
        std::lock_guard<std::mutex> lk(m_);
        if (!coutRedirect_)
            coutRedirect_ = std::make_unique<OstreamRedirect>(std::cout, "main", Level::Debug);
        if (!cerrRedirect_)
            cerrRedirect_ = std::make_unique<OstreamRedirect>(std::cerr, "main", Level::Error);
        ensureSeed_();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

instance()

static Logger & Logger::instance ( )

inlinestatic

Definition at line 39 of file Logger.h.

    {
        static Logger L;
        return L;
    }

Here is the caller graph for this function:

log() [1/2]

void Logger::log ( const std::string & channel, const std::string & line )

inline

Definition at line 48 of file Logger.h.

    {
        log(channel, Level::Info, line);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

log() [2/2]

void Logger::log ( const std::string & channel, Level lvl, const std::string & line )

inline

Definition at line 54 of file Logger.h.

    {
        LogEntry e{line, lvl, nowMs_(), {}};
        // auto-detect if level was Info but looks like warn/error
        if (lvl == Level::Info)
            e.level = autoDetect_(line);
        commit_(channel, std::move(e));
    }

Here is the call graph for this function:

nowMs_()

static uint64_t Logger::nowMs_ ( )

inlinestaticprivate

Definition at line 262 of file Logger.h.

    {
        using namespace std::chrono;
        return duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
    }

Here is the caller graph for this function:

removeSink()

void Logger::removeSink ( int id )

inline

Definition at line 103 of file Logger.h.

    {
        std::lock_guard<std::mutex> lk(m_);
        sinks_.erase(std::remove_if(sinks_.begin(), sinks_.end(),
                                    [id](auto& p)
                                    { return p.first == id; }),
                     sinks_.end());
    }

setChannelCapacity()

void Logger::setChannelCapacity ( size_t cap )

inline

Definition at line 89 of file Logger.h.

    {
        std::lock_guard<std::mutex> lk(m_);
        capacity_ = cap;
    }

uninstallStdCapture()

void Logger::uninstallStdCapture ( )

inline

Definition at line 127 of file Logger.h.

    {
        std::lock_guard<std::mutex> lk(m_);
        cerrRedirect_.reset();
        coutRedirect_.reset();
    }

Member Data Documentation

capacity_

size_t Logger::capacity_ = 4000

private

Definition at line 307 of file Logger.h.

cerrRedirect_

std::unique_ptr<OstreamRedirect> Logger::cerrRedirect_

private

Definition at line 313 of file Logger.h.

channels_

std::unordered_map<std::string, std::deque<LogEntry> > Logger::channels_

private

Definition at line 308 of file Logger.h.

coutRedirect_

std::unique_ptr<OstreamRedirect> Logger::coutRedirect_

private

Definition at line 312 of file Logger.h.

m_

std::mutex Logger::m_

mutableprivate

Definition at line 306 of file Logger.h.

nextSinkId_

int Logger::nextSinkId_ = 0

private

Definition at line 309 of file Logger.h.

seeded_

bool Logger::seeded_ = false

private

Definition at line 311 of file Logger.h.

sinks_

std::vector<std::pair<int, Sink> > Logger::sinks_

private

Definition at line 310 of file Logger.h.

---

The documentation for this class was generated from the following file:

• include/debug/Logger.h