- fix Logger

- add e2e tests for Logging Service

Author: Valodya

src/logging/collector.js

@@ -7,102 +7,102 @@ import Logger from './logger'
 
 let lastFlushListeners
 
+function flush(asyncHandler) {
+  if (LoggingCollector.pool.length) {
+    if (LoggingCollector.flushInterval) {
+      clearTimeout(LoggingCollector.flushInterval)
+    }
+
+    let listeners
+
+    const cb = method => function() {
+      listeners.forEach(callbacks => {
+        callbacks[method].apply(null, arguments)
+      })
+
+      if (listeners === lastFlushListeners) {
+        lastFlushListeners = null
+      }
+    }
+
+    if (asyncHandler) {
+      listeners = lastFlushListeners = lastFlushListeners ? lastFlushListeners.splice(0) : []
+      listeners.push(asyncHandler)
+    }
+
+    console.log('LoggingCollector.pool', LoggingCollector.pool)
+
+    Request.put({
+      isAsync     : !!asyncHandler,
+      asyncHandler: asyncHandler && new Async(cb('success'), cb('fault')),
+      url         : Urls.logging(),
+      data        : LoggingCollector.pool
+    })
+
+    LoggingCollector.pool = []
+
+  } else if (asyncHandler) {
+    if (lastFlushListeners) {
+      lastFlushListeners.push(asyncHandler)
+    } else {
+      setTimeout(asyncHandler.success, 0)
+    }
+  }
+}
+
 const LoggingCollector = {
-  loggers      : {},
-  pool         : [],
-  numOfMessages: 10,
-  timeFrequency: 1,
 
   reset() {
-    this.loggers = {}
-    this.pool = []
-    this.numOfMessages = 10
-    this.timeFrequency = 1
+    LoggingCollector.loggers = {}
+    LoggingCollector.pool = []
+    LoggingCollector.numOfMessages = 10
+    LoggingCollector.timeFrequency = 1
   },
 
   getLogger(loggerName) {
     if (!Utils.isString(loggerName)) {
       throw new Error("Invalid 'loggerName' value. LoggerName must be a string value")
     }
 
-    return this.loggers[loggerName] = this.loggers[loggerName] || new Logger(loggerName)
+    return LoggingCollector.loggers[loggerName] = LoggingCollector.loggers[loggerName] || new Logger(loggerName)
   },
 
   push(logger, logLevel, message, exception) {
     const messageObj = {
       logger,
-      logLevel,
       message,
       exception,
+      'log-level': logLevel,
       timestamp: Date.now()
     }
 
-    this.pool.push(messageObj)
+    LoggingCollector.pool.push(messageObj)
 
-    this.checkMessagesLen()
+    LoggingCollector.checkMessagesLen()
   },
 
-  checkMessagesLen: function() {
-    if (this.pool.length >= this.numOfMessages) {
-      this.sendRequest()
+  checkMessagesLen() {
+    if (LoggingCollector.pool.length >= LoggingCollector.numOfMessages) {
+      LoggingCollector.sendRequest()
     }
   },
 
-  flush    : Utils.promisified('_flush'),
-  flushSync: Utils.synchronized('_flush'),
+  flush    : Utils.promisified(flush),
+  flushSync: Utils.synchronized(flush),
 
-  _flush: function(asyncHandler) {
-    if (this.pool.length) {
-      if (this.flushInterval) {
-        clearTimeout(this.flushInterval)
-      }
-
-      let listeners
-
-      const cb = method => function() {
-        listeners.forEach(callbacks => {
-          callbacks[method].apply(null, arguments)
-        })
-
-        if (listeners === lastFlushListeners) {
-          lastFlushListeners = null
-        }
-      }
-
-      if (asyncHandler) {
-        listeners = lastFlushListeners = lastFlushListeners ? lastFlushListeners.splice(0) : []
-        listeners.push(asyncHandler)
-      }
-
-      Request.put({
-        isAsync     : !!asyncHandler,
-        asyncHandler: asyncHandler && new Async(cb('success'), cb('fault')),
-        url         : Urls.logging(),
-        data        : this.pool
-      })
-
-      this.pool = []
-
-    } else if (asyncHandler) {
-      if (lastFlushListeners) {
-        lastFlushListeners.push(asyncHandler)
-      } else {
-        setTimeout(asyncHandler.success, 0)
-      }
-    }
-  },
-
-  sendRequest: function() {
-    this.flushInterval = setTimeout(() => this.flush(), this.timeFrequency * 1000)
+  sendRequest() {
+    LoggingCollector.flushInterval = setTimeout(() => LoggingCollector.flush(), LoggingCollector.timeFrequency * 1000)
   },
 
-  setLogReportingPolicy: function(numOfMessages, timeFrequency) {
-    this.numOfMessages = numOfMessages
-    this.timeFrequency = timeFrequency
+  setLogReportingPolicy(numOfMessages, timeFrequency) {
+    LoggingCollector.numOfMessages = numOfMessages
+    LoggingCollector.timeFrequency = timeFrequency
 
     //TODO: check when set new timeFrequency
-    this.checkMessagesLen()
+    LoggingCollector.checkMessagesLen()
   }
 }
 
+LoggingCollector.reset()
+
 export default LoggingCollector

test/e2e/specs/logging.js

@@ -0,0 +1,40 @@
+import '../helpers/global'
+import sandbox from '../helpers/sandbox'
+
+const Backendless = sandbox.Backendless
+
+describe('Backendless.Logging', function() {
+
+  sandbox.forSuite()
+
+  it('has name', function() {
+    return Promise.resolve()
+      .then(() => Backendless.Logging.getLogger('MyLogger'))
+      .then(logger => expect(logger.name).to.be.equal('MyLogger'))
+  })
+
+  it('equals loggers', function() {
+    const logger1 = Backendless.Logging.getLogger('MyLogger')
+    const logger2 = Backendless.Logging.getLogger('MyLogger')
+
+    return expect(logger1).to.be.equal(logger2)
+  })
+
+  it('send messages pool', function() {
+    return Promise.resolve()
+      .then(() => Backendless.Logging.getLogger('MyLogger'))
+      .then(logger => {
+        logger.debug('I\'m debug message')
+        logger.info('I\'m info message')
+        logger.warn('I\'m warn message', new Error('I\'m warn exception').stack)
+        logger.error('I\'m error message', new Error('I\'m error exception').stack)
+        logger.fatal('I\'m fatal message', new Error('I\'m fatal exception').stack)
+        logger.trace('I\'m debug message')
+        logger.debug('I\'m debug message')
+        logger.debug('I\'m debug message')
+
+        return Backendless.Logging.flush()
+      })
+  })
+
+})