feat: add console backend constructor that gets level from env (#6)

Author: cwaldren-ld

apps/hello-cpp/main.cpp

@@ -12,7 +12,7 @@ using launchdarkly::Logger;
 using launchdarkly::LogLevel;
 
 int main() {
-    Logger logger(std::make_unique<ConsoleBackend>(LogLevel::kInfo, "Hello"));
+    Logger logger(std::make_unique<ConsoleBackend>("Hello"));
 
     if (auto num = launchdarkly::foo()) {
         LD_LOG(logger, LogLevel::kInfo) << "Got: " << *num << '\n';

libs/common/CMakeLists.txt

@@ -30,6 +30,6 @@ include(FetchContent)
 # Add main SDK sources.
 add_subdirectory(src)
 
-if(BUILD_TESTING)
+if (BUILD_TESTING)
     add_subdirectory(tests)
-endif()
+endif ()

libs/common/include/console_backend.hpp

@@ -8,7 +8,18 @@ namespace launchdarkly {
  */
 class ConsoleBackend : public ILogBackend {
    public:
+    /**
+     * Constructs a ConsoleBackend which logs at the given level or above.
+     * @param level Emit logs at this level or above.
+     * @param name Log tag.
+     */
     ConsoleBackend(LogLevel level, std::string name);
+    /**
+     * Constructs a ConsoleBackend which logs at the level given by the
+     * LD_LOG_LEVEL environment variable, or info level by default.
+     * @param name Log tag.
+     */
+    ConsoleBackend(std::string name);
 
     bool enabled(LogLevel level) override;
 

libs/common/include/log_level.hpp

@@ -12,5 +12,19 @@ enum class LogLevel {
     kError,
 };
 
-char const* GetLDLogLevelName(LogLevel level);
+/**
+ * Lookup the name of a LogLevel.
+ * @param level Target level.
+ * @param default_ Default name to return if the level wasn't recognized.
+ * @return Name of the level as a string, or default_ if not recognized.
+ */
+char const* GetLogLevelName(LogLevel level, char const* default_);
+/**
+ * Lookup a LogLevel by name.
+ * @param level Name of level.
+ * @param default_ Default level to return if the level wasn't recognized.
+ * @return LogLevel matching the name, or default_ if not recognized.
+ */
+LogLevel GetLogLevelEnum(char const* name, LogLevel default_);
+
 }  // namespace launchdarkly

libs/common/src/console_backend.cpp

@@ -11,6 +11,11 @@ ConsoleBackend::ConsoleBackend(LogLevel level, std::string name)
     name_.append("] ");
 }
 
+ConsoleBackend::ConsoleBackend(std::string name)
+    : ConsoleBackend(
+          GetLogLevelEnum(std::getenv("LD_LOG_LEVEL"), LogLevel::kInfo),
+          std::move(name)) {}
+
 bool ConsoleBackend::enabled(LogLevel level) {
     return level >= level_;
 }

libs/common/src/log_level.cpp

@@ -1,21 +1,45 @@
 #include "log_level.hpp"
 
+#include <algorithm>
+#include <string>
+
 namespace launchdarkly {
-char const* GetLDLogLevelName(LogLevel level) {
+
+char const* GetLogLevelName(LogLevel level, char const* default_) {
     switch (level) {
-        case LogLevel::kDebug: {
-            return "kDebug";
-        } break;
-        case LogLevel::kInfo: {
-            return "kInfo";
-        } break;
+        case LogLevel::kDebug:
+            return "debug";
+        case LogLevel::kInfo:
+            return "info";
         case LogLevel::kWarn: {
-            return "kWarn";
-        } break;
-        case LogLevel::kError: {
-            return "kError";
-        } break;
+            return "warn";
+            case LogLevel::kError:
+                return "error";
+            default:
+                return default_;
+        }
+    }
+}
+
+LogLevel GetLogLevelEnum(char const* level, LogLevel default_) {
+    if (level == nullptr) {
+        return default_;
+    }
+    std::string lowercase = level;
+    std::transform(lowercase.begin(), lowercase.end(), lowercase.begin(),
+                   tolower);
+
+    if (lowercase == "debug") {
+        return LogLevel::kDebug;
+    } else if (lowercase == "info") {
+        return LogLevel::kInfo;
+    } else if (lowercase == "warn") {
+        return LogLevel::kWarn;
+    } else if (lowercase == "error") {
+        return LogLevel::kError;
+    } else {
+        return default_;
     }
-    return "INVALID";
 }
+
 }  // namespace launchdarkly

libs/common/tests/ld_logger_test.cpp

@@ -89,7 +89,8 @@ INSTANTIATE_TEST_SUITE_P(LDLoggerTest,
                                          LogLevel::kWarn,
                                          LogLevel::kError),
                          [](testing::TestParamInfo<LogLevel> const& info) {
-                             return launchdarkly::GetLDLogLevelName(info.param);
+                             return launchdarkly::GetLogLevelName(info.param,
+                                                                  "unknown");
                          });
 
 TEST(LDLoggerTest, UsesOstreamForEnabledLevel) {