@mimik/sumologic-winston-logger 1.6.21 → 2.0.0

package/configuration/config.js

@@ -1,10 +1,37 @@
 /* eslint no-process-env: "off" */
-const fs = require('fs');
-const isUndefined = require('lodash.isundefined');
-const isNil = require('lodash.isnil');
-const trim = require('lodash.trim');
-const split = require('lodash.split');
-const difference = require('lodash.difference');
+import {
+  ALL_MODE,
+  ALL_MODES,
+  AWS_KINESIS,
+  AWS_S3,
+  DEFAULT_ENV,
+  DEFAULT_EXIT_DELAY,
+  DEFAULT_FILTER_FILE,
+  DEFAULT_KINESIS_MAX_EVENTS,
+  DEFAULT_KINESIS_MAX_SIZE,
+  DEFAULT_KINESIS_TIMEOUT,
+  DEFAULT_LEVEL,
+  DEFAULT_MODE,
+  DEFAULT_NO_STACK,
+  DEFAULT_S3_MAX_EVENTS,
+  DEFAULT_S3_MAX_SIZE,
+  DEFAULT_S3_TIMEOUT,
+  NONE_MODE,
+  SUMOLOGIC,
+} from '../lib/common.js';
+import difference from 'lodash.difference';
+import fs from 'fs';
+import isNil from 'lodash.isnil';
+import isUndefined from 'lodash.isundefined';
+import process from 'process';
+import split from 'lodash.split';
+import trim from 'lodash.trim';
+
+const DECIMAL = 10;
+const EXISTING_ERRORS = 1;
+const NO_MODE = 0;
+const KNOWN_MODE = 0;
+const SINGLE_MODE = 1;
 
 /**
  *
@@ -66,41 +93,21 @@ const difference = require('lodash.difference');
  * If `global.serverType` is set, this value is used over SERVER_TYPE.
  * If `global.serverType` is set, the value of `global.serverId` is used over `SERVER_ID`.
  */
-const {
-  DEFAULT_LEVEL,
-  DEFAULT_ENV,
-  DEFAULT_FILTER_FILE,
-  DEFAULT_S3_MAX_SIZE,
-  DEFAULT_S3_MAX_EVENTS,
-  DEFAULT_S3_TIMEOUT,
-  DEFAULT_KINESIS_MAX_SIZE,
-  DEFAULT_KINESIS_MAX_EVENTS,
-  DEFAULT_KINESIS_TIMEOUT,
-  DEFAULT_MODE,
-  DEFAULT_EXIT_DELAY,
-  DEFAULT_NO_STACK,
-  SUMOLOGIC,
-  AWS_S3,
-  AWS_KINESIS,
-  ALL,
-  NONE,
-  ALL_MODES,
-} = require('../lib/common');
 
 const checkConfig = (config) => {
   const errs = [];
 
-  function traverseNodeSync(node, path) {
+  const traverseNodeSync = (node, path) => {
     Object.keys(node).forEach((prop) => {
       if (typeof node[prop] === 'object' && node[prop]) {
         traverseNodeSync(node[prop], `${path}.${prop}`);
       }
       else if (isUndefined(node[prop])) errs.push(`${path}.${prop}`);
     });
-  }
+  };
 
   traverseNodeSync(config, 'configuration');
-  if (errs.length > 0) {
+  if (errs.length > EXISTING_ERRORS) {
     throw new Error(`Missing values for ${errs}`);
   }
 };
@@ -109,11 +116,11 @@ const checkMode = (mode) => {
   let logMode = null;
 
   if (mode) {
-    logMode = split(trim(mode), /\s*,\s*/);
-    if (logMode.length === 0) throw new Error('Invalid LOG_MODE: cannot be an empty array');
-    if (difference(logMode, ALL_MODES).length !== 0) throw new Error(`Invalid items in LOG_MODE: ${mode}`);
-    if (logMode.includes(NONE) && logMode.length !== 1) throw new Error(`Cannot have multiple modes when ${NONE} is selected`);
-    if (logMode.includes(ALL)) logMode = [SUMOLOGIC, AWS_S3]; // legacy support
+    logMode = split(trim(mode), /\s*,\s*/u);
+    if (logMode.length === NO_MODE) throw new Error('Invalid LOG_MODE: cannot be an empty array');
+    if (difference(logMode, ALL_MODES).length !== KNOWN_MODE) throw new Error(`Invalid items in LOG_MODE: ${mode}`);
+    if (logMode.includes(NONE_MODE) && logMode.length !== SINGLE_MODE) throw new Error(`Cannot have multiple modes when ${NONE_MODE} is selected`);
+    if (logMode.includes(ALL_MODE)) logMode = [SUMOLOGIC, AWS_S3]; // legacy support
   }
   return logMode;
 };
@@ -131,7 +138,7 @@ const configuration = {
   filter: {
     file: process.env.FILTER_FILE || DEFAULT_FILTER_FILE,
   },
-  exitDelay: parseInt(process.env.EXIT_DELAY, 10) || DEFAULT_EXIT_DELAY, // in ms
+  exitDelay: parseInt(process.env.EXIT_DELAY, DECIMAL) || DEFAULT_EXIT_DELAY, // in ms
   noStack: process.env.NO_STACK || DEFAULT_NO_STACK,
 };
 configuration.mode = checkMode(process.env.LOG_MODE) || DEFAULT_MODE;
@@ -148,9 +155,9 @@ if (configuration.mode.includes(AWS_KINESIS)) {
     streamNameError: process.env.KINESIS_AWS_STREAM_NAME_ERROR,
     streamNameOther: process.env.KINESIS_AWS_STREAM_NAME_OTHER,
     region: process.env.KINESIS_AWS_REGION,
-    timeout: parseInt(process.env.KINESIS_AWS_TIMEOUT, 10) || DEFAULT_KINESIS_TIMEOUT, // in ms
-    maxSize: parseInt(process.env.KINESIS_AWS_MAX_SIZE, 10) || DEFAULT_KINESIS_MAX_SIZE, // in mB
-    maxEvents: parseInt(process.env.KINESIS_AWS_MAX_EVENTS, 10) || DEFAULT_KINESIS_MAX_EVENTS,
+    timeout: parseInt(process.env.KINESIS_AWS_TIMEOUT, DECIMAL) || DEFAULT_KINESIS_TIMEOUT, // in ms
+    maxSize: parseInt(process.env.KINESIS_AWS_MAX_SIZE, DECIMAL) || DEFAULT_KINESIS_MAX_SIZE, // in mB
+    maxEvents: parseInt(process.env.KINESIS_AWS_MAX_EVENTS, DECIMAL) || DEFAULT_KINESIS_MAX_EVENTS,
   };
 
   if (!isNil(process.env.KINESIS_AWS_ACCESS_KEY_ID)) configuration[AWS_KINESIS].accessKeyId = process.env.KINESIS_AWS_ACCESS_KEY_ID;
@@ -160,9 +167,9 @@ if (configuration.mode.includes(AWS_S3)) {
   configuration[AWS_S3] = {
     bucketname: process.env.S3_AWS_BUCKET_NAME,
     region: process.env.S3_AWS_REGION,
-    timeout: parseInt(process.env.S3_AWS_TIMEOUT, 10) || DEFAULT_S3_TIMEOUT, // in minutes
-    maxSize: parseInt(process.env.S3_AWS_MAX_SIZE, 10) || DEFAULT_S3_MAX_SIZE, // in mB
-    maxEvents: parseInt(process.env.S3_AWS_MAX_EVENTS, 10) || DEFAULT_S3_MAX_EVENTS,
+    timeout: parseInt(process.env.S3_AWS_TIMEOUT, DECIMAL) || DEFAULT_S3_TIMEOUT, // in minutes
+    maxSize: parseInt(process.env.S3_AWS_MAX_SIZE, DECIMAL) || DEFAULT_S3_MAX_SIZE, // in mB
+    maxEvents: parseInt(process.env.S3_AWS_MAX_EVENTS, DECIMAL) || DEFAULT_S3_MAX_EVENTS,
   };
 
   if (!isNil(process.env.S3_AWS_ACCESS_KEY_ID)) configuration[AWS_S3].accessKeyId = process.env.S3_AWS_ACCESS_KEY_ID;
@@ -172,7 +179,9 @@ const { filter } = configuration;
 let filterConfig = [];
 
 if (filter.file) {
-  try { filterConfig = JSON.parse(fs.readFileSync(filter.file).toString()); }
+  try {
+    filterConfig = JSON.parse(fs.readFileSync(filter.file).toString());
+  }
   catch (err) {
     throw new Error(`Invalid file for logger config: ${filter.file}, error: ${err.message}`);
   }
@@ -180,4 +189,4 @@ if (filter.file) {
 filter.config = filterConfig;
 checkConfig(configuration);
 
-module.exports = configuration;
+export default configuration;

package/eslint.config.js

@@ -0,0 +1,60 @@
+import importPlugin from 'eslint-plugin-import';
+import js from '@eslint/js';
+import processDoc from '@mimik/eslint-plugin-document-env';
+import stylistic from '@stylistic/eslint-plugin';
+
+const MAX_LENGTH_LINE = 180;
+const MAX_FUNCTION_PARAMETERS = 6;
+const MAX_LINES_IN_FILES = 400;
+const MAX_LINES_IN_FUNCTION = 100;
+const MAX_STATEMENTS_IN_FUNCTION = 45;
+const MIN_KEYS_IN_OBJECT = 10;
+
+export default [
+  {
+    ignores: ['mochawesome-report/**', 'node_modules/**', 'dist/**'],
+  },
+  importPlugin.flatConfigs.recommended,
+  stylistic.configs['recommended-flat'],
+  js.configs.all,
+  {
+    plugins: {
+      processDoc,
+    },
+    languageOptions: {
+      ecmaVersion: 2022,
+      globals: {
+        console: 'readonly',
+        describe: 'readonly',
+        it: 'readonly',
+        require: 'readonly',
+      },
+      sourceType: 'module',
+    },
+    rules: {
+      '@stylistic/brace-style': ['warn', 'stroustrup', { allowSingleLine: true }],
+      '@stylistic/line-comment-position': ['off'],
+      '@stylistic/semi': ['error', 'always'],
+      'capitalized-comments': ['off'],
+      'curly': ['off'],
+      'id-length': ['error', { exceptions: ['x', 'y', 'z', 'i', 'j', 'k'] }],
+      'import/no-extraneous-dependencies': ['error', { devDependencies: true }],
+      'import/no-unresolved': ['error', { amd: true, caseSensitiveStrict: true, commonjs: true }],
+      'init-declarations': ['off'],
+      'linebreak-style': ['off'],
+      'max-len': ['warn', MAX_LENGTH_LINE, { ignoreComments: true }],
+      'max-lines': ['warn', MAX_LINES_IN_FILES],
+      'max-lines-per-function': ['warn', MAX_LINES_IN_FUNCTION],
+      'max-params': ['error', MAX_FUNCTION_PARAMETERS],
+      'max-statements': ['warn', MAX_STATEMENTS_IN_FUNCTION],
+      'no-confusing-arrow': ['off'], // arrow isnt confusing
+      'no-inline-comments': ['off'],
+      'no-process-env': ['error'],
+      'no-undefined': ['off'],
+      'one-var': ['error', 'never'],
+      'processDoc/validate-document-env': ['error'],
+      'quotes': ['warn', 'single'],
+      'sort-keys': ['error', 'asc', { caseSensitive: true, minKeys: MIN_KEYS_IN_OBJECT, natural: false }],
+    },
+  },
+];

package/index.js

@@ -1,24 +1,30 @@
-const { createLogger, format, transports } = require('winston');
-
-const Sumologic = require('./lib/sumologicTransport');
-const AwsS3 = require('./lib/awsS3Transport');
-const AwsKinesis = require('./lib/awsKinesisTransport');
-const {
-  stackInfo,
-  correlationId,
-  filterMeta,
-} = require('./lib/formatLib');
-const config = require('./configuration/config');
-const {
-  SUMOLOGIC,
-  AWS_S3,
+import {
   AWS_KINESIS,
-  NONE,
-  WARN,
-  // LOG,
+  AWS_S3,
   FLUSH,
   FLUSH_EXIT,
-} = require('./lib/common');
+  // LOG,
+  NONE_MODE,
+  SUMOLOGIC,
+  WARN,
+} from './lib/common.js';
+import {
+  correlationId,
+  filterMeta,
+  stackInfo,
+} from './lib/formatLib.js';
+import {
+  createLogger,
+  format,
+  transports,
+} from 'winston';
+
+import AwsKinesis from './lib/awsKinesisTransport.js';
+import AwsS3 from './lib/awsS3Transport.js';
+import Sumologic from './lib/sumologicTransport.js';
+import config from './configuration/config.js';
+import process from 'process';
+import { setTimeout } from 'timers';
 
 let sumo;
 let awsS3;
@@ -56,45 +62,45 @@ if (config.mode.includes(SUMOLOGIC)) {
     serverType: config.server.type,
     serverId: config.server.id,
   });
-  sumo.on(WARN, (data) => miniLog.warn('Could not send logs: ', data, data.correlationId));
+  sumo.on(WARN, data => miniLog.warn('Could not send logs: ', data, data.correlationId));
   // sumo.on(LOG, (data) => console.log('sumo done')); // miniLog.info('Information sent: ', data));
   logger.add(sumo);
 }
 if (config.mode.includes(AWS_S3)) {
   awsS3 = new AwsS3({
-    level: config.level.log,
-    bucketname: config[AWS_S3].bucketname,
-    region: config[AWS_S3].region,
     accessKeyId: config[AWS_S3].accessKeyId,
-    secretAccessKey: config[AWS_S3].secretAccessKey,
-    timeout: config[AWS_S3].timeout,
+    bucketname: config[AWS_S3].bucketname,
+    format: format.combine(format.timestamp(), format.json()),
+    level: config.level.log,
     maxEvents: config[AWS_S3].maxEvents,
     maxSize: config[AWS_S3].maxSize,
-    serverType: config.server.type,
+    region: config[AWS_S3].region,
+    secretAccessKey: config[AWS_S3].secretAccessKey,
     serverId: config.server.id,
-    format: format.combine(format.timestamp(), format.json()),
+    serverType: config.server.type,
+    timeout: config[AWS_S3].timeout,
   });
-  awsS3.on(WARN, (data) => miniLog.warn('Could not send logs: ', data));
+  awsS3.on(WARN, data => miniLog.warn('Could not send logs: ', data));
   // awsS3.on(LOG, (data) => console.log('awsS3 done')); // miniLog.info('Information sent : ', data));
   logger.add(awsS3);
 }
 if (config.mode.includes(AWS_KINESIS)) {
   awsKinesis = new AwsKinesis({
-    level: config.level.log,
-    streamNameInfo: config[AWS_KINESIS].streamNameInfo,
-    streamNameError: config[AWS_KINESIS].streamNameError,
-    streamNameOther: config[AWS_KINESIS].streamNameOther,
-    region: config[AWS_KINESIS].region,
     accessKeyId: config[AWS_KINESIS].accessKeyId,
-    secretAccessKey: config[AWS_KINESIS].secretAccessKey,
-    timeout: config[AWS_KINESIS].timeout,
+    format: format.combine(format.timestamp(), format.json()),
+    level: config.level.log,
     maxEvents: config[AWS_KINESIS].maxEvents,
     maxSize: config[AWS_KINESIS].maxSize,
-    serverType: config.server.type,
+    region: config[AWS_KINESIS].region,
+    secretAccessKey: config[AWS_KINESIS].secretAccessKey,
     serverId: config.server.id,
-    format: format.combine(format.timestamp(), format.json()),
+    serverType: config.server.type,
+    streamNameError: config[AWS_KINESIS].streamNameError,
+    streamNameInfo: config[AWS_KINESIS].streamNameInfo,
+    streamNameOther: config[AWS_KINESIS].streamNameOther,
+    timeout: config[AWS_KINESIS].timeout,
   });
-  awsKinesis.on(WARN, (data) => miniLog.warn('Could not send logs: ', data));
+  awsKinesis.on(WARN, data => miniLog.warn('Could not send logs: ', data));
   // awsKinesis.on(LOG, (data) => console.log('awsKinesis done')); // miniLog.info('Information sent: ', data));
   logger.add(awsKinesis);
 }
@@ -105,7 +111,7 @@ logger.flushAndExit = (code) => {
     let awsS3Done = false;
     let awsKinesisDone = false;
 
-    if (config.mode.includes(NONE)) return process.exit(code);
+    if (config.mode.includes(NONE_MODE)) return process.exit(code);
     if (awsS3) {
       awsS3.flush(FLUSH_EXIT);
       awsS3.on(FLUSH_EXIT, () => {
@@ -142,7 +148,7 @@ logger.flush = () => {
     let awsS3Done = false;
     let awsKinesisDone = false;
 
-    if (config.mode.includes(NONE)) return null;
+    if (config.mode.includes(NONE_MODE)) return null;
     if (awsS3) {
       awsS3.flush(FLUSH);
       awsS3.on(FLUSH, () => {
@@ -175,4 +181,4 @@ logger.flush = () => {
 
 logger.LEVELS = ['error', 'warn', 'info', 'verbose', 'debug', 'silly'];
 
-module.exports = logger;
+export default logger;

package/lib/awsKinesisTransport.js

@@ -1,36 +1,44 @@
-const Transport = require('winston-transport');
-const Promise = require('bluebird');
-const { KinesisClient, PutRecordsCommand } = require('@aws-sdk/client-kinesis');
-
-const {
+import {
   AWS_KINESIS,
-  LOG,
-  WARN,
-  MESSAGE,
-  UNKNOWN_TYPE,
-  UNKNOWN_ID,
   CLIENTS,
-  PARTITION_KEY,
-  INFO,
   ERROR,
+  INFO,
+  LOG,
+  MESSAGE,
   OTHER,
-} = require('./common');
+  PARTITION_KEY,
+  UNKNOWN_ID,
+  UNKNOWN_TYPE,
+  WARN,
+} from './common.js';
+import {
+  KinesisClient,
+  PutRecordsCommand,
+} from '@aws-sdk/client-kinesis';
+import {
+  setImmediate,
+  setInterval,
+} from 'timers';
+import Buffer from 'buffer';
+import Promise from 'bluebird';
+import Transport from 'winston-transport';
 
+const RANDOM_MIN = 0;
 const RANDOM_LIMIT = 100;
+const MEGA = 1048576; // 2^20 conversion to mega
+const SYSTEM_ERROR = 500;
 
 const events = {};
 
-function randomInt(low, high) {
-  return Math.floor(Math.random() * (high - low) + low);
-}
+const randomInt = (low, high) => Math.floor(Math.random() * (high - low) + low);
 
-module.exports = class AwsKinesis extends Transport {
+export default class AwsKinesis extends Transport {
   constructor(options = {}) {
     super(options);
     this.serverType = options.serverType || UNKNOWN_TYPE;
     this.serverId = `${options.serverId || UNKNOWN_ID}${CLIENTS}`; // adding CLIENTS to conform to oauth tokens
     this.name = AWS_KINESIS;
-    this.maxSize = 1024 * 1024 * options.maxSize; // in mB
+    this.maxSize = MEGA * options.maxSize; // in mB
     this.maxEvents = options.maxEvents;
     this.timeInterval = options.timeout; // in ms
     this.streamNameInfo = options.streamNameInfo;
@@ -75,10 +83,10 @@ module.exports = class AwsKinesis extends Transport {
   send(Records, lvl) {
     return this.put(Records, lvl)
       .then(() => this.emit(LOG, { message: `log sent to ${AWS_KINESIS}` }))
-      .catch((err) => this.emit(WARN, {
+      .catch(err => this.emit(WARN, {
         data: Records,
         message: `could not log to ${AWS_KINESIS}`,
-        error: { message: err.message, statusCode: err.statusCode || 500, details: err },
+        error: { message: err.message, statusCode: err.statusCode || SYSTEM_ERROR, details: err },
       }));
   }
 
@@ -90,10 +98,10 @@ module.exports = class AwsKinesis extends Transport {
             events[level].data = []; // we may lose some logs due to concurrency issues
             events[level].size = 0;
           })
-          .catch((err) => this.emit(WARN, {
+          .catch(err => this.emit(WARN, {
             data: events[level].Records,
             message: `could not log to ${AWS_KINESIS}`,
-            error: { message: err.message, statusCode: err.statusCode || 500, details: err },
+            error: { message: err.message, statusCode: err.statusCode || SYSTEM_ERROR, details: err },
           }));
       }
       return Promise.resolve();
@@ -105,8 +113,8 @@ module.exports = class AwsKinesis extends Transport {
     const messageInfo = info[MESSAGE];
     const infoSize = messageInfo.length;
     let { level } = info;
-    const { serverType } = global;
-    let { serverId } = global;
+    const { serverType } = globalThis;
+    let { serverId } = globalThis;
     const data = JSON.parse(messageInfo);
 
     if (serverType) {
@@ -126,7 +134,7 @@ module.exports = class AwsKinesis extends Transport {
       levelData = events[level];
     }
     levelData.size += infoSize;
-    levelData.Records.push({ Data: Buffer.from(JSON.stringify(data)), PartitionKey: `${PARTITION_KEY}-${randomInt(0, RANDOM_LIMIT)}` });
+    levelData.Records.push({ Data: Buffer.from(JSON.stringify(data)), PartitionKey: `${PARTITION_KEY}-${randomInt(RANDOM_MIN, RANDOM_LIMIT)}` });
     if (levelData.Records.length >= this.maxEvents || levelData.size >= this.maxSize) {
       this.send(levelData.Records, level);
       levelData.Records = [];

package/lib/awsS3Transport.js

@@ -1,30 +1,42 @@
-const Transport = require('winston-transport');
-const Promise = require('bluebird');
-const { S3Client, PutObjectCommand } = require('@aws-sdk/client-s3');
-
-const {
+import {
   AWS_S3,
+  CLIENTS,
   LOG,
-  WARN,
   MESSAGE,
-  UNKNOWN_TYPE,
   UNKNOWN_ID,
-  CLIENTS,
-} = require('./common');
+  UNKNOWN_TYPE,
+  WARN,
+} from './common.js';
+import {
+  PutObjectCommand,
+  S3Client,
+} from '@aws-sdk/client-s3';
+import {
+  setImmediate,
+  setInterval,
+} from 'timers';
+import Promise from 'bluebird';
+import Transport from 'winston-transport';
 
 const events = {};
 const typeEvents = {};
 
-module.exports = class AwsS3 extends Transport {
+const INCR = 1;
+const NONE = 0;
+const MEGA = 1048576; // 2^20 conversion to mega
+const MILLI_MIN = 60000; // 1000*60 conversion to minute
+const SYSTEM_ERROR = 500;
+
+export default class AwsS3 extends Transport {
   constructor(options = {}) {
     super(options);
     this.serverType = options.serverType || UNKNOWN_TYPE;
     this.serverId = `${options.serverId || UNKNOWN_ID}${CLIENTS}`; // adding CLIENTS to conform to oauth tokens
     this.server = `${this.serverType}/${this.serverId}`;
     this.name = AWS_S3;
-    this.maxSize = 1024 * 1024 * options.maxSize; // in mB
+    this.maxSize = MEGA * options.maxSize; // in mB
     this.maxEvents = options.maxEvents;
-    this.timeInterval = 1000 * 60 * options.timeout; // in minutes
+    this.timeInterval = MILLI_MIN * options.timeout; // in minutes
     this.bucketname = options.bucketname;
     this.s3ClientConfig = {
       region: options.region,
@@ -59,7 +71,7 @@ module.exports = class AwsS3 extends Transport {
   put(data, lvl, date) {
     const command = new PutObjectCommand({
       Bucket: this.bucketname,
-      Key: `${lvl}/${this.server}/${date.getFullYear()}/${date.getMonth() + 1}/${date.getDate()}/${date.toISOString()}.json`,
+      Key: `${lvl}/${this.server}/${date.getFullYear()}/${date.getMonth() + INCR}/${date.getDate()}/${date.toISOString()}.json`,
       Body: JSON.stringify(data),
     });
 
@@ -69,10 +81,10 @@ module.exports = class AwsS3 extends Transport {
   send(data, lvl, date) {
     return this.put(data, lvl, date)
       .then(() => this.emit(LOG, { message: `log sent to ${AWS_S3}` }))
-      .catch((err) => this.emit(WARN, {
+      .catch(err => this.emit(WARN, {
         data,
         message: `could not log to ${AWS_S3}`,
-        error: { message: err.message, statusCode: err.statusCode || 500, details: err },
+        error: { message: err.message, statusCode: err.statusCode || SYSTEM_ERROR, details: err },
       }));
   }
 
@@ -80,20 +92,20 @@ module.exports = class AwsS3 extends Transport {
     const errors = [];
     let count = 0;
 
-    return Promise.map(Object.keys(data), (sType) => Promise.each(Object.keys(data[sType]), (sId) => {
+    return Promise.map(Object.keys(data), sType => Promise.each(Object.keys(data[sType]), (sId) => {
       const command = new PutObjectCommand({
         Bucket: this.bucketname,
-        Key: `${lvl}/${sType}/${sId}/${date.getFullYear()}/${date.getMonth() + 1}/${date.getDate()}/${date.toISOString()}.json`,
+        Key: `${lvl}/${sType}/${sId}/${date.getFullYear()}/${date.getMonth() + INCR}/${date.getDate()}/${date.toISOString()}.json`,
         Body: JSON.stringify(data[sType][sId]),
       });
 
       return this.s3.send(command)
         .then(() => {
-          count += 1;
+          count += INCR;
         })
-        .catch((err) => errors.push({
+        .catch(err => errors.push({
           data: data[sType][sId],
-          error: { message: err.message, statusCode: err.statusCode || 500, details: err },
+          error: { message: err.message, statusCode: err.statusCode || SYSTEM_ERROR, details: err },
         }));
     }))
       .then(() => ({ count, errors }));
@@ -105,8 +117,8 @@ module.exports = class AwsS3 extends Transport {
         const { count, errors } = result;
         const errorCount = errors.length;
 
-        if (errorCount === 0) return this.emit(LOG, { message: `${count} logs sent to ${AWS_S3}` });
-        if (count === 0) {
+        if (errorCount === NONE) return this.emit(LOG, { message: `${count} logs sent to ${AWS_S3}` });
+        if (count === NONE) {
           return this.emit(WARN, {
             errors,
             nblogs: errorCount,
@@ -131,7 +143,7 @@ module.exports = class AwsS3 extends Transport {
             events[level].data = []; // we may lose some logs due to concurrency issues
             events[level].size = 0;
           })
-          .catch((err) => this.emit(WARN, { error: err.message, message: `could not log to ${AWS_S3}` }));
+          .catch(err => this.emit(WARN, { error: err.message, message: `could not log to ${AWS_S3}` }));
       }
       return Promise.resolve();
     })
@@ -149,8 +161,8 @@ module.exports = class AwsS3 extends Transport {
             const { count, errors } = result;
             const errorCount = errors.length;
 
-            if (errorCount === 0) return this.emit(LOG, { message: `${count} logs sent to ${AWS_S3}` });
-            if (count === 0) {
+            if (errorCount === NONE) return this.emit(LOG, { message: `${count} logs sent to ${AWS_S3}` });
+            if (count === NONE) {
               return this.emit(WARN, {
                 errors,
                 nblogs: errorCount,
@@ -174,8 +186,8 @@ module.exports = class AwsS3 extends Transport {
     const messageInfo = info[MESSAGE];
     const infoSize = messageInfo.length;
     const { level } = info;
-    const { serverType } = global;
-    let { serverId } = global;
+    const { serverType } = globalThis;
+    let { serverId } = globalThis;
     const data = JSON.parse(messageInfo);
 
     if (serverType) {