Implementation of RT DB C++ log level methods.

Added a way to set the logger verbosity of the RT DB via the C++ interface.

PiperOrigin-RevId: 254108819

Author: smiles

database/src/android/database_android.cc

@@ -18,6 +18,7 @@
 #include <jni.h>
 #include "app/src/include/firebase/app.h"
 #include "app/src/include/firebase/future.h"
+#include "app/src/include/firebase/log.h"
 #include "app/src/reference_counted_future_impl.h"
 #include "app/src/util_android.h"
 #include "database/database_resources.h"
@@ -35,6 +36,19 @@ namespace internal {
 
 const char kApiIdentifier[] = "Database";
 
+// clang-format off
+#define LOGGER_LEVEL_METHODS(X)                                         \
+  X(ValueOf, "valueOf",                                                 \
+    "(Ljava/lang/String;)Lcom/google/firebase/database/Logger$Level;",  \
+    util::kMethodTypeStatic)
+// clang-format on
+METHOD_LOOKUP_DECLARATION(logger_level, LOGGER_LEVEL_METHODS)
+
+METHOD_LOOKUP_DEFINITION(
+    logger_level,
+    PROGUARD_KEEP_CLASS "com/google/firebase/database/Logger$Level",
+    LOGGER_LEVEL_METHODS)
+
 // clang-format off
 #define FIREBASE_DATABASE_METHODS(X)                                    \
   X(GetInstance, "getInstance",                                         \
@@ -147,7 +161,7 @@ Mutex DatabaseInternal::init_mutex_;  // NOLINT
 int DatabaseInternal::initialize_count_ = 0;
 std::map<jint, Error>* DatabaseInternal::java_error_to_cpp_ = nullptr;
 
-DatabaseInternal::DatabaseInternal(App* app) {
+DatabaseInternal::DatabaseInternal(App* app) : log_level_(kLogLevelInfo) {
   app_ = nullptr;
   if (!Initialize(app)) return;
   app_ = app;
@@ -170,7 +184,7 @@ DatabaseInternal::DatabaseInternal(App* app) {
 }
 
 DatabaseInternal::DatabaseInternal(App* app, const char* url)
-    : constructor_url_(url) {
+    : constructor_url_(url), log_level_(kLogLevelInfo) {
   app_ = nullptr;
   if (!Initialize(app)) return;
   app_ = app;
@@ -213,12 +227,23 @@ static const struct {
     {database_error::kFieldCount, kErrorNone},  // sentinel value for end
 };
 
+// C++ log levels mapped to Logger.Level enum value names.
+const char* kCppLogLevelToLoggerLevelName[] = {
+  "DEBUG",  // kLogLevelVerbose --> Logger.Level.DEBUG
+  "DEBUG",  // kLogLevelDebug --> Logger.Level.DEBUG
+  "INFO",  // kLogLevelInfo --> Logger.Level.INFO
+  "WARN",  // kLogLevelWarning --> Logger.Level.WARN
+  "ERROR",  // kLogLevelError --> Logger.Level.ERROR
+  "NONE",  // kLogLevelAssert --> Logger.Level.NONE
+};
+
 bool DatabaseInternal::Initialize(App* app) {
   MutexLock init_lock(init_mutex_);
   if (initialize_count_ == 0) {
     JNIEnv* env = app->GetJNIEnv();
     jobject activity = app->activity();
     if (!(firebase_database::CacheMethodIds(env, activity) &&
+          logger_level::CacheMethodIds(env, activity) &&
           database_error::CacheMethodIds(env, activity) &&
           database_error::CacheFieldIds(env, activity) &&
           // Call Initialize on all other RTDB internal classes.
@@ -332,6 +357,7 @@ bool DatabaseInternal::InitializeEmbeddedClasses(App* app) {
 void DatabaseInternal::ReleaseClasses(App* app) {
   JNIEnv* env = app->GetJNIEnv();
   firebase_database::ReleaseClass(env);
+  logger_level::ReleaseClass(env);
   database_error::ReleaseClass(env);
 
   // Call Terminate on all other RTDB internal classes.
@@ -493,6 +519,33 @@ void DatabaseInternal::SetPersistenceEnabled(bool enabled) const {
   util::CheckAndClearJniExceptions(env);
 }
 
+void DatabaseInternal::set_log_level(LogLevel log_level) {
+  FIREBASE_ASSERT_RETURN_VOID(log_level <
+                              (sizeof(kCppLogLevelToLoggerLevelName) /
+                               sizeof(kCppLogLevelToLoggerLevelName[0])));
+  JNIEnv* env = app_->GetJNIEnv();
+  jstring enum_name = env->NewStringUTF(
+      kCppLogLevelToLoggerLevelName[log_level]);
+  if (!util::CheckAndClearJniExceptions(env)) {
+    jobject log_level_enum_obj = env->CallStaticObjectMethod(
+        logger_level::GetClass(),
+        logger_level::GetMethodId(logger_level::kValueOf), enum_name);
+    if (!util::CheckAndClearJniExceptions(env)) {
+      env->CallVoidMethod(
+          obj_,
+          firebase_database::GetMethodId(firebase_database::kSetLogLevel),
+          log_level_enum_obj);
+      if (!util::CheckAndClearJniExceptions(env)) {
+        log_level_ = log_level;
+      }
+      env->DeleteLocalRef(log_level_enum_obj);
+    }
+    env->DeleteLocalRef(enum_name);
+  }
+}
+
+LogLevel DatabaseInternal::log_level() const { return log_level_; }
+
 Error DatabaseInternal::ErrorFromResultAndErrorCode(
     util::FutureResult result_code, jint error_code) const {
   switch (result_code) {

database/src/android/database_android.h

@@ -22,6 +22,7 @@
 #include "app/src/cleanup_notifier.h"
 #include "app/src/future_manager.h"
 #include "app/src/include/firebase/app.h"
+#include "app/src/include/firebase/log.h"
 #include "app/src/mutex.h"
 #include "app/src/util_android.h"
 #include "database/src/android/database_reference_android.h"
@@ -64,6 +65,14 @@ class DatabaseInternal {
 
   void SetPersistenceEnabled(bool enabled) const;
 
+  // Set the logging verbosity.
+  // kLogLevelDebug and kLogLevelVerbose are interpreted as the same level by
+  // the Android implementation.
+  void set_log_level(LogLevel log_level);
+
+  // Get the logging verbosity.
+  LogLevel log_level() const;
+
   // Convert a future result code and error code from a Java DatabaseError into
   // a C++ Error enum.
   Error ErrorFromResultAndErrorCode(util::FutureResult result_code,
@@ -203,6 +212,8 @@ class DatabaseInternal {
   // The url passed to the constructor (or "" if none was passed).
   // We keep it so that we can find the database in our cache.
   std::string constructor_url_;
+
+  LogLevel log_level_;
 };
 
 }  // namespace internal

database/src/common/database.cc

@@ -195,12 +195,13 @@ void Database::set_persistence_enabled(bool enabled) {
   if (internal_) internal_->SetPersistenceEnabled(enabled);
 }
 
-#if defined(INTERNAL_EXPERIMENTAL) || defined(SWIG)
-void Database::set_log_level(LogLevel level) {
+void Database::set_log_level(LogLevel log_level) {
+  if (internal_) internal_->set_log_level(log_level);
 }
 
-LogLevel Database::log_level() const { return kLogLevelInfo; }
-#endif  // defined(INTERNAL_EXPERIMENTAL) || defined(SWIG)
+LogLevel Database::log_level() const {
+  return internal_ ? internal_->log_level() : kLogLevelInfo;
+}
 
 }  // namespace database
 }  // namespace firebase

database/src/desktop/database_desktop.cc

@@ -69,7 +69,8 @@ DatabaseInternal::DatabaseInternal(App* app, const char* url)
       cleanup_(),
       safe_this_(this),
       constructor_url_(url),
-      repo_(app, this, url) {
+      repo_(app, this, url),
+      log_level_(kLogLevelInfo) {
   assert(app);
   assert(url);
 
@@ -185,6 +186,12 @@ void DatabaseInternal::SetPersistenceEnabled(bool /*enabled*/) {
   LogWarning("Persistence is not currently supported.");
 }
 
+void DatabaseInternal::set_log_level(LogLevel log_level) {
+  log_level_ = log_level;
+}
+
+LogLevel DatabaseInternal::log_level() const { return log_level_; }
+
 void DatabaseInternal::SetVerboseLogging(bool /*enable*/) {}
 
 bool DatabaseInternal::RegisterValueListener(

database/src/desktop/database_desktop.h

@@ -85,6 +85,12 @@ class DatabaseInternal {
 
   void SetPersistenceEnabled(bool enabled);
 
+  // Set the logging verbosity.
+  void set_log_level(LogLevel log_level);
+
+  // Get the logging verbosity.
+  LogLevel log_level() const;
+
   static void SetVerboseLogging(bool enable);
 
   FutureManager& future_manager() { return future_manager_; }
@@ -189,6 +195,8 @@ class DatabaseInternal {
 
   // The local copy of the repository, for offline support and local caching.
   Repo repo_;
+
+  LogLevel log_level_;
 };
 
 }  // namespace internal

database/src/ios/database_ios.h

@@ -85,7 +85,13 @@ class DatabaseInternal {
   // Sets whether pending write data will persist between application exits.
   void SetPersistenceEnabled(bool enabled);
 
-  static void SetVerboseLogging(bool enable);
+  // Set the logging verbosity.
+  // The iOS implementation only enables logging for kLogLevelVerbose &
+  // kLogLevelDebug, logging is disabled in for all other levels.
+  void set_log_level(LogLevel log_level);
+
+  // Get the logging verbosity.
+  LogLevel log_level() const;
 
 #ifdef __OBJC__
   bool RegisterValueListener(
@@ -180,6 +186,8 @@ class DatabaseInternal {
   // The url passed to the constructor (or "" if none was passed).
   // We keep it so that we can find the database in our cache.
   std::string constructor_url_;
+
+  LogLevel log_level_;
 };
 
 #pragma clang assume_nonnull end

database/src/ios/database_ios.mm

@@ -15,6 +15,7 @@
 #include "database/src/ios/database_ios.h"
 
 #include "app/src/app_ios.h"
+#include "app/src/util.h"
 #include "app/src/include/firebase/app.h"
 #include "app/src/include/firebase/future.h"
 #include "app/src/reference_counted_future_impl.h"
@@ -26,7 +27,7 @@
 namespace internal {
 
 DatabaseInternal::DatabaseInternal(App* app)
-    : app_(app) {
+    : app_(app), log_level_(kLogLevelInfo) {
   @try {
     impl_.reset(new FIRDatabasePointer(
         [FIRDatabase databaseForApp:static_cast<FIRAppPointer*>(app->data_)->ptr]));
@@ -40,7 +41,7 @@
 }
 
 DatabaseInternal::DatabaseInternal(App* app, const char* url)
-    : app_(app), constructor_url_(url) {
+    : app_(app), constructor_url_(url), log_level_(kLogLevelInfo) {
   @try {
     impl_.reset(new FIRDatabasePointer(
         [FIRDatabase databaseForApp:static_cast<FIRAppPointer*>(app->data_)->ptr URL:@(url)]));
@@ -104,8 +105,31 @@ new DatabaseReferenceInternal(const_cast<DatabaseInternal*>(this),
 
 void DatabaseInternal::SetPersistenceEnabled(bool enabled) { impl().persistenceEnabled = enabled; }
 
-void DatabaseInternal::SetVerboseLogging(bool enable) {
-  [FIRDatabase setLoggingEnabled:enable ? YES : NO];
+void DatabaseInternal::set_log_level(LogLevel log_level) {
+  // iOS FIRDatabase only supports logging or not logging.  Since the default logging level (Info)
+  // should be quiet except for notices that can be resolved by the developer fixing their code,
+  // logging is enabled for only kLogLevelVerbose & kLogLevelDebug.
+  switch (log_level) {
+    case kLogLevelVerbose:
+      FIREBASE_CASE_FALLTHROUGH;
+    case kLogLevelDebug:
+      [FIRDatabase setLoggingEnabled:YES];
+      break;
+    case kLogLevelInfo:
+      FIREBASE_CASE_FALLTHROUGH;
+    case kLogLevelWarning:
+      FIREBASE_CASE_FALLTHROUGH;
+    case kLogLevelError:
+      FIREBASE_CASE_FALLTHROUGH;
+    case kLogLevelAssert:
+      [FIRDatabase setLoggingEnabled:NO];
+      break;
+  }
+  log_level_ = log_level;
+}
+
+LogLevel DatabaseInternal::log_level() const {
+  return log_level_;
 }
 
 bool DatabaseInternal::RegisterValueListener(