BKNDLSS-32283 Implement LogLevels in the JS-SDK (#239)

Author: stanislaw-grin

src/index.js

@@ -146,8 +146,11 @@ class Backendless {
 
     app.__removeService('LocalCache')
 
+    const loggingConfig = Object.assign({ loadLevels: true, defaultLevel: 'all', levels: {} }, config.logging)
+
     if (app.__hasService('Logging')) {
       app.Logging.reset()
+      app.Logging.setConfig(loggingConfig)
     }
 
     if (app.__hasService('Users')) {
@@ -156,6 +159,8 @@ class Backendless {
 
     delete this.__device
 
+    app.loggingConfig = loggingConfig
+
     return app
   }
 

src/logging/index.js

@@ -6,6 +6,16 @@ export default class Logging {
     this.app = app
 
     this.reset()
+
+    this.setConfig(app.loggingConfig)
+  }
+
+  setConfig(config) {
+    this.config = config
+
+    if (config.loadLevels) {
+      this.loadLoggingLevels()
+    }
   }
 
   reset() {
@@ -16,6 +26,20 @@ export default class Logging {
     this.messagesLimit = 100
   }
 
+  loadLoggingLevels() {
+    this.app.request
+      .get({ url: this.app.urls.loggingLevels() })
+      .then(loggers => {
+        loggers.forEach(logger => {
+          this.config.levels[logger.name] = logger.level
+        })
+      })
+      .catch(error => {
+        // eslint-disable-next-line no-console
+        console.error('Could not load logging levels: ', error)
+      })
+  }
+
   getLogger(loggerName) {
     if (!loggerName || typeof loggerName !== 'string') {
       throw new Error('Logger Name must be provided and must be a string.')

src/logging/logger.js

@@ -1,3 +1,14 @@
+const LogLevelPriorities = {
+  off  : 0,
+  fatal: 1,
+  error: 2,
+  warn : 3,
+  info : 4,
+  debug: 5,
+  trace: 6,
+  all  : 6,
+}
+
 export default class Logger {
 
   constructor(name, logging) {
@@ -6,26 +17,44 @@ export default class Logger {
   }
 
   debug(message) {
-    return this.logging.push(this.name, 'DEBUG', message)
+    return this.log('DEBUG', message)
   }
 
   info(message) {
-    return this.logging.push(this.name, 'INFO', message)
+    return this.log('INFO', message)
   }
 
   warn(message, exception) {
-    return this.logging.push(this.name, 'WARN', message, exception)
+    return this.log('WARN', message, exception)
   }
 
   error(message, exception) {
-    return this.logging.push(this.name, 'ERROR', message, exception)
+    return this.log('ERROR', message, exception)
   }
 
   fatal(message, exception) {
-    return this.logging.push(this.name, 'FATAL', message, exception)
+    return this.log('FATAL', message, exception)
   }
 
   trace(message) {
-    return this.logging.push(this.name, 'TRACE', message)
+    return this.log('TRACE', message)
+  }
+
+  log(level, message, exception) {
+    if (this.min(level)) {
+      return this.logging.push(this.name, level, message, exception)
+    }
+  }
+
+  min(level) {
+    const configuredLevel = this.logging.config.levels[this.name]
+
+    if (!configuredLevel) {
+      const { defaultLevel } = this.logging.config
+
+      return LogLevelPriorities[defaultLevel.toLowerCase()] >= LogLevelPriorities[level.toLowerCase()]
+    }
+
+    return LogLevelPriorities[configuredLevel.toLowerCase()] >= LogLevelPriorities[level.toLowerCase()]
   }
 }

src/urls.js

@@ -27,6 +27,10 @@ export default class Urls {
     return `${this.root()}/log`
   }
 
+  loggingLevels() {
+    return `${this.logging()}/logger`
+  }
+
   //cache
 
   cache() {

test/unit/specs/logging.js

@@ -1,7 +1,7 @@
 import { expect } from 'chai'
 import { describe, it } from 'mocha'
 
-import Backendless, { forSuite, prepareMockRequest, APP_PATH, Utils } from '../helpers/sandbox'
+import Backendless, { API_KEY, APP_ID, forSuite, prepareMockRequest, APP_PATH, Utils } from '../helpers/sandbox'
 
 describe('<Logging>', function() {
 
@@ -430,4 +430,85 @@ describe('<Logging>', function() {
       'message'  : 'debug message - 2',
     })
   })
+
+  it('should apply default logging config', async () => {
+    logger.fatal('fatal message')
+    logger.error('error message')
+    logger.warn('warn message')
+    logger.info('info message')
+    logger.debug('debug message')
+    logger.trace('trace message')
+
+    const req = prepareMockRequest()
+
+    await Backendless.Logging.flush()
+
+    expect(req.body).to.deep.equal([
+      { 'log-level': 'FATAL', 'logger': loggerName, 'message': 'fatal message', timestamp: req.body[0].timestamp },
+      { 'log-level': 'ERROR', 'logger': loggerName, 'message': 'error message', timestamp: req.body[1].timestamp },
+      { 'log-level': 'WARN', 'logger': loggerName, 'message': 'warn message', timestamp: req.body[2].timestamp },
+      { 'log-level': 'INFO', 'logger': loggerName, 'message': 'info message', timestamp: req.body[3].timestamp },
+      { 'log-level': 'DEBUG', 'logger': loggerName, 'message': 'debug message', timestamp: req.body[4].timestamp },
+      { 'log-level': 'TRACE', 'logger': loggerName, 'message': 'trace message', timestamp: req.body[5].timestamp },
+    ])
+  })
+
+  it('should apply log levels to logging config', async () => {
+    prepareMockRequest([
+      {
+        name : loggerName,
+        level: 'FATAL'
+      }
+    ])
+
+    Backendless.initApp({
+      appId  : APP_ID,
+      apiKey : API_KEY,
+      logging: {
+        defaultLevel: 'info',
+        levels      : {
+          [loggerName]: 'warn'
+        }
+      }
+    })
+
+    const req = prepareMockRequest()
+
+    logger.debug('debug message')
+    logger.info('info message')
+    logger.fatal('fatal message')
+    logger.trace('trace message')
+
+    await Backendless.Logging.flush()
+
+    expect(req.body).to.deep.equal([
+      { 'log-level': 'FATAL', 'logger': loggerName, 'message': 'fatal message', timestamp: req.body[0].timestamp },
+    ])
+  })
+
+  it('should not load log levels', async () => {
+    Backendless.initApp({
+      appId  : APP_ID,
+      apiKey : API_KEY,
+      logging: {
+        loadLevels: false,
+      }
+    })
+
+    const req = prepareMockRequest()
+
+    logger.debug('debug message')
+    logger.info('info message')
+    logger.fatal('fatal message')
+    logger.trace('trace message')
+
+    await Backendless.Logging.flush()
+
+    expect(req.body).to.deep.equal([
+      { 'log-level': 'DEBUG', 'logger': loggerName, 'message': 'debug message', timestamp: req.body[0].timestamp },
+      { 'log-level': 'INFO', 'logger': loggerName, 'message': 'info message', timestamp: req.body[1].timestamp },
+      { 'log-level': 'FATAL', 'logger': loggerName, 'message': 'fatal message', timestamp: req.body[2].timestamp },
+      { 'log-level': 'TRACE', 'logger': loggerName, 'message': 'trace message', timestamp: req.body[3].timestamp },
+    ])
+  })
 })