log.h

Go to the documentation of this file.

#pragma once
 
// libc++ offers compatibility-only transitive includes through C++20.
// Suppress those while loading our explicit dependencies, then restore the
// caller's setting. This does not change standard-library types or ABI.
#pragma push_macro("_LIBCPP_REMOVE_TRANSITIVE_INCLUDES")
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
#define _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
#endif
 
#include "zeroerr/internal/config.h"
 
#include "zeroerr/internal/threadsafe.h"
#include "zeroerr/internal/typetraits.h"
 
#include "zeroerr/dbg.h"
#include "zeroerr/format.h"
#include "zeroerr/print.h"
 
#include "zeroerr/internal/time.h"
#include <iosfwd>
#include <cstddef>
#include <map>
#include "zeroerr/string.h"
#include <utility>
#include <vector>
 
ZEROERR_SUPPRESS_COMMON_WARNINGS_PUSH
 
extern const char* ZEROERR_LOG_CATEGORY;
 
namespace zeroerr {
 
// clang-format off
#define ZEROERR_INFO(...)  ZEROERR_SUPPRESS_VARIADIC_MACRO ZEROERR_EXPAND(ZEROERR_INFO_(__VA_ARGS__)) ZEROERR_SUPPRESS_VARIADIC_MACRO_POP
#define ZEROERR_LOG(...)   ZEROERR_SUPPRESS_VARIADIC_MACRO ZEROERR_EXPAND(ZEROERR_LOG_(LOG_l, __VA_ARGS__)) ZEROERR_SUPPRESS_VARIADIC_MACRO_POP
#define ZEROERR_WARN(...)  ZEROERR_SUPPRESS_VARIADIC_MACRO ZEROERR_EXPAND(ZEROERR_LOG_(WARN_l, __VA_ARGS__)) ZEROERR_SUPPRESS_VARIADIC_MACRO_POP
#define ZEROERR_ERROR(...) ZEROERR_SUPPRESS_VARIADIC_MACRO ZEROERR_EXPAND(ZEROERR_LOG_(ERROR_l, __VA_ARGS__)) ZEROERR_SUPPRESS_VARIADIC_MACRO_POP
#define ZEROERR_FATAL(...) ZEROERR_SUPPRESS_VARIADIC_MACRO ZEROERR_EXPAND(ZEROERR_LOG_(FATAL_l, __VA_ARGS__)) ZEROERR_SUPPRESS_VARIADIC_MACRO_POP
// clang-format on
 
#ifdef ZEROERR_USE_SHORT_LOG_MACRO
 
#ifdef INFO
#undef INFO
#endif
 
#ifdef LOG
#undef LOG
#endif
 
#ifdef WARN
#undef WARN
#endif
 
#ifdef ERR
#undef ERR
#endif
 
#ifdef FATAL
#undef FATAL
#endif
 
#ifdef VERBOSE
#undef VERBOSE
#endif
 
#define INFO(...)  ZEROERR_INFO(__VA_ARGS__)
#define LOG(...)   ZEROERR_LOG(__VA_ARGS__)
#define WARN(...)  ZEROERR_WARN(__VA_ARGS__)
#define ERR(...)   ZEROERR_ERROR(__VA_ARGS__)
#define FATAL(...) ZEROERR_FATAL(__VA_ARGS__)
#define VERBOSE(v) ZEROERR_VERBOSE(v)
 
#define LOG_GET(func, id, name, type) ZEROERR_LOG_GET(func, id, name, type)
 
#endif  // ZEROERR_USE_SHORT_LOG_MACRO
 
#define ZEROERR_LOG_IF(condition, ACTION, ...) \
    do {                                       \
        if (condition) ACTION(__VA_ARGS__);    \
    } while (0)
 
 
#define INFO_IF(cond, ...)  ZEROERR_LOG_IF(cond, ZEROERR_INFO, __VA_ARGS__)
#define LOG_IF(cond, ...)   ZEROERR_LOG_IF(cond, ZEROERR_LOG, __VA_ARGS__)
#define WARN_IF(cond, ...)  ZEROERR_LOG_IF(cond, ZEROERR_WARN, __VA_ARGS__)
#define ERR_IF(cond, ...)   ZEROERR_LOG_IF(cond, ZEROERR_ERROR, __VA_ARGS__)
#define FATAL_IF(cond, ...) ZEROERR_LOG_IF(cond, ZEROERR_FATAL, __VA_ARGS__)
 
 
#define ZEROERR_LOG_EVERY_(n, ACTION, ...) \
    do {                                   \
        static unsigned counter = 0;       \
        if (counter == 0) {                \
            counter = n;                   \
            ACTION(__VA_ARGS__);           \
        }                                  \
        --counter;                         \
    } while (0)
 
 
#define INFO_EVERY_(n, ...)  ZEROERR_LOG_EVERY_(n, ZEROERR_INFO, __VA_ARGS__)
#define LOG_EVERY_(n, ...)   ZEROERR_LOG_EVERY_(n, ZEROERR_LOG, __VA_ARGS__)
#define WARN_EVERY_(n, ...)  ZEROERR_LOG_EVERY_(n, ZEROERR_WARN, __VA_ARGS__)
#define ERR_EVERY_(n, ...)   ZEROERR_LOG_EVERY_(n, ZEROERR_ERROR, __VA_ARGS__)
#define FATAL_EVERY_(n, ...) ZEROERR_LOG_EVERY_(n, ZEROERR_FATAL, __VA_ARGS__)
 
 
#define ZEROERR_LOG_IF_EVERY_(n, cond, ACTION, ...) \
    do {                                            \
        if (cond) {                                 \
            static unsigned counter = 0;            \
            if (counter == 0) {                     \
                counter = n;                        \
                ACTION(__VA_ARGS__);                \
            }                                       \
            --counter;                              \
        }                                           \
    } while (0)
 
#define INFO_IF_EVERY_(n, cond, ...)  ZEROERR_LOG_IF_EVERY_(n, cond, ZEROERR_INFO, __VA_ARGS__)
#define LOG_IF_EVERY_(n, cond, ...)   ZEROERR_LOG_IF_EVERY_(n, cond, ZEROERR_LOG, __VA_ARGS__)
#define WARN_IF_EVERY_(n, cond, ...)  ZEROERR_LOG_IF_EVERY_(n, cond, ZEROERR_WARN, __VA_ARGS__)
#define ERR_IF_EVERY_(n, cond, ...)   ZEROERR_LOG_IF_EVERY_(n, cond, ZEROERR_ERROR, __VA_ARGS__)
#define FATAL_IF_EVERY_(n, cond, ...) ZEROERR_LOG_IF_EVERY_(n, cond, ZEROERR_FATAL, __VA_ARGS__)
 
#define ZEROERR_LOG_FIRST(cond, ACTION, ...) \
    do {                                     \
        static bool first = true;            \
        if (first && (cond)) {               \
            first = false;                   \
            ACTION(__VA_ARGS__);             \
        }                                    \
    } while (0)
 
#define INFO_FIRST(cond, ...)  ZEROERR_LOG_FIRST(cond, ZEROERR_INFO, __VA_ARGS__)
#define LOG_FIRST(cond, ...)   ZEROERR_LOG_FIRST(cond, ZEROERR_LOG, __VA_ARGS__)
#define WARN_FIRST(cond, ...)  ZEROERR_LOG_FIRST(cond, ZEROERR_WARN, __VA_ARGS__)
#define ERR_FIRST(cond, ...)   ZEROERR_LOG_FIRST(cond, ZEROERR_ERROR, __VA_ARGS__)
#define FATAL_FIRST(cond, ...) ZEROERR_LOG_FIRST(cond, ZEROERR_FATAL, __VA_ARGS__)
 
#define ZEROERR_LOG_FIRST_(n, cond, ACTION, ...) \
    do {                                         \
        static unsigned counter = n;             \
        if (counter && (cond)) {                 \
            counter--;                           \
            ACTION(__VA_ARGS__);                 \
        }                                        \
    } while (0)
 
#define INFO_FIRST_(n, cond, ...)  ZEROERR_LOG_FIRST_(n, cond, ZEROERR_INFO, __VA_ARGS__)
#define LOG_FIRST_(n, cond, ...)   ZEROERR_LOG_FIRST_(n, cond, ZEROERR_LOG, __VA_ARGS__)
#define WARN_FIRST_(n, cond, ...)  ZEROERR_LOG_FIRST_(n, cond, ZEROERR_WARN, __VA_ARGS__)
#define ERR_FIRST_(n, cond, ...)   ZEROERR_LOG_FIRST_(n, cond, ZEROERR_ERROR, __VA_ARGS__)
#define FATAL_FIRST_(n, cond, ...) ZEROERR_LOG_FIRST_(n, cond, ZEROERR_FATAL, __VA_ARGS__)
 
#ifdef _DEBUG
#define DLOG(ACTION, ...) ZEROERR_EXPAND(ACTION(__VA_ARGS__))
#else
#define DLOG(ACTION, ...)
#endif
 
extern int _ZEROERR_G_VERBOSE;
 
#define ZEROERR_VERBOSE(v) if (zeroerr::_ZEROERR_G_VERBOSE >= (v))
 
#define ZEROERR_LOG_(severity, message, ...)                                        \
    do {                                                                            \
        ZEROERR_G_CONTEXT_SCOPE(true);                                              \
        auto msg = zeroerr::makeLogRecord(__VA_ARGS__);                             \
                                                                                    \
        static zeroerr::LogInfo log_info{__FILE__,                                  \
                                         __func__,                                  \
                                         message,                                   \
                                         ZEROERR_LOG_CATEGORY,                      \
                                         __LINE__,                                  \
                                         sizeof(msg.entry),                         \
                                         zeroerr::LogSeverity::severity};           \
        msg.entry.info = &log_info;                                                 \
        msg.stream.write(std::move(msg.entry));                                     \
    } while (0)
 
#define ZEROERR_INFO_(...) \
    ZEROERR_INFO_IMPL(ZEROERR_NAMEGEN(_capture_), ZEROERR_NAMEGEN(_capture_), __VA_ARGS__)
 
#define ZEROERR_INFO_IMPL(mb_name, v_name, ...)                                \
    auto v_name = zeroerr::MakeContextScope([&](zeroerr::StringBuffer& _capture_name) { \
        zeroerr::Printer print(_capture_name);                                          \
        print.isQuoted = false;                                                \
        print(__VA_ARGS__);                                                    \
    })
 
#ifdef ZEROERR_G_CONTEXT_SCOPE
#undef ZEROERR_G_CONTEXT_SCOPE
#endif
 
#define ZEROERR_G_CONTEXT_SCOPE(x)                                                     \
    if (x) {                                                                           \
        for (auto* zeroerr_context_scope : zeroerr::_ZEROERR_G_CONTEXT_SCOPE_VECTOR) { \
            zeroerr_context_scope->str(zeroerr::getStderrPrinter().os);                                     \
        }                                                                              \
    }
 
#ifdef ZEROERR_PRINT_ASSERT_DEFAULT_PRINTER
#undef ZEROERR_PRINT_ASSERT_DEFAULT_PRINTER
#endif
 
#define ZEROERR_PRINT_ASSERT_DEFAULT_PRINTER(cond, level, ...) \
    ZEROERR_LOG_IF(cond, level, __VA_ARGS__)
 
 
// This macro can access the log in memory
#define ZEROERR_LOG_GET(func, id, name, type) \
    zeroerr::LogStream::getDefault().getLog<type>(#func, id, #name)
 
 
namespace detail {
 
template <typename T, unsigned... I>
zeroerr::String gen_str(const char* msg, const T& args, seq<I...>) {
    return format(msg, std::get<I>(args)...);
}
 
template <typename T>
zeroerr::String gen_str(const char* msg, const T&, seq<>) {
    return msg;
}
 
}  // namespace detail
 
 
enum LogSeverity {
    INFO_l,  // it will not write to file if no other log related
    LOG_l,
    WARN_l,
    ERROR_l,
    FATAL_l,  // it will contain a stack trace
};

struct LogInfo {
    const char*                filename;
    const char*                function;
    const char*                message;
    const char*                category;
    unsigned                   line;
    unsigned                   size;
    LogSeverity                severity;
    std::map<zeroerr::String, int> names;
 
    LogInfo(const char* filename, const char* function, const char* message, const char* category,
            unsigned line, unsigned size, LogSeverity severity);
};
 
struct LogMessage;
typedef zeroerr::String (*LogCustomCallback)(const LogMessage&, bool colorful);

extern void setLogLevel(LogSeverity level);

extern void setLogCategory(const char* categories);

extern void setLogCustomCallback(LogCustomCallback callback);

extern void suspendLog();

extern void resumeLog();

struct alignas(std::max_align_t) LogMessage {
    // time is assigned when the log message is created
    LogMessage();
 
    // convert the log message to a string
    virtual zeroerr::String str() const = 0;
 
    // get the raw data pointer of the field with the name
    virtual void* getRawLog(zeroerr::String name) const = 0;
 
    // a map of the data indexing by the field name
    // for example: log("print {i}", 1);
    // a map of {"i": "1"} will be returned
    virtual std::map<zeroerr::String, zeroerr::String> getData() const = 0;
 
    // meta data of this log message
    const LogInfo* info = nullptr;
 
    virtual ~LogMessage() = default;
 
    // recorded wall time
    Timestamp time;
};
 

template <typename... T>
struct LogMessageImpl final : LogMessage {
    std::tuple<T...> args;
    LogMessageImpl(T... args) : LogMessage(), args(std::move(args)...) {}
 
    zeroerr::String str() const override {
        return gen_str(info->message, args, detail::gen_seq<sizeof...(T)>{});
    }
 
    // This is a helper class to get the raw pointer of the tuple
    struct GetTuplePtr {
        void* ptr = nullptr;
        template <typename H>
        void operator()(H& v) {
            ptr = (void*)&v;
        }
    };
 
    void* getRawLog(zeroerr::String name) const override {
        GetTuplePtr f;
        detail::visit_at(args, info->names.at(name), f);
        return f.ptr;
    }
 
    struct PrintTupleData {
        std::map<zeroerr::String, zeroerr::String> data;
        Printer                            print;
        zeroerr::String                        name;
 
        PrintTupleData() : print() {
            print.isCompact  = true;
            print.line_break = "";
        }
 
        template <typename H>
        void operator()(H& v) {
            data[name] = print(v);
        }
    };
 
    std::map<zeroerr::String, zeroerr::String> getData() const override {
        PrintTupleData printer;
        for (auto it = info->names.begin(); it != info->names.end(); ++it) {
            printer.name = it->first;
            detail::visit_at(args, it->second, printer);
        }
        return printer.data;
    }
};
 
struct DataBlock;
class LogStream;
 
class Logger {
public:
    virtual ~Logger()              = default;
    virtual void flush(DataBlock*) = 0;
};
 
struct PushResult {
    LogMessage* log;
    unsigned    size;
    LogStream&  stream;
};

class LogIterator {
public:
    LogIterator() : p(nullptr), q(nullptr) {}
    LogIterator(LogStream& stream, zeroerr::String message = "", zeroerr::String function_name = "",
                int line = -1);
    LogIterator(const LogIterator& rhs) : p(rhs.p), q(rhs.q) {}
    LogIterator& operator=(const LogIterator& rhs) {
        p = rhs.p;
        q = rhs.q;
        return *this;
    }
 
    LogIterator& operator++();
    LogIterator  operator++(int) {
        LogIterator tmp = *this;
        ++*this;
        return tmp;
    }
 
    template <typename T>
    T get(zeroerr::String name) {
        void* data = q->getRawLog(name);
        if (data) return *(T*)(data);
        return T{};
    }
 
    bool operator==(const LogIterator& rhs) const { return p == rhs.p && q == rhs.q; }
    bool operator!=(const LogIterator& rhs) const { return !(*this == rhs); }
 
    LogMessage& get() const { return *q; }
    LogMessage& operator*() const { return *q; }
    LogMessage* operator->() const { return q; }
 
    void check_at_safe_pos();
 
    friend class LogStream;
 
protected:
    bool check_filter();
    void next();
 
    DataBlock*  p;
    LogMessage* q;
 
    zeroerr::String function_name_filter;
    zeroerr::String message_filter;
    int         line_filter = -1;
};

class LogStream {
public:
    LogStream();
    virtual ~LogStream();
 
    enum FlushMode { FLUSH_AT_ONCE, FLUSH_WHEN_FULL, FLUSH_MANUALLY };
    enum LogMode { ASYNC, SYNC };
    enum DirMode {
        SINGLE_FILE       = 0,
        DAILY_FILE        = 1,
        SPLIT_BY_SEVERITY = 1 << 1,
        SPLIT_BY_CATEGORY = 1 << 2
    };
 

    // Low-level API: callers must externally synchronize metadata assignment
    // and flush. Prefer LOG/ZEROERR_LOG for concurrent producers.
    template <typename... T>
    PushResult push(T&&... args) {
        static_assert(alignof(LogMessageImpl<detail::to_store_type_t<T>...>) <= alignof(std::max_align_t),
                      "Over-aligned log arguments are not supported");
        ZEROERR_LOCK(*mutex);
        unsigned size = sizeof(LogMessageImpl<detail::to_store_type_t<T>...>);
        void* p = alloc_block(size);
        LogMessage* msg =
            new (p) LogMessageImpl<detail::to_store_type_t<T>...>(std::forward<T>(args)...);
        commit_block(ZEROERR_LOAD(m_last), size);
        return {msg, size, *this};
    }
 
 
    // Construct arguments before acquiring the stream lock. Publish only complete
    // records, so a concurrent flush cannot observe partially initialized data.
    template <typename... T>
    void write(LogMessageImpl<T...>&& message) {
        static_assert(alignof(LogMessageImpl<T...>) <= alignof(std::max_align_t),
                      "Over-aligned log arguments are not supported");
        ZEROERR_LOCK(*mutex);
        void* storage = alloc_block(sizeof(message));
        new (storage) LogMessageImpl<T...>(std::move(message));
        auto* last = ZEROERR_LOAD(m_last);
        commit_block(last, sizeof(message));
        if (flush_mode == FLUSH_AT_ONCE) flush_unlocked();
    }

    template <typename T>
    T getLog(zeroerr::String func, unsigned line, zeroerr::String name) {
        void* data = getRawLog(func, line, name);
        if (data) return *(T*)(data);
        return T{};
    }

    template <typename T>
    T getLog(zeroerr::String func, zeroerr::String msg, zeroerr::String name) {
        void* data = getRawLog(func, msg, name);
        if (data) return *(T*)(data);
        return T{};
    }
 
    LogIterator begin(zeroerr::String message = "", zeroerr::String function_name = "", int line = -1) {
        return LogIterator(*this, message, function_name, line);
    }
    LogIterator end() { return LogIterator(); }
    LogIterator current(zeroerr::String message = "", zeroerr::String function_name = "", int line = -1);
 
    void flush();
    void setFileLogger(zeroerr::String name, DirMode mode1 = SINGLE_FILE, DirMode mode2 = SINGLE_FILE,
                       DirMode mode3 = SINGLE_FILE);
    void setStdoutLogger();
    void setStderrLogger();
 
    static LogStream& getDefault();
 
    void setFlushAtOnce() { flush_mode = FLUSH_AT_ONCE; }
    void setFlushWhenFull() { flush_mode = FLUSH_WHEN_FULL; }
    void setFlushManually() { flush_mode = FLUSH_MANUALLY; }
    void setAsyncLog() { log_mode = ASYNC; }
    void setSyncLog() { log_mode = SYNC; }
 
    FlushMode getFlushMode() const { return flush_mode; }
    void      setFlushMode(FlushMode mode) { flush_mode = mode; }
    LogMode   getLogMode() const { return log_mode; }
    void      setLogMode(LogMode mode) { log_mode = mode; }
 
    // Compatibility flag; publication now always uses the stream mutex.
    bool use_lock_free = true;
 
    friend class LogIterator;
 
private:
    DataBlock* first;
    ZEROERR_ATOMIC(DataBlock*) m_last;
    Logger*   logger     = nullptr;
    FlushMode flush_mode = FLUSH_AT_ONCE;
    LogMode   log_mode   = SYNC;
#ifndef ZEROERR_NO_THREAD_SAFE
    detail::Mutex* mutex;
#endif
 
    // The implementation of alloc objects by giving a size
    void* alloc_block(unsigned size);
    void commit_block(DataBlock* block, unsigned size);
    void flush_unlocked();
 
 
    // The implementation of getLog which returns a raw pointer
    // This way can reduce the overhead of code generation by template
    void* getRawLog(zeroerr::String func, unsigned line, zeroerr::String name);
    void* getRawLog(zeroerr::String func, zeroerr::String msg, zeroerr::String name);
};
 
 
// A temporary owns argument storage while producers prepare records in parallel.
template <typename... T>
struct LogRecord {
    LogStream& stream;
    LogMessageImpl<detail::to_store_type_t<T>...> entry;
    LogRecord(LogStream& stream, T&&... args)
        : stream(stream), entry(std::forward<T>(args)...) {}
};
 
template <typename... T>
LogRecord<T...> makeLogRecord(LogStream& stream, T&&... args) {
    return LogRecord<T...>(stream, std::forward<T>(args)...);
}
 
template <typename... T>
LogRecord<T...> makeLogRecord(T&&... args) {
    return LogRecord<T...>(LogStream::getDefault(), std::forward<T>(args)...);
}
 
template <typename... T>
PushResult log(T&&... args) {
    return LogStream::getDefault().push(std::forward<T>(args)...);
}
 
template <typename... T>
PushResult log(LogStream& stream, T&&... args) {
    return stream.push(std::forward<T>(args)...);
}
 

class IContextScope {
public:
    virtual void str(zeroerr::StringBuffer& os) const = 0;
};
 
extern thread_local std::vector<IContextScope*> _ZEROERR_G_CONTEXT_SCOPE_VECTOR;

template <typename F>
class ContextScope : public IContextScope {
public:
    ContextScope(F f) : f_(f) { _ZEROERR_G_CONTEXT_SCOPE_VECTOR.push_back(this); }
    ~ContextScope() { _ZEROERR_G_CONTEXT_SCOPE_VECTOR.pop_back(); }
 
    virtual void str(zeroerr::StringBuffer& os) const override { return f_(os); }
 
protected:
    F f_;
};

template <typename F>
ContextScope<F> MakeContextScope(const F& f) {
    return ContextScope<F>(f);
}
 
 
}  // namespace zeroerr
 
ZEROERR_SUPPRESS_COMMON_WARNINGS_POP
 
#pragma pop_macro("_LIBCPP_REMOVE_TRANSITIVE_INCLUDES")