Add a setting to configure the default log level for the Log Console (jupyterlab#17547)

* Add a setting to configure the default log level

* docstrings

* tweaks

* Translatable settings

* add test

Author: jtpio

packages/logconsole-extension/schema/plugin.json

@@ -39,6 +39,19 @@
       "title": "Status Bar Item flash",
       "description": "Whether to flash on new log message or not",
       "default": true
+    },
+    "defaultLogLevel": {
+      "type": "string",
+      "title": "Default Log Level",
+      "description": "Default log level for loggers",
+      "oneOf": [
+        { "const": "critical", "title": "Critical" },
+        { "const": "error", "title": "Error" },
+        { "const": "warning", "title": "Warning" },
+        { "const": "info", "title": "Info" },
+        { "const": "debug", "title": "Debug" }
+      ],
+      "default": "warning"
     }
   },
   "additionalProperties": false,

packages/logconsole-extension/src/index.tsx

@@ -298,6 +298,8 @@ function activateLogConsole(
       loggerRegistry.maxLength = settings.get('maxLogEntries')
         .composite as number;
       status.model.flashEnabled = settings.get('flash').composite as boolean;
+      loggerRegistry.defaultLogLevel = settings.get('defaultLogLevel')
+        .composite as LogLevel;
     };
 
     Promise.all([settingRegistry.load(LOG_CONSOLE_PLUGIN_ID), app.restored])

packages/logconsole/src/logger.ts

@@ -201,6 +201,7 @@ export class Logger implements ILogger {
       contentFactory: new LogConsoleModelContentFactory(),
       maxLength: options.maxLength
     });
+    this._level = options.level ?? 'warning';
   }
 
   /**
@@ -408,10 +409,16 @@ export class Logger implements ILogger {
   private _stateChanged = new Signal<this, IStateChange>(this);
   private _rendermime: IRenderMimeRegistry | null = null;
   private _version = 0;
-  private _level: LogLevel = 'warning';
+  private _level: LogLevel;
 }
 
+/**
+ * The namespace for Logger class statics.
+ */
 export namespace Logger {
+  /**
+   * The options used to initialize a Logger.
+   */
   export interface IOptions {
     /**
      * The log source identifier.
@@ -421,10 +428,20 @@ export namespace Logger {
      * The maximum number of messages to store.
      */
     maxLength: number;
+    /**
+     * The default log level.
+     */
+    level?: LogLevel;
   }
 }
 
+/**
+ * The namespace for Logger class private statics.
+ */
 namespace Private {
+  /**
+   * The log level enum.
+   */
   export enum LogLevel {
     debug,
     info,

packages/logconsole/src/registry.ts

@@ -4,7 +4,12 @@
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
 import { ISignal, Signal } from '@lumino/signaling';
 import { Logger } from './logger';
-import { ILogger, ILoggerRegistry, ILoggerRegistryChange } from './tokens';
+import {
+  ILogger,
+  ILoggerRegistry,
+  ILoggerRegistryChange,
+  LogLevel
+} from './tokens';
 
 /**
  * A concrete implementation of ILoggerRegistry.
@@ -19,6 +24,7 @@ export class LoggerRegistry implements ILoggerRegistry {
   constructor(options: LoggerRegistry.IOptions) {
     this._defaultRendermime = options.defaultRendermime;
     this._maxLength = options.maxLength;
+    this._defaultLogLevel = options.defaultLogLevel ?? 'warning';
   }
 
   /**
@@ -35,7 +41,11 @@ export class LoggerRegistry implements ILoggerRegistry {
       return logger;
     }
 
-    logger = new Logger({ source, maxLength: this.maxLength });
+    logger = new Logger({
+      source,
+      maxLength: this.maxLength,
+      level: this.defaultLogLevel
+    });
     logger.rendermime = this._defaultRendermime;
     loggers.set(source, logger);
 
@@ -73,6 +83,17 @@ export class LoggerRegistry implements ILoggerRegistry {
     });
   }
 
+  /**
+   * The default log level for new loggers.
+   * The new value will be applied to new loggers only.
+   */
+  get defaultLogLevel(): LogLevel {
+    return this._defaultLogLevel;
+  }
+  set defaultLogLevel(value: LogLevel) {
+    this._defaultLogLevel = value;
+  }
+
   /**
    * Whether the register is disposed.
    */
@@ -95,13 +116,31 @@ export class LoggerRegistry implements ILoggerRegistry {
   private _defaultRendermime: IRenderMimeRegistry;
   private _loggers = new Map<string, ILogger>();
   private _maxLength: number;
+  private _defaultLogLevel: LogLevel;
   private _registryChanged = new Signal<this, ILoggerRegistryChange>(this);
   private _isDisposed = false;
 }
 
+/**
+ * The namespace for LoggerRegistry class statics.
+ */
 export namespace LoggerRegistry {
+  /**
+   * The options used to initialize a LoggerRegistry.
+   */
   export interface IOptions {
+    /**
+     * The default rendermime to render outputs with when logger is not
+     * supplied with one.
+     */
     defaultRendermime: IRenderMimeRegistry;
+    /**
+     * The maximum length of the log messages.
+     */
     maxLength: number;
+    /**
+     * The default log level for the loggers.
+     */
+    defaultLogLevel?: LogLevel;
   }
 }

packages/logconsole/test/registry.spec.ts

@@ -43,6 +43,20 @@ describe('LoggerRegistry', () => {
       expect(registry).toBeInstanceOf(LoggerRegistry);
       expect(registry.maxLength).toBe(10);
     });
+
+    it('should use "warning" as the default log level if not specified', () => {
+      expect(registry.defaultLogLevel).toBe('warning');
+    });
+
+    it('should use the provided default log level if specified', () => {
+      const customRegistry = new LoggerRegistry({
+        defaultRendermime,
+        maxLength: 10,
+        defaultLogLevel: 'info'
+      });
+      expect(customRegistry.defaultLogLevel).toBe('info');
+      customRegistry.dispose();
+    });
   });
 
   describe('#getLogger()', () => {
@@ -85,4 +99,26 @@ describe('LoggerRegistry', () => {
       expect(B.maxLength).toEqual(12);
     });
   });
+
+  describe('#defaultLogLevel', () => {
+    it('should be applied to newly created loggers', () => {
+      const A = registry.getLogger('A');
+      expect(A.level).toBe(registry.defaultLogLevel);
+    });
+
+    it('should only affect loggers created after it is changed', () => {
+      const A = registry.getLogger('A');
+      expect(A.level).toBe('warning');
+
+      registry.defaultLogLevel = 'info';
+      expect(registry.defaultLogLevel).toBe('info');
+
+      // A's level should not be changed
+      expect(A.level).toBe('warning');
+
+      // B should get the new default
+      const B = registry.getLogger('B');
+      expect(B.level).toBe('info');
+    });
+  });
 });