Added core logging

integration-tests/tests/src/tests/shared-realms.ts

@@ -23,6 +23,33 @@ import { openRealmBefore, openRealmBeforeEach } from "../hooks";
 import { createLocalConfig } from "../utils/open-realm";
 
 describe("SharedRealm operations", () => {
+  describe("logger", () => {
+    it.only("logger callback gets called", async function () {
+      type Log = {
+        message: string;
+        level: string;
+      };
+      let logs: Log[] = [];
+
+      Realm.setLoggerCallback((level, message) => {
+        logs.push({ level, message });
+      });
+
+      Realm.setLogLevel("all");
+
+      const realm = await Realm.open({ schema: [{ name: "Person", properties: { name: "string" } }] });
+      realm.write(() => realm.create("Person", { name: "Alice" }));
+
+      expect(logs).to.not.be.empty;
+      console.log(logs.length);
+      logs = [];
+
+      Realm.setLogLevel("error");
+      realm.write(() => realm.create("Person", { name: "Alice" }));
+      expect(logs).to.be.empty;
+    });
+  });
+
   describe("object deletion", () => {
     openRealmBefore({ schema: [{ name: "Person", properties: { name: "string" } }] });
 

packages/bindgen/spec.yml

@@ -625,6 +625,7 @@ classes:
       is_empty_realm: '(realm: SharedRealm) -> bool'
       base64_decode: '(input: StringData) -> BinaryData'
       make_logger_factory: '(log: (level: LoggerLevel, message: const std::string&) off_thread) -> LoggerFactory'
+      make_logger:  '(log: (level: LoggerLevel, message: const std::string&) off_thread) -> SharedLogger'
       simulate_sync_error: '(session: SyncSession&, code: const int&, message: const std::string&, type: const std::string&, is_fatal: bool)'
       consume_thread_safe_reference_to_shared_realm: '(tsr: ThreadSafeReference) -> SharedRealm'
       file_exists: '(path: StringData) -> bool'

packages/bindgen/src/realm_js_helpers.h

@@ -194,6 +194,15 @@ struct Helpers {
     using LoggerFactory = std::function<std::shared_ptr<util::Logger>(util::Logger::Level)>;
     using LogCallback = std::function<void(util::Logger::Level, const std::string& message)>;
     static LoggerFactory make_logger_factory(LogCallback&& logger)
+    {
+        return [logger = std::move(logger)](util::Logger::Level level) mutable {
+            auto out = make_logger(std::move(logger));
+            out->set_level_threshold(level);
+            return out;
+        };
+    }
+
+    static std::shared_ptr<util::Logger> make_logger(LogCallback&& logger)
     {
         class MyLogger final : public util::Logger {
         public:
@@ -210,11 +219,7 @@ struct Helpers {
             LogCallback m_log;
         };
 
-        return [logger = std::move(logger)](util::Logger::Level level) {
-            auto out = std::make_shared<MyLogger>(logger);
-            out->set_level_threshold(level);
-            return out;
-        };
+        return std::make_shared<MyLogger>(logger);
     }
 
     static void simulate_sync_error(SyncSession& session, const int& code, const std::string& message,

packages/realm/src/Logger.ts

@@ -0,0 +1,71 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright 2023 Realm Inc.
+//
+// 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.
+//
+////////////////////////////////////////////////////////////////////////////
+
+import { assert, binding } from "./internal";
+
+export type LogLevel = "all" | "trace" | "debug" | "detail" | "info" | "warn" | "error" | "fatal" | "off";
+
+export enum NumericLogLevel {
+  All = 0,
+  Trace = 1,
+  Debug = 2,
+  Detail = 3,
+  Info = 4,
+  Warn = 5,
+  Error = 6,
+  Fatal = 7,
+  Off = 8,
+}
+
+export type Logger = (level: NumericLogLevel, message: string) => void;
+
+export type LoggerCallback = (level: LogLevel, message: string) => void;
+
+/** @internal */
+export function toBindingLoggerLevel(arg: LogLevel): binding.LoggerLevel {
+  const result = Object.entries(NumericLogLevel).find(([name]) => {
+    return name.toLowerCase() === arg;
+  });
+  assert(result, `Unexpected log level: ${arg}`);
+  const [, level] = result;
+  assert.number(level, "Expected a numeric level");
+  return level as number as binding.LoggerLevel;
+}
+
+/** @internal */
+export function fromBindingLoggerLevelToNumericLogLevel(arg: binding.LoggerLevel): NumericLogLevel {
+  // For now, these map 1-to-1
+  return arg as unknown as NumericLogLevel;
+}
+
+const translationTable = new Map<binding.LoggerLevel, LogLevel>([
+  [binding.LoggerLevel.All, "all"],
+  [binding.LoggerLevel.Trace, "trace"],
+  [binding.LoggerLevel.Debug, "debug"],
+  [binding.LoggerLevel.Detail, "detail"],
+  [binding.LoggerLevel.Info, "info"],
+  [binding.LoggerLevel.Warn, "warn"],
+  [binding.LoggerLevel.Error, "error"],
+  [binding.LoggerLevel.Fatal, "fatal"],
+  [binding.LoggerLevel.Off, "off"],
+]);
+
+/** @internal */
+export function fromBindingLoggerLevelToLogLevel(arg: binding.LoggerLevel): LogLevel {
+  return translationTable.get(arg) ?? "all";
+}

packages/realm/src/Realm.ts

@@ -88,6 +88,8 @@ import {
   List,
   LocalAppConfiguration,
   LogLevel,
+  Logger,
+  LoggerCallback,
   MapToDecorator,
   MigrationCallback,
   MongoDB,
@@ -154,6 +156,8 @@ import {
   binding,
   extendDebug,
   flags,
+  fromBindingLoggerLevelToLogLevel,
+  fromBindingLoggerLevelToNumericLogLevel,
   fromBindingRealmSchema,
   fs,
   index,
@@ -162,6 +166,7 @@ import {
   normalizeRealmSchema,
   safeGlobalThis,
   toArrayBuffer,
+  toBindingLoggerLevel,
   toBindingSchema,
   toBindingSyncConfig,
   validateConfiguration,
@@ -261,6 +266,21 @@ export class Realm {
 
   private static internals = new Set<binding.WeakRef<binding.Realm>>();
 
+  //TODO Add default logger
+  //TODO Add docs
+  static setLogLevel(level: LogLevel) {
+    const numericLevel = toBindingLoggerLevel(level);
+    binding.Logger.setDefaultLevelThreshold(numericLevel);
+  }
+
+  //TODO Add docs
+  static setLoggerCallback(loggerCallback: LoggerCallback) {
+    const logger = binding.Helpers.makeLogger((level, message) => {
+      loggerCallback(fromBindingLoggerLevelToLogLevel(level), message);
+    });
+    binding.Logger.setDefaultLogger(logger);
+  }
+
   /**
    * Clears the state by closing and deleting any Realm in the default directory and logout all users.
    * @private Not a part of the public API: It's primarily used from the library's tests.

packages/realm/src/app-services/Sync.ts

@@ -19,7 +19,10 @@
 import {
   App,
   ConnectionState,
+  LogLevel,
+  Logger,
   MutableSubscriptionSet,
+  NumericLogLevel,
   OpenRealmBehaviorConfiguration,
   OpenRealmBehaviorType,
   OpenRealmTimeOutBehavior,
@@ -31,41 +34,12 @@ import {
   User,
   assert,
   binding,
+  fromBindingLoggerLevelToNumericLogLevel,
+  toBindingLoggerLevel,
   toBindingSyncConfig,
   validateSyncConfiguration,
 } from "../internal";
 
-export type LogLevel = "all" | "trace" | "debug" | "detail" | "info" | "warn" | "error" | "fatal" | "off";
-
-export enum NumericLogLevel {
-  All = 0,
-  Trace = 1,
-  Debug = 2,
-  Detail = 3,
-  Info = 4,
-  Warn = 5,
-  Error = 6,
-  Fatal = 7,
-  Off = 8,
-}
-
-export type Logger = (level: NumericLogLevel, message: string) => void;
-
-function toBindingLoggerLevel(arg: LogLevel): binding.LoggerLevel {
-  const result = Object.entries(NumericLogLevel).find(([name]) => {
-    return name.toLowerCase() === arg;
-  });
-  assert(result, `Unexpected log level: ${arg}`);
-  const [, level] = result;
-  assert.number(level, "Expected a numeric level");
-  return level as number as binding.LoggerLevel;
-}
-
-function fromBindingLoggerLevel(arg: binding.LoggerLevel): NumericLogLevel {
-  // For now, these map 1-to-1
-  return arg as unknown as NumericLogLevel;
-}
-
 export class Sync {
   /** @deprecated Please use named imports */
   static Session = SyncSession;
@@ -82,13 +56,16 @@ export class Sync {
   /** @deprecated Please use named imports */
   static NumericLogLevel = NumericLogLevel;
 
+  //TODO Deprecate
   static setLogLevel(app: App, level: LogLevel) {
     const numericLevel = toBindingLoggerLevel(level);
     app.internal.syncManager.setLogLevel(numericLevel);
   }
+
+  //TODO Deprecate
   static setLogger(app: App, logger: Logger) {
     const factory = binding.Helpers.makeLoggerFactory((level, message) => {
-      logger(fromBindingLoggerLevel(level), message);
+      logger(fromBindingLoggerLevelToNumericLogLevel(level), message);
     });
     app.internal.syncManager.setLoggerFactory(factory);
   }

packages/realm/src/binding.ts

@@ -16,7 +16,7 @@
 //
 ////////////////////////////////////////////////////////////////////////////
 
-import { IndexSet, Int64, Logger, LoggerLevel, ObjKey, Timestamp } from "../generated/ts/native.mjs";
+import { IndexSet, Int64, ObjKey, Timestamp } from "../generated/ts/native.mjs";
 
 /** @internal */
 export * from "../generated/ts/native.mjs"; // core types are transitively exported.
@@ -73,6 +73,3 @@ export function isEmptyObjKey(objKey: ObjKey) {
   // This relies on the JS representation of an ObjKey being a bigint
   return Int64.equals(objKey as unknown as Int64, -1);
 }
-
-// Silence logs from core by default
-Logger.setDefaultLevelThreshold(LoggerLevel.Off);

packages/realm/src/internal.ts

@@ -69,6 +69,7 @@ export * from "./Set";
 export * from "./Dictionary";
 
 export * from "./Types";
+export * from "./Logger";
 
 export * from "./app-services/utils";
 export * from "./app-services/SyncConfiguration";