Merge pull request #276 from shubham1172/shubham1172/customizable-logging

Use a logging module and make it extensible

Author: XavierGeerinck

package.json

@@ -13,9 +13,10 @@
         "test:e2e:http": "TEST_SECRET_1=secret_val_1 TEST_SECRET_2=secret_val_2 dapr run --app-id test-suite --app-protocol http --app-port 50001 --dapr-http-port 50000 --components-path ./test/components -- jest --runInBand --detectOpenHandles --testMatch [ '**/test/e2e/http/(client|server).test.ts' ]",
         "test:e2e:http:actors": "TEST_SECRET_1=secret_val_1 TEST_SECRET_2=secret_val_2 dapr run --app-id test-suite --app-protocol http --app-port 50001 --dapr-http-port 50000 --components-path ./test/components -- jest --runInBand --detectOpenHandles --testMatch [ '**/test/e2e/http/actors.test.ts' ]",
         "test:unit": "jest --runInBand --detectOpenHandles",
-        "test:unit:all": "npm run test:unit:main && npm run test:unit:actors && npm run test:unit:utils",
+        "test:unit:all": "npm run test:unit:main && npm run test:unit:actors && npm run test:unit:logger && npm run test:unit:utils",
         "test:unit:main": "NODE_ENV=test npm run test:unit 'test/unit/main/.*\\.test\\.ts'",
         "test:unit:actors": "NODE_ENV=test npm run test:unit 'test/unit/actor/.*\\.test\\.ts'",
+        "test:unit:logger": "NODE_ENV=test npm run test:unit 'test/unit/logger/.*\\.test\\.ts'",
         "test:unit:utils": "NODE_ENV=test npm run test:unit 'test/unit/utils/.*\\.test\\.ts'",
         "lint": "eslint . --ext .js,.jsx,.ts,.tsx",
         "build": "./scripts/build.sh",

src/actors/runtime/AbstractActor.ts

@@ -13,6 +13,7 @@ limitations under the License.
 
 import { Temporal } from "@js-temporal/polyfill";
 import DaprClient from "../../implementation/Client/DaprClient";
+import { Logger } from "../../logger/Logger";
 import ActorId from "../ActorId";
 import ActorClient from "../client/ActorClient/ActorClient";
 import ActorStateManager from "./ActorStateManager";
@@ -42,6 +43,7 @@ export default abstract class AbstractActor {
   private readonly actorClient: ActorClient;
   private readonly daprStateProvider: StateProvider;
   private readonly actorType: any; // set at constructor level
+  private readonly logger: Logger;
 
   /**
    * Instantiates a new Actor
@@ -52,7 +54,7 @@ export default abstract class AbstractActor {
   constructor(daprClient: DaprClient, id: ActorId) {
     this.daprClient = daprClient;
     this.actorClient = new ActorClient(daprClient.getDaprHost(), daprClient.getDaprPort(), daprClient.getCommunicationProtocol(), daprClient.getOptions());
-
+    this.logger = new Logger("Actors", "AbstractActor", daprClient.getOptions().logger)
     this.id = id;
 
     this.stateManager = new ActorStateManager(this);
@@ -201,7 +203,7 @@ export default abstract class AbstractActor {
   }
 
   async receiveReminder(_data: string): Promise<void> {
-    console.warn(JSON.stringify({
+    this.logger.warn(JSON.stringify({
       error: "ACTOR_METHOD_NOT_IMPLEMENTED",
       errorMsg: `A reminder was created for the actor with id: ${this.id} but the method 'receiveReminder' was not implemented`,
     }));

src/actors/runtime/ActorManager.ts

@@ -87,7 +87,6 @@ export default class ActorManager<T extends AbstractActor> {
 
   async getActiveActor(actorId: ActorId): Promise<T> {
     if (!this.actors.has(actorId.getId())) {
-      // console.log(`Doesn't have active actor (${actorId.getId()}), activating it`);
       await this.activateActor(actorId);
     }
 

src/implementation/Client/DaprClient.ts

@@ -52,6 +52,7 @@ import HTTPClient from './HTTPClient/HTTPClient';
 import CommunicationProtocolEnum from '../../enum/CommunicationProtocol.enum';
 import { DaprClientOptions } from '../../types/DaprClientOptions';
 import { Settings } from '../../utils/Settings.util';
+import { Logger } from '../../logger/Logger';
 
 export default class DaprClient {
   readonly daprHost: string;
@@ -71,18 +72,21 @@ export default class DaprClient {
   readonly configuration: IClientConfiguration;
   readonly actor: IClientActorBuilder;
 
+  private readonly logger: Logger;
+
   constructor(
     daprHost?: string
     , daprPort?: string
     , communicationProtocol: CommunicationProtocolEnum = CommunicationProtocolEnum.HTTP
     , options: DaprClientOptions = {
-      isKeepAlive: true
-    }
+      isKeepAlive: true,
+    },
   ) {
     this.daprHost = daprHost ?? Settings.getDefaultHost();
     this.daprPort = daprPort ?? Settings.getDefaultPort(communicationProtocol);
     this.communicationProtocol = communicationProtocol;
     this.options = options;
+    this.logger = new Logger("DaprClient", "DaprClient", this.options.logger);
 
     // Validation on port
     if (!/^[0-9]+$/.test(this.daprPort)) {
@@ -142,9 +146,9 @@ export default class DaprClient {
     let isHealthyRetryCount = 0;
     const isHealthyMaxRetryCount = 60; // 1s startup delay and we try max for 60s
 
-    console.log(`[Dapr-JS][Client] Awaiting Sidecar to be Started`);
+    this.logger.info(`Awaiting Sidecar to be Started`);
     while (!isHealthy) {
-      console.log(`[Dapr-JS][Client] Waiting till Dapr Sidecar Started (#${isHealthyRetryCount})`);
+      this.logger.verbose(`Waiting for the Dapr Sidecar to start, retry count: (#${isHealthyRetryCount})`);
       await NodeJSUtils.sleep(Settings.getDaprSidecarPollingDelayMs());
 
       // Implement API call manually as we need to enable calling without initialization
@@ -171,7 +175,7 @@ export default class DaprClient {
     await this.awaitSidecarStarted();
     await this.daprClient.start();
     await this.daprClient.setIsInitialized(true);
-    console.log(`[Dapr-JS][Client] Sidecar Started`);
+    this.logger.info("Sidecar Started");
   }
 
   getDaprClient(): IClient {

src/implementation/Client/GRPCClient/GRPCClient.ts

@@ -17,6 +17,7 @@ import IClient from "../../../interfaces/Client/IClient";
 import CommunicationProtocolEnum from "../../../enum/CommunicationProtocol.enum";
 import { DaprClientOptions } from "../../../types/DaprClientOptions";
 import { Settings } from '../../../utils/Settings.util';
+import { Logger } from "../../../logger/Logger";
 
 export default class GRPCClient implements IClient {
   private isInitialized: boolean;
@@ -26,21 +27,23 @@ export default class GRPCClient implements IClient {
   private readonly clientHost: string;
   private readonly clientPort: string;
   private readonly options: DaprClientOptions;
+  private readonly logger: Logger;
 
   constructor(
     host = Settings.getDefaultHost()
     , port = Settings.getDefaultGrpcPort()
     , options: DaprClientOptions = {
       isKeepAlive: true
-    }
+    },
   ) {
     this.clientHost = host;
     this.clientPort = port;
     this.clientCredentials = grpc.ChannelCredentials.createInsecure();
     this.options = options;
+    this.logger = new Logger("GRPCClient", "GRPCClient", options.logger);
     this.isInitialized = false;
 
-    console.log(`[Dapr-JS][gRPC] Opening connection to ${this.clientHost}:${this.clientPort}`);
+    this.logger.info(`Opening connection to ${this.clientHost}:${this.clientPort}`);
     this.client = new DaprClient(`${this.clientHost}:${this.clientPort}`, this.clientCredentials);
   }
 
@@ -78,7 +81,7 @@ export default class GRPCClient implements IClient {
     return new Promise((resolve, reject) => {
       this.client.waitForReady(deadline, (err?) => {
         if (err) {
-          console.error(err);
+          this.logger.error(`Error waiting for client to be ready: ${err}`);
           return reject();
         }
 

src/implementation/Client/GRPCClient/pubsub.ts

@@ -14,13 +14,17 @@ limitations under the License.
 import GRPCClient from './GRPCClient';
 import { PublishEventRequest } from "../../../proto/dapr/proto/runtime/v1/dapr_pb";
 import IClientPubSub from "../../../interfaces/Client/IClientPubSub";
+import { Logger } from '../../../logger/Logger';
 
 // https://docs.dapr.io/reference/api/pubsub_api/
 export default class GRPCClientPubSub implements IClientPubSub {
   client: GRPCClient;
+  
+  private readonly logger: Logger;
 
   constructor(client: GRPCClient) {
     this.client = client;
+    this.logger = new Logger("GRPCClient", "PubSub", client.getOptions().logger);
   }
 
   // @todo: should return a specific typed Promise<TypePubSubPublishResponse> instead of Promise<any>
@@ -34,7 +38,7 @@ export default class GRPCClientPubSub implements IClientPubSub {
       const client = this.client.getClient();
       client.publishEvent(msgService, (err, _res) => {
         if (err) {
-          console.error(err);
+          this.logger.error(`publish failed: ${err}`);
           return reject(false);
         }
 

src/implementation/Client/HTTPClient/HTTPClient.ts

@@ -19,6 +19,7 @@ import https from "https";
 import { DaprClientOptions } from "../../../types/DaprClientOptions";
 import { Settings } from '../../../utils/Settings.util';
 import { THTTPExecuteParams } from "../../../types/http/THTTPExecuteParams.type"
+import { Logger } from "../../../logger/Logger";
 
 export default class HTTPClient implements IClient {
   private isInitialized: boolean;
@@ -28,6 +29,7 @@ export default class HTTPClient implements IClient {
   private readonly clientPort: string;
   private readonly clientUrl: string;
   private readonly options: DaprClientOptions;
+  private readonly logger: Logger;
 
   private readonly httpAgent;
   private readonly httpsAgent;
@@ -37,11 +39,12 @@ export default class HTTPClient implements IClient {
     , port = Settings.getDefaultHttpPort()
     , options: DaprClientOptions = {
       isKeepAlive: true
-    }
+    },
   ) {
     this.clientHost = host;
     this.clientPort = port;
     this.options = options;
+    this.logger = new Logger("HTTPClient", "HTTPClient", this.options.logger);
     this.isInitialized = false;
 
     if (!this.clientHost.startsWith('http://') && !this.clientHost.startsWith('https://')) {
@@ -138,7 +141,7 @@ export default class HTTPClient implements IClient {
           params.headers["Content-Type"] = "text/plain";
           break;
         default:
-          console.log(`Unknown body type: ${typeof params?.body}, defaulting to "text/plain"`);
+          this.logger.warn(`Unknown body type: ${typeof params?.body}, defaulting to "text/plain"`);
           params.headers["Content-Type"] = "text/plain";
           break;
       }
@@ -153,7 +156,8 @@ export default class HTTPClient implements IClient {
       await this.start();
     }
 
-    // console.log(`${params.method} - ${urlFull} (${params.body})`);
+    this.logger.debug(`Fetching ${params.method} ${urlFull} with body: (${params.body})`);
+
     const res = await fetch(urlFull, params);
 
     // Parse body
@@ -184,7 +188,7 @@ export default class HTTPClient implements IClient {
     }
     // All the others
     else {
-      console.log(txtParsed);
+      this.logger.debug("Execute response text: %s", txtParsed);
       throw new Error(JSON.stringify({
         error: "UNKNOWN",
         error_msg: `An unknown problem occured and we got the status ${res.status} with response ${JSON.stringify(res)}`

src/implementation/Client/HTTPClient/pubsub.ts

@@ -13,13 +13,16 @@ limitations under the License.
 
 import HTTPClient from './HTTPClient';
 import IClientPubSub from '../../../interfaces/Client/IClientPubSub';
+import { Logger } from '../../../logger/Logger';
 
 // https://docs.dapr.io/reference/api/pubsub_api/
 export default class HTTPClientPubSub implements IClientPubSub {
   client: HTTPClient;
+  private readonly logger: Logger;
 
   constructor(client: HTTPClient) {
     this.client = client;
+    this.logger = new Logger("HTTPClient", "PubSub", client.getOptions().logger);
   }
 
   async publish(pubSubName: string, topic: string, data: object = {}): Promise<boolean> {
@@ -31,8 +34,8 @@ export default class HTTPClientPubSub implements IClientPubSub {
         },
         body: JSON.stringify(data),
       });
-    } catch (e) {
-      console.error(e);
+    } catch (e: any) {
+      this.logger.error(`publish failed: ${e}`);
       return false;
     }
 

src/implementation/Server/DaprServer.ts

@@ -32,6 +32,7 @@ import HTTPServerActor from './HTTPServer/actor';
 import { DaprClientOptions } from '../../types/DaprClientOptions';
 import { DaprClient } from '../..';
 import { Settings } from '../../utils/Settings.util';
+import { Logger } from '../../logger/Logger';
 
 export default class DaprServer {
   // App details
@@ -41,6 +42,8 @@ export default class DaprServer {
   private readonly daprHost: string;
   private readonly daprPort: string;
 
+  private readonly logger: Logger;
+
   readonly daprServer: IServer;
   readonly pubsub: IServerPubSub;
   readonly binding: IServerBinding;
@@ -62,6 +65,7 @@ export default class DaprServer {
     this.serverPort = serverPort ?? Settings.getDefaultAppPort(communicationProtocol);
     this.daprHost = daprHost ?? Settings.getDefaultHost();
     this.daprPort = daprPort ?? Settings.getDefaultPort(communicationProtocol);
+    this.logger = new Logger("DaprServer", "DaprServer", clientOptions.logger);
 
     // Create a client to interface with the sidecar from the server side
     this.client = new DaprClient(daprHost, daprPort, communicationProtocol, clientOptions);
@@ -113,7 +117,7 @@ export default class DaprServer {
     await this.client.start();
 
     // We are initialized
-    console.log(`[Dapr-JS][Server] Sidecar Started`);
+    this.logger.info("Sidecar Started");
   }
 
   async stop(): Promise<void> {

src/implementation/Server/GRPCServer/GRPCServer.ts

@@ -16,6 +16,7 @@ import GRPCServerImpl from "./GRPCServerImpl";
 import { AppCallbackService } from "../../../proto/dapr/proto/runtime/v1/appcallback_grpc_pb";
 import IServer from "../../../interfaces/Server/IServer";
 import { DaprClient } from "../../..";
+import { Logger } from "../../../logger/Logger";
 
 // eslint-disable-next-line
 export interface IServerType extends grpc.Server { }
@@ -30,21 +31,23 @@ export default class GRPCServer implements IServer {
   serverImpl: IServerImplType;
   serverCredentials: grpc.ServerCredentials;
   client: DaprClient;
+  private readonly logger: Logger;
 
   constructor(client: DaprClient) {
     this.isInitialized = false;
 
     this.serverHost = "";
     this.serverPort = "";
     this.client = client;
+    this.logger = new Logger("GRPCServer", "GRPCServer", client.options.logger);
 
     // Create Server
     this.server = new grpc.Server();
     this.serverCredentials = grpc.ServerCredentials.createInsecure();
-    this.serverImpl = new GRPCServerImpl();
+    this.serverImpl = new GRPCServerImpl(client.options.logger);
 
     // Add our implementation
-    console.log("[Dapr-JS][gRPC] Adding Service Implementation - AppCallbackService")
+    this.logger.info("Adding Service Implementation - AppCallbackService")
     // @ts-ignore
     this.server.addService(AppCallbackService, this.serverImpl);
   }
@@ -102,14 +105,14 @@ export default class GRPCServer implements IServer {
   }
 
   private async initializeBind(): Promise<void> {
-    console.log(`[Dapr-JS][gRPC] Starting to listen on ${this.serverHost}:${this.serverPort}`);
+    this.logger.info(`Starting to listen on ${this.serverHost}:${this.serverPort}`);
     return new Promise((resolve, reject) => {
       this.server.bindAsync(`${this.serverHost}:${this.serverPort}`, this.serverCredentials, (err, _port) => {
         if (err) {
           return reject(err);
         }
 
-        console.log(`[Dapr-JS][gRPC] Listening on ${this.serverHost}:${this.serverPort}`);
+        this.logger.info(`Listening on ${this.serverHost}:${this.serverPort}`);
         return resolve();
       });
     })