Add ability to set log level (#70)

src/CMakeLists.txt

@@ -34,7 +34,8 @@ set(SOURCES
     cpprealm/internal/bridge/async_open_task.cpp
     cpprealm/persisted_double.cpp
     cpprealm/internal/bridge/object_id.cpp
-    cpprealm/persisted_object_id.cpp) # REALM_SOURCES
+    cpprealm/persisted_object_id.cpp
+    cpprealm/logger.cpp) # REALM_SOURCES
 
 set(HEADERS
     cpprealm/sdk.hpp
@@ -92,7 +93,8 @@ set(HEADERS
     cpprealm/internal/bridge/sync_manager.hpp
     cpprealm/internal/bridge/async_open_task.hpp
     cpprealm/internal/bridge/object_id.hpp
-    cpprealm/persisted_object_id.hpp) # REALM_INSTALL_HEADERS
+    cpprealm/persisted_object_id.hpp
+    cpprealm/logger.hpp) # REALM_INSTALL_HEADERS
 
 add_library(cpprealm STATIC ${SOURCES} ${HEADERS})
 include(GNUInstallDirs)

src/cpprealm/analytics.cpp

@@ -16,7 +16,7 @@
 //
 ////////////////////////////////////////////////////////////////////////////
 
-#include "db.hpp"
+#include <cpprealm/analytics.hpp>
 #include <external/json/json.hpp>
 
 #if __APPLE__ || __MACH__

src/cpprealm/app.hpp

@@ -211,27 +211,6 @@ struct user {
 
 
 class App {
-    static std::unique_ptr<util::Logger> defaultSyncLogger(util::Logger::Level level) {
-    struct SyncLogger : public util::Logger {
-            void do_log(Level level, const std::string& message) override {
-                std::string copy = message;
-                switch (level) {
-                    case Level::all:
-                    case Level::warn:
-                        std::cout<<"sync: "<<copy<<std::endl;
-                        break;
-                    case Level::error:
-                        std::cerr<<"sync: "<<copy<<std::endl;
-                        break;
-                    default:
-                        break;
-                }
-            }
-        };
-        auto logger = std::make_unique<SyncLogger>();
-        logger->set_level_threshold(level);
-        return std::move(logger);
-    }
 public:
     explicit App(const std::string& app_id, const std::optional<std::string>& base_url = {}, const std::optional<std::string>& path = {});
 

src/cpprealm/db.hpp

@@ -22,19 +22,16 @@
 #include <filesystem>
 #include <iostream>
 
-#if !defined(REALM_DISABLE_ANALYTICS)
-#include <cpprealm/analytics.hpp>
-#endif
-
 #include <cpprealm/asymmetric_object.hpp>
-#include <cpprealm/results.hpp>
-#include <cpprealm/task.hpp>
 #include <cpprealm/flex_sync.hpp>
-#include <cpprealm/thread_safe_reference.hpp>
-#include <cpprealm/scheduler.hpp>
-#include <cpprealm/internal/bridge/schema.hpp>
 #include <cpprealm/internal/bridge/async_open_task.hpp>
+#include <cpprealm/internal/bridge/schema.hpp>
 #include <cpprealm/internal/bridge/sync_session.hpp>
+#include <cpprealm/logger.hpp>
+#include <cpprealm/results.hpp>
+#include <cpprealm/scheduler.hpp>
+#include <cpprealm/task.hpp>
+#include <cpprealm/thread_safe_reference.hpp>
 #include <utility>
 
 namespace realm {
@@ -51,11 +48,6 @@ struct db {
         (schema.push_back(Ts::schema.to_core_schema()), ...);
         config.set_schema(schema);
         m_realm = internal::bridge::realm(config);
-        static bool initialized;
-        if (!initialized) {
-            realm_analytics::send();
-            initialized = true;
-        }
     }
 
     sync_subscription_set subscriptions()
@@ -161,15 +153,7 @@ struct db {
 
 private:
     db(internal::bridge::realm realm) //NOLINT
-    : m_realm(std::move(realm))
-    {
-
-        static bool initialized;
-        if (!initialized) {
-            realm_analytics::send();
-            initialized = true;
-        }
-    }
+    : m_realm(std::move(realm)) { }
     template <typename>
     friend struct object;
     template <typename T, typename>

src/cpprealm/internal/bridge/realm.cpp

@@ -1,4 +1,6 @@
+#include <cpprealm/analytics.hpp>
 #include <cpprealm/internal/bridge/realm.hpp>
+#include <cpprealm/logger.hpp>
 #include <cpprealm/scheduler.hpp>
 #include <cpprealm/internal/bridge/object_schema.hpp>
 #include <cpprealm/internal/bridge/schema.hpp>
@@ -52,6 +54,12 @@ namespace realm::internal::bridge {
     #endif
 #endif
 
+    class null_logger : public logger {
+    public:
+        null_logger() = default;
+        void do_log(logger::level, const std::string&) override {}
+    };
+
     realm::realm(std::shared_ptr<Realm> v)
     : m_realm(std::move(v)){}
 
@@ -190,6 +198,13 @@ namespace realm::internal::bridge {
         return *reinterpret_cast<const RealmConfig*>(&m_config);
     }
     realm::realm(const config &v) {
+        static bool initialized;
+        if (!initialized) {
+            set_default_level_threshold(logger::level::off);
+            set_default_logger(std::make_shared<null_logger>());
+            realm_analytics::send();
+            initialized = true;
+        }
         m_realm = Realm::get_shared_realm(static_cast<RealmConfig>(v));
     }
 

src/cpprealm/internal/bridge/sync_manager.cpp

@@ -1,5 +1,4 @@
 #include <cpprealm/internal/bridge/sync_manager.hpp>
-
 #include <realm/object-store/sync/sync_manager.hpp>
 
 namespace realm::internal::bridge {
@@ -10,4 +9,8 @@ namespace realm::internal::bridge {
     sync_manager::sync_manager(const std::shared_ptr<SyncManager> &v) {
         m_manager = v;
     }
+
+    void sync_manager::set_log_level(logger::level level) {
+        m_manager->set_log_level(static_cast<util::Logger::Level>(level));
+    }
 }

src/cpprealm/internal/bridge/sync_manager.hpp

@@ -3,15 +3,16 @@
 
 #include <memory>
 #include <cpprealm/internal/bridge/realm.hpp>
+#include <cpprealm/logger.hpp>
 
 namespace realm {
     class SyncManager;
 
     namespace internal::bridge {
-
         struct sync_manager {
             sync_manager(const std::shared_ptr<SyncManager> &);
             [[nodiscard]] std::string path_for_realm(const realm::sync_config&) const;
+            void set_log_level(logger::level);
         private:
             std::shared_ptr<SyncManager> m_manager;
         };

src/cpprealm/logger.cpp

@@ -0,0 +1,80 @@
+#include "logger.hpp"
+#include "realm/util/logger.hpp"
+
+namespace realm {
+    static_assert((int)util::Logger::Level::off == (int)logger::level::off);
+    static_assert((int)util::Logger::Level::fatal == (int)logger::level::fatal);
+    static_assert((int)util::Logger::Level::error == (int)logger::level::error);
+    static_assert((int)util::Logger::Level::warn == (int)logger::level::warn);
+    static_assert((int)util::Logger::Level::info == (int)logger::level::info);
+    static_assert((int)util::Logger::Level::detail == (int)logger::level::detail);
+    static_assert((int)util::Logger::Level::debug == (int)logger::level::debug);
+    static_assert((int)util::Logger::Level::all == (int)logger::level::all);
+
+    inline logger::level log_level_for_level(util::Logger::Level log_level) {
+        switch (log_level) {
+            case util::Logger::Level::off:
+                return logger::level::off;
+            case util::Logger::Level::fatal:
+                return logger::level::fatal;
+            case util::Logger::Level::error:
+                return logger::level::error;
+            case util::Logger::Level::warn:
+                return logger::level::warn;
+            case util::Logger::Level::info:
+                return logger::level::info;
+            case util::Logger::Level::detail:
+                return logger::level::detail;
+            case util::Logger::Level::debug:
+                return logger::level::debug;
+            case util::Logger::Level::trace:
+                return logger::level::trace;
+            case util::Logger::Level::all:
+                return logger::level::all;
+        }
+        abort();
+    }
+
+    inline util::Logger::Level log_level_for_level(logger::level log_level) {
+        switch (log_level) {
+            case logger::level::off:
+                return util::Logger::Level::off;
+            case logger::level::fatal:
+                return util::Logger::Level::fatal;
+            case logger::level::error:
+                return util::Logger::Level::error;
+            case logger::level::warn:
+                return util::Logger::Level::warn;
+            case logger::level::info:
+                return util::Logger::Level::info;
+            case logger::level::detail:
+                return util::Logger::Level::detail;
+            case logger::level::debug:
+                return util::Logger::Level::debug;
+            case logger::level::trace:
+                return util::Logger::Level::trace;
+            case logger::level::all:
+                return util::Logger::Level::all;
+        }
+        abort();
+    }
+
+    struct internal_logger : public util::Logger {
+        internal_logger(std::shared_ptr<logger> &&s) {
+            m_logger = std::move(s);
+        }
+        void do_log(util::Logger::Level level, const std::string &msg) override {
+            m_logger->do_log(log_level_for_level(level), msg);
+        }
+
+    private:
+        std::shared_ptr<logger> m_logger;
+    };
+
+    void set_default_logger(std::shared_ptr<struct logger>&& l) {
+        util::Logger::set_default_logger(std::make_shared<internal_logger>(std::move(l)));
+    }
+    void set_default_level_threshold(logger::level l) {
+        util::Logger::set_default_level_threshold(log_level_for_level(l));
+    }
+}

src/cpprealm/logger.hpp

@@ -0,0 +1,37 @@
+#ifndef REALM_LOGGER_HPP
+#define REALM_LOGGER_HPP
+
+#include <memory>
+#include <string>
+
+namespace realm {
+    struct logger {
+        /// Specifies criticality when passed to log(). Functions as a criticality
+        /// threshold when returned from LevelThreshold::get().
+        ///
+        ///     error   Be silent unless when there is an error.
+        ///     warn    Be silent unless when there is an error or a warning.
+        ///     info    Reveal information about what is going on, but in a
+        ///             minimalistic fashion to avoid general overhead from logging
+        ///             and to keep volume down.
+        ///     detail  Same as 'info', but prioritize completeness over minimalism.
+        ///     debug   Reveal information that can aid debugging, no longer paying
+        ///             attention to efficiency.
+        ///     trace   A version of 'debug' that allows for very high volume
+        ///             output.
+        enum class level { all = 0,
+                           trace = 1,
+                           debug = 2,
+                           detail = 3,
+                           info = 4,
+                           warn = 5,
+                           error = 6,
+                           fatal = 7,
+                           off = 8 };
+        virtual void do_log(level, const std::string &) = 0;
+    };
+    void set_default_logger(std::shared_ptr<struct logger>&&);
+    void set_default_level_threshold(logger::level);
+}
+
+#endif//REALM_LOGGER_HPP

tests/flx_sync_tests.cpp

@@ -8,6 +8,7 @@ using namespace realm;
 TEST_CASE("flx_sync", "[sync]") {
     auto app = realm::App(Admin::shared().cached_app_id(), Admin::shared().base_url());
     SECTION("all") {
+        app.get_sync_manager().set_log_level(logger::level::off);
         auto user = app.login(realm::App::credentials::anonymous()).get_future().get();
         auto flx_sync_config = user.flexible_sync_configuration();
         auto synced_realm = realm::async_open<AllTypesObject, AllTypesObjectLink, AllTypesObjectEmbedded>(flx_sync_config).get_future().get().resolve();