Update logging references in DaprServer

shubham1172 · shubham1172 · commit 7775787ee4da · 2022-06-07T14:13:04.000+05:30
Signed-off-by: Shubham Sharma &lt;shubhash@microsoft.com&gt;
diff --git a/src/implementation/Server/DaprServer.ts b/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(clientOptions.loggerOptions);
 
     // Create a client to interface with the sidecar from the server side
     this.client = new DaprClient(daprHost, daprPort, communicationProtocol, clientOptions);
@@ -82,24 +86,24 @@ export default class DaprServer {
     // Builder
     switch (communicationProtocol) {
       case CommunicationProtocolEnum.GRPC: {
-        const server = new GRPCServer(this.client);
+        const server = new GRPCServer(this.client, this.logger);
         this.daprServer = server;
 
-        this.pubsub = new GRPCServerPubSub(server);
-        this.binding = new GRPCServerBinding(server);
-        this.invoker = new GRPCServerInvoker(server);
+        this.pubsub = new GRPCServerPubSub(server, this.logger);
+        this.binding = new GRPCServerBinding(server, this.logger);
+        this.invoker = new GRPCServerInvoker(server, this.logger);
         this.actor = new GRPCServerActor(server);
         break;
       }
       case CommunicationProtocolEnum.HTTP:
       default: {
-        const server = new HTTPServer(this.client);
+        const server = new HTTPServer(this.client, this.logger);
         this.daprServer = server;
 
-        this.pubsub = new HTTPServerPubSub(server);
-        this.binding = new HTTPServerBinding(server);
-        this.invoker = new HTTPServerInvoker(server);
-        this.actor = new HTTPServerActor(server, this.client);
+        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);
         break;
       }
     }
diff --git a/src/implementation/Server/GRPCServer/GRPCServer.ts b/src/implementation/Server/GRPCServer/GRPCServer.ts
@@ -17,6 +17,7 @@ import { AppCallbackService } from "../../../proto/dapr/proto/runtime/v1/appcall
 import IServer from "../../../interfaces/Server/IServer";
 import { DaprClient } from "../../..";
 import * as NodeJSUtils from "../../../utils/NodeJS.util";
+import { Logger } from "../../../logger/Logger";
 
 // eslint-disable-next-line
 export interface IServerType extends grpc.Server { }
@@ -32,21 +33,26 @@ export default class GRPCServer implements IServer {
   serverCredentials: grpc.ServerCredentials;
   daprSidecarPollingDelayMs = 1000;
   client: DaprClient;
+  private readonly logger: Logger;
 
-  constructor(client: DaprClient) {
+  private readonly LOG_COMPONENT: string = "GRPCServer";
+  private readonly LOG_AREA: string = "GRPCServer";
+
+  constructor(client: DaprClient, logger: Logger) {
     this.isInitialized = false;
 
     this.serverHost = "";
     this.serverPort = "";
     this.client = client;
+    this.logger = logger;
 
     // Create Server
     this.server = new grpc.Server();
     this.serverCredentials = grpc.ServerCredentials.createInsecure();
-    this.serverImpl = new GRPCServerImpl();
+    this.serverImpl = new GRPCServerImpl(this.logger);
 
     // Add our implementation
-    console.log("[Dapr-JS][gRPC] Adding Service Implementation - AppCallbackService")
+    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, "Adding Service Implementation - AppCallbackService")
     // @ts-ignore
     this.server.addService(AppCallbackService, this.serverImpl);
   }
@@ -92,9 +98,9 @@ export default class GRPCServer implements IServer {
     let isHealthyRetryCount = 0;
     const isHealthyMaxRetryCount = 60; // 1s startup delay and we try max for 60s
 
-    console.log(`[Dapr-JS] Letting Dapr pick-up the server (Maximum 60s wait time)`);
+    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, `Letting Dapr pick-up the server (Maximum 60s wait time)`);
     while (!isHealthy) {
-      console.log(`[Dapr-JS] - Waiting till Dapr Started (#${isHealthyRetryCount})`);
+      this.logger.verbose(this.LOG_COMPONENT, this.LOG_AREA, `Waiting for Dapr to start, retry counter is (#${isHealthyRetryCount})`);
       await NodeJSUtils.sleep(this.daprSidecarPollingDelayMs);
       isHealthy = await this.client.health.isHealthy();
       isHealthyRetryCount++;
@@ -123,14 +129,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(this.LOG_COMPONENT, this.LOG_AREA, `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(this.LOG_COMPONENT, this.LOG_AREA, `Listening on ${this.serverHost}:${this.serverPort}`);
         return resolve();
       });
     })
diff --git a/src/implementation/Server/GRPCServer/GRPCServerImpl.ts b/src/implementation/Server/GRPCServer/GRPCServerImpl.ts
@@ -22,16 +22,23 @@ import { TypeDaprInvokerCallback } from "../../../types/DaprInvokerCallback.type
 import * as HttpVerbUtil from "../../../utils/HttpVerb.util";
 import { TypeDaprBindingCallback } from "../../../types/DaprBindingCallback.type";
 import { TypeDaprPubSubCallback } from "../../../types/DaprPubSubCallback.type";
+import { Logger } from "../../../logger/Logger";
 
 
 // https://github.com/badsyntax/grpc-js-typescript/issues/1#issuecomment-705419742
 // @ts-ignore
 export default class GRPCServerImpl implements IAppCallbackServer {
+    private readonly logger: Logger;
+
+    private readonly LOG_COMPONENT: string = "GRPCServer";
+    private readonly LOG_AREA: string = "GRPCServerImpl";
+
     handlersInvoke: { [key: string]: TypeDaprInvokerCallback };
     handlersBindings: { [key: string]: TypeDaprBindingCallback };
     handlersTopics: { [key: string]: TypeDaprPubSubCallback };
 
-    constructor() {
+    constructor(logger: Logger) {
+        this.logger = logger;
         this.handlersInvoke = {};
         this.handlersBindings = {};
         this.handlersTopics = {};
@@ -74,7 +81,7 @@ export default class GRPCServerImpl implements IAppCallbackServer {
         const handlersInvokeKey = `${methodStr.toLowerCase()}|${method.toLowerCase()}`;
 
         if (!this.handlersInvoke[handlersInvokeKey]) {
-            console.warn(`[Dapr-JS][gRPC][Invoke] ${methodStr} /${method} was not handled`);
+            this.logger.warn(this.LOG_COMPONENT, this.LOG_AREA, `${methodStr} /${method} was not handled`)
             return;
         }
 
@@ -112,7 +119,7 @@ export default class GRPCServerImpl implements IAppCallbackServer {
         const handlerKey = this.createInputBindingHandlerKey(req.getName());
         
         if (!this.handlersBindings[handlerKey]) {
-            console.warn(`[Dapr-JS][gRPC][Bindings] Event for binding: "${handlerKey}" was not handled`);
+            this.logger.warn(this.LOG_COMPONENT, this.LOG_AREA, `Event for binding: "${handlerKey}" was not handled`);
             return;
         }
 
@@ -140,7 +147,7 @@ export default class GRPCServerImpl implements IAppCallbackServer {
         const handlerKey = this.createPubSubSubscriptionHandlerKey(req.getPubsubName(), req.getTopic());
         
         if (!this.handlersTopics[handlerKey]) {
-            console.warn(`[Dapr-JS][gRPC][PubSub] Event from topic: "${handlerKey}" was not handled`);
+            this.logger.warn(this.LOG_COMPONENT, this.LOG_AREA, `Event from topic: "${handlerKey}" was not handled`);
             return;
         }
 
@@ -160,7 +167,7 @@ export default class GRPCServerImpl implements IAppCallbackServer {
             res.setStatus(TopicEventResponse.TopicEventResponseStatus.SUCCESS);
         } catch (e) {
             // @todo: for now we drop, maybe we should allow retrying as well more easily?
-            console.error(e);
+            this.logger.error(this.LOG_COMPONENT, this.LOG_AREA, `Error handling topic event: ${e}`);
             res.setStatus(TopicEventResponse.TopicEventResponseStatus.DROP);
         }
 
diff --git a/src/implementation/Server/GRPCServer/binding.ts b/src/implementation/Server/GRPCServer/binding.ts
@@ -14,18 +14,24 @@ limitations under the License.
 import GRPCServer from './GRPCServer';
 import { TypeDaprBindingCallback } from '../../../types/DaprBindingCallback.type';
 import IServerBinding from '../../../interfaces/Server/IServerBinding';
+import { Logger } from '../../../logger/Logger';
 
 // https://docs.dapr.io/reference/api/bindings_api/
 export default class DaprBinding implements IServerBinding {
   server: GRPCServer;
+  private readonly logger: Logger;
 
-  constructor(server: GRPCServer) {
+  private readonly LOG_COMPONENT: string = "GRPCServer";
+  private readonly LOG_AREA: string = "Binding";
+
+  constructor(server: GRPCServer, logger: Logger) {
     this.server = server;
+    this.logger = logger;
   }
 
   // Receive an input from an external system
   async receive(bindingName: string, cb: TypeDaprBindingCallback): Promise<any> {
-    console.log(`Registering GRPC onBindingInput Handler: Binding = ${bindingName}`);
+    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, `Registering GRPC onBindingInput Handler: Binding = ${bindingName}`);
     this.server.getServerImpl().registerInputBindingHandler(bindingName, cb);
   }
 }
diff --git a/src/implementation/Server/GRPCServer/invoker.ts b/src/implementation/Server/GRPCServer/invoker.ts
@@ -16,18 +16,24 @@ import { TypeDaprInvokerCallback } from '../../../types/DaprInvokerCallback.type
 import { InvokerListenOptionsType } from '../../../types/InvokerListenOptions.type';
 import { HttpMethod } from '../../../enum/HttpMethod.enum';
 import IServerInvoker from '../../../interfaces/Server/IServerInvoker';
+import { Logger } from '../../../logger/Logger';
 
 // https://docs.dapr.io/reference/api/service_invocation_api/
 export default class DaprInvoker implements IServerInvoker {
   server: GRPCServer;
+  private readonly logger: Logger;
 
-  constructor(server: GRPCServer) {
+  private readonly LOG_COMPONENT: string = "GRPCServer";
+  private readonly LOG_AREA: string = "Invoker";
+
+  constructor(server: GRPCServer, logger: Logger) {
     this.server = server;
+    this.logger = logger;
   }
 
   async listen(methodName: string, cb: TypeDaprInvokerCallback, options: InvokerListenOptionsType = {}): Promise<any> {
     const httpMethod: HttpMethod = options?.method?.toLowerCase() as HttpMethod || HttpMethod.GET;
-    console.log(`Registering onInvoke Handler ${httpMethod} /${methodName}`);
+    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, `Registering onInvoke Handler ${httpMethod} /${methodName}`)
     this.server.getServerImpl().registerOnInvokeHandler(httpMethod, methodName, cb);
   }
 }
diff --git a/src/implementation/Server/GRPCServer/pubsub.ts b/src/implementation/Server/GRPCServer/pubsub.ts
@@ -14,17 +14,23 @@ limitations under the License.
 import GRPCServer from "./GRPCServer";
 import { TypeDaprPubSubCallback } from "../../../types/DaprPubSubCallback.type";
 import IServerPubSub from "../../../interfaces/Server/IServerPubSub";
+import { Logger } from "../../../logger/Logger";
 
 // https://docs.dapr.io/reference/api/pubsub_api/
 export default class DaprPubSub implements IServerPubSub {
   server: GRPCServer;
+  private readonly logger: Logger;
 
-  constructor(server: GRPCServer) {
+  private readonly LOG_COMPONENT: string = "GRPCServer";
+  private readonly LOG_AREA: string = "PubSub";
+
+  constructor(server: GRPCServer, logger: Logger) {
     this.server = server;
+    this.logger = logger;
   }
 
   async subscribe(pubSubName: string, topic: string, cb: TypeDaprPubSubCallback): Promise<void> {
-    console.log(`Registering onTopicEvent Handler: PubSub = ${pubSubName}; Topic = ${topic}`);
+    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, `Registering onTopicEvent Handler: PubSub = ${pubSubName}; Topic = ${topic}`)
     this.server.getServerImpl().registerPubSubSubscriptionHandler(pubSubName, topic, cb);
   }
 }
diff --git a/src/implementation/Server/HTTPServer/HTTPServer.ts b/src/implementation/Server/HTTPServer/HTTPServer.ts
@@ -18,6 +18,7 @@ import IServer from "../../../interfaces/Server/IServer";
 import * as NodeJSUtils from "../../../utils/NodeJS.util";
 import { DaprClient } from "../../..";
 import { createHttpTerminator } from 'http-terminator';
+import { Logger } from "../../../logger/Logger";
 
 // eslint-disable-next-line
 export interface IServerImplType extends HTTPServerImpl { }
@@ -33,11 +34,16 @@ export default class HTTPServer implements IServer {
   serverImpl: IServerImplType;
   daprSidecarPollingDelayMs = 1000;
   client: DaprClient;
+  private readonly logger: Logger;
 
-  constructor(client: DaprClient) {
+  private readonly LOG_COMPONENT: string = "HTTPServer";
+  private readonly LOG_AREA: string = "HTTPServer";
+
+  constructor(client: DaprClient, logger: Logger) {
     this.serverHost = "";
     this.serverPort = "";
     this.client = client;
+    this.logger = logger;
 
     this.isInitialized = false;
 
@@ -103,14 +109,14 @@ export default class HTTPServer implements IServer {
 
     // Initialize Server Listener
     await this.server.start(parseInt(port, 10));
-    console.log(`[Dapr-JS] Listening on ${port}`);
+    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, `Listening on ${port}`);
     this.serverAddress = `http://${host}:${port}`;
 
     // Add PubSub Routes
-    console.log(`[Dapr API][PubSub] Registering ${this.serverImpl.pubSubSubscriptionRoutes.length} PubSub Subscriptions`);
+    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, `Registering ${this.serverImpl.pubSubSubscriptionRoutes.length} PubSub Subscriptions`);
     this.server.get('/dapr/subscribe', (req, res) => {
       res.send(this.serverImpl.pubSubSubscriptionRoutes);
-      console.log(`[Dapr API][PubSub] Registered ${this.serverImpl.pubSubSubscriptionRoutes.length} PubSub Subscriptions`);
+      this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, `Registered ${this.serverImpl.pubSubSubscriptionRoutes.length} PubSub Subscriptions`);
     });
 
     // We need to call the Singleton to start listening on the port, else Dapr will not pick it up correctly
@@ -120,9 +126,9 @@ export default class HTTPServer implements IServer {
     let isHealthyRetryCount = 0;
     const isHealthyMaxRetryCount = 60; // 1s startup delay and we try max for 60s
 
-    console.log(`[Dapr-JS] Letting Dapr pick-up the server (Maximum 60s wait time)`);
+    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, `Letting Dapr pick-up the server (Maximum 60s wait time)`);
     while (!isHealthy) {
-      console.log(`[Dapr-JS] - Waiting till Dapr Started (#${isHealthyRetryCount})`);
+      this.logger.verbose(this.LOG_COMPONENT, this.LOG_AREA, `Waiting for Dapr to start, retry counter is (#${isHealthyRetryCount})`);
       await NodeJSUtils.sleep(this.daprSidecarPollingDelayMs);
       isHealthy = await this.client.health.isHealthy();
       isHealthyRetryCount++;
@@ -133,7 +139,7 @@ export default class HTTPServer implements IServer {
     }
 
     // We are initialized
-    console.log(`[Dapr-JS] Server Started`);
+    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, "Server Started");
     this.isInitialized = true;
   }
 
diff --git a/src/implementation/Server/HTTPServer/actor.ts b/src/implementation/Server/HTTPServer/actor.ts
@@ -21,16 +21,22 @@ import IResponse from '../../../types/http/IResponse';
 import { GetRegisteredActorsType } from '../../../types/response/GetRegisteredActors.type';
 import BufferSerializer from '../../../actors/runtime/BufferSerializer';
 import { DaprClient } from '../../..';
+import { Logger } from '../../../logger/Logger';
 
 // https://docs.dapr.io/reference/api/bindings_api/
 export default class HTTPServerActor implements IServerActor {
   private readonly server: HTTPServer;
   private readonly client: DaprClient;
   private readonly serializer: BufferSerializer;
+  private readonly logger: Logger;
 
-  constructor(server: HTTPServer, client: DaprClient) {
+  private readonly LOG_COMPONENT: string = "HTTPServer";
+  private readonly LOG_AREA: string = "Actors";
+
+  constructor(server: HTTPServer, client: DaprClient, logger: Logger) {
     this.client = client;
     this.server = server;
+    this.logger = logger;
     this.serializer = new BufferSerializer();
   }
 
@@ -52,7 +58,7 @@ export default class HTTPServerActor implements IServerActor {
    * This will create the routes that get invoked by the Dapr Sidecar
    */
   async init(): Promise<void> {
-    console.log("[Actors] Initializing");
+    this.logger.info(this.LOG_COMPONENT, this.LOG_AREA, "Initializing Actors");
 
     // Probes the application for a response to state that the app is healthy and running
     // https://docs.dapr.io/reference/api/actors_api/#health-check
diff --git a/src/implementation/Server/HTTPServer/binding.ts b/src/implementation/Server/HTTPServer/binding.ts
@@ -14,15 +14,21 @@ limitations under the License.
 import HTTPServer from './HTTPServer';
 import HttpStatusCode from '../../../enum/HttpStatusCode.enum';
 import IServerBinding from '../../../interfaces/Server/IServerBinding';
+import { Logger } from '../../../logger/Logger';
 
 // https://docs.dapr.io/reference/api/bindings_api/
 type FunctionDaprInputCallback = (data: any) => Promise<any>;
 
 export default class HTTPServerBinding implements IServerBinding {
   private readonly server: HTTPServer;
+  private readonly logger: Logger;
 
-  constructor(server: HTTPServer) {
+  private readonly LOG_COMPONENT: string = "HTTPServer";
+  private readonly LOG_AREA: string = "Binding";
+
+  constructor(server: HTTPServer, logger: Logger) {
     this.server = server;
+    this.logger = logger;
   }
 
   // Receive an input from an external system
@@ -47,7 +53,7 @@ export default class HTTPServerBinding implements IServerBinding {
       } catch (e) {
         res.statusCode = HttpStatusCode.INTERNAL_SERVER_ERROR;
 
-        console.debug(e);
+        this.logger.error(this.LOG_COMPONENT, this.LOG_AREA, `receive failed: ${e}`);
 
         return res.end(JSON.stringify({
           error: "COULD_NOT_PROCESS_CALLBACK",
diff --git a/src/implementation/Server/HTTPServer/invoker.ts b/src/implementation/Server/HTTPServer/invoker.ts
diff --git a/src/implementation/Server/HTTPServer/pubsub.ts b/src/implementation/Server/HTTPServer/pubsub.ts
