Add documentation for logger usage and make keepAlive optional (#289)

* WIP add logs

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

* Make keepAlive optional

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

* Update docs

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

* Fix links

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

* Rephrase

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

Author: shubham1172

daprdocs/content/en/js-sdk-docs/js-logger/_index.md

@@ -0,0 +1,105 @@
+---
+type: docs
+title: "Logging in JavaScript SDK"
+linkTitle: "Logging"
+weight: 500
+description: Configuring logging in JavaScript SDK
+---
+
+## Introduction
+
+The JavaScript SDK comes with a out-of-box `Console` based logger. The SDK emits various internal logs to help users understand the chain of events and troubleshoot problems. A consumer of this SDK can customize the verbosity of the log, as well as provide their own implementation for the logger.
+
+## Configure log level
+
+There are five levels of logging in **descending order of importance** - `error`, `warn`, `info`, `verbose`, and `debug`. Setting the log to a level means that the logger will emit all the logs that are at least as important as the mentioned level. For example, setting to `verbose` log means that the SDK will not emit `debug` level logs. The default log level is `info`.
+
+### Dapr Client
+
+```js
+import { CommunicationProtocolEnum, DaprClient, LogLevel } from "@dapr/dapr";
+
+// create a client instance with log level set to verbose.
+const client = new DaprClient(
+    daprHost, 
+    daprPort, 
+    CommunicationProtocolEnum.HTTP, 
+    { logger: { level: LogLevel.Verbose } });
+```
+
+> For more details on how to use the Client, see [JavaScript Client]({{< ref js-client >}}).
+
+### DaprServer
+
+```js
+import { CommunicationProtocolEnum, DaprServer, LogLevel } from "@dapr/dapr";
+
+// create a server instance with log level set to error.
+const server = new DaprServer(
+    serverHost,
+    serverPort, 
+    daprHost,
+    daprPort,
+    CommunicationProtocolEnum.HTTP,
+    { logger: { level: LogLevel.Error } });
+```
+
+> For more details on how to use the Server, see [JavaScript Server]({{< ref js-server >}}).
+
+## Custom LoggerService
+
+The JavaScript SDK uses the in-built `Console` for logging. To use a custom logger like Winston or Pino, you can implement the `LoggerService` interface.
+
+### Winston based logging:
+
+Create a new implementation of `LoggerService`.
+
+```ts
+import { LoggerService } from "@dapr/dapr";
+import * as winston from 'winston';
+
+export class WinstonLoggerService implements LoggerService {
+    private logger;
+
+    constructor() {
+        this.logger = winston.createLogger({
+            transports: [
+                new winston.transports.Console(),
+                new winston.transports.File({ filename: 'combined.log' })
+            ]
+        });
+    }
+
+    error(message: any, ...optionalParams: any[]): void {
+        this.logger.error(message, ...optionalParams)
+    }
+    warn(message: any, ...optionalParams: any[]): void {
+        this.logger.warn(message, ...optionalParams)
+    }
+    info(message: any, ...optionalParams: any[]): void {
+        this.logger.info(message, ...optionalParams)
+    }
+    verbose(message: any, ...optionalParams: any[]): void {
+        this.logger.verbose(message, ...optionalParams)
+    }
+    debug(message: any, ...optionalParams: any[]): void {
+        this.logger.debug(message, ...optionalParams)
+    }
+}
+```
+
+Pass the new implementation to the SDK.
+
+```ts
+import { CommunicationProtocolEnum, DaprClient, LogLevel } from "@dapr/dapr";
+import { WinstonLoggerService } from "./WinstonLoggerService";
+
+const winstonLoggerService = new WinstonLoggerService();
+
+// create a client instance with log level set to verbose and logger service as winston.
+const client = new DaprClient(
+    daprHost,
+    daprPort,
+    CommunicationProtocolEnum.HTTP,
+    { logger: { level: LogLevel.Verbose, service: winstonLoggerService } });
+```

src/actors/client/ActorClient/ActorClient.ts

@@ -26,9 +26,7 @@ export default class ActorClient {
   readonly actor: IClientActor;
   readonly options: DaprClientOptions;
 
-  constructor(daprHost: string, daprPort: string, communicationProtocol: CommunicationProtocolEnum, options: DaprClientOptions = {
-    isKeepAlive: true
-  }) {
+  constructor(daprHost: string, daprPort: string, communicationProtocol: CommunicationProtocolEnum, options: DaprClientOptions = {}) {
     this.daprHost = daprHost;
     this.daprPort = daprPort;
     this.communicationProtocol = communicationProtocol;

src/implementation/Client/DaprClient.ts

@@ -78,9 +78,7 @@ export default class DaprClient {
     daprHost?: string
     , daprPort?: string
     , communicationProtocol: CommunicationProtocolEnum = CommunicationProtocolEnum.HTTP
-    , options: DaprClientOptions = {
-      isKeepAlive: true,
-    },
+    , options: DaprClientOptions = {},
   ) {
     this.daprHost = daprHost ?? Settings.getDefaultHost();
     this.daprPort = daprPort ?? Settings.getDefaultPort(communicationProtocol);

src/implementation/Client/GRPCClient/GRPCClient.ts

@@ -32,9 +32,7 @@ export default class GRPCClient implements IClient {
   constructor(
     host = Settings.getDefaultHost()
     , port = Settings.getDefaultGrpcPort()
-    , options: DaprClientOptions = {
-      isKeepAlive: true
-    },
+    , options: DaprClientOptions = {},
   ) {
     this.clientHost = host;
     this.clientPort = port;

src/implementation/Client/HTTPClient/HTTPClient.ts

@@ -37,16 +37,19 @@ export default class HTTPClient implements IClient {
   constructor(
     host = Settings.getDefaultHost()
     , port = Settings.getDefaultHttpPort()
-    , options: DaprClientOptions = {
-      isKeepAlive: true
-    },
+    , options: DaprClientOptions = {},
   ) {
     this.clientHost = host;
     this.clientPort = port;
     this.options = options;
     this.logger = new Logger("HTTPClient", "HTTPClient", this.options.logger);
     this.isInitialized = false;
 
+    // fallback to default
+    if (this.options.isKeepAlive === undefined) {
+      this.options.isKeepAlive = true;
+    }
+
     if (!this.clientHost.startsWith('http://') && !this.clientHost.startsWith('https://')) {
       this.clientUrl = `http://${this.clientHost}:${this.clientPort}/v1.0`;
     } else {

src/implementation/Server/DaprServer.ts

@@ -57,9 +57,7 @@ export default class DaprServer {
     , daprHost?: string
     , daprPort?: string
     , communicationProtocol: CommunicationProtocolEnum = CommunicationProtocolEnum.HTTP
-    , clientOptions: DaprClientOptions = {
-      isKeepAlive: true
-    }
+    , clientOptions: DaprClientOptions = {}
   ) {
     this.serverHost = serverHost ?? Settings.getDefaultHost();
     this.serverPort = serverPort ?? Settings.getDefaultAppPort(communicationProtocol);

src/types/DaprClientOptions.ts

@@ -14,6 +14,13 @@ limitations under the License.
 import { LoggerOptions } from "./logger/LoggerOptions";
 
 export type DaprClientOptions = {
-  isKeepAlive: boolean;
+  /**
+   * If set to false, the HTTP client will not reuse the same connection for multiple requests.
+   * Default is true.
+   */
+  isKeepAlive?: boolean;
+  /**
+   * Options related to logging.
+   */
   logger?: LoggerOptions;
 }

src/types/logger/LoggerOptions.ts

@@ -18,6 +18,14 @@ import { LogLevel } from "./LogLevel"
  * LoggerOptions provides options for configuring the logger.
  */
 export type LoggerOptions = {
+    /**
+     * The minimum level of messages to log.
+     * Default is LogLevel.Info.
+     */
     level?: LogLevel
+    /**
+     * Logging implementation to use.
+     * Default is to use the console.
+     */
     service?: LoggerService
 }