about summary refs log tree commit diff
path: root/src/libutil/logging.hh
blob: bb89643d0a0b29ee5fb4e19a96d2b055a171314a (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#pragma once

#include "types.hh"

namespace nix {

typedef enum {
    lvlError = 0,
    lvlInfo,
    lvlTalkative,
    lvlChatty,
    lvlDebug,
    lvlVomit
} Verbosity;

typedef enum {
    actUnknown = 0,
    actCopyPath = 100,
    actDownload = 101,
    actRealise = 102,
    actCopyPaths = 103,
    actBuilds = 104,
    actBuild = 105,
    actOptimiseStore = 106,
} ActivityType;

typedef uint64_t ActivityId;

class Logger
{
    friend class Activity;

public:

    virtual ~Logger() { }

    virtual void log(Verbosity lvl, const FormatOrString & fs) = 0;

    void log(const FormatOrString & fs)
    {
        log(lvlInfo, fs);
    }

    virtual void warn(const std::string & msg);

    virtual void startActivity(ActivityId act, ActivityType type, const std::string & s) { };

    virtual void stopActivity(ActivityId act) { };

    virtual void progress(ActivityId act, uint64_t done = 0, uint64_t expected = 0, uint64_t running = 0, uint64_t failed = 0) { };

    virtual void progress(ActivityId act, const std::string & s) { };

    virtual void setExpected(ActivityId act, ActivityType type, uint64_t expected) { };
};

struct Activity
{
    Logger & logger;

    const ActivityId id;

    Activity(Logger & logger, ActivityType type, const std::string & s = "");

    ~Activity()
    { logger.stopActivity(id); }

    void progress(uint64_t done = 0, uint64_t expected = 0, uint64_t running = 0, uint64_t failed = 0) const
    { logger.progress(id, done, expected, running, failed); }

    void progress(const std::string & s) const
    { logger.progress(id, s); }

    void setExpected(ActivityType type2, uint64_t expected) const
    { logger.setExpected(id, type2, expected); }

    friend class Logger;
};

extern Logger * logger;

Logger * makeDefaultLogger();

extern Verbosity verbosity; /* suppress msgs > this */

/* Print a message if the current log level is at least the specified
   level. Note that this has to be implemented as a macro to ensure
   that the arguments are evaluated lazily. */
#define printMsg(level, args...) \
    do { \
        if (level <= nix::verbosity) { \
            logger->log(level, fmt(args)); \
        } \
    } while (0)

#define printError(args...) printMsg(lvlError, 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, Args... args)
{
    boost::format f(fs);
    nop{boost::io::detail::feed(f, args)...};
    logger->warn(f.str());
}

void warnOnce(bool & haveWarned, const FormatOrString & fs);

void writeToStderr(const string & s);

}