kuzzle 2.42.0 → 2.43.0

package/lib/config/default.config.js

@@ -70,16 +70,7 @@ const defaultConfig = {
             initTimeout: 10000,
             maxConcurrentPipes: 50,
             pipesBufferSize: 50000,
-            include: ["kuzzle-plugin-logger", "kuzzle-plugin-auth-passport-local"],
-        },
-        "kuzzle-plugin-logger": {
-            services: {
-                stdout: {
-                    level: "info",
-                    addDate: true,
-                    dateFormat: "YYYY-MM-DD HH-mm-ss",
-                },
-            },
+            include: ["kuzzle-plugin-auth-passport-local"],
         },
         "kuzzle-plugin-auth-passport-local": {
             algorithm: "sha512",
@@ -194,10 +185,20 @@ const defaultConfig = {
         },
     },
     server: {
+        appLogs: {
+            level: "info",
+            transport: {
+                targets: [
+                    {
+                        preset: "stdout",
+                    },
+                ],
+            },
+        },
         logs: {
             transports: [
                 {
-                    transport: "console",
+                    preset: "console",
                     level: "info",
                     stderrLevels: [],
                     silent: true,

package/lib/core/backend/applicationManager.d.ts

@@ -1,6 +1,7 @@
+import Kuzzle from "../../kuzzle/kuzzle";
 import { Backend } from "./index";
 export declare class ApplicationManager {
     protected _application: any;
     constructor(application: Backend);
-    protected get _kuzzle(): any;
+    protected get _kuzzle(): Kuzzle;
 }

package/lib/core/backend/internalLogger.d.ts

@@ -1,5 +1,9 @@
 import { ApplicationManager } from "./index";
 export declare class InternalLogger extends ApplicationManager {
+    /**
+     * Logs a trace message
+     */
+    trace(message: any): void;
     /**
      * Logs an debug message
      */
@@ -16,9 +20,19 @@ export declare class InternalLogger extends ApplicationManager {
      * Logs an error message
      */
     error(message: any): void;
+    /**
+     * Logs a fatal message
+     */
+    fatal(message: any): void;
     /**
      * Logs a verbose message
+     *
+     * @deprecated Use InternalLogger.debug instead.
      */
     verbose(message: any): void;
+    /**
+     * Change the log level
+     */
+    level(level: string): void;
     private _log;
 }

package/lib/core/backend/internalLogger.js

@@ -27,6 +27,12 @@ exports.InternalLogger = void 0;
 const util_1 = __importDefault(require("util"));
 const index_1 = require("./index");
 class InternalLogger extends index_1.ApplicationManager {
+    /**
+     * Logs a trace message
+     */
+    trace(message) {
+        this._log("trace", message);
+    }
     /**
      * Logs an debug message
      */
@@ -51,12 +57,32 @@ class InternalLogger extends index_1.ApplicationManager {
     error(message) {
         this._log("error", message);
     }
+    /**
+     * Logs a fatal message
+     */
+    fatal(message) {
+        this._log("fatal", message);
+    }
     /**
      * Logs a verbose message
+     *
+     * @deprecated Use InternalLogger.debug instead.
      */
     verbose(message) {
         this._log("verbose", message);
     }
+    /**
+     * Change the log level
+     */
+    level(level) {
+        if (!this._application.started) {
+            // eslint-disable-next-line no-console
+            console.log("InternalLogger.level() is not available before the application is started");
+        }
+        else {
+            this._kuzzle.log.level = level;
+        }
+    }
     _log(level, message) {
         if (!this._application.started) {
             // eslint-disable-next-line no-console

package/lib/core/plugin/pluginsManager.js

@@ -43,10 +43,7 @@ const strategyError = kerror.wrap("plugin", "strategy");
 const controllerError = kerror.wrap("plugin", "controller");
 
 // Without those plugins, Kuzzle won't start at all.
-const CORE_PLUGINS = [
-  "kuzzle-plugin-logger",
-  "kuzzle-plugin-auth-passport-local",
-];
+const CORE_PLUGINS = ["kuzzle-plugin-auth-passport-local"];
 
 /**
  * @class PluginsManager

package/lib/kuzzle/Logger.d.ts

@@ -0,0 +1,26 @@
+import { KuzzleLogger } from "kuzzle-logger";
+import { KuzzleConfiguration } from "../../";
+/**
+ * The Logger class provides logging functionality for Kuzzle.
+ */
+export declare class Logger extends KuzzleLogger {
+    private warnedForSillyDeprecation;
+    private warnedForVerboseDeprecation;
+    constructor(kuzzleConfig: KuzzleConfiguration);
+    /**
+     * Logs a message with the "silly" level.
+     *
+     * @deprecated Use Logger.trace instead.
+     * @param message - The message to log.
+     */
+    silly(message: string): void;
+    /**
+     * Logs a message with the "verbose" level.
+     *
+     * @deprecated Use Logger.debug instead.
+     * @param message - The message to log.
+     */
+    verbose(message: string): void;
+    getLevel(): string;
+    setLevel(level: string): void;
+}

package/lib/kuzzle/Logger.js

@@ -0,0 +1,114 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * 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
+ *
+ * https://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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const kuzzle_logger_1 = require("kuzzle-logger");
+/**
+ * The Logger class provides logging functionality for Kuzzle.
+ */
+class Logger extends kuzzle_logger_1.KuzzleLogger {
+    constructor(kuzzleConfig) {
+        const config = kuzzleConfig.server.appLogs;
+        const deprecatedConfig = kuzzleConfig.plugins["kuzzle-plugin-logger"];
+        const getMergingObject = () => {
+            const mergingObject = {};
+            mergingObject.failsafeMode = Boolean(kuzzleConfig.plugins.common.failsafeMode);
+            if (global.kuzzle.id) {
+                mergingObject.nodeId = global.kuzzle.id;
+            }
+            if (global.kuzzle.asyncStore?.exists() &&
+                global.kuzzle.asyncStore?.has("REQUEST")) {
+                const request = global.kuzzle.asyncStore.get("REQUEST");
+                mergingObject.requestId = request.id;
+            }
+            return mergingObject;
+        };
+        super(deprecatedConfig?.services
+            ? {
+                getMergingObject,
+                serviceName: "kuzzle",
+                transport: {
+                    targets: Object.entries(deprecatedConfig.services).map(([serviceName, serviceConfig]) => {
+                        if (serviceName === "stdout") {
+                            let level = serviceConfig.level || "info";
+                            if (level === "silly") {
+                                level = "trace";
+                            }
+                            if (level === "verbose") {
+                                level = "debug";
+                            }
+                            return {
+                                level,
+                                preset: "stdout",
+                            };
+                        }
+                    }),
+                },
+            }
+            : {
+                ...config,
+                getMergingObject,
+            });
+        this.warnedForSillyDeprecation = false;
+        this.warnedForVerboseDeprecation = false;
+        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.
+     *
+     * @deprecated Use Logger.trace instead.
+     * @param message - The message to log.
+     */
+    silly(message) {
+        if (!this.warnedForSillyDeprecation) {
+            this.warnedForSillyDeprecation = true;
+            this.warn("[DEPRECATED] Logger.silly is deprecated, use Logger.trace instead. Logging messages at trace level.");
+        }
+        this.trace(message);
+    }
+    /**
+     * Logs a message with the "verbose" level.
+     *
+     * @deprecated Use Logger.debug instead.
+     * @param message - The message to log.
+     */
+    verbose(message) {
+        if (!this.warnedForVerboseDeprecation) {
+            this.warnedForVerboseDeprecation = true;
+            this.warn("[DEPRECATED] Logger.verbose is deprecated, use Logger.debug instead. Logging messages at debug level.");
+        }
+        this.debug(message);
+    }
+    getLevel() {
+        return this.level;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+}
+exports.Logger = Logger;
+//# sourceMappingURL=Logger.js.map

package/lib/kuzzle/kuzzle.d.ts

@@ -12,7 +12,7 @@ import { ImportConfig, InstallationConfig, StartOptions, SupportConfig } from ".
 import KuzzleEventEmitter from "./event/KuzzleEventEmitter";
 import InternalIndexHandler from "./internalIndexHandler";
 import kuzzleStateEnum from "./kuzzleStateEnum";
-import Logger from "./log";
+import { Logger } from "./Logger";
 import vault from "./vault";
 export declare const BACKEND_IMPORT_KEY = "backend:init:import";
 declare class Kuzzle extends KuzzleEventEmitter {

package/lib/kuzzle/kuzzle.js

@@ -78,7 +78,7 @@ const dumpGenerator_1 = __importDefault(require("./dumpGenerator"));
 const KuzzleEventEmitter_1 = __importDefault(require("./event/KuzzleEventEmitter"));
 const internalIndexHandler_1 = __importDefault(require("./internalIndexHandler"));
 const kuzzleStateEnum_1 = __importDefault(require("./kuzzleStateEnum"));
-const log_1 = __importDefault(require("./log"));
+const Logger_1 = require("./Logger");
 const vault_1 = __importDefault(require("./vault"));
 exports.BACKEND_IMPORT_KEY = "backend:init:import";
 let _kuzzle = null;
@@ -105,7 +105,7 @@ class Kuzzle extends KuzzleEventEmitter_1.default {
         global.kuzzle = this;
         this._state = kuzzleStateEnum_1.default.STARTING;
         this.config = config;
-        this.log = new log_1.default();
+        this.log = new Logger_1.Logger(config);
         this.rootPath = path_1.default.resolve(path_1.default.join(__dirname, "../.."));
         this.internalIndex = new internalIndexHandler_1.default();
         this.pluginsManager = new pluginsManager_1.default();

package/lib/service/storage/7/elasticsearch.js

@@ -955,6 +955,13 @@ class ES7 {
      * @returns {Promise.<{ successes: [_id, _source, _status], errors: [ document, status, reason ] }>}
      */
     async bulkUpdateByQuery(index, collection, query, changes, { refresh = false, } = {}) {
+        const esRequest = {
+            body: {
+                query: this._sanitizeSearchBody({ query }).query,
+            },
+            index: this._getAlias(index, collection),
+            refresh,
+        };
         const script = {
             params: {},
             source: "",
@@ -964,14 +971,9 @@ class ES7 {
             script.source += `ctx._source.${key} = params['${key}'];`;
             script.params[key] = value;
         }
-        const esRequest = {
-            body: {
-                query: this._sanitizeSearchBody({ query }).query,
-                script,
-            },
-            index: this._getAlias(index, collection),
-            refresh,
-        };
+        if (script.source !== "") {
+            esRequest.body.script = script;
+        }
         (0, debug_1.default)("Bulk Update by query: %o", esRequest);
         let response;
         try {

package/lib/service/storage/8/elasticsearch.js

@@ -971,6 +971,11 @@ class ES8 {
      * @returns {Promise.<{ successes: [_id, _source, _status], errors: [ document, status, reason ] }>}
      */
     async bulkUpdateByQuery(index, collection, query, changes, { refresh = false, } = {}) {
+        const esRequest = {
+            index: this._getAlias(index, collection),
+            query: this._sanitizeSearchBody({ query }).query,
+            refresh,
+        };
         const script = {
             params: {},
             source: "",
@@ -980,12 +985,9 @@ class ES8 {
             script.source += `ctx._source.${key} = params['${key}'];`;
             script.params[key] = value;
         }
-        const esRequest = {
-            index: this._getAlias(index, collection),
-            query: this._sanitizeSearchBody({ query }).query,
-            refresh,
-            script,
-        };
+        if (script.source !== "") {
+            esRequest.script = script;
+        }
         (0, debug_1.default)("Bulk Update by query: %o", esRequest);
         let response;
         try {

package/lib/types/config/PluginsConfiguration.d.ts

@@ -27,7 +27,7 @@ export type PluginsConfiguration = {
          * Edit this list to deactivate one or more of those plugins.
          * NOTE: this list does not control plugins installed manually.
          *
-         * @default ["kuzzle-plugin-logger","kuzzle-plugin-auth-passport-local"]
+         * @default ["kuzzle-plugin-auth-passport-local"]
          */
         include: string[];
         /**
@@ -67,23 +67,16 @@ export type PluginsConfiguration = {
         pipesBufferSize: number;
     };
     /**
-     * Default logger plugin configuration.
-     *
-     * This plugin use Winston to transport the logs.
-     *
-     * @see https://github.com/kuzzleio/kuzzle-plugin-logger
+     * Logger plugin configuration.
+     * @deprecated use server.logs
      */
-    "kuzzle-plugin-logger": {
+    "kuzzle-plugin-logger"?: {
         /**
-         * Winston transport services declaration
+         * Services declaration
          */
         services: {
             /**
              * Print logs to STDOUT
-             *
-             * @default
-             *
-             * @see https://github.com/winstonjs/winston/blob/master/docs/transports.md#console-transport
              */
             stdout: {
                 /**

package/lib/types/config/ServerConfiguration.d.ts

@@ -1,3 +1,4 @@
+import { KuzzleLoggerConfig } from "kuzzle-logger";
 import { JSONObject } from "../../../index";
 export type ServerConfiguration = {
     /**
@@ -16,8 +17,9 @@ export type ServerConfiguration = {
      */
     port: number;
     /**
-     * Configuration section for Kuzzle access logs.
+     * Configuration section for Kuzzle logs.
      */
+    appLogs: Omit<KuzzleLoggerConfig, "getMergingObject">;
     logs: {
         /**
         * An array of Winston transports configurations to output access

package/lib/util/debug.js

@@ -34,4 +34,18 @@ debug.formatters.a = (value) => {
   return util.inspect(value, inspectOpts).replace(/\s*\n\s*/g, " ");
 };
 
-module.exports = debug;
+debug.formatArgs = () => {};
+
+function createDebug(namespace) {
+  const myDebug = debug(namespace);
+  myDebug.log = (...args) => {
+    if (!["debug", "trace"].includes(global.kuzzle.log.level)) {
+      global.kuzzle.log.level = "debug";
+    }
+    global.kuzzle.log.debug({ namespace }, ...args);
+  };
+
+  return myDebug;
+}
+
+module.exports = createDebug;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kuzzle",
   "author": "The Kuzzle Team <support@kuzzle.io>",
-  "version": "2.42.0",
+  "version": "2.43.0",
   "description": "Kuzzle is an open-source solution that handles all the data management through a secured API, with a large choice of protocols.",
   "bin": "bin/start-kuzzle-server",
   "scripts": {
@@ -45,8 +45,8 @@
     "json2yaml": "1.1.0",
     "jsonwebtoken": "9.0.2",
     "koncorde": "4.6.0",
+    "kuzzle-logger": "^1.2.0",
     "kuzzle-plugin-auth-passport-local": "6.4.1",
-    "kuzzle-plugin-logger": "3.0.3",
     "kuzzle-sdk": "^7.15.0",
     "kuzzle-vault": "2.1.0",
     "lodash": "4.17.21",
@@ -97,6 +97,11 @@
     "mock-require": "3.0.3",
     "mqtt": "5.10.4",
     "nyc": "17.1.0",
+    "pino-caller": "^3.4.0",
+    "pino-elasticsearch": "^8.1.0",
+    "pino-loki": "^2.5.0",
+    "pino-pretty": "^13.0.0",
+    "pino-transport-ecs": "^1.1.0",
     "request": "2.88.2",
     "request-promise": "4.2.6",
     "rewire": "5.0.0",

package/lib/kuzzle/log.js

@@ -1,74 +0,0 @@
-/*
- * Kuzzle, a backend software, self-hostable and ready to use
- * to power modern apps
- *
- * Copyright 2015-2022 Kuzzle
- * mailto: support AT kuzzle.io
- * website: http://kuzzle.io
- *
- * 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
- *
- * https://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.
- */
-
-"use strict";
-
-class Logger {
-  constructor() {
-    this.logMethods = ["info", "warn", "error", "silly", "debug", "verbose"];
-
-    this.failsafeModeString = global.kuzzle.config.plugins.common.failsafeMode
-      ? "[FAILSAFE MODE] "
-      : "";
-
-    this._useConsole();
-
-    global.kuzzle.once("core:kuzzleStart", this._useLogger.bind(this));
-  }
-
-  _useConsole() {
-    // until kuzzle has started, use the console to print logs
-    for (const method of this.logMethods) {
-      this[method] = (message) => {
-        /* eslint-disable-next-line no-console */
-        const writer = console[method] || console.log;
-
-        writer(`${this.failsafeModeString}${message}`);
-      };
-    }
-  }
-
-  _useLogger() {
-    // when kuzzle has started, use the event to dispatch logs
-    for (const method of this.logMethods) {
-      this[method] = (message) => {
-        if (
-          global.kuzzle.asyncStore.exists() &&
-          global.kuzzle.asyncStore.has("REQUEST")
-        ) {
-          const request = global.kuzzle.asyncStore.get("REQUEST");
-
-          global.kuzzle.emit(
-            `log:${method}`,
-            `[${global.kuzzle.id}] ${this.failsafeModeString}[${request.id}] ${message}`,
-          );
-        } else {
-          global.kuzzle.emit(
-            `log:${method}`,
-            `[${global.kuzzle.id}] ${this.failsafeModeString}${message}`,
-          );
-        }
-      };
-    }
-  }
-}
-
-module.exports = Logger;