logging: rename the `DEBUG` log level to `DBG`
[folly.git] / folly / experimental / logging / LogLevel.h
1 /*
2  * Copyright 2004-present Facebook, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *   http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #pragma once
17
18 #include <cstdint>
19 #include <iosfwd>
20 #include <string>
21 #include <type_traits>
22
23 #include <folly/Portability.h>
24 #include <folly/Range.h>
25
26 namespace folly {
27
28 /**
29  * Log level values.
30  *
31  * Higher levels are more important than lower ones.
32  *
33  * However, the numbers in the DBG* level names are reversed, and can be
34  * thought of as debug verbosity levels.  Increasing DBG* numbers mean
35  * increasing level of verbosity.  DBG0 is the least verbose debug level,
36  * DBG1 is one level higher of verbosity, etc.
37  */
38 enum class LogLevel : uint32_t {
39   UNINITIALIZED = 0,
40   NONE = 1,
41   MIN_LEVEL = 1,
42
43   // "DBG" is the lowest (aka most verbose) debug log level.
44   // This level is intended to be primarily used in log category settings.
45   // In your code it is usually better to use one of the finer-grained DBGn
46   // levels.  In your log category settings you can then set the log category
47   // level to a specific DBGn level, or to to main DBG level to enable all DBGn
48   // messages.
49   //
50   // This is named "DBG" rather than "DEBUG" since some open source projects
51   // define "DEBUG" as a preprocessor macro.
52   DBG = 900,
53
54   DBG0 = 1000,
55   DBG1 = 999,
56   DBG2 = 998,
57   DBG3 = 997,
58   DBG4 = 996,
59   DBG5 = 995,
60   DBG6 = 994,
61   DBG7 = 993,
62   DBG8 = 992,
63   DBG9 = 991,
64
65   INFO = 2000,
66   WARN = 3000,
67   WARNING = 3000,
68
69   // Unfortunately Windows headers #define ERROR, so we cannot use
70   // it as an enum value name.  We only provide ERR instead.
71   ERR = 4000,
72
73   CRITICAL = 5000,
74
75   // DFATAL log messages crash the program on debug builds.
76   DFATAL = 0x7ffffffe,
77   // FATAL log messages always abort the program.
78   // This level is equivalent to MAX_LEVEL.
79   FATAL = 0x7fffffff,
80
81   // The most significant bit is used by LogCategory to store a flag value,
82   // so the maximum value has that bit cleared.
83   //
84   // (We call this MAX_LEVEL instead of MAX just since MAX() is commonly
85   // defined as a preprocessor macro by some C headers.)
86   MAX_LEVEL = 0x7fffffff,
87 };
88
89 /*
90  * Support adding and subtracting integers from LogLevels, to create slightly
91  * adjusted log level values.
92  */
93 inline constexpr LogLevel operator+(LogLevel level, uint32_t value) {
94   // Cap the result at LogLevel::MAX_LEVEL
95   return ((static_cast<uint32_t>(level) + value) >
96           static_cast<uint32_t>(LogLevel::MAX_LEVEL))
97       ? LogLevel::MAX_LEVEL
98       : static_cast<LogLevel>(static_cast<uint32_t>(level) + value);
99 }
100 inline LogLevel& operator+=(LogLevel& level, uint32_t value) {
101   level = level + value;
102   return level;
103 }
104 inline constexpr LogLevel operator-(LogLevel level, uint32_t value) {
105   return static_cast<LogLevel>(static_cast<uint32_t>(level) - value);
106 }
107 inline LogLevel& operator-=(LogLevel& level, uint32_t value) {
108   level = level - value;
109   return level;
110 }
111
112 /**
113  * Construct a LogLevel from a string name.
114  */
115 LogLevel stringToLogLevel(folly::StringPiece name);
116
117 /**
118  * Get a human-readable string representing the LogLevel.
119  */
120 std::string logLevelToString(LogLevel level);
121
122 /**
123  * Print a LogLevel in a human readable format.
124  */
125 std::ostream& operator<<(std::ostream& os, LogLevel level);
126
127 /**
128  * Returns true if and only if a LogLevel is fatal.
129  */
130 inline constexpr bool isLogLevelFatal(LogLevel level) {
131   return folly::kIsDebug ? (level >= LogLevel::DFATAL)
132                          : (level >= LogLevel::FATAL);
133 }
134 } // namespace folly