@autofleet/node-common 1.1.2 → 1.1.4

package/.circleci/config.yml

@@ -0,0 +1,26 @@
+version: 2
+jobs:
+  test:
+    docker:
+      - image: circleci/node:8.9.4
+    steps:
+      - checkout
+      - restore_cache:
+          keys:
+          - v1-dependencies-{{ checksum "package.json" }}
+          # fallback to using the latest cache if no exact match is found
+          - v1-dependencies-
+      - run: npm i
+      - save_cache:
+          paths:
+            - node_modules
+          key: v1-dependencies-{{ checksum "package.json" }}
+      - run: npm run coverage
+      - run: rm -rf ./coverage
+      - run: npm run linter
+
+workflows:
+  version: 2
+  build_and_test:
+    jobs:
+      - test

package/.eslintrc.json

@@ -4,8 +4,5 @@
   ],
   "env": {
     "jest": true
-  },
-  "rules": {
-    "semi": ["error", "never"]
   }
 }

package/README.md

@@ -12,7 +12,7 @@ Server 2 Servers communication.
 
 Implement:
 * Retriving service urls from environment
-* Retry - TBD
+* Retry - Using https://github.com/softonic/axios-retry
 * Caching - TBD
 * Syntatic response for fail - TBD
 * Circuit Breaking - TBD

package/index.js

@@ -1,4 +1,9 @@
+const Network = require('./network');
+const Logger = require('./logger');
+const Settings = require('./settings');
+
 module.exports = {
-  Network: require('./network'),
-  Logger: require('./logger'),
-}
+  Network,
+  Logger,
+  Settings,
+};

package/logger/example.js

@@ -1,6 +1,5 @@
-const logger = require('./index')('debug')
+const logger = require('./index')();
 
-logger.info('it is working')
-logger.error('errors displayed in logs/error.log')
-logger.debug('debug with object', { a: 5 })
-logger.debug('debug with 2 objects', { 1: { a: 5 }, 2: { b: 2 } })
+logger.info('it is working');
+logger.error('errors displayed in logs/error.log');
+logger.debug('debug with object', { a: 5 });

package/logger/index.js

@@ -1,64 +1,51 @@
-const { createLogger, transports, format } = require('winston')
+const winston = require('winston');
 
-const { combine, timestamp, printf } = format
+const { createLogger } = winston;
+require('dotenv').config();
 
-require('dotenv').config()
+const { env } = process;
 
-const { env } = process
+const infoEnvNmaes = [
+  'production',
+  'staging',
+  'test',
+];
 
 const getLevel = (logLevel) => {
-  if (logLevel) return logLevel
-  if (env.LOG_LEVEL) return env.LOG_LEVEL
-  if (env.NODE_ENV === 'development') return 'debug'
-  // test and producion will return info
-  return 'info'
-}
-
-const getTransporters = () => {
-  const consoleTrasporter = new transports.Console()
-  let transporters = [consoleTrasporter]
-  if (env.USE_LOG_FILES === 'true') {
-    transporters = transporters.concat([
-      new transports.File({ filename: 'logs/error.log', level: 'error' }),
-      new transports.File({ filename: 'logs/all.log' }),
-    ])
+  if (logLevel) return logLevel;
+  if (env.LOG_LEVEL) return env.LOG_LEVEL;
+  if (infoEnvNmaes.includes(env.NODE_ENV)) return 'info';
+  if (env.NODE_ENV === 'development') return 'debug';
+  return 'debug';
+};
+
+const getFormat = () => {
+  if (env.NODE_ENV === 'producation') {
+    return winston.format.json();
   }
-  return transporters
-}
 
-const newLogger = (level, transporters) => {
-  const customFormat = printf((info) => {
-    const level = info.level
-    const message = info.message
-    const timestamp = info.timestamp
-    delete info.level
-    delete info.message
-    delete info.timestamp
-    const params = JSON.stringify(info, null, 2)
-    return `${level}: ${message} ${timestamp} \n ${params} \n *****************`
-  })
+  return winston.format.combine(
+    winston.format.splat(),
+    winston.format.colorize(),
+    winston.format.simple(),
+  );
+};
 
+const createLoggerInstance = (level, transports) => {
   const logger = createLogger({
-    format: combine(
-      format.colorize(),
-      // format.json(),
-      format.simple(),
-      // prettyPrint(),
-      timestamp(),
-      customFormat,
-    ),
     level,
-    transports: transporters,
-  })
+    format: getFormat(),
+    transports: [new winston.transports.Console()],
+    exceptionHandlers: transports,
+    exitOnError: false,
+  });
 
-  return logger
-}
+  return logger;
+};
 
 const getLogger = (logLevel) => {
-  const level = getLevel(logLevel)
-  const transporters = getTransporters()
-  return newLogger(level, transporters)
-}
-
-module.exports = getLogger
+  const level = getLevel(logLevel);
+  return createLoggerInstance(level);
+};
 
+module.exports = getLogger;

package/logger/index.test.js

@@ -1,108 +1,54 @@
-const Logger = require('./index')
-const fs = require('fs')
-const wait = require('wait-promise')
+const Logger = require('./index');
 
-const { env } = process
-
-const deleteLogFile = (filePath) => {
-  const dir = 'logs'
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir)
-  }
-  if (fs.existsSync(filePath)) {
-    fs.unlinkSync(filePath)
-  }
-}
-
-const waitForFileToHaveContent = (filePath => wait.limit(30).until(() => {
-  if (fs.existsSync(filePath)) {
-    const content = fs.readFileSync(filePath, 'utf8')
-    return content !== ''
-  }
-  return false
-}))
+const { env } = process;
 
 describe('Logger', () => {
   it('it`s default level is info', () => {
-    env.NODE_ENV = ''
-    const logger = Logger()
-    expect(logger).toBeDefined()
-    expect(logger.level).toBe('info')
-  })
+    env.NODE_ENV = '';
+    const logger = Logger();
+    expect(logger).toBeDefined();
+    expect(logger.level).toBe('debug');
+  });
 
   it('its default develpment level is debug', () => {
-    env.NODE_ENV = 'development'
-    const logger = Logger()
-    expect(logger.level).toBe('debug')
-  })
+    env.NODE_ENV = 'development';
+    const logger = Logger();
+    expect(logger.level).toBe('debug');
+  });
 
   it('its default test level is info', () => {
-    env.NODE_ENV = 'test'
-    const logger = Logger()
-    expect(logger.level).toBe('info')
-  })
+    env.NODE_ENV = 'test';
+    const logger = Logger();
+    expect(logger.level).toBe('info');
+  });
 
   it('its default production level is info', () => {
-    env.NODE_ENV = 'production'
-    const logger = Logger()
-    expect(logger.level).toBe('info')
-  })
+    env.NODE_ENV = 'production';
+    const logger = Logger();
+    expect(logger.level).toBe('info');
+  });
 
   it('its level can be override by LOG_LEVEL env variable', () => {
-    env.NODE_ENV = 'development'
-    env.LOG_LEVEL = 'warn'
-    const logger = Logger()
-    expect(logger.level).toBe('warn')
-  })
+    env.NODE_ENV = 'development';
+    env.LOG_LEVEL = 'warn';
+    const logger = Logger();
+    expect(logger.level).toBe('warn');
+  });
 
   it('its level can be override by function variable', () => {
-    env.NODE_ENV = 'production'
-    env.LOG_LEVEL = 'warn'
-    const logger = Logger('silly')
-    expect(logger.level).toBe('silly')
-  })
+    env.NODE_ENV = 'production';
+    env.LOG_LEVEL = 'warn';
+    const logger = Logger('silly');
+    expect(logger.level).toBe('silly');
+  });
 
   it('its has functions for each level', () => {
-    const logger = Logger()
-    expect(logger.error).toBeFunction()
-    expect(logger.warn).toBeFunction()
-    expect(logger.info).toBeFunction()
-    expect(logger.verbose).toBeFunction()
-    expect(logger.debug).toBeFunction()
-    expect(logger.silly).toBeFunction()
-  })
-
-  it('it can have general file transporters', async () => {
-    env.USE_LOG_FILES = 'true'
-    const allPath = 'logs/all.log'
-    deleteLogFile(allPath)
-
-    const logger = Logger()
-    const errorText = 'this is error'
-    logger.error(errorText)
-
-    await waitForFileToHaveContent(allPath)
-
-    expect(fs.existsSync(allPath)).toBe(true)
-
-    const contents = fs.readFileSync(allPath, 'utf8')
-    expect(contents).toBe(`error: ${errorText}\n`)
-  })
-
-  it('it can have general file transporters', async () => {
-    env.USE_LOG_FILES = 'true'
-    const errorPath = 'logs/error.log'
-    deleteLogFile(errorPath)
-
-    expect(fs.existsSync(errorPath)).toBe(false)
-
-    const logger = Logger()
-    const errorText = 'this is error'
-    logger.error(errorText)
-
-    await waitForFileToHaveContent(errorPath)
-
-    const contents = fs.readFileSync(errorPath, 'utf8')
-    expect(contents).toBe(`error: ${errorText}\n`)
-  })
-})
+    const logger = Logger();
+    expect(logger.error).toBeFunction();
+    expect(logger.warn).toBeFunction();
+    expect(logger.info).toBeFunction();
+    expect(logger.verbose).toBeFunction();
+    expect(logger.debug).toBeFunction();
+    expect(logger.silly).toBeFunction();
+  });
+});

package/network/index.js

@@ -1,12 +1,15 @@
-const axios = require('axios')
-const httpAdapter = require('axios/lib/adapters/http')
-require('dotenv').config()
+const axios = require('axios');
+const axiosRetry = require('axios-retry');
+const Logger = require('../logger');
+const qs = require('qs');
+const httpAdapter = require('axios/lib/adapters/http');
+require('dotenv').config();
 /**
  * Add support for nock testing
  * see s://github.com/axios/axios/issues/305
  */
 if (process.env.NODE_ENV === 'test') {
-  axios.defaults.adapter = httpAdapter
+  axios.defaults.adapter = httpAdapter;
 }
 
 const HTTPMethods = [
@@ -17,36 +20,66 @@ const HTTPMethods = [
   'put',
   'patch',
   'options',
-]
+];
 
 const defaultSettings = {
   timeout: 2500,
   headers: { 'X-AF-AUTH': 'ANYONE' },
-}
+  paramsSerializer: params => qs.stringify(params),
+};
 
 module.exports = class Network {
   constructor(settings = {}) {
-    this.settings = Object.assign(defaultSettings, settings)
-    this.validate()
-    this.createBaseUrl()
-    this.buildClassHttpMethods()
+    this.settings = Object.assign({}, defaultSettings, settings);
+    this.createBaseUrl();
+
+    this.axios = axios.create(this.settings);
+    this.addRetry(settings);
+    this.buildClassHttpMethods();
+    this.addLogs();
   }
 
-  validate() {
-    if (!this.settings.serviceUrl && !this.settings.serviceName) {
-      throw new Error('At least one of the settings Missing serviceUrl or serviceName')
-    }
+  addRetry(settings) {
+    axiosRetry(this.axios, {
+      retries: 0,
+      retryDelay: axiosRetry.exponentialDelay,
+      ...settings,
+    });
+  }
+
+  addLogs() {
+    const logger = Logger();
+    this.axios.interceptors.request.use((request) => {
+      logger.info(`Start Request: [${request.method.toUpperCase()}] ${request.baseURL} ${request.url}`, {
+        headers: request.headers,
+        query: request.query,
+        body: request.body,
+      });
+      return request;
+    });
+
+    this.axios.interceptors.response.use((response) => {
+      logger.info(`Finish Request: [${response.config.method.toUpperCase()} ${response.config.url}`);
+      return response;
+    }, (response) => {
+      logger.error(`Faild Request: [${response.config.method.toUpperCase()}] ${response.config.url}`);
+      return response;
+    });
   }
 
   createBaseUrl() {
-    const { settings } = this
+    if (!this.settings.serviceUrl && !this.settings.serviceName) {
+      throw new Error('At least one of the settings Missing serviceUrl or serviceName');
+    }
+
+    const { settings } = this;
     if (settings.serviceUrl) {
-      settings.baseURL = settings.serviceUrl
+      settings.baseURL = settings.serviceUrl;
     } else if (settings.serviceName) {
-      const envServiceHostName = `${settings.serviceName}_SERVICE_HOST`
-      settings.baseURL = `http://${process.env[envServiceHostName]}`
+      const envServiceHostName = `${settings.serviceName}_SERVICE_HOST`;
+      settings.baseURL = `http://${process.env[envServiceHostName]}`;
       if (!settings.baseURL) {
-        throw new Error(`Missing environment variable: ${envServiceHostName}`)
+        throw new Error(`Missing environment variable: ${envServiceHostName}`);
       }
     }
   }
@@ -55,9 +88,8 @@ module.exports = class Network {
    * Build class methods that wrap axios methods
    */
   buildClassHttpMethods() {
-    this.axios = axios.create(this.settings)
     HTTPMethods.forEach((method) => {
-      this[method] = (...args) => this.axios[method](...args)
-    })
+      this[method] = (...args) => this.axios[method](...args);
+    });
   }
-}
+};

package/network/index.test.js

@@ -1,31 +1,68 @@
-const nock = require('nock')
-const Network = require('./index')
+const nock = require('nock');
+const Network = require('./index');
 
 nock('http://www.google.com')
   .get('/resource')
-  .reply(200, { one: 1 })
+  .reply(200, { one: 1 });
 
 
 nock('https://www.apple.com')
   .get('/resource')
-  .reply(200, { two: 2 })
+  .reply(200, { two: 2 });
 
 describe('Network', () => {
   it('Making requests by service name from ENV', async () => {
-    process.env.TEST_SERVICE_HOST = 'www.google.com'
-    const n = new Network({ serviceName: 'TEST' })
-    const response = await n.get('/resource')
-    expect(response).toBeDefined()
-    expect(response.data).toBeDefined()
-    expect(response.data.one).toBe(1)
-  })
+    process.env.TEST_SERVICE_HOST = 'www.google.com';
+    const n = new Network({ serviceName: 'TEST' });
+    const response = await n.get('/resource');
+    expect(response).toBeDefined();
+    expect(response.data).toBeDefined();
+    expect(response.data.one).toBe(1);
+  });
 
-  it('Making requests by service name from ENV', async () => {
-    process.env.TEST_SERVICE_HOST = 'www.google.com'
-    const n = new Network({ serviceUrl: 'https://www.apple.com' })
-    const response = await n.get('/resource')
-    expect(response).toBeDefined()
-    expect(response.data).toBeDefined()
-    expect(response.data.two).toBe(2)
-  })
-})
+  it('Making requests by service name from url', async () => {
+    const n = new Network({ serviceUrl: 'https://www.apple.com' });
+    const response = await n.get('/resource');
+    expect(response).toBeDefined();
+    expect(response.data).toBeDefined();
+    expect(response.data.two).toBe(2);
+  });
+
+  it('Getting 404', async () => {
+    const n = new Network({ serviceUrl: 'https://www.apple.com' });
+    const response = await n.get('/resource', {
+      query: {
+        a: 'b',
+      },
+    });
+    expect(response).toBeDefined();
+    expect(response.data).not.toBeDefined();
+  });
+
+  test('Retry 1 time', async () => {
+    nock('https://www.apple2.com')
+      .get('/resource')
+      .once()
+      .reply(500);
+
+
+    nock('https://www.apple2.com')
+      .get('/resource')
+      .once()
+      .reply(200, { two: 2 });
+
+    const n = new Network({ serviceUrl: 'https://www.apple2.com' });
+    const response = await n.get('/resource', {
+      query: {
+        a: 'b',
+      },
+      'axios-retry': {
+        retries: 1,
+      },
+    });
+
+    expect(response).toBeDefined();
+    expect(response.data).toBeDefined();
+    expect(response.data.two).toBe(2);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/node-common",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "",
   "scripts": {
     "coverage": "jest --coverage --forceExit --runInBand",
@@ -23,10 +23,12 @@
   "homepage": "https://gitlab.com/AutoFleet/node-common#README",
   "dependencies": {
     "axios": "^0.18.0",
+    "axios-retry": "^3.1.0",
     "dotenv": "^5.0.1",
     "jest": "^22.4.3",
-    "wait-promise": "^0.4.1",
-    "winston": "^3.0.0-rc5"
+    "node-cache": "^4.2.0",
+    "qs": "^6.5.2",
+    "winston": "^3.0.0-rc4"
   },
   "devDependencies": {
     "eslint": "^4.19.1",

package/settings/example.js

@@ -0,0 +1,30 @@
+/* eslint no-console: 0 */
+const Settings = require('./index');
+
+const settings = new Settings({
+  serviceUrl: 'http://localhost:8085/',
+});
+
+const fleetId = 'e7bbfcad-98a8-421d-962f-fd1c7790c789';
+
+const testSettings = async () => {
+  const generalSetting = await settings.get('ride.matching_retry', 1);
+  const fleetSetting = await settings.get('ride.matching_retry', 1, [{ fleetId }]);
+  const notFoundKey = await settings.get('not.found.key', 1, [{ fleetId }]);
+  await settings.get('not.found.key', 1, [{ fleetId }, { dor: 1 }]);
+
+  try {
+    await settings.get('not.found.key');
+  } catch (error) {
+    console.log(error);
+  }
+
+  console.log(generalSetting);
+  console.log(fleetSetting);
+  console.log(notFoundKey);
+};
+
+testSettings();
+setTimeout(() => {
+  testSettings();
+}, 500);

package/settings/index.js

@@ -0,0 +1,52 @@
+const NodeCache = require('node-cache');
+const Network = require('../network');
+const Logger = require('../logger');
+
+const logger = Logger();
+require('dotenv').config();
+
+const fiveMinutes = 60 * 5;
+
+module.exports = class SettingsManager {
+  constructor({ serviceUrl, ttl = fiveMinutes }) {
+    const localServiceUrl = serviceUrl || process.env.SETTING_MS_SERVICE_HOST;
+
+    this.ttl = ttl;
+    this.settingsCache = new NodeCache();
+    this.network = new Network({
+      serviceUrl: localServiceUrl,
+    });
+  }
+
+  async get(key, defaultValue, labels = []) {
+    if (!defaultValue) {
+      throw new Error('Can\'t get a key without defaultValue');
+    }
+
+    const cacheKey = `${key}_${JSON.stringify(labels)}`;
+    const cacheValue = this.settingsCache.get(cacheKey);
+    if (cacheValue !== undefined) {
+      return cacheValue;
+    }
+
+    let networkValue;
+    try {
+      const networkReponse = await this.network.get(`/api/v1/setting/get-setting/${key}`, {
+        params: {
+          labels,
+        },
+      });
+      networkValue = networkReponse.data.value;
+    } catch (error) {
+      logger.error('Cant get setting from network', error);
+    }
+
+    const returnValue = networkValue || defaultValue;
+    this.settingsCache.set(cacheKey, returnValue, this.ttl);
+    return returnValue;
+  }
+
+  flush() {
+    return this.settingsCache.flushAll();
+  }
+};

package/settings/index.test.js

@@ -0,0 +1,74 @@
+const nock = require('nock');
+const Settings = require('./index');
+
+const serviceUrl = 'http://localhost:8085';
+
+const mockSetting = (key, value, labels, response = 200) => nock(serviceUrl)
+  .get(`/api/v1/setting/get-setting/${key}`)
+  .query(labels ? { labels } : undefined)
+  .reply(response, { value });
+
+describe('Settings', () => {
+  it('Get a key from server', async () => {
+    const m = mockSetting('key1', 'value1');
+    const settings = new Settings({
+      serviceUrl,
+    });
+
+    const value = await settings.get('key1', 'dv');
+    expect(value).toEqual('value1');
+    expect(m.isDone()).toBeTruthy();
+  });
+
+  it('Cache from server', async () => {
+    const m = mockSetting('key1', 'value1');
+    const settings = new Settings({
+      serviceUrl,
+    });
+
+    const value = await settings.get('key1', 'dv');
+    expect(value).toEqual('value1');
+    expect(m.isDone()).toBeTruthy();
+
+    const value2 = await settings.get('key1', 'dv');
+    expect(value2).toEqual('value1');
+  });
+
+  it('Finds with labels', async () => {
+    const m = mockSetting('key1', 'value1', [{ fleetId: 'uuid' }]);
+    const settings = new Settings({
+      serviceUrl,
+    });
+
+    const value = await settings.get('key1', 'dv', [{ fleetId: 'uuid' }]);
+    expect(value).toEqual('value1');
+    expect(m.isDone()).toBeTruthy();
+  });
+
+  it('Returns default value when network error', async () => {
+    const settings = new Settings({
+      serviceUrl,
+    });
+
+    const value = await settings.get('key1', 'dv', [{ fleetId: 'uuid' }]);
+    expect(value).toEqual('dv');
+  });
+
+  it('Values can be flushed', async () => {
+    const m1 = mockSetting('key1', 'value1');
+    const settings = new Settings({
+      serviceUrl,
+    });
+
+    const value = await settings.get('key1', 'dv');
+    expect(value).toEqual('value1');
+    expect(m1.isDone()).toBeTruthy();
+
+    settings.flush();
+    const m2 = mockSetting('key1', 'value2');
+
+    const value2 = await settings.get('key1', 'dv');
+    expect(value2).toEqual('value2');
+    expect(m2.isDone()).toBeTruthy();
+  });
+});