feat(sdk): add console logger (open-telemetry#203)

* feat: add console logger

* fix: review comments

Author: mayurkale22

packages/opentelemetry-basic-tracer/src/BasicTracer.ts

@@ -23,7 +23,7 @@ import {
   isValid,
   randomSpanId,
   NoRecordingSpan,
-  NoopLogger,
+  ConsoleLogger,
 } from '@opentelemetry/core';
 import {
   BinaryFormat,
@@ -55,7 +55,7 @@ export class BasicTracer implements types.Tracer {
     this._httpTextFormat = config.httpTextFormat || new HttpTraceContext();
     this._sampler = config.sampler || ALWAYS_SAMPLER;
     this._scopeManager = config.scopeManager;
-    this._logger = config.logger || new NoopLogger();
+    this._logger = config.logger || new ConsoleLogger(config.logLevel);
   }
 
   /**

packages/opentelemetry-basic-tracer/src/types.ts

@@ -22,6 +22,7 @@ import {
   Logger,
   Sampler,
 } from '@opentelemetry/types';
+import { LogLevel } from '@opentelemetry/core';
 
 /**
  * BasicTracerConfig provides an interface for configuring a Basic Tracer.
@@ -48,6 +49,9 @@ export interface BasicTracerConfig {
    */
   logger?: Logger;
 
+  /** level of logger.  */
+  logLevel?: LogLevel;
+
   /**
    * Sampler determines if a span should be recorded or should be a NoopSpan.
    */

packages/opentelemetry-core/src/common/ConsoleLogger.ts

@@ -0,0 +1,51 @@
+/**
+ * Copyright 2019, OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Logger } from '@opentelemetry/types';
+import { LogLevel } from './types';
+
+export class ConsoleLogger implements Logger {
+  constructor(level: LogLevel = LogLevel.DEBUG) {
+    if (level >= LogLevel.DEBUG) {
+      this.debug = (...args) => {
+        console.debug(...args);
+      };
+    }
+    if (level >= LogLevel.INFO) {
+      this.info = (...args) => {
+        console.info(...args);
+      };
+    }
+    if (level >= LogLevel.WARN) {
+      this.warn = (...args) => {
+        console.warn(...args);
+      };
+    }
+    if (level >= LogLevel.ERROR) {
+      this.error = (...args) => {
+        console.error(...args);
+      };
+    }
+  }
+
+  debug(message: string, ...args: unknown[]) {}
+
+  error(message: string, ...args: unknown[]) {}
+
+  warn(message: string, ...args: unknown[]) {}
+
+  info(message: string, ...args: unknown[]) {}
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2019, OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** Defines a log levels. */
+export enum LogLevel {
+  ERROR,
+  WARN,
+  INFO,
+  DEBUG,
+}

packages/opentelemetry-core/src/index.ts

@@ -14,7 +14,9 @@
  * limitations under the License.
  */
 
+export * from './common/ConsoleLogger';
 export * from './common/NoopLogger';
+export * from './common/types';
 export * from './context/propagation/BinaryTraceContext';
 export * from './context/propagation/HttpTraceContext';
 export * from './platform';

packages/opentelemetry-core/test/common/ConsoleLogger.test.ts

@@ -0,0 +1,120 @@
+/**
+ * Copyright 2019, OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as assert from 'assert';
+import { ConsoleLogger } from '../../src/common/ConsoleLogger';
+import { LogLevel } from '../../src/common/types';
+
+describe('ConsoleLogger', () => {
+  const origDebug = console.debug;
+  const origInfo = console.info;
+  const origWarn = console.warn;
+  const origError = console.error;
+  let debugCalledArgs: unknown;
+  let infoCalledArgs: unknown;
+  let warnCalledArgs: unknown;
+  let errorCalledArgs: unknown;
+
+  beforeEach(() => {
+    // mock
+    console.debug = (...args: unknown[]) => {
+      debugCalledArgs = args;
+    };
+    console.info = (...args: unknown[]) => {
+      infoCalledArgs = args;
+    };
+    console.warn = (...args: unknown[]) => {
+      warnCalledArgs = args;
+    };
+    console.error = (...args: unknown[]) => {
+      errorCalledArgs = args;
+    };
+  });
+
+  afterEach(() => {
+    // restore
+    debugCalledArgs = null;
+    infoCalledArgs = null;
+    warnCalledArgs = null;
+    errorCalledArgs = null;
+    console.debug = origDebug;
+    console.info = origInfo;
+    console.warn = origWarn;
+    console.error = origError;
+  });
+
+  describe('constructor', () => {
+    it('should log with default level', () => {
+      const consoleLogger = new ConsoleLogger();
+      consoleLogger.error('error called %s', 'param1');
+      assert.deepStrictEqual(errorCalledArgs, ['error called %s', 'param1']);
+      consoleLogger.warn('warn called %s', 'param1');
+      assert.deepStrictEqual(warnCalledArgs, ['warn called %s', 'param1']);
+      consoleLogger.info('info called %s', 'param1');
+      assert.deepStrictEqual(infoCalledArgs, ['info called %s', 'param1']);
+      consoleLogger.debug('debug called %s', 'param1');
+      assert.deepStrictEqual(debugCalledArgs, ['debug called %s', 'param1']);
+    });
+
+    it('should log with debug', () => {
+      const consoleLogger = new ConsoleLogger(LogLevel.DEBUG);
+      consoleLogger.error('error called');
+      assert.deepStrictEqual(errorCalledArgs, ['error called']);
+      consoleLogger.warn('warn called %s', 'param1');
+      assert.deepStrictEqual(warnCalledArgs, ['warn called %s', 'param1']);
+      consoleLogger.info('info called %s', 'param1');
+      assert.deepStrictEqual(infoCalledArgs, ['info called %s', 'param1']);
+      consoleLogger.debug('debug called %s', 'param1');
+      assert.deepStrictEqual(debugCalledArgs, ['debug called %s', 'param1']);
+    });
+
+    it('should log with info', () => {
+      const consoleLogger = new ConsoleLogger(LogLevel.INFO);
+      consoleLogger.error('error called %s', 'param1');
+      assert.deepStrictEqual(errorCalledArgs, ['error called %s', 'param1']);
+      consoleLogger.warn('warn called %s', 'param1');
+      assert.deepStrictEqual(warnCalledArgs, ['warn called %s', 'param1']);
+      consoleLogger.info('info called %s', 'param1');
+      assert.deepStrictEqual(infoCalledArgs, ['info called %s', 'param1']);
+      consoleLogger.debug('debug called %s', 'param1');
+      assert.strictEqual(debugCalledArgs, null);
+    });
+
+    it('should log with warn', () => {
+      const consoleLogger = new ConsoleLogger(LogLevel.WARN);
+      consoleLogger.error('error called %s', 'param1');
+      assert.deepStrictEqual(errorCalledArgs, ['error called %s', 'param1']);
+      consoleLogger.warn('warn called %s', 'param1');
+      assert.deepStrictEqual(warnCalledArgs, ['warn called %s', 'param1']);
+      consoleLogger.info('info called %s', 'param1');
+      assert.strictEqual(infoCalledArgs, null);
+      consoleLogger.debug('debug called %s', 'param1');
+      assert.strictEqual(debugCalledArgs, null);
+    });
+
+    it('should log with error', () => {
+      const consoleLogger = new ConsoleLogger(LogLevel.ERROR);
+      consoleLogger.error('error called %s', 'param1');
+      assert.deepStrictEqual(errorCalledArgs, ['error called %s', 'param1']);
+      consoleLogger.warn('warn called %s', 'param1');
+      assert.strictEqual(warnCalledArgs, null);
+      consoleLogger.info('info called %s', 'param1');
+      assert.strictEqual(infoCalledArgs, null);
+      consoleLogger.debug('debug called %s', 'param1');
+      assert.strictEqual(debugCalledArgs, null);
+    });
+  });
+});