logging.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libutil/types.hh"
#include "lix/libutil/error.hh"
#include "lix/libutil/config.hh"
 
namespace nix {
 
typedef enum {
    actUnknown = 0,
    actCopyPath = 100,
    actFileTransfer = 101,
    actRealise = 102,
    actCopyPaths = 103,
    actBuilds = 104,

    actBuild = 105,
    actOptimiseStore = 106,
    actVerifyPaths = 107,

    actSubstitute = 108,

    actQueryPathInfo = 109,

    actPostBuildHook = 110,
    actBuildWaiting = 111,
} ActivityType;
 
template<>
struct json::is_integral_enum<ActivityType> : std::true_type {};
 
typedef enum {
    resFileLinked = 100,

    resBuildLogLine = 101,
    resUntrustedPath = 102,
    resCorruptedPath = 103,

    resSetPhase = 104,

    resProgress = 105,

    resSetExpected = 106,

    resPostBuildLogLine = 107,
} ResultType;
 
template<>
struct json::is_integral_enum<ResultType> : std::true_type {};
 
typedef uint64_t ActivityId;
 
struct LoggerSettings : Config
{
    #include "logging-settings.gen.inc"
};
 
extern LoggerSettings loggerSettings;
 
class Logger
{
    friend struct Activity;
 
public:
 
    struct Field
    {
        // FIXME: use std::variant.
        enum { tInt = 0, tString = 1 } type;
        uint64_t i = 0;
        std::string s;
        Field(const std::string & s) : type(tString), s(s) { }
        Field(const char * s) : type(tString), s(s) { }
        Field(const uint64_t & i) : type(tInt), i(i) { }
    };
 
    typedef std::vector<Field> Fields;
 
    virtual ~Logger() { }
 
    virtual void pause() { };
    virtual void resetProgress() { };
    virtual void resume() { };
 
    // Whether the logger prints the whole build log
    virtual bool isVerbose() { return false; }
 
    virtual void log(Verbosity lvl, std::string_view s) = 0;
 
    void log(std::string_view s)
    {
        log(lvlInfo, s);
    }
 
    virtual void logEI(const ErrorInfo & ei) = 0;
 
    void logEI(Verbosity lvl, ErrorInfo ei)
    {
        ei.level = lvl;
        logEI(ei);
    }
 
    virtual void warn(const std::string & msg);
 
    virtual void startActivity(ActivityId act, Verbosity lvl, ActivityType type,
        const std::string & s, const Fields & fields, ActivityId parent) { };
 
    virtual void stopActivity(ActivityId act) { };
 
    virtual void result(ActivityId act, ResultType type, const Fields & fields) { };
 
    virtual void writeToStdout(std::string_view s);
 
    template<typename... Args>
    inline void cout(const Args & ... args)
    {
        writeToStdout(fmt(args...));
    }
 
    virtual std::optional<char> ask(std::string_view s)
    { return {}; }
 
    virtual void setPrintBuildLogs(bool printBuildLogs)
    { }
 
    virtual void setPrintMultiline(bool printMultiline)
    { }
};

struct nop
{
    template<typename... T> nop(T...)
    { }
};
 
ActivityId getCurActivity();
void setCurActivity(const ActivityId activityId);
 
struct Activity
{
    Logger & logger;
 
    const ActivityId id;
 
    Activity(Logger & logger, Verbosity lvl, ActivityType type, const std::string & s = "",
        const Logger::Fields & fields = {}, ActivityId parent = getCurActivity());
 
    Activity(Logger & logger, ActivityType type,
        const Logger::Fields & fields = {}, ActivityId parent = getCurActivity())
        : Activity(logger, lvlError, type, "", fields, parent) { };
 
    Activity(const Activity & act) = delete;
 
    ~Activity();
 
    void progress(uint64_t done = 0, uint64_t expected = 0, uint64_t running = 0, uint64_t failed = 0) const
    { result(resProgress, done, expected, running, failed); }
 
    void setExpected(ActivityType type2, uint64_t expected) const
    { result(resSetExpected, type2, expected); }
 
    template<typename... Args>
    void result(ResultType type, const Args & ... args) const
    {
        Logger::Fields fields;
        nop{(fields.emplace_back(Logger::Field(args)), 1)...};
        result(type, fields);
    }
 
    void result(ResultType type, const Logger::Fields & fields) const
    {
        logger.result(id, type, fields);
    }
 
    friend class Logger;
};
 
class PushActivity
{
    std::optional<ActivityId> prevAct;
 
public:
    PushActivity(ActivityId act) : prevAct(getCurActivity())
    {
        setCurActivity(act);
    }
 
    PushActivity(PushActivity && other)
    {
        std::swap(prevAct, other.prevAct);
    }
 
    PushActivity & operator=(PushActivity && other)
    {
        auto tmp(std::move(other));
        std::swap(prevAct, tmp.prevAct);
        return *this;
    }
 
    ~PushActivity()
    {
        if (prevAct) {
            setCurActivity(*prevAct);
        }
    }
};
 
extern Logger * logger;
 
Logger * makeSimpleLogger(bool printBuildLogs = true);
 
Logger * makeJSONLogger(Logger & prevLogger);

extern Verbosity verbosity;

#define logErrorInfo(level, errorInfo...) \
    do { \
        if ((level) <= nix::verbosity) {     \
            logger->logEI((level), errorInfo);  \
        } \
    } while (0)
 
#define logError(errorInfo...) logErrorInfo(lvlError, errorInfo)
#define logWarning(errorInfo...) logErrorInfo(lvlWarn, errorInfo)

#define printMsgUsing(loggerParam, level, args...)              \
    do {                                                        \
        auto _lix_logger_print_lvl = level;                     \
        if (_lix_logger_print_lvl <= nix::verbosity) {          \
            loggerParam->log(_lix_logger_print_lvl, fmt(args)); \
        }                                                       \
    } while (0)
#define printMsg(level, args...) printMsgUsing(logger, level, args)
 
#define printError(args...) printMsg(lvlError, args)
#define notice(args...) printMsg(lvlNotice, args)
#define printInfo(args...) printMsg(lvlInfo, args)
#define printTalkative(args...) printMsg(lvlTalkative, args)
#define debug(args...) printMsg(lvlDebug, args)
#define vomit(args...) printMsg(lvlVomit, args)

template<typename... Args>
inline void warn(const std::string & fs, const Args & ... args)
{
    logger->warn(HintFmt(fs, args...).str());
}
 
void writeLogsToStderr(std::string_view s);

void logFatal(std::string const & s);

std::optional<JSON> parseJSONMessage(const std::string & msg, std::string_view source);

bool handleJSONLogMessage(JSON & json,
    const Activity & act, std::map<ActivityId, Activity> & activities,
    std::string_view source,
    bool trusted);

bool handleJSONLogMessage(const std::string & msg,
    const Activity & act, std::map<ActivityId, Activity> & activities,
    std::string_view source,
    bool trusted);
 
}