folly/experimental/logging/LogLevel.cpp

   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 #include <folly/experimental/logging/LogLevel.h>
  17
  18 #include <cctype>
  19 #include <ostream>
  20
  21 #include <folly/Conv.h>
  22
  23 using std::string;
  24
  25 namespace folly {
  26
  27 LogLevel stringToLogLevel(StringPiece name) {
  28   string lowerNameStr;
  29   lowerNameStr.reserve(name.size());
  30   for (char c : name) {
  31     lowerNameStr.push_back(static_cast<char>(std::tolower(c)));
  32   }
  33   StringPiece lowerName{lowerNameStr};
  34
  35   // If the string is of the form "LogLevel::foo" or "LogLevel(foo)"
  36   // strip it down just to "foo".  This makes sure we can process both
  37   // the "LogLevel::DEBUG" and "LogLevel(1234)" formats produced by
  38   // logLevelToString().
  39   constexpr StringPiece lowercasePrefix{"loglevel::"};
  40   constexpr StringPiece wrapperPrefix{"loglevel("};
  41   if (lowerName.startsWith(lowercasePrefix)) {
  42     lowerName.advance(lowercasePrefix.size());
  43   } else if (lowerName.startsWith(wrapperPrefix) && lowerName.endsWith(")")) {
  44     lowerName.advance(wrapperPrefix.size());
  45     lowerName.subtract(1);
  46   }
  47
  48   if (lowerName == "none") {
  49     return LogLevel::NONE;
  50   } else if (lowerName == "debug") {
  51     return LogLevel::DEBUG;
  52   } else if (lowerName == "info") {
  53     return LogLevel::INFO;
  54   } else if (lowerName == "warn" || lowerName == "warning") {
  55     return LogLevel::WARN;
  56   } else if (lowerName == "error" || lowerName == "err") {
  57     return LogLevel::ERR;
  58   } else if (lowerName == "critical") {
  59     return LogLevel::CRITICAL;
  60   } else if (lowerName == "max" || lowerName == "max_level") {
  61     return LogLevel::MAX_LEVEL;
  62   }
  63
  64   if (lowerName.startsWith("dbg")) {
  65     auto remainder = lowerName.subpiece(3);
  66     auto level = folly::tryTo<int>(remainder).value_or(-1);
  67     if (level < 0 || level > 100) {
  68       throw std::range_error("invalid dbg logger level: " + name.str());
  69     }
  70     return LogLevel::DBG0 - level;
  71   }
  72
  73   // Try as an plain integer if all else fails
  74   try {
  75     auto level = folly::to<uint32_t>(lowerName);
  76     return static_cast<LogLevel>(level);
  77   } catch (const std::exception& ex) {
  78     throw std::range_error("invalid logger name " + name.str());
  79   }
  80 }
  81
  82 string logLevelToString(LogLevel level) {
  83   if (level == LogLevel::NONE) {
  84     return "LogLevel::NONE";
  85   } else if (level == LogLevel::DEBUG) {
  86     return "LogLevel::DEBUG";
  87   } else if (level == LogLevel::INFO) {
  88     return "LogLevel::INFO";
  89   } else if (level == LogLevel::WARN) {
  90     return "LogLevel::WARN";
  91   } else if (level == LogLevel::ERR) {
  92     return "LogLevel::ERR";
  93   } else if (level == LogLevel::CRITICAL) {
  94     return "LogLevel::CRITICAL";
  95   } else if (level == LogLevel::MAX_LEVEL) {
  96     return "LogLevel::MAX_LEVEL";
  97   }
  98
  99   if (static_cast<uint32_t>(level) <= static_cast<uint32_t>(LogLevel::DBG0) &&
 100       static_cast<uint32_t>(level) > static_cast<uint32_t>(LogLevel::DEBUG)) {
 101     auto num =
 102         static_cast<uint32_t>(LogLevel::DBG0) - static_cast<uint32_t>(level);
 103     return folly::to<string>("LogLevel::DBG", num);
 104   }
 105   return folly::to<string>("LogLevel(", static_cast<uint32_t>(level), ")");
 106 }
 107
 108 std::ostream& operator<<(std::ostream& os, LogLevel level) {
 109   os << logLevelToString(level);
 110   return os;
 111 }
 112 }