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   DEBUG = 900,
  44   DBG0 = 1000,
  45   DBG1 = 999,
  46   DBG2 = 998,
  47   DBG3 = 997,
  48   DBG4 = 996,
  49   DBG5 = 995,
  50   DBG6 = 994,
  51   DBG7 = 993,
  52   DBG8 = 992,
  53   DBG9 = 991,
  54
  55   INFO = 2000,
  56   WARN = 3000,
  57   WARNING = 3000,
  58
  59   // Unfortunately Windows headers #define ERROR
  60   // On Windows platforms we avoid defining ERROR.  However we make it
  61   // available on other platforms, to make it easier to convert code from
  62   // other log libraries that also use ERROR as their log level name (e.g.,
  63   // glog).
  64   ERR = 4000,
  65
  66   CRITICAL = 5000,
  67
  68   // DFATAL log messages crash the program on debug builds.
  69   DFATAL = 0x7ffffffe,
  70   // FATAL log messages always abort the program.
  71   // This level is equivalent to MAX_LEVEL.
  72   FATAL = 0x7fffffff,
  73
  74   // The most significant bit is used by LogCategory to store a flag value,
  75   // so the maximum value has that bit cleared.
  76   //
  77   // (We call this MAX_LEVEL instead of MAX just since MAX() is commonly
  78   // defined as a preprocessor macro by some C headers.)
  79   MAX_LEVEL = 0x7fffffff,
  80 };
  81
  82 /*
  83  * Support adding and subtracting integers from LogLevels, to create slightly
  84  * adjusted log level values.
  85  */
  86 inline constexpr LogLevel operator+(LogLevel level, uint32_t value) {
  87   auto newValue = static_cast<uint32_t>(level) + value;
  88   // Cap the result at LogLevel::MAX_LEVEL
  89   if (newValue > static_cast<uint32_t>(LogLevel::MAX_LEVEL)) {
  90     return LogLevel::MAX_LEVEL;
  91   }
  92   return static_cast<LogLevel>(newValue);
  93 }
  94 inline LogLevel& operator+=(LogLevel& level, uint32_t value) {
  95   level = level + value;
  96   return level;
  97 }
  98 inline constexpr LogLevel operator-(LogLevel level, uint32_t value) {
  99   return static_cast<LogLevel>(static_cast<uint32_t>(level) - value);
 100 }
 101 inline LogLevel& operator-=(LogLevel& level, uint32_t value) {
 102   level = level - value;
 103   return level;
 104 }
 105
 106 /**
 107  * Construct a LogLevel from a string name.
 108  */
 109 LogLevel stringToLogLevel(folly::StringPiece name);
 110
 111 /**
 112  * Get a human-readable string representing the LogLevel.
 113  */
 114 std::string logLevelToString(LogLevel level);
 115
 116 /**
 117  * Print a LogLevel in a human readable format.
 118  */
 119 std::ostream& operator<<(std::ostream& os, LogLevel level);
 120
 121 /**
 122  * Returns true if and only if a LogLevel is fatal.
 123  */
 124 inline constexpr bool isLogLevelFatal(LogLevel level) {
 125   return folly::kIsDebug ? (level >= LogLevel::DFATAL)
 126                          : (level >= LogLevel::FATAL);
 127 }
 128 }