Refactor the logger module

Signed-off-by: Shubham Sharma <[email protected]>

Author: shubham1172

src/actors/client/ActorClient/ActorClient.ts

@@ -35,18 +35,16 @@ export default class ActorClient {
     this.communicationProtocol = communicationProtocol;
     this.options = options;
 
-    const logger = new Logger(this.options.logger);
-
     // Builder
     switch (communicationProtocol) {
       case CommunicationProtocolEnum.GRPC: {
-        const client = new GRPCClient(this.daprHost, this.daprPort, this.options, logger);
+        const client = new GRPCClient(this.daprHost, this.daprPort, this.options);
         this.actor = new ActorClientGRPC(client);
         break;
       }
       case CommunicationProtocolEnum.HTTP:
       default: {
-        const client = new HTTPClient(this.daprHost, this.daprPort, this.options, logger);
+        const client = new HTTPClient(this.daprHost, this.daprPort, this.options);
         this.actor = new ActorClientHTTP(client);
         break;
       }

src/actors/runtime/AbstractActor.ts

@@ -45,9 +45,6 @@ export default abstract class AbstractActor {
   private readonly actorType: any; // set at constructor level
   private readonly logger: Logger;
 
-  private readonly LOG_COMPONENT: string = "Actors";
-  private readonly LOG_AREA: string = "AbstractActor";
-
   /**
    * Instantiates a new Actor
    * 
@@ -57,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(daprClient.getOptions().logger)
+    this.logger = new Logger("Actors", "AbstractActor", daprClient.getOptions().logger)
     this.id = id;
 
     this.stateManager = new ActorStateManager(this);
@@ -206,7 +203,7 @@ export default abstract class AbstractActor {
   }
 
   async receiveReminder(_data: string): Promise<void> {
-    this.logger.warn(this.LOG_COMPONENT, this.LOG_AREA, 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/implementation/Client/DaprClient.ts

@@ -53,13 +53,13 @@ import CommunicationProtocolEnum from '../../enum/CommunicationProtocol.enum';
 import { DaprClientOptions } from '../../types/DaprClientOptions';
 import { Settings } from '../../utils/Settings.util';
 import { Logger } from '../../logger/Logger';
+import { LoggerOptions } from "../../types/logger/LoggerOptions";
 
 export default class DaprClient {
   readonly daprHost: string;
   readonly daprPort: string;
   readonly options: DaprClientOptions;
   readonly communicationProtocol: CommunicationProtocolEnum;
-  readonly logger: Logger;
 
   readonly daprClient: IClient;
   readonly pubsub: IClientPubSub;
@@ -73,8 +73,7 @@ export default class DaprClient {
   readonly configuration: IClientConfiguration;
   readonly actor: IClientActorBuilder;
 
-  private readonly LOG_COMPONENT: string = "DaprClient";
-  private readonly LOG_AREA: string = "DaprClient";
+  private readonly logger: Logger;
 
   constructor(
     daprHost?: string
@@ -88,7 +87,7 @@ export default class DaprClient {
     this.daprPort = daprPort ?? Settings.getDefaultPort(communicationProtocol);
     this.communicationProtocol = communicationProtocol;
     this.options = options;
-    this.logger = new Logger(this.options.logger);
+    this.logger = new Logger("DaprClient", "DaprClient", this.options.logger);
 
     // Validation on port
     if (!/^[0-9]+$/.test(this.daprPort)) {
@@ -98,11 +97,11 @@ export default class DaprClient {
     // Builder
     switch (communicationProtocol) {
       case CommunicationProtocolEnum.GRPC: {
-        const client = new GRPCClient(this.daprHost, this.daprPort, this.options, this.logger);
+        const client = new GRPCClient(this.daprHost, this.daprPort, this.options);
         this.daprClient = client;
 
         this.state = new GRPCClientState(client);
-        this.pubsub = new GRPCClientPubSub(client, this.logger);
+        this.pubsub = new GRPCClientPubSub(client);
         this.binding = new GRPCClientBinding(client);
         this.invoker = new GRPCClientInvoker(client);
         this.secret = new GRPCClientSecret(client);
@@ -115,11 +114,11 @@ export default class DaprClient {
       }
       case CommunicationProtocolEnum.HTTP:
       default: {
-        const client = new HTTPClient(this.daprHost, this.daprPort, this.options, this.logger);
+        const client = new HTTPClient(this.daprHost, this.daprPort, this.options);
         this.daprClient = client;
 
         this.state = new HTTPClientState(client);
-        this.pubsub = new HTTPClientPubSub(client, this.logger);
+        this.pubsub = new HTTPClientPubSub(client);
         this.binding = new HTTPClientBinding(client);
         this.invoker = new HTTPClientInvoker(client);
         this.secret = new HTTPClientSecret(client);
@@ -148,9 +147,9 @@ export default class DaprClient {
     let isHealthyRetryCount = 0;
     const isHealthyMaxRetryCount = 60; // 1s startup delay and we try max for 60s
 
-    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, `Awaiting Sidecar to be Started`);
+    this.logger.info(`Awaiting Sidecar to be Started`);
     while (!isHealthy) {
-      this.logger.verbose(this.LOG_COMPONENT, this.LOG_AREA,`Waiting for the Dapr Sidecar to start, retry count: (#${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
@@ -177,7 +176,7 @@ export default class DaprClient {
     await this.awaitSidecarStarted();
     await this.daprClient.start();
     await this.daprClient.setIsInitialized(true);
-    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, "Sidecar Started");
+    this.logger.info("Sidecar Started");
   }
 
   getDaprClient(): IClient {

src/implementation/Client/GRPCClient/GRPCClient.ts

@@ -29,25 +29,21 @@ export default class GRPCClient implements IClient {
   private readonly options: DaprClientOptions;
   private readonly logger: Logger;
 
-  private readonly LOG_COMPONENT: string = "GRPCClient";
-  private readonly LOG_AREA: string = "GRPCClient";
-
   constructor(
     host = Settings.getDefaultHost()
     , port = Settings.getDefaultGrpcPort()
     , options: DaprClientOptions = {
       isKeepAlive: true
     },
-    logger: Logger,
   ) {
     this.clientHost = host;
     this.clientPort = port;
     this.clientCredentials = grpc.ChannelCredentials.createInsecure();
     this.options = options;
-    this.logger = logger;
+    this.logger = new Logger("GRPCClient", "GRPCClient", options.logger);
     this.isInitialized = false;
 
-    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA,`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);
   }
 
@@ -85,7 +81,7 @@ export default class GRPCClient implements IClient {
     return new Promise((resolve, reject) => {
       this.client.waitForReady(deadline, (err?) => {
         if (err) {
-          this.logger.error(this.LOG_COMPONENT, this.LOG_AREA, `Error waiting for client to be ready: ${err}`);
+          this.logger.error(`Error waiting for client to be ready: ${err}`);
           return reject();
         }
 

src/implementation/Client/GRPCClient/pubsub.ts

@@ -21,12 +21,10 @@ export default class GRPCClientPubSub implements IClientPubSub {
   client: GRPCClient;
 
   private readonly logger: Logger;
-  private readonly LOG_COMPONENT: string = "GRPCClient";
-  private readonly LOG_AREA: string = "PubSub";
 
-  constructor(client: GRPCClient, logger: Logger) {
+  constructor(client: GRPCClient) {
     this.client = client;
-    this.logger = logger;
+    this.logger = new Logger("GRPCClient", "PubSub", client.getOptions().logger);
   }
 
   // @todo: should return a specific typed Promise<TypePubSubPublishResponse> instead of Promise<any>
@@ -40,7 +38,7 @@ export default class GRPCClientPubSub implements IClientPubSub {
       const client = this.client.getClient();
       client.publishEvent(msgService, (err, _res) => {
         if (err) {
-          this.logger.error(this.LOG_COMPONENT, this.LOG_AREA, `publish failed: ${err}`);
+          this.logger.error(`publish failed: ${err}`);
           return reject(false);
         }
 

src/implementation/Client/HTTPClient/HTTPClient.ts

@@ -34,21 +34,17 @@ export default class HTTPClient implements IClient {
   private readonly httpAgent;
   private readonly httpsAgent;
 
-  private readonly LOG_COMPONENT: string = "HTTPClient";
-  private readonly LOG_AREA: string = "HTTPClient";
-
   constructor(
     host = Settings.getDefaultHost()
     , port = Settings.getDefaultHttpPort()
     , options: DaprClientOptions = {
       isKeepAlive: true
     },
-    logger: Logger,
   ) {
     this.clientHost = host;
     this.clientPort = port;
     this.options = options;
-    this.logger = logger;
+    this.logger = new Logger("HTTPClient", "HTTPClient", this.options.logger);
     this.isInitialized = false;
 
     if (!this.clientHost.startsWith('http://') && !this.clientHost.startsWith('https://')) {
@@ -145,7 +141,7 @@ export default class HTTPClient implements IClient {
           params.headers["Content-Type"] = "text/plain";
           break;
         default:
-          this.logger.warn(this.LOG_COMPONENT, this.LOG_AREA, `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;
       }
@@ -160,7 +156,7 @@ export default class HTTPClient implements IClient {
       await this.start();
     }
 
-    this.logger.debug(this.LOG_COMPONENT, this.LOG_AREA, `Fetching ${params.method} ${urlFull} with body: (${params.body})`);
+    this.logger.debug(`Fetching ${params.method} ${urlFull} with body: (${params.body})`);
 
     const res = await fetch(urlFull, params);
 
@@ -192,7 +188,7 @@ export default class HTTPClient implements IClient {
     }
     // All the others
     else {
-      this.logger.debug(this.LOG_COMPONENT, this.LOG_AREA, "Response text: %s", 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

@@ -19,12 +19,10 @@ import { Logger } from '../../../logger/Logger';
 export default class HTTPClientPubSub implements IClientPubSub {
   client: HTTPClient;
   private readonly logger: Logger;
-  private readonly LOG_COMPONENT: string = "HTTPClient";
-  private readonly LOG_AREA: string = "PubSub";
 
-  constructor(client: HTTPClient, logger: Logger) {
+  constructor(client: HTTPClient) {
     this.client = client;
-    this.logger = logger;
+    this.logger = new Logger("HTTPClient", "PubSub", client.getOptions().logger);
   }
 
   async publish(pubSubName: string, topic: string, data: object = {}): Promise<boolean> {
@@ -37,7 +35,7 @@ export default class HTTPClientPubSub implements IClientPubSub {
         body: JSON.stringify(data),
       });
     } catch (e: any) {
-      this.logger.error(this.LOG_COMPONENT, this.LOG_AREA, `publish failed: ${e}`);
+      this.logger.error(`publish failed: ${e}`);
       return false;
     }
 

src/implementation/Server/DaprServer.ts

@@ -51,9 +51,6 @@ export default class DaprServer {
   readonly actor: IServerActor;
   readonly client: DaprClient;
 
-  private readonly LOG_COMPONENT: string = "DaprServer";
-  private readonly LOG_AREA: string = "DaprServer";
-
   constructor(
     serverHost?: string
     , serverPort?: string
@@ -68,7 +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(clientOptions.logger);
+    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);
@@ -89,24 +86,24 @@ export default class DaprServer {
     // Builder
     switch (communicationProtocol) {
       case CommunicationProtocolEnum.GRPC: {
-        const server = new GRPCServer(this.client, this.logger);
+        const server = new GRPCServer(this.client);
         this.daprServer = server;
 
-        this.pubsub = new GRPCServerPubSub(server, this.logger);
-        this.binding = new GRPCServerBinding(server, this.logger);
-        this.invoker = new GRPCServerInvoker(server, this.logger);
+        this.pubsub = new GRPCServerPubSub(server);
+        this.binding = new GRPCServerBinding(server);
+        this.invoker = new GRPCServerInvoker(server);
         this.actor = new GRPCServerActor(server);
         break;
       }
       case CommunicationProtocolEnum.HTTP:
       default: {
-        const server = new HTTPServer(this.client, this.logger);
+        const server = new HTTPServer(this.client);
         this.daprServer = server;
 
-        this.pubsub = new HTTPServerPubSub(server, this.logger);
-        this.binding = new HTTPServerBinding(server, this.logger);
-        this.invoker = new HTTPServerInvoker(server, this.logger);
-        this.actor = new HTTPServerActor(server, this.client, this.logger);
+        this.pubsub = new HTTPServerPubSub(server);
+        this.binding = new HTTPServerBinding(server);
+        this.invoker = new HTTPServerInvoker(server);
+        this.actor = new HTTPServerActor(server, this.client);
         break;
       }
     }
@@ -120,7 +117,7 @@ export default class DaprServer {
     await this.client.start();
 
     // We are initialized
-    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, "Sidecar Started");
+    this.logger.info("Sidecar Started");
   }
 
   async stop(): Promise<void> {

src/implementation/Server/GRPCServer/GRPCServer.ts

@@ -33,24 +33,21 @@ export default class GRPCServer implements IServer {
   client: DaprClient;
   private readonly logger: Logger;
 
-  private readonly LOG_COMPONENT: string = "GRPCServer";
-  private readonly LOG_AREA: string = "GRPCServer";
-
-  constructor(client: DaprClient, logger: Logger) {
+  constructor(client: DaprClient) {
     this.isInitialized = false;
 
     this.serverHost = "";
     this.serverPort = "";
     this.client = client;
-    this.logger = logger;
+    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.logger);
+    this.serverImpl = new GRPCServerImpl(client.options.logger);
 
     // Add our implementation
-    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, "Adding Service Implementation - AppCallbackService")
+    this.logger.info("Adding Service Implementation - AppCallbackService")
     // @ts-ignore
     this.server.addService(AppCallbackService, this.serverImpl);
   }
@@ -108,14 +105,14 @@ export default class GRPCServer implements IServer {
   }
 
   private async initializeBind(): Promise<void> {
-    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, `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);
         }
 
-        this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, `Listening on ${this.serverHost}:${this.serverPort}`);
+        this.logger.info(`Listening on ${this.serverHost}:${this.serverPort}`);
         return resolve();
       });
     })