Added core logging

CHANGELOG.md

@@ -5,6 +5,7 @@
 
 ### Enhancements
 * Enable multiple processes to operate on an encrypted Realm simultaneously. ([realm/realm-core#1845](https://github.com/realm/realm-core/issues/1845))
+* Added `Realm.setLoggerCallback`, that allows to setup a single static logger for the duration of the app lifetime. Differently from the now deprecated sync logger (that was setup with `Sync.setLogger`), this new one will emit messages coming also from the local database, and not only from sync. It is also possible to change the log level during the whole duration of the app lifetime with `Realm.setLogLevel`. ([#2546](https://github.com/realm/realm-js/issues/2546))
 
 ### Fixed
 * Fix a stack overflow crash when using the query parser with long chains of AND/OR conditions. ([realm/realm-core#6428](https://github.com/realm/realm-core/pull/6428), since v10.11.0)

integration-tests/tests/src/setup-globals.ts

@@ -62,3 +62,8 @@ describe("Test Harness", function (this: Mocha.Suite) {
   Suite.prototype.longTimeout = longTimeout;
   Context.prototype.longTimeout = longTimeout;
 });
+
+import { Realm } from "realm";
+
+//Disable the logger to avoid console flooding
+Realm.setLogLevel("off");

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

@@ -22,7 +22,57 @@ import { Realm, List } from "realm";
 import { openRealmBefore, openRealmBeforeEach } from "../hooks";
 import { createLocalConfig } from "../utils/open-realm";
 
-describe("SharedRealm operations", () => {
+describe.only("SharedRealm operations", () => {
+  describe("logger", () => {
+    it("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;
+      expect(logs.map((l) => l.level)).to.contain.members(["trace", "debug"]);
+      logs = [];
+
+      Realm.setLogLevel("trace");
+      realm.write(() => realm.create("Person", { name: "Alice" }));
+      expect(logs.map((l) => l.level)).to.contain.members(["trace", "debug"]);
+      logs = [];
+
+      Realm.setLogLevel("debug");
+      realm.write(() => realm.create("Person", { name: "Alice" }));
+      expect(logs.map((l) => l.level))
+        .to.contain("debug")
+        .and.to.not.contain("trace");
+      logs = [];
+
+      Realm.setLogLevel("warn");
+      realm.write(() => realm.create("Person", { name: "Alice" }));
+      expect(logs).to.be.empty;
+
+      Realm.setLogLevel("error");
+      realm.write(() => realm.create("Person", { name: "Alice" }));
+      expect(logs).to.be.empty;
+
+      //This will also disable the logger again after the test
+      Realm.setLogLevel("off");
+      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,91 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// 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 bindingLogLevel = inverseTranslationTable[arg];
+  assert(bindingLogLevel !== undefined, `Unexpected log level: ${arg}`);
+  return bindingLogLevel;
+}
+
+/** @internal */
+export function fromBindingLoggerLevelToNumericLogLevel(arg: binding.LoggerLevel): NumericLogLevel {
+  // For now, these map 1-to-1
+  return arg as unknown as NumericLogLevel;
+}
+
+const translationTable: Record<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",
+};
+
+const inverseTranslationTable: Record<LogLevel, binding.LoggerLevel> = Object.fromEntries(
+  Object.entries(translationTable).map(([key, val]) => [val, Number(key)]),
+) as unknown as Record<LogLevel, binding.LoggerLevel>;
+
+/** @internal */
+export function fromBindingLoggerLevelToLogLevel(arg: binding.LoggerLevel): LogLevel {
+  return translationTable[arg];
+}
+
+const consoleErrorLevels: LogLevel[] = ["error", "fatal"];
+const consoleWarnLevels: LogLevel[] = ["warn"];
+
+/** @internal */
+export const defaultLogger: LoggerCallback = function (logLevel: LogLevel, message: string) {
+  const formattedLogMessage = `[${logLevel}] ${message}`;
+  /* eslint-disable no-console */
+  if (consoleErrorLevels.includes(logLevel)) {
+    console.error(formattedLogMessage);
+  } else if (consoleWarnLevels.includes(logLevel)) {
+    console.error(formattedLogMessage);
+  } else {
+    console.log(formattedLogMessage);
+  }
+  /* eslint-enable no-console */
+};
+
+/** @internal */
+export const defaultLoggerLevel: LogLevel = "warn";

packages/realm/src/Realm.ts

@@ -88,6 +88,7 @@ import {
   List,
   LocalAppConfiguration,
   LogLevel,
+  LoggerCallback,
   MapToDecorator,
   MigrationCallback,
   MongoDB,
@@ -152,8 +153,11 @@ import {
   UserState,
   assert,
   binding,
+  defaultLogger,
+  defaultLoggerLevel,
   extendDebug,
   flags,
+  fromBindingLoggerLevelToLogLevel,
   fromBindingRealmSchema,
   fs,
   index,
@@ -162,6 +166,7 @@ import {
   normalizeRealmSchema,
   safeGlobalThis,
   toArrayBuffer,
+  toBindingLoggerLevel,
   toBindingSchema,
   toBindingSyncConfig,
   validateConfiguration,
@@ -261,6 +266,30 @@ export class Realm {
 
   private static internals = new Set<binding.WeakRef<binding.Realm>>();
 
+  /**
+   * Sets the log level.
+   * @param level The log level to be used by the logger.
+   * @note The log level can be changed during the lifetime of the application.
+   * @since v12.0.0
+   */
+  static setLogLevel(level: LogLevel) {
+    const bindingLoggerLevel = toBindingLoggerLevel(level);
+    binding.Logger.setDefaultLevelThreshold(bindingLoggerLevel);
+  }
+
+  /**
+   * Sets the logger callback.
+   * @param loggerCallback The callback invoked by the logger.
+   * @note The logger callback needs to be setup before opening the first realm.
+   * @since v12.0.0
+   */
+  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.
@@ -1971,6 +2000,10 @@ declare global {
   }
 }
 
+//Set default logger and log level.
+Realm.setLoggerCallback(defaultLogger);
+Realm.setLogLevel(defaultLoggerLevel);
+
 // Patch the global at runtime
 let warnedAboutGlobalRealmUse = false;
 Object.defineProperty(safeGlobalThis, "Realm", {

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;
 
+  /** @deprecated Please use Realm.setLogLevel. Will be removed in v13.0.0. */
   static setLogLevel(app: App, level: LogLevel) {
     const numericLevel = toBindingLoggerLevel(level);
     app.internal.syncManager.setLogLevel(numericLevel);
   }
+
+  /** @deprecated Please use Realm.setLoggerCallback. Will be removed in v13.0.0. */
   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/index.ts

@@ -88,6 +88,7 @@ export {
   InvalidateEvent,
   List,
   LocalAppConfiguration,
+  LoggerCallback,
   LogLevel,
   mapTo,
   MapToDecorator,

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";