kuzzle 2.19.2 → 2.19.3

package/lib/core/network/accessLogger.js

@@ -19,7 +19,7 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
 // winston is CPU-hungry: isolating it in a worker thread allows for a more
 // efficient CPU resources management, and more performances in the end
@@ -28,57 +28,55 @@ const {
   isMainThread,
   parentPort,
   workerData,
-} = require('worker_threads');
+} = require("worker_threads");
 
-const winston = require('winston');
-const WinstonElasticsearch = require('winston-elasticsearch');
-const WinstonSyslog = require('winston-syslog');
-const moment = require('moment');
+const winston = require("winston");
+const WinstonElasticsearch = require("winston-elasticsearch");
+const WinstonSyslog = require("winston-syslog");
+const moment = require("moment");
 
-const { KuzzleRequest } = require('../../api/request');
+const { KuzzleRequest } = require("../../api/request");
 
-const ALLOWED_TRANSPORTS = [
-  'console',
-  'elasticsearch',
-  'file',
-  'syslog',
-];
+const ALLOWED_TRANSPORTS = ["console", "elasticsearch", "file", "syslog"];
 
 class AccessLogger {
-  constructor () {
+  constructor() {
     this.isActive = false;
     this.worker = null;
   }
 
-  async init () {
+  async init() {
     const config = global.kuzzle.config.server;
 
     for (const out of config.logs.transports) {
-      if (out.transport && ! ALLOWED_TRANSPORTS.includes(out.transport)) {
-        global.kuzzle.log.error(`Failed to initialize logger transport "${out.transport}": unsupported transport. Skipped.`);
-      }
-      else {
-        this.isActive = this.isActive || ! out.silent;
+      if (out.transport && !ALLOWED_TRANSPORTS.includes(out.transport)) {
+        global.kuzzle.log.error(
+          `Failed to initialize logger transport "${out.transport}": unsupported transport. Skipped.`
+        );
+      } else {
+        this.isActive = this.isActive || !out.silent;
       }
     }
 
-    if (! this.isActive) {
+    if (!this.isActive) {
       return;
     }
 
-    const anonymous = await global.kuzzle.ask('core:security:user:anonymous:get');
+    const anonymous = await global.kuzzle.ask(
+      "core:security:user:anonymous:get"
+    );
 
     this.worker = new Worker(__filename, {
       workerData: {
         anonymousUserId: anonymous._id,
         config,
         kuzzleId: global.kuzzle.id,
-      }
+      },
     });
   }
 
-  log (connection, request, extra) {
-    if (! this.isActive) {
+  log(connection, request, extra) {
+    if (!this.isActive) {
       return;
     }
 
@@ -94,7 +92,7 @@ class AccessLogger {
     // logs
     const size = request.response
       ? Buffer.byteLength(JSON.stringify(request.response)).toString()
-      : '-';
+      : "-";
 
     try {
       this.worker.postMessage({
@@ -103,117 +101,116 @@ class AccessLogger {
         request: serialized,
         size,
       });
-    }
-    catch (error) {
-      global.kuzzle.log.error(`Failed to write access log for request "${request.id}": ${error.message}`);
+    } catch (error) {
+      global.kuzzle.log.error(
+        `Failed to write access log for request "${request.id}": ${error.message}`
+      );
     }
   }
 }
 
 class AccessLoggerWorker {
-  constructor (config, anonymousUserId) {
+  constructor(config, anonymousUserId) {
     this.config = config;
     this.logger = null;
     this.anonymousUserId = anonymousUserId;
   }
 
-  init () {
+  init() {
     this.initTransport();
 
-    parentPort.on('message', ({ connection, extra, request, size }) => {
+    parentPort.on("message", ({ connection, extra, request, size }) => {
       this.logAccess(
         connection,
         new KuzzleRequest(request.data, request.options),
         size,
-        extra);
+        extra
+      );
     });
   }
 
-  initTransport () {
+  initTransport() {
     const transports = [];
 
     for (const conf of this.config.logs.transports) {
       const opts = {
-        colorize: conf.colorize === true
-          ? winston.format.colorize()
-          : false,
+        colorize: conf.colorize === true ? winston.format.colorize() : false,
         depth: conf.depth || false,
         format: conf.format
           ? winston.format[conf.format]()
           : winston.format.json(),
-        level: conf.level || 'info',
-        prettyPrint: conf.prettyPrint === true
-          ? winston.format.prettyPrint()
-          : false,
+        level: conf.level || "info",
+        prettyPrint:
+          conf.prettyPrint === true ? winston.format.prettyPrint() : false,
         silent: conf.silent || false,
-        timestamp: conf.timestamp === true
-          ? winston.format.timestamp()
-          : false
+        timestamp: conf.timestamp === true ? winston.format.timestamp() : false,
       };
 
-      switch (conf.transport || 'console') {
-        case 'console':
+      switch (conf.transport || "console") {
+        case "console":
           transports.push(
             new winston.transports.Console(
-              Object.assign(
-                opts,
-                {
-                  humanReadableUnhandledException: conf.humanReadableUnhandledException || true,
-                  stderrLevels: conf.stderrLevels || ['error', 'debug']
-                })));
+              Object.assign(opts, {
+                humanReadableUnhandledException:
+                  conf.humanReadableUnhandledException || true,
+                stderrLevels: conf.stderrLevels || ["error", "debug"],
+              })
+            )
+          );
           break;
-        case 'elasticsearch':
+        case "elasticsearch":
           transports.push(
             new WinstonElasticsearch(
-              Object.assign(
-                opts,
-                {
-                  clientOpts: conf.clientOpts || {},
-                  ensureMappingTemplate: conf.ensureMappingTemplate !== false,
-                  flushInterval: conf.flushInterval || 2000,
-                  index: conf.index,
-                  indexPrefix: conf.indexPrefix || 'kuzzle-access',
-                  indexSuffixPattern: conf.indexSuffixPattern || 'YYYY.MM',
-                  mappingTemplate: conf.mappingTemplate || 'access.log.mapping.json',
-                  messageType: conf.messageType || 'access'
-                })));
+              Object.assign(opts, {
+                clientOpts: conf.clientOpts || {},
+                ensureMappingTemplate: conf.ensureMappingTemplate !== false,
+                flushInterval: conf.flushInterval || 2000,
+                index: conf.index,
+                indexPrefix: conf.indexPrefix || "kuzzle-access",
+                indexSuffixPattern: conf.indexSuffixPattern || "YYYY.MM",
+                mappingTemplate:
+                  conf.mappingTemplate || "access.log.mapping.json",
+                messageType: conf.messageType || "access",
+              })
+            )
+          );
           break;
-        case 'file':
+        case "file":
           transports.push(
             new winston.transports.File(
-              Object.assign(
-                opts,
-                {
-                  eol: conf.eol || '\n',
-                  filename: conf.filename || 'kuzzle.access.log',
-                  logstash: conf.logstash || false,
-                  maxFiles: conf.maxFiles,
-                  maxRetries: conf.maxRetries || 2,
-                  maxSize: conf.maxSize,
-                  tailable: conf.tailable,
-                  zippedArchive: conf.zippedArchive || false
-                })));
+              Object.assign(opts, {
+                eol: conf.eol || "\n",
+                filename: conf.filename || "kuzzle.access.log",
+                logstash: conf.logstash || false,
+                maxFiles: conf.maxFiles,
+                maxRetries: conf.maxRetries || 2,
+                maxSize: conf.maxSize,
+                tailable: conf.tailable,
+                zippedArchive: conf.zippedArchive || false,
+              })
+            )
+          );
           break;
-        case 'syslog':
+        case "syslog":
           transports.push(
             new WinstonSyslog(
-              Object.assign(
-                opts,
-                {
-                  app_name: conf.app_name || process.title,
-                  eol: conf.eol,
-                  facility: conf.facility || 'local0',
-                  host: conf.host || 'localhost',
-                  localhost: conf.localhost || 'localhost',
-                  path: conf.path || '/dev/log',
-                  pid: conf.pid || process.pid,
-                  port: conf.port || 514,
-                  protocol: conf.protocol || 'udp4',
-                  type: conf.type || 'BSD'
-                })));
+              Object.assign(opts, {
+                app_name: conf.app_name || process.title,
+                eol: conf.eol,
+                facility: conf.facility || "local0",
+                host: conf.host || "localhost",
+                localhost: conf.localhost || "localhost",
+                path: conf.path || "/dev/log",
+                pid: conf.pid || process.pid,
+                port: conf.port || 514,
+                protocol: conf.protocol || "udp4",
+                type: conf.type || "BSD",
+              })
+            )
+          );
           break;
         default:
-          // do nothing
+        // do nothing
       }
     }
 
@@ -226,15 +223,15 @@ class AccessLoggerWorker {
    * @param {String} size - response size, in bytes
    * @param {Object} [extra]
    */
-  logAccess (connection, request, size, extra = null) {
-    if (this.config.logs.accessLogFormat === 'logstash') {
+  logAccess(connection, request, size, extra = null) {
+    if (this.config.logs.accessLogFormat === "logstash") {
       // custom kuzzle logs to be exported to logstash
       this.logger.info({
         connection,
         error: request.error,
         extra,
         request: request.input,
-        status: request.status
+        status: request.status,
       });
       return;
     }
@@ -246,17 +243,18 @@ class AccessLoggerWorker {
     let user = null;
 
     if (request.context.token !== null) {
-      user = request.context.token.userId === this.anonymousUserId
-        ? '(anonymous)'
-        : request.context.token.userId;
+      user =
+        request.context.token.userId === this.anonymousUserId
+          ? "(anonymous)"
+          : request.context.token.userId;
     }
 
     // = apache combined
     const protocol = connection.protocol.toUpperCase();
     let url;
-    let verb = 'DO';
+    let verb = "DO";
 
-    if (connection.protocol.indexOf('HTTP/') === 0) {
+    if (connection.protocol.indexOf("HTTP/") === 0) {
       verb = extra.method;
       url = extra.url;
     }
@@ -276,20 +274,22 @@ class AccessLoggerWorker {
         url += `/${request.input.args._id}`;
       }
 
-      let queryString = '';
+      let queryString = "";
 
       for (const k of Object.keys(request.input.args)) {
-        if (k === '_id' || k === 'index' || k === 'collection') {
+        if (k === "_id" || k === "index" || k === "collection") {
           continue;
         }
 
         const val = request.input.args[k];
 
         if (queryString.length > 0) {
-          queryString += '&';
+          queryString += "&";
         }
 
-        queryString += `${k}=${typeof val === 'object' ? JSON.stringify(val) : val}`;
+        queryString += `${k}=${
+          typeof val === "object" ? JSON.stringify(val) : val
+        }`;
       }
 
       if (queryString.length > 0) {
@@ -298,45 +298,51 @@ class AccessLoggerWorker {
     }
 
     if (user === null) {
-      user = '(unknown)';
+      user = "(unknown)";
     }
 
     const ip = this.getIP(connection);
-    const when = moment().format('DD/MMM/YYYY:HH:mm:ss ZZ');
-    const status = request.status || '-';
+    const when = moment().format("DD/MMM/YYYY:HH:mm:ss ZZ");
+    const status = request.status || "-";
     const referer = connection.headers.referer
       ? `"${connection.headers.referer}"`
-      : '-';
-    const agent = connection.headers['user-agent']
-      ? `"${connection.headers['user-agent']}"`
-      : '-';
-
-    this.logger.info(`${ip} - ${user} [${when}] "${verb} ${url} ${protocol}" ${status} ${size} ${referer} ${agent}`);
+      : "-";
+    const agent = connection.headers["user-agent"]
+      ? `"${connection.headers["user-agent"]}"`
+      : "-";
+
+    this.logger.info(
+      `${ip} - ${user} [${when}] "${verb} ${url} ${protocol}" ${status} ${size} ${referer} ${agent}`
+    );
   }
 
   /**
    * @param  {ClientConnection} connection
    */
-  getIP (connection) {
+  getIP(connection) {
     const { ips } = connection;
 
     if (ips.length === 0) {
-      return '-';
+      return "-";
     }
 
-    const idx = Math.max(0, ips.length - 1 - this.config.logs.accessLogIpOffset);
+    const idx = Math.max(
+      0,
+      ips.length - 1 - this.config.logs.accessLogIpOffset
+    );
 
     return ips[idx];
   }
 }
 
-if (! isMainThread) {
+if (!isMainThread) {
   // Needed for instantiating a serialized KuzzleRequest object
   global.kuzzle = { id: workerData.kuzzleId };
 
   const worker = new AccessLoggerWorker(
     workerData.config,
-    workerData.anonymousUserId);
+    workerData.anonymousUserId
+  );
 
   worker.init();
 }

package/lib/core/network/clientConnection.js

@@ -19,10 +19,10 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const { isPlainObject } = require('../../util/safeObject');
-const uuid = require('uuid');
+const { isPlainObject } = require("../../util/safeObject");
+const uuid = require("uuid");
 
 /**
  * @class ClientConnection
@@ -31,12 +31,12 @@ const uuid = require('uuid');
  * @param {object} [headers] - Optional extra key-value object. I.e., for http, will receive the request headers
  */
 class ClientConnection {
-  constructor (protocol, ips, headers = null) {
+  constructor(protocol, ips, headers = null) {
     this.id = uuid.v4();
     this.protocol = protocol;
     this.headers = {};
 
-    if (! Array.isArray(ips)) {
+    if (!Array.isArray(ips)) {
       throw new TypeError(`Expected ips to be an Array, got ${typeof ips}`);
     }
     this.ips = ips;

package/lib/core/network/context.js

@@ -19,7 +19,7 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
 const {
   BadRequestError,
@@ -38,15 +38,15 @@ const {
   UnauthorizedError,
   Request,
   RequestContext,
-  RequestInput
-} = require('../../kerror/errors');
-const ClientConnection = require('./clientConnection');
-const ProtocolBase = require('./protocols/protocol');
+  RequestInput,
+} = require("../../kerror/errors");
+const ClientConnection = require("./clientConnection");
+const ProtocolBase = require("./protocols/protocol");
 
-const debug = require('../../util/debug')('kuzzle:network:protocols');
+const debug = require("../../util/debug")("kuzzle:network:protocols");
 
 class Context {
-  constructor () {
+  constructor() {
     this.ClientConnection = ClientConnection;
     this.debug = debug;
     this.errors = {
@@ -71,7 +71,7 @@ class Context {
     this.RequestInput = RequestInput;
 
     this.log = {};
-    for (const type of ['silly', 'debug', 'verbose', 'info', 'warn', 'error']) {
+    for (const type of ["silly", "debug", "verbose", "info", "warn", "error"]) {
       this.log[type] = (...args) => global.kuzzle.log[type](...args);
     }
   }