kuzzle 2.44.0 → 2.46.0-beta.1

package/lib/core/cache/cacheEngine.js

@@ -31,6 +31,8 @@ class CacheEngine {
 
     this.public = new Redis(config.memoryStorage, "public_adapter");
     this.internal = new Redis(config.internalCache, "internal_adapter");
+
+    this.logger = global.kuzzle.log.child("core:cache:cacheEngine");
   }
 
   /**
@@ -44,7 +46,7 @@ class CacheEngine {
     this.registerInternalEvents();
     this.registerPublicEvents();
 
-    global.kuzzle.log.info("[✔] Cache initialized");
+    this.logger.info("[✔] Cache initialized");
   }
 
   registerInternalEvents() {

package/lib/core/network/accessLogger.js

@@ -43,6 +43,7 @@ class AccessLogger {
   constructor() {
     this.isActive = false;
     this.worker = null;
+    this.logger = global.kuzzle.log.child("core:network:accessLogger");
   }
 
   async init() {
@@ -50,7 +51,7 @@ class AccessLogger {
 
     for (const out of config.logs.transports) {
       if (out.transport && !ALLOWED_TRANSPORTS.includes(out.transport)) {
-        global.kuzzle.log.error(
+        this.logger.error(
           `Failed to initialize logger transport "${out.transport}": unsupported transport. Skipped.`,
         );
       } else {
@@ -102,7 +103,7 @@ class AccessLogger {
         size,
       });
     } catch (error) {
-      global.kuzzle.log.error(
+      this.logger.error(
         `Failed to write access log for request "${request.id}": ${error.message}`,
       );
     }

package/lib/core/network/entryPoint.js

@@ -52,6 +52,8 @@ class EntryPoint {
     this.accessLogger = new AccessLogger();
 
     this.isShuttingDown = false;
+
+    this.logger = global.kuzzle.log.child("core:network:entrypoint");
   }
 
   dispatch(event, data) {
@@ -142,7 +144,7 @@ class EntryPoint {
     try {
       this.protocols.get(client.protocol).joinChannel(channel, connectionId);
     } catch (e) {
-      global.kuzzle.log.error(
+      this.logger.error(
         `[join] protocol ${client && client.protocol} failed: ${e.message}`,
       );
     }
@@ -164,7 +166,7 @@ class EntryPoint {
     try {
       this.protocols.get(client.protocol).leaveChannel(channel, connectionId);
     } catch (e) {
-      global.kuzzle.log.error(
+      this.logger.error(
         `[leave channel] protocol ${client && client.protocol} failed: ${
           e.message
         }`,
@@ -202,9 +204,7 @@ class EntryPoint {
       return Bluebird.resolve()
         .then(() => protocol.init(this, new Context()))
         .catch((error) => {
-          global.kuzzle.log.error(
-            `Error during "${manifest.name}" protocol init:`,
-          );
+          this.logger.error(`Error during "${manifest.name}" protocol init:`);
           throw error;
         })
         .timeout(
@@ -318,7 +318,7 @@ class EntryPoint {
       try {
         protocol.broadcast(sanitized);
       } catch (e) {
-        global.kuzzle.log.error(
+        this.logger.error(
           `[broadcast] protocol ${name} failed: ${e.message}\n${e.stack}`,
         );
       }
@@ -348,7 +348,7 @@ class EntryPoint {
     try {
       this.protocols.get(client.protocol).notify(removeStacktrace(data));
     } catch (e) {
-      global.kuzzle.log.error(
+      this.logger.error(
         `[notify] protocol ${client.protocol} failed: ${e.message}`,
       );
     }

package/lib/core/network/protocols/httpwsProtocol.js

@@ -120,6 +120,8 @@ class HttpWsProtocol extends Protocol {
 
     // Map<string, uWS.WebSocket>
     this.socketByConnectionId = new Map();
+
+    this.logger = global.kuzzle.log.child("core:network:protocols:httpws");
   }
 
   async init(entrypoint) {
@@ -318,7 +320,7 @@ class HttpWsProtocol extends Protocol {
     // This hack is only here to indicate that uWebSockets killed the connection early
     // because the received payload exceeded the configured threshold.
     if (code === 1006 && reason.startsWith("Received too big message")) {
-      global.kuzzle.log.error(
+      this.logger.error(
         `[${connection.id}] connection closed: payload exceeded the threshold`,
       );
     }
@@ -1146,7 +1148,7 @@ class HttpWsProtocol extends Protocol {
     const cfg = this.config.websocket;
 
     if (cfg === undefined) {
-      global.kuzzle.log.warn(
+      this.logger.warn(
         "[websocket] no configuration found for websocket: disabling it",
       );
       return { enabled: false };
@@ -1157,7 +1159,7 @@ class HttpWsProtocol extends Protocol {
 
     if (idleTimeout === 0 || idleTimeout < 1000) {
       idleTimeout = DEFAULT_IDLE_TIMEOUT;
-      global.kuzzle.log.warn(
+      this.logger.warn(
         `[websocket] The "idleTimeout" parameter can neither be deactivated or be set with a value lower than 1000. Defaulted to ${DEFAULT_IDLE_TIMEOUT}.`,
       );
     }
@@ -1168,7 +1170,7 @@ class HttpWsProtocol extends Protocol {
      * @deprecated -- to be removed in the next major version
      */
     if (cfg.heartbeat) {
-      global.kuzzle.log.warn(
+      this.logger.warn(
         '[websocket] The "heartbeat" parameter has been deprecated and is now ignored. The "idleTimeout" parameter should now be configured instead.',
       );
     }
@@ -1190,9 +1192,7 @@ class HttpWsProtocol extends Protocol {
     const cfg = this.config.http;
 
     if (cfg === undefined) {
-      global.kuzzle.log.warn(
-        "[http] no configuration found for http: disabling it",
-      );
+      this.logger.warn("[http] no configuration found for http: disabling it");
       return { enabled: false };
     }
 

package/lib/core/network/protocols/mqttProtocol.js

@@ -45,11 +45,12 @@ class MqttProtocol extends Protocol {
 
     this.connections = new Map();
     this.connectionsById = new Map();
+    this.logger = global.kuzzle.log.child("core:network:protocols:mqtt");
 
     // needs to be bound to this object's context
     this.publishCallback = function pubcb(error) {
       if (error) {
-        global.kuzzle.info(`[MQTT] Publishing message failed: ${error}`);
+        this.logger.info(`[MQTT] Publishing message failed: ${error}`);
       }
     };
   }
@@ -201,7 +202,7 @@ class MqttProtocol extends Protocol {
         client.id,
         packet,
       );
-      global.kuzzle.log.error(
+      this.logger.error(
         `[MQTT] Received a packet from an unregistered client: ${client.id}`,
       );
       return;

package/lib/core/network/router.js

@@ -36,6 +36,7 @@ class Router {
   constructor() {
     this.connections = new Map();
     this.http = new HttpRouter();
+    this.logger = global.kuzzle.log.child("core:network:router");
   }
 
   /**
@@ -45,7 +46,7 @@ class Router {
    */
   newConnection(requestContext) {
     if (!requestContext.connection.id || !requestContext.connection.protocol) {
-      global.kuzzle.log.error(
+      this.logger.error(
         kerror.get(
           "protocol",
           "runtime",
@@ -68,7 +69,7 @@ class Router {
     const connId = requestContext.connection.id;
 
     if (!connId || !requestContext.connection.protocol) {
-      global.kuzzle.log.error(
+      this.logger.error(
         kerror.get(
           "protocol",
           "runtime",
@@ -80,7 +81,7 @@ class Router {
     }
 
     if (!this.connections.has(connId)) {
-      global.kuzzle.log.error(
+      this.logger.error(
         kerror.get(
           "protocol",
           "runtime",

package/lib/core/plugin/pluginContext.d.ts

@@ -4,6 +4,7 @@ import { KuzzleRequest, RequestContext, RequestInput } from "../../../index";
 import { Mutex } from "../../util/mutex";
 import { BackendCluster } from "../backend";
 import { EmbeddedSDK } from "../shared/sdk/embeddedSdk";
+import { KuzzleLogger } from "kuzzle-logger/dist";
 export interface Repository {
     create(document: JSONObject, options: any): Promise<any>;
     createOrReplace(document: JSONObject, options: any): Promise<any>;
@@ -139,6 +140,10 @@ export declare class PluginContext {
      * Decrypted secrets from Kuzzle Vault
      */
     secrets: JSONObject;
+    /**
+     * Logger instance
+     */
+    logger: KuzzleLogger;
     /**
      * Internal Logger
      */

package/lib/core/plugin/pluginContext.js

@@ -125,14 +125,16 @@ class PluginContext {
             RequestInput: index_1.RequestInput,
         };
         Object.freeze(this.constructors);
+        this.logger = globalThis.kuzzle.log.child(`${pluginName}`);
         /* context.log ======================================================== */
+        // @deprecated backward compatibility only
         this.log = {
-            debug: (msg) => global.kuzzle.log.debug(`[${pluginName}] ${msg}`),
-            error: (msg) => global.kuzzle.log.error(`[${pluginName}] ${msg}`),
-            info: (msg) => global.kuzzle.log.info(`[${pluginName}] ${msg}`),
-            silly: (msg) => global.kuzzle.log.silly(`[${pluginName}] ${msg}`),
-            verbose: (msg) => global.kuzzle.log.verbose(`[${pluginName}] ${msg}`),
-            warn: (msg) => global.kuzzle.log.warn(`[${pluginName}] ${msg}`),
+            debug: (msg) => this.logger.debug(`[${pluginName}] ${msg}`),
+            error: (msg) => this.logger.error(`[${pluginName}] ${msg}`),
+            info: (msg) => this.logger.info(`[${pluginName}] ${msg}`),
+            silly: (msg) => this.logger.trace(`[${pluginName}] ${msg}`),
+            verbose: (msg) => this.logger.trace(`[${pluginName}] ${msg}`),
+            warn: (msg) => this.logger.warn(`[${pluginName}] ${msg}`),
         };
         Object.freeze(this.log);
         /* context.accessors ================================================== */

package/lib/core/plugin/pluginsManager.js

@@ -90,9 +90,11 @@ class PluginsManager {
 
     this.config = global.kuzzle.config.plugins;
 
+    this.logger = global.kuzzle.log.child("core:plugin:pluginsManager");
+
     // @deprecated - Warn about the pipeTimeout configuration being obsolete
     if (this.config.common.pipeTimeout) {
-      global.kuzzle.log.warn(
+      this.logger.warn(
         'The configuration "plugins.common.pipeTimeout" has been deprecated and is now unused. It can be safely removed from configuration files',
       );
     }
@@ -208,13 +210,13 @@ class PluginsManager {
     this._plugins = new Map([...this.loadPlugins(plugins), ...this._plugins]);
 
     global.kuzzle.on("plugin:hook:loop-error", ({ error, pluginName }) => {
-      global.kuzzle.log.error(
+      this.logger.error(
         `[${pluginName}] Infinite loop detected on event "hook:onError": ${error}`,
       );
     });
 
     global.kuzzle.on("hook:onError", ({ error, event, pluginName }) => {
-      global.kuzzle.log.error(
+      this.logger.error(
         `[${pluginName}] Error executing hook on "${event}": ${error}${error.stack}`,
       );
     });
@@ -228,7 +230,7 @@ class PluginsManager {
         this.config.common.failsafeMode &&
         !CORE_PLUGINS.includes(plugin.name)
       ) {
-        global.kuzzle.log.info(
+        this.logger.info(
           `Failsafe mode activated, skipping plugin "${plugin.name}"`,
         );
         continue;
@@ -311,6 +313,12 @@ class PluginsManager {
 
     await Promise.all(loadPlugins);
 
+    this.logger.info(
+      `[✔] Successfully loaded ${
+        this.loadedPlugins.length
+      } plugins: ${this.loadedPlugins.join(", ")}`,
+    );
+
     return defaultImports;
   }
 
@@ -489,7 +497,7 @@ class PluginsManager {
           const elapsed = Date.now() - now;
 
           if (elapsed > warnDelay) {
-            global.kuzzle.log.warn(
+            this.logger.warn(
               `${plugin.logPrefix} pipe for event '${event}' is slow (${elapsed}ms)`,
             );
           }

package/lib/core/realtime/hotelClerk.d.ts

@@ -46,6 +46,7 @@ export declare class HotelClerk {
      * Shortcut to the Koncorde instance on the global object.
      */
     private koncorde;
+    private readonly logger;
     constructor(realtimeModule: any);
     /**
      * Registers the ask events.

package/lib/core/realtime/hotelClerk.js

@@ -100,6 +100,7 @@ class HotelClerk {
          * Map<connectionId, ConnectionRooms>
          */
         this.subscriptions = new Map();
+        this.logger = global.kuzzle.log.child("core:realtime:hotelClerk");
         this.module = realtimeModule;
         this.koncorde = global.kuzzle.koncorde;
     }
@@ -172,7 +173,7 @@ class HotelClerk {
          * Clear subscriptions when a connection is dropped
          */
         global.kuzzle.on("connection:remove", (connection) => {
-            this.removeConnection(connection.id).catch((err) => global.kuzzle.log.info(err));
+            this.removeConnection(connection.id).catch((err) => this.logger.info(err));
         });
     }
     /**
@@ -339,7 +340,7 @@ class HotelClerk {
             // No need to raise an error if the connection does not have room subscriptions
             return;
         }
-        await bluebird_1.default.map(connectionRooms.roomIds, (roomId) => this.unsubscribe(connectionId, roomId, notify).catch((error) => global.kuzzle.log.error(error)));
+        await bluebird_1.default.map(connectionRooms.roomIds, (roomId) => this.unsubscribe(connectionId, roomId, notify).catch((error) => this.logger.error(error)));
     }
     /**
      * Clear all connections made to this node:
@@ -421,7 +422,7 @@ class HotelClerk {
         }
         const room = this.rooms.get(roomId);
         if (!room) {
-            global.kuzzle.log.error(`Cannot remove room "${roomId}": room not found`);
+            this.logger.error(`Cannot remove room "${roomId}": room not found`);
             throw realtimeError.get("room_not_found", roomId);
         }
         for (const channel of Object.keys(room.channels)) {

package/lib/core/realtime/notifier.js

@@ -56,6 +56,7 @@ class NotifierController {
   constructor(realtimeModule) {
     this.module = realtimeModule;
     this.ttl = global.kuzzle.config.limits.subscriptionDocumentTTL;
+    this.logger = global.kuzzle.log.child("core:realtime:notifier");
   }
 
   async init() {
@@ -430,7 +431,7 @@ class NotifierController {
         payload: updatedInfo.notification,
       });
     } catch (error) {
-      global.kuzzle.log.error(error);
+      this.logger.error(error);
     }
   }
 

package/lib/core/security/roleRepository.js

@@ -52,6 +52,7 @@ class RoleRepository extends ObjectRepository {
     this.collection = "roles";
     this.ObjectConstructor = Role;
     this.roles = new Map();
+    this.logger = global.kuzzle.log.child("core:security:roleRepository");
   }
 
   init() {
@@ -438,7 +439,7 @@ class RoleRepository extends ObjectRepository {
         // then we need to display non-existing controllers with the sanity check
         // made after plugins controllers loading.
         if (global.kuzzle.state === kuzzleStateEnum.RUNNING || forceWarn) {
-          global.kuzzle.log.warn(
+          this.logger.warn(
             `The role "${role._id}" gives access to the non-existing controller "${roleController}".`,
           );
         }
@@ -461,7 +462,7 @@ class RoleRepository extends ObjectRepository {
 
           // see the other comment
           if (global.kuzzle.state === kuzzleStateEnum.RUNNING || forceWarn) {
-            global.kuzzle.log.warn(
+            this.logger.warn(
               `The role "${role._id}" gives access to the non-existing action "${action}" for the controller "${roleController}".`,
             );
           }

package/lib/core/security/securityLoader.js

@@ -32,7 +32,9 @@ const kerror = require("../../kerror");
  * @class SecurityLoader
  */
 class SecurityLoader {
-  constructor() {}
+  constructor() {
+    this.logger = global.kuzzle.log.child("core:security:loader");
+  }
 
   async init() {
     /**
@@ -134,9 +136,7 @@ class SecurityLoader {
       throw kerror.get("security", "user", "prevent_overwrite");
     } else if (onExistingUsers === "skip") {
       if (warning) {
-        global.kuzzle.log.info(
-          `Users skipped during import: ${existingUserIds}`,
-        );
+        this.logger.info(`Users skipped during import: ${existingUserIds}`);
       }
       return Object.entries(users).reduce((memo, [userId, content]) => {
         if (!existingUserIds.includes(userId)) {
@@ -147,9 +147,7 @@ class SecurityLoader {
       }, {});
     } else if (onExistingUsers === "overwrite") {
       if (warning) {
-        global.kuzzle.log.info(
-          `Users overwritten during import: ${existingUserIds}`,
-        );
+        this.logger.info(`Users overwritten during import: ${existingUserIds}`);
       }
       const mDeleteUsers = new Request({
         action: "mDeleteUsers",

package/lib/core/shared/store.d.ts

@@ -33,6 +33,7 @@ export declare class Store {
     updateMapping: (...args: any[]) => Promise<any>;
     protected index: string;
     protected scope: storeScopeEnum;
+    private readonly logger;
     constructor(index: string, scope: storeScopeEnum);
     /**
      * Initialize the index, and creates provided collections

package/lib/core/shared/store.js

@@ -55,6 +55,7 @@ const mutex_1 = require("../../util/mutex");
  */
 class Store {
     constructor(index, scope) {
+        this.logger = global.kuzzle.log.child("core:shared:store");
         this.index = index;
         this.scope = scope;
         const methodsMapping = {
@@ -150,7 +151,7 @@ class Store {
                     if (global.NODE_ENV === "development") {
                         throw kerror.get("storage", "wrong_collection_number_of_shards", collection, this.index, this.scope, "number_of_shards", config.settings.number_of_shards, existingSettings.number_of_shards);
                     }
-                    global.kuzzle.log.warn(`Attempt to recreate an existing collection ${collection} of index ${this.index} of scope ${this.scope} with non matching static setting : number_of_shards at ${config.settings.number_of_shards} while existing one is at ${existingSettings.number_of_shards}`);
+                    this.logger.warn(`Attempt to recreate an existing collection ${collection} of index ${this.index} of scope ${this.scope} with non matching static setting : number_of_shards at ${config.settings.number_of_shards} while existing one is at ${existingSettings.number_of_shards}`);
                 }
                 return global.kuzzle.ask(`core:storage:${this.scope}:collection:create`, this.index, collection, 
                 // @deprecated

package/lib/core/statistics/statistics.js

@@ -47,6 +47,8 @@ class Statistics {
       failedRequests: new Map(),
       ongoingRequests: new Map(),
     };
+
+    this.logger = global.kuzzle.log.child("core:statistics");
   }
 
   /**
@@ -339,7 +341,7 @@ class Statistics {
       try {
         await this.writeStats();
       } catch (error) {
-        global.kuzzle.log.error(`Cannot write stats frame: ${error}`);
+        this.logger.error(`Cannot write stats frame: ${error}`);
       }
     }, this.interval);
 

package/lib/core/storage/storageEngine.js

@@ -32,6 +32,11 @@ class StorageEngine {
 
     // Storage client for private indexes only
     this.private = new ClientAdapter(storeScopeEnum.PRIVATE);
+    this.logger = global.kuzzle.log.child("core:storage:storageEngine");
+
+    this.logger.info(
+      `[ℹ] Elasticsearch configuration is set to major version : ${global.kuzzle.config.services.storageEngine.majorVersion}`,
+    );
   }
 
   /**
@@ -51,7 +56,7 @@ class StorageEngine {
       }
     }
 
-    global.kuzzle.log.info("[✔] Storage initialized");
+    this.logger.info("[✔] Storage initialized");
   }
 }
 

package/lib/core/validation/validation.js

@@ -50,6 +50,7 @@ class Validation {
     this.koncorde = new Koncorde();
 
     this.rawConfiguration = {};
+    this.logger = global.kuzzle.log.child("core:validation");
   }
 
   /**
@@ -462,10 +463,10 @@ class Validation {
               return null;
             })
             .catch((error) => {
-              global.kuzzle.log.error(
+              this.logger.error(
                 `Specification for the collection ${collectionName} triggered an error`,
               );
-              global.kuzzle.log.error(`Error: ${error.message}`);
+              this.logger.error(`Error: ${error.message}`);
 
               return null;
             });
@@ -586,7 +587,7 @@ class Validation {
 
         processed.validators = filterId;
       } catch (e) {
-        global.kuzzle.log.error(e);
+        this.logger.error(e);
         throw assertionError.getFrom(e, "invalid_filters", e.message);
       }
     }
@@ -619,7 +620,7 @@ class Validation {
 
         if (result.isValid === false) {
           errors = _.concat(errors, result.errors);
-          global.kuzzle.log.error(result.errors.join("\n"));
+          this.logger.error(result.errors.join("\n"));
         } else {
           const field = result.fieldSpec;
 
@@ -637,7 +638,7 @@ class Validation {
           fields[field.depth].push(field);
         }
       } catch (error) {
-        global.kuzzle.log.error(error);
+        this.logger.error(error);
         throwOrStoreError(error, verboseErrors, errors);
       }
     }

package/lib/kuzzle/Logger.d.ts

@@ -6,7 +6,7 @@ import { KuzzleConfiguration } from "../../";
 export declare class Logger extends KuzzleLogger {
     private warnedForSillyDeprecation;
     private warnedForVerboseDeprecation;
-    constructor(kuzzleConfig: KuzzleConfiguration);
+    constructor(kuzzleConfig: KuzzleConfiguration, namespace?: string);
     /**
      * Logs a message with the "silly" level.
      *

package/lib/kuzzle/Logger.js

@@ -26,15 +26,18 @@ const kuzzle_logger_1 = require("kuzzle-logger");
  * The Logger class provides logging functionality for Kuzzle.
  */
 class Logger extends kuzzle_logger_1.KuzzleLogger {
-    constructor(kuzzleConfig) {
+    constructor(kuzzleConfig, namespace = "kuzzle") {
         const config = kuzzleConfig.server.appLogs;
         const deprecatedConfig = kuzzleConfig.plugins["kuzzle-plugin-logger"];
         const getMergingObject = () => {
             const mergingObject = {};
-            mergingObject.namespace = "kuzzle";
+            mergingObject.namespace = namespace;
             mergingObject.failsafeMode = Boolean(kuzzleConfig.plugins.common.failsafeMode);
-            if (global.kuzzle.id) {
-                mergingObject.nodeId = global.kuzzle.id;
+            if (global.nodeId) {
+                mergingObject.nodeId = global.nodeId;
+            }
+            if (namespace !== "kuzzle") {
+                return mergingObject;
             }
             if (global.kuzzle.asyncStore?.exists() &&
                 global.kuzzle.asyncStore?.has("REQUEST")) {
@@ -74,9 +77,6 @@ class Logger extends kuzzle_logger_1.KuzzleLogger {
         if (deprecatedConfig) {
             this.warn("[DEPRECATED] The plugins.kuzzle-plugin-logger configuration is deprecated, use server.logs instead.");
         }
-        global.kuzzle.onPipe("kuzzle:shutdown", async () => {
-            await this.flush();
-        });
     }
     /**
      * Logs a message with the "silly" level.