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 == "uninitialized") {
  49     return LogLevel::UNINITIALIZED;
  50   } else if (lowerName == "none") {
  51     return LogLevel::NONE;
  52   } else if (lowerName == "debug") {
  53     return LogLevel::DEBUG;
  54   } else if (lowerName == "info") {
  55     return LogLevel::INFO;
  56   } else if (lowerName == "warn" || lowerName == "warning") {
  57     return LogLevel::WARN;
  58   } else if (lowerName == "error" || lowerName == "err") {
  59     return LogLevel::ERR;
  60   } else if (lowerName == "critical") {
  61     return LogLevel::CRITICAL;
  62   } else if (lowerName == "dfatal") {
  63     return LogLevel::DFATAL;
  64   } else if (lowerName == "fatal") {
  65     return LogLevel::FATAL;
  66   } else if (lowerName == "max" || lowerName == "max_level") {
  67     return LogLevel::MAX_LEVEL;
  68   }
  69
  70   if (lowerName.startsWith("dbg")) {
  71     auto remainder = lowerName.subpiece(3);
  72     auto level = folly::tryTo<int>(remainder).value_or(-1);
  73     if (level < 0 || level > 100) {
  74       throw std::range_error("invalid dbg logger level: " + name.str());
  75     }
  76     return LogLevel::DBG0 - level;
  77   }
  78
  79   // Try as an plain integer if all else fails
  80   try {
  81     auto level = folly::to<uint32_t>(lowerName);
  82     return static_cast<LogLevel>(level);
  83   } catch (const std::exception&) {
  84     throw std::range_error("invalid logger name " + name.str());
  85   }
  86 }
  87
  88 string logLevelToString(LogLevel level) {
  89   if (level == LogLevel::UNINITIALIZED) {
  90     return "LogLevel::UNINITIALIZED";
  91   } else if (level == LogLevel::NONE) {
  92     return "LogLevel::NONE";
  93   } else if (level == LogLevel::DEBUG) {
  94     return "LogLevel::DEBUG";
  95   } else if (level == LogLevel::INFO) {
  96     return "LogLevel::INFO";
  97   } else if (level == LogLevel::WARN) {
  98     return "LogLevel::WARN";
  99   } else if (level == LogLevel::ERR) {
 100     return "LogLevel::ERR";
 101   } else if (level == LogLevel::CRITICAL) {
 102     return "LogLevel::CRITICAL";
 103   } else if (level == LogLevel::DFATAL) {
 104     return "LogLevel::DFATAL";
 105   } else if (level == LogLevel::FATAL) {
 106     return "LogLevel::FATAL";
 107   }
 108
 109   if (static_cast<uint32_t>(level) <= static_cast<uint32_t>(LogLevel::DBG0) &&
 110       static_cast<uint32_t>(level) > static_cast<uint32_t>(LogLevel::DEBUG)) {
 111     auto num =
 112         static_cast<uint32_t>(LogLevel::DBG0) - static_cast<uint32_t>(level);
 113     return folly::to<string>("LogLevel::DBG", num);
 114   }
 115   return folly::to<string>("LogLevel(", static_cast<uint32_t>(level), ")");
 116 }
 117
 118 std::ostream& operator<<(std::ostream& os, LogLevel level) {
 119   os << logLevelToString(level);
 120   return os;
 121 }
 122 }