docs: add jsdoc to consolelogger

Author: eldreygalindo

packages/opencensus-core/src/common/console-logger.ts

@@ -19,57 +19,88 @@ import {Logger, LoggerOptions} from './types';
 const logDriver = require('log-driver');
 
 
- class ConsoleLogger implements Logger {
-
+/**
+ * This class represente a console-logger
+ */
+class ConsoleLogger implements Logger {
   // tslint:disable:no-any
-  private logger:any; 
+  private logger: any;
   static LEVELS = ['error', 'warn', 'info', 'debug', 'silly'];
 
+  /**
+   * Constructs a new ConsoleLogger instance
+   * @param options A logger configuration object.
+   */
   constructor(options?: LoggerOptions|string) {
     let opt: LoggerOptions = {};
-    if (typeof options === "string") {
-      opt = {
-        level: options
-      };
+    if (typeof options === 'string') {
+      opt = {level: options};
     } else {
       opt = options || {};
     }
 
-    this.logger = logDriver({
-      levels:  ConsoleLogger.LEVELS,
-      level: opt.level || 'error'
-    });
+    this.logger =
+        logDriver({levels: ConsoleLogger.LEVELS, level: opt.level || 'error'});
   }
 
+  /**
+   * Logger error function.
+   * @param message menssage erro to log in console
+   * @param args arguments to log in console
+   */
   // tslint:disable:no-any
   error(message: any, ...args: any[]): void {
     this.logger.error(arguments);
   }
 
+  /**
+   * Logger warning function.
+   * @param message menssage warning to log in console
+   * @param args arguments to log in console
+   */
   // tslint:disable:no-any
   warn(message: any, ...args: any[]): void {
     this.logger.warn(arguments);
   }
 
+  /**
+   * Logger info function.
+   * @param message menssage info to log in console
+   * @param args arguments to log in console
+   */
   // tslint:disable:no-any
   info(message: any, ...args: any[]): void {
     this.logger.info(arguments);
   }
 
+  /**
+   * Logger debug function.
+   * @param message menssage debug to log in console
+   * @param args arguments to log in console
+   */
   // tslint:disable:no-any
-  debug (message: any, ...args: any[]): void {
+  debug(message: any, ...args: any[]): void {
     this.logger.debug(arguments);
   }
 
+  /**
+   * Logger silly function.
+   * @param message menssage silly to log in console
+   * @param args arguments to log in console
+   */
   // tslint:disable:no-any
-  silly (message: any, ...args: any[]): void {
+  silly(message: any, ...args: any[]): void {
     this.logger.silly(arguments);
   }
 }
 
 let defaultLogger = null;
 
-const logger  = (options?: LoggerOptions|string) => {
+/**
+ *  Function logger exported to others classes.
+ * @param options A logger options or strig to logger in console
+ */
+const logger = (options?: LoggerOptions|string) => {
   defaultLogger = new ConsoleLogger(options);
   logger['logger'] = defaultLogger;
   return defaultLogger;

packages/opencensus-core/src/common/types.ts

@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 
- // tslint:disable:no-any
+// tslint:disable:no-any
 export type LogFunction = (message: any, ...args: any[]) => void;
 
+/** Defines an logger interface. */
 export interface Logger {
   error: LogFunction;
   warn: LogFunction;
@@ -25,8 +26,8 @@ export interface Logger {
   silly: LogFunction;
 }
 
+/** Defines an logger options interface. */
 export interface LoggerOptions {
   level?: string;
   tag?: string;
 }
-

packages/opencensus-core/test/test-console-logger.ts

@@ -22,153 +22,152 @@ const LEVELS = ['error', 'warn', 'info', 'debug', 'silly'];
 let consoleTxt = '';
 
 
-
-
 describe('ConsoleLogger', () => {
   const intercept = require('intercept-stdout');
   const unhookIntercept = intercept((txt) => {
     consoleTxt = txt;
     return txt;
   });
+
+/** Should create a new ConsoleLogger */
   describe('new ConsoleLogger()', () => {
-    it('should levels from consoleLogger equals default levels', () => {
+    it('should consoleLogger with default levels', () => {
       const consoleLogger = logger();
       assert.equal(LEVELS.length, consoleLogger.logger.levels.length);
     });
 
-    it('should level from consoleLogger equal error', () => {
+    it('should consoleLogger with error', () => {
       const consoleLogger = logger(LEVELS[0]);
       assert.strictEqual(LEVELS[0], consoleLogger.logger.level);
     });
   });
 
-  /**
-   * 
-   */
+  /** Should logger only error log */
   describe('error logger', () => {
     const consoleLogger = logger(LEVELS[0]);
 
-    it('should logger error in console', () => {
+    it('should logger error', () => {
       consoleTxt = '';
-      consoleLogger.error('error test logger in console');
+      consoleLogger.error('error test logger');
       unhookIntercept();
       const validateString = consoleTxt.indexOf('error');
 
       assert.ok(validateString >= 0);
     });
 
-    it('should not logger warn in console', () => {
+    it('should not logger warn', () => {
       consoleTxt = '';
-      consoleLogger.warn('warn test logger in console');
+      consoleLogger.warn('warn test logger');
       unhookIntercept();
 
       const validateString = consoleTxt.indexOf('warn');
 
       assert.equal(validateString, -1);
     });
 
-    it('should not logger info in console', () => {
+    it('should not logger info', () => {
       consoleTxt = '';
-      consoleLogger.info('info test logger in console');
+      consoleLogger.info('info test logger');
       unhookIntercept();
 
       const validateString = consoleTxt.indexOf('info');
 
       assert.equal(validateString, -1);
     });
 
-    it('should not logger debug in console', () => {
+    it('should not logger debug', () => {
       consoleTxt = '';
-      consoleLogger.debug('debug test logger in console');
+      consoleLogger.debug('debug test logger');
       unhookIntercept();
       const validateString = consoleTxt.indexOf('debug');
 
       assert.equal(validateString, -1);
     });
 
-    it('should not logger silly in console', () => {
+    it('should not logger silly', () => {
       consoleTxt = '';
-      consoleLogger.silly('silly test logger in console');
+      consoleLogger.silly('silly test logger');
       unhookIntercept();
       const validateString = consoleTxt.indexOf('silly');
 
       assert.equal(validateString, -1);
     });
   });
-
+  
+  /** Should logger error, warn and info log */
    describe('info logger', () => {
 
     const consoleLogger = logger(LEVELS[2]);
 
-    it('should logger error in console', () => {
+    it('should logger error', () => {
       const intercept = require('intercept-stdout');
       const unhookIntercept = intercept((txt) => {
         consoleTxt = txt;
         return txt;
       });
 
       consoleTxt = '';
-      consoleLogger.error('error test logger in console');
+      consoleLogger.error('error test logger');
       unhookIntercept();
       const validateString = consoleTxt.indexOf('error');
 
       assert.ok(validateString >= 0);
     });
 
-    it('should not logger warn in console', () => {
+    it('should not logger warn', () => {
       const intercept = require('intercept-stdout');
       const unhookIntercept = intercept((txt) => {
         consoleTxt = txt;
         return txt;
       });
 
       consoleTxt = '';
-      consoleLogger.warn('warn test logger in console');
+      consoleLogger.warn('warn test logger');
       unhookIntercept();
       const validateString = consoleTxt.indexOf('warn');
 
       assert.ok(validateString >= 0);
     });
 
-    it('should logger info in console', () => {
+    it('should logger info', () => {
       const intercept = require('intercept-stdout');
       const unhookIntercept = intercept((txt) => {
         consoleTxt = txt;
         return txt;
       });
 
       consoleTxt = '';
-      consoleLogger.info('info test logger in console');
+      consoleLogger.info('info test logger');
       unhookIntercept();
       const validateString = consoleTxt.indexOf('info');
 
       assert.ok(validateString >= 0);
     });
 
-    it('should not logger debug in console', () => {
+    it('should not logger debug', () => {
       const intercept = require('intercept-stdout');
       const unhookIntercept = intercept((txt) => {
         consoleTxt = txt;
         return txt;
       });
 
       consoleTxt = '';
-      consoleLogger.debug('debug test logger in console');
+      consoleLogger.debug('debug test logger');
       unhookIntercept();
       const validateString = consoleTxt.indexOf('debug');
 
       assert.equal(validateString, -1);
     });
 
-    it('should not logger silly in console', () => {
+    it('should not logger silly', () => {
       const intercept = require('intercept-stdout');
       const unhookIntercept = intercept((txt) => {
         consoleTxt = txt;
         return txt;
       });
 
       consoleTxt = '';
-      consoleLogger.silly('silly test logger in console');
+      consoleLogger.silly('silly test logger');
       unhookIntercept();
       const validateString = consoleTxt.indexOf('silly');