Added a logger class that supports logging to the system logger, or a filtered logger that can be chained off other loggers (including the system logger).

PiperOrigin-RevId: 266273967

Author: amablue

app/CMakeLists.txt

@@ -84,7 +84,9 @@ build_flatbuffers("${CMAKE_CURRENT_LIST_DIR}/google_services.fbs"
 
 set(log_common_SRCS
     src/log.cc
-    set/log.h)
+    set/log.h
+    src/logger.cc
+    src/logger.h)
 set(log_common_HDRS)
 set(log_android_SRCS
     src/jobject_reference.cc

app/src/app_common.cc

@@ -147,12 +147,18 @@ const char* kCpuArchitecture = "x86";
 
 const char* kApiClientHeader = "x-goog-api-client";
 
+SystemLogger g_system_logger;  // NOLINT
+
 // Private cross platform data associated with an app.
 struct AppData {
+  AppData() : logger(&g_system_logger) {}
+
   // App associated with this data.
   App* app;
   // Notifies subscribers when the app is about to be destroyed.
   CleanupNotifier cleanup_notifier;
+  // A per-app logger.
+  Logger logger;
 };
 
 // Tracks library registrations.
@@ -244,7 +250,7 @@ App* AddApp(App* app, std::map<std::string, InitResult>* results) {
     g_default_app = app;
     created_first_app = true;
   }
-  UniquePtr<AppData> app_data(new AppData);
+  UniquePtr<AppData> app_data = MakeUnique<AppData>();
   app_data->app = app;
   app_data->cleanup_notifier.RegisterOwner(app);
   if (!g_apps) g_apps = new std::map<std::string, UniquePtr<AppData>>();
@@ -431,6 +437,18 @@ void GetOuterMostSdkAndVersion(std::string* sdk, std::string* version) {
   }
 }
 
+// Find a logger associated with an app by app name.
+Logger* FindAppLoggerByName(const char* name) {
+  assert(name);
+  MutexLock lock(g_app_mutex);
+  if (g_apps) {
+    auto it = g_apps->find(std::string(name));
+    if (it == g_apps->end()) return nullptr;
+    return &it->second->logger;
+  }
+  return nullptr;
+}
+
 }  // namespace app_common
 // NOLINTNEXTLINE - allow namespace overridden
 }  // namespace FIREBASE_NAMESPACE

app/src/app_common.h

@@ -23,6 +23,7 @@
 #include <string>
 
 #include "app/src/include/firebase/app.h"
+#include "app/src/logger.h"
 
 #if !defined(FIREBASE_NAMESPACE)
 #define FIREBASE_NAMESPACE firebase
@@ -95,6 +96,9 @@ std::string GetLibraryVersion(const char* library);
 // version is the version of the SDK respective SDK.
 void GetOuterMostSdkAndVersion(std::string* sdk, std::string* version);
 
+// Find a logger associated with an app by app name.
+Logger* FindAppLoggerByName(const char* name);
+
 }  // namespace app_common
 // NOLINTNEXTLINE - allow namespace overridden
 }  // namespace FIREBASE_NAMESPACE

app/src/log.cc

@@ -18,6 +18,7 @@
 
 #include <stdarg.h>
 #include <stdio.h>
+
 #include <cstdlib>
 
 #include "app/src/assert.h"
@@ -45,9 +46,9 @@ static void DefaultLogCallback(LogLevel log_level, const char* message,
                                void* /*callback_data*/);
 
 #if FIREBASE_LOG_DEBUG
-static const LogLevel kDefaultLogLevel = kLogLevelDebug;
+const LogLevel kDefaultLogLevel = kLogLevelDebug;
 #else
-static const LogLevel kDefaultLogLevel = kLogLevelInfo;
+const LogLevel kDefaultLogLevel = kLogLevelInfo;
 #endif  // FIREBASE_LOG_DEBUG
 
 LogLevel g_log_level = kDefaultLogLevel;

app/src/log.h

@@ -28,6 +28,8 @@
 
 namespace FIREBASE_NAMESPACE {
 
+extern const LogLevel kDefaultLogLevel;
+
 // Common log methods.
 
 // All messages at or above the specified log level value are displayed.

app/src/logger.cc

@@ -0,0 +1,103 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "app/src/logger.h"
+
+#include "app/src/log.h"
+
+namespace FIREBASE_NAMESPACE {
+
+LoggerBase::~LoggerBase() {}
+
+void LoggerBase::LogDebug(const char* format, ...) const {
+  va_list list;
+  va_start(list, format);
+  FilterLogMessageV(kLogLevelDebug, format, list);
+  va_end(list);
+}
+
+void LoggerBase::LogInfo(const char* format, ...) const {
+  va_list list;
+  va_start(list, format);
+  FilterLogMessageV(kLogLevelInfo, format, list);
+  va_end(list);
+}
+
+void LoggerBase::LogWarning(const char* format, ...) const {
+  va_list list;
+  va_start(list, format);
+  FilterLogMessageV(kLogLevelWarning, format, list);
+  va_end(list);
+}
+
+void LoggerBase::LogError(const char* format, ...) const {
+  va_list list;
+  va_start(list, format);
+  FilterLogMessageV(kLogLevelError, format, list);
+  va_end(list);
+}
+
+void LoggerBase::LogAssert(const char* format, ...) const {
+  va_list list;
+  va_start(list, format);
+  FilterLogMessageV(kLogLevelAssert, format, list);
+  va_end(list);
+}
+
+void LoggerBase::LogMessage(LogLevel log_level, const char* format, ...) const {
+  va_list list;
+  va_start(list, format);
+  FilterLogMessageV(log_level, format, list);
+  va_end(list);
+}
+
+void LoggerBase::LogMessageV(LogLevel log_level, const char* format,
+                             va_list args) const {
+  FilterLogMessageV(log_level, format, args);
+}
+
+void LoggerBase::FilterLogMessageV(LogLevel log_level, const char* format,
+                                   va_list args) const {
+  if (log_level >= this->GetLogLevel()) {
+    LogMessageImplV(log_level, format, args);
+  }
+}
+
+SystemLogger::~SystemLogger() {}
+
+void SystemLogger::SetLogLevel(LogLevel log_level) {
+  ::FIREBASE_NAMESPACE::SetLogLevel(log_level);
+}
+
+LogLevel SystemLogger::GetLogLevel() const {
+  return ::FIREBASE_NAMESPACE::GetLogLevel();
+}
+
+void SystemLogger::LogMessageImplV(LogLevel log_level, const char* format,
+                                   va_list args) const {
+  ::FIREBASE_NAMESPACE::LogMessageV(log_level, format, args);
+}
+
+Logger::~Logger() {}
+
+void Logger::SetLogLevel(LogLevel log_level) { log_level_ = log_level; }
+
+LogLevel Logger::GetLogLevel() const { return log_level_; }
+
+void Logger::LogMessageImplV(LogLevel log_level, const char* format,
+                             va_list args) const {
+  parent_logger_->LogMessageV(log_level, format, args);
+}
+
+}  // namespace FIREBASE_NAMESPACE

app/src/logger.h

@@ -0,0 +1,127 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FIREBASE_APP_CLIENT_CPP_SRC_LOGGER_H_
+#define FIREBASE_APP_CLIENT_CPP_SRC_LOGGER_H_
+
+#include <stdarg.h>
+
+#include "app/src/include/firebase/log.h"
+#include "app/src/log.h"
+
+#if !defined(FIREBASE_NAMESPACE)
+#define FIREBASE_NAMESPACE firebase
+#endif
+
+namespace FIREBASE_NAMESPACE {
+
+// This is a base class for logger implementations.
+class LoggerBase {
+ public:
+  virtual ~LoggerBase();
+
+  // Set the log level.
+  //
+  // Implementations of LoggerBase are responsible for tracking the log level.
+  virtual void SetLogLevel(LogLevel log_level) = 0;
+
+  // Get the currently set log level.
+  //
+  // Implementations of LoggerBase are responsible for tracking the log level.
+  virtual LogLevel GetLogLevel() const = 0;
+
+  // Log a debug message to the system log.
+  void LogDebug(const char* format, ...) const;
+
+  // Log an info message to the system log.
+  void LogInfo(const char* format, ...) const;
+
+  // Log a warning to the system log.
+  void LogWarning(const char* format, ...) const;
+
+  // Log an error to the system log.
+  void LogError(const char* format, ...) const;
+
+  // Log an assert and stop the application.
+  void LogAssert(const char* format, ...) const;
+
+  // Log a firebase message via LogMessageV().
+  void LogMessage(LogLevel log_level, const char* format, ...) const;
+
+  // Log a firebase message.
+  void LogMessageV(LogLevel log_level, const char* format, va_list args) const;
+
+ private:
+  // Handles the filtering for any message passed to it. If the log level of the
+  // message is greater than or equal to the log level of the logger, the
+  // message will be passed along to LogMessageImplV.
+  void FilterLogMessageV(LogLevel log_level, const char* format,
+                         va_list args) const;
+
+  // LogMessageImplV is responsible for doing the actual logging. It should pass
+  // along the format string and arguments to whatever library calls handle
+  // displaying logs for the given platform.
+  virtual void LogMessageImplV(LogLevel log_level, const char* format,
+                               va_list args) const = 0;
+};
+
+// A logger that calls through to the system logger.
+class SystemLogger : public LoggerBase {
+ public:
+  ~SystemLogger() override;
+
+  void SetLogLevel(LogLevel log_level) override;
+
+  LogLevel GetLogLevel() const override;
+
+ private:
+  // Logs a message to the system logger.
+  //
+  // In Firebase we already have a whole set of wrappers around system level
+  // logging, so this merely calls through to ::firebase::LogMessageV.
+  void LogMessageImplV(LogLevel log_level, const char* format,
+                       va_list args) const override;
+};
+
+// Logger is a general logger class that can be chained off of other loggers. It
+// does not actually handle displaying the logs themselves, but rather passes
+// the message and arguments up to its parent if the message is not filtered.
+// Filtering follows the standard rules: the log level of the message must be at
+// least as high as that of the current logger being used.  This is useful for
+// if you want to have finer grained control over subsystems.
+class Logger : public LoggerBase {
+ public:
+  explicit Logger(const LoggerBase* parent_logger)
+      : parent_logger_(parent_logger), log_level_(kDefaultLogLevel) {}
+  Logger(const LoggerBase* parent_logger, LogLevel log_level)
+      : parent_logger_(parent_logger), log_level_(log_level) {}
+
+  ~Logger() override;
+
+  void SetLogLevel(LogLevel log_level) override;
+
+  LogLevel GetLogLevel() const override;
+
+ private:
+  // Passes messages to the parent logger to be displayed.
+  void LogMessageImplV(LogLevel log_level, const char* format,
+                       va_list args) const override;
+
+  const LoggerBase* parent_logger_;
+  LogLevel log_level_;
+};
+
+}  // namespace FIREBASE_NAMESPACE
+
+#endif  // FIREBASE_APP_CLIENT_CPP_SRC_LOGGER_H_