logging: add numbered INFO* log level values

[folly.git] / folly / experimental / logging / LogLevel.cpp

diff --git a/folly/experimental/logging/LogLevel.cpp b/folly/experimental/logging/LogLevel.cpp
index c16eadba972e0cc57d08d6347fa8751d07d3a1d4..fc09b006784f6476480730909a3fc8d38853d1aa 100644 (file)
--- a/folly/experimental/logging/LogLevel.cpp
+++ b/folly/experimental/logging/LogLevel.cpp
@@ -15,6 +15,7 @@
  */
 #include <folly/experimental/logging/LogLevel.h>
 
+#include <array>
 #include <cctype>
 #include <ostream>
 
@@ -24,6 +25,20 @@ using std::string;
 
 namespace folly {
 
+namespace {
+struct NumberedLevelInfo {
+  LogLevel min;
+  LogLevel max;
+  StringPiece lowerPrefix;
+  StringPiece upperPrefix;
+};
+
+constexpr std::array<NumberedLevelInfo, 2> numberedLogLevels = {
+    NumberedLevelInfo{LogLevel::DBG, LogLevel::DBG0, "dbg", "DBG"},
+    NumberedLevelInfo{LogLevel::INFO, LogLevel::INFO0, "info", "INFO"},
+};
+} // namespace
+
 LogLevel stringToLogLevel(StringPiece name) {
   string lowerNameStr;
   lowerNameStr.reserve(name.size());
@@ -34,7 +49,7 @@ LogLevel stringToLogLevel(StringPiece name) {
 
   // If the string is of the form "LogLevel::foo" or "LogLevel(foo)"
   // strip it down just to "foo".  This makes sure we can process both
-  // the "LogLevel::DEBUG" and "LogLevel(1234)" formats produced by
+  // the "LogLevel::WARN" and "LogLevel(1234)" formats produced by
   // logLevelToString().
   constexpr StringPiece lowercasePrefix{"loglevel::"};
   constexpr StringPiece wrapperPrefix{"loglevel("};
@@ -49,8 +64,8 @@ LogLevel stringToLogLevel(StringPiece name) {
     return LogLevel::UNINITIALIZED;
   } else if (lowerName == "none") {
     return LogLevel::NONE;
-  } else if (lowerName == "debug") {
-    return LogLevel::DEBUG;
+  } else if (lowerName == "debug" || lowerName == "dbg") {
+    return LogLevel::DBG;
   } else if (lowerName == "info") {
     return LogLevel::INFO;
   } else if (lowerName == "warn" || lowerName == "warning") {
@@ -67,13 +82,19 @@ LogLevel stringToLogLevel(StringPiece name) {
     return LogLevel::MAX_LEVEL;
   }
 
-  if (lowerName.startsWith("dbg")) {
-    auto remainder = lowerName.subpiece(3);
+  for (const auto& info : numberedLogLevels) {
+    if (!lowerName.startsWith(info.lowerPrefix)) {
+      continue;
+    }
+    auto remainder = lowerName.subpiece(info.lowerPrefix.size());
     auto level = folly::tryTo<int>(remainder).value_or(-1);
-    if (level < 0 || level > 100) {
-      throw std::range_error("invalid dbg logger level: " + name.str());
+    if (level < 0 ||
+        static_cast<unsigned int>(level) > (static_cast<uint32_t>(info.max) -
+                                            static_cast<uint32_t>(info.min))) {
+      throw std::range_error(to<string>(
+          "invalid ", info.lowerPrefix, " logger level: ", name.str()));
     }
-    return LogLevel::DBG0 - level;
+    return info.max - level;
   }
 
   // Try as an plain integer if all else fails
@@ -81,37 +102,39 @@ LogLevel stringToLogLevel(StringPiece name) {
     auto level = folly::to<uint32_t>(lowerName);
     return static_cast<LogLevel>(level);
   } catch (const std::exception&) {
-    throw std::range_error("invalid logger name " + name.str());
+    throw std::range_error("invalid logger level: " + name.str());
   }
 }
 
 string logLevelToString(LogLevel level) {
   if (level == LogLevel::UNINITIALIZED) {
-    return "LogLevel::UNINITIALIZED";
+    return "UNINITIALIZED";
   } else if (level == LogLevel::NONE) {
-    return "LogLevel::NONE";
-  } else if (level == LogLevel::DEBUG) {
-    return "LogLevel::DEBUG";
+    return "NONE";
+  } else if (level == LogLevel::DBG) {
+    return "DEBUG";
   } else if (level == LogLevel::INFO) {
-    return "LogLevel::INFO";
+    return "INFO";
   } else if (level == LogLevel::WARN) {
-    return "LogLevel::WARN";
+    return "WARN";
   } else if (level == LogLevel::ERR) {
-    return "LogLevel::ERR";
+    return "ERR";
   } else if (level == LogLevel::CRITICAL) {
-    return "LogLevel::CRITICAL";
+    return "CRITICAL";
   } else if (level == LogLevel::DFATAL) {
-    return "LogLevel::DFATAL";
+    return "DFATAL";
   } else if (level == LogLevel::FATAL) {
-    return "LogLevel::FATAL";
+    return "FATAL";
   }
 
-  if (static_cast<uint32_t>(level) <= static_cast<uint32_t>(LogLevel::DBG0) &&
-      static_cast<uint32_t>(level) > static_cast<uint32_t>(LogLevel::DEBUG)) {
-    auto num =
-        static_cast<uint32_t>(LogLevel::DBG0) - static_cast<uint32_t>(level);
-    return folly::to<string>("LogLevel::DBG", num);
+  for (const auto& info : numberedLogLevels) {
+    if (static_cast<uint32_t>(level) <= static_cast<uint32_t>(info.max) &&
+        static_cast<uint32_t>(level) > static_cast<uint32_t>(info.min)) {
+      auto num = static_cast<uint32_t>(info.max) - static_cast<uint32_t>(level);
+      return folly::to<string>(info.upperPrefix, num);
+    }
   }
+
   return folly::to<string>("LogLevel(", static_cast<uint32_t>(level), ")");
 }
 
@@ -119,4 +142,4 @@ std::ostream& operator<<(std::ostream& os, LogLevel level) {
   os << logLevelToString(level);
   return os;
 }
-}
+} // namespace folly