Fix-logging (#69)

* Better error when could not connect to runtime

* Fix logging

* Fixes

Author: woksin

Source/sdk/ClientBuilder.ts

@@ -63,11 +63,10 @@ export class ClientBuilder {
         this._projectionsBuilder = new ProjectionsBuilder(this._projectionsAssociations);
         this._logger = createLogger({
             level: 'info',
-            format: format.prettyPrint(),
-            defaultMeta: { microserviceId: _microserviceId.toString() },
+            format: format.simple(),
             transports: [
                 new transports.Console({
-                    format: format.prettyPrint()
+                    format: format.simple()
                 })
             ]
         });

Source/services/ClientProcessor.ts

@@ -50,7 +50,7 @@ export abstract class ClientProcessor<TIdentifier extends ConceptAs<Guid, string
                     if (failure) {
                         subscriber.error(new RegistrationFailed(this._kind, this._identifier.value, failures.toSDK(failure)!));
                     } else {
-                        this._logger.debug(`${this._kind} ${this._identifier} registered with the Runtime, start handling requests.`);
+                        this._logger.info(`${this._kind} ${this._identifier} registered with the Runtime, start handling requests.`);
                     }
                 },
                 error: (error: Error) => {

Source/services/CouldNotConnectToRuntime.ts

@@ -0,0 +1,17 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Exception } from '@dolittle/rudiments';
+
+/**
+ * Exception that gets thrown when the a the connection to the Runtime could not be established.
+ */
+export class CouldNotConnectToRuntime extends Exception {
+
+    /**
+     * Initializes a new instance of {@link CouldNotConnectToRuntime}.
+     */
+    constructor(address: string) {
+        super(`Could not connect to a Runtime on '${address}'. PLease make sure a Runtime is running, and that the private port (usually 50053) is accessible on the specified port.`);
+    }
+}

Source/services/ReactiveGrpc.ts

@@ -5,6 +5,7 @@ import { Cancellation } from '@dolittle/sdk.resilience';
 import * as grpc from '@grpc/grpc-js';
 import { Observable, Subject } from 'rxjs';
 import { concatMap } from 'rxjs/operators';
+import { CouldNotConnectToRuntime } from './CouldNotConnectToRuntime';
 import { ClientStreamMethod, DuplexMethod, ServerStreamMethod, UnaryMethod } from './GrpcMethods';
 
 
@@ -21,7 +22,7 @@ export function reactiveUnary<TArgument, TResponse>(client: grpc.Client, method:
     const metadata = new grpc.Metadata();
     const call = method.call(client, argument, metadata, {}, (error: grpc.ServiceError | null, message?: TResponse) => {
         if (error) {
-            subject.error(error);
+            subject.error(getErrorFromGrpc(error, client.getChannel().getTarget()));
         } else {
             subject.next(message);
             subject.complete();
@@ -44,14 +45,14 @@ export function reactiveClientStream<TRequest, TResponse>(client: grpc.Client, m
     const metadata = new grpc.Metadata();
     const stream = method.call(client, metadata, {}, (error: grpc.ServiceError | null, message?: TResponse) => {
         if (error) {
-            subject.error(error);
+            subject.error(getErrorFromGrpc(error, client.getChannel().getTarget()));
         } else {
             subject.next(message);
             subject.complete();
         }
     });
     handleCancellation(stream, cancellation);
-    handleClientRequests(stream, requests, subject);
+    handleClientRequests(stream, requests, subject, client.getChannel().getTarget());
     return subject;
 }
 
@@ -84,7 +85,7 @@ export function reactiveDuplex<TRequest, TResponse>(client: grpc.Client, method:
     const metadata = new grpc.Metadata();
     const stream = method.call(client, metadata, {});
     handleCancellation(stream, cancellation);
-    handleClientRequests(stream, requests, subject);
+    handleClientRequests(stream, requests, subject, client.getChannel().getTarget());
     handleServerResponses(stream, subject);
     return subject;
 }
@@ -107,7 +108,7 @@ function handleCancellation(call: grpc.Call, cancellation: Cancellation) {
  * @param {Observable} requests The requests to write to the Runtime.
  * @param {Subject} subject The Subject which contains the responses from the Runtime.
  */
-function handleClientRequests<TRequest, TResponse>(stream: grpc.ClientWritableStream<TRequest>, requests: Observable<TRequest>, subject: Subject<TResponse>) {
+function handleClientRequests<TRequest, TResponse>(stream: grpc.ClientWritableStream<TRequest>, requests: Observable<TRequest>, subject: Subject<TResponse>, address: string) {
     requests.pipe(concatMap((message: TRequest) => {
         const subject = new Subject<void>();
         stream.write(message, undefined, () => {
@@ -120,6 +121,9 @@ function handleClientRequests<TRequest, TResponse>(stream: grpc.ClientWritableSt
         },
         error: (error: any) => {
             stream.cancel();
+            if (isGrpcError(error)) {
+                error = getErrorFromGrpc(error, address);
+            }
             subject.error(error);
         }
     });
@@ -141,3 +145,15 @@ function handleServerResponses<TResponse>(stream: grpc.ClientReadableStream<TRes
         subject.error(error);
     });
 }
+
+function getErrorFromGrpc(error: grpc.ServiceError, address: string) {
+    if (error.code === grpc.status.UNAVAILABLE) {
+        return new CouldNotConnectToRuntime(address);
+    } else {
+        return error;
+    }
+}
+
+function isGrpcError(error: any): error is grpc.ServiceError {
+    return error.code !== undefined;
+}

Source/services/index.ts

@@ -1,6 +1,7 @@
 // Copyright (c) Dolittle. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+export { CouldNotConnectToRuntime } from './CouldNotConnectToRuntime';
 export { DidNotReceiveConnectResponse } from './DidNotReceiveConnectResponse';
 export { ClientStreamMethod, DuplexMethod, ServerStreamMethod, UnaryMethod } from './GrpcMethods';
 export { IReverseCallClient, ReverseCallCallback } from './IReverseCallClient';