2858957f2fccd72144866dfac2bed7e3d0002835
[folly.git] / 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::WARN" 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" || lowerName == "dbg") {
53     return LogLevel::DBG;
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 level: " + name.str());
85   }
86 }
87
88 string logLevelToString(LogLevel level) {
89   if (level == LogLevel::UNINITIALIZED) {
90     return "UNINITIALIZED";
91   } else if (level == LogLevel::NONE) {
92     return "NONE";
93   } else if (level == LogLevel::DBG) {
94     return "DEBUG";
95   } else if (level == LogLevel::INFO) {
96     return "INFO";
97   } else if (level == LogLevel::WARN) {
98     return "WARN";
99   } else if (level == LogLevel::ERR) {
100     return "ERR";
101   } else if (level == LogLevel::CRITICAL) {
102     return "CRITICAL";
103   } else if (level == LogLevel::DFATAL) {
104     return "DFATAL";
105   } else if (level == LogLevel::FATAL) {
106     return "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::DBG)) {
111     auto num =
112         static_cast<uint32_t>(LogLevel::DBG0) - static_cast<uint32_t>(level);
113     return folly::to<string>("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 } // namespace folly