Add logging infrastructure to the Java Client (#2720)

Author: mikaelm12

clients/java/signalr/src/main/java/Chat.java

@@ -9,7 +9,7 @@ public static void main(String[] args) throws Exception {
             Scanner reader = new Scanner(System.in);  // Reading from System.in
             String input;
             input = reader.nextLine();
-            HubConnection hubConnection = new HubConnection(input);
+            HubConnection hubConnection = new HubConnection(input, LogLevel.Information);
 
             hubConnection.on("Send", (message) -> {
                 System.out.println("REGISTERED HANDLER: " + message);

clients/java/signalr/src/main/java/ConsoleLogger.java

@@ -0,0 +1,44 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+public class ConsoleLogger implements Logger {
+    private LogLevel logLevel;
+    public ConsoleLogger(LogLevel logLevel) {
+            this.logLevel = logLevel;
+    }
+
+    @Override
+    public void log(LogLevel logLevel, String message) {
+        if(logLevel.value >= this.logLevel.value){
+            switch (logLevel) {
+                case Debug:
+                case Information:
+                    System.out.println(message);
+                    break;
+                case Warning:
+                case Error:
+                case Critical:
+                    System.err.println(message);
+                    break;
+            }
+        }
+    }
+
+    @Override
+    public void log(LogLevel logLevel, String formattedMessage, Object... args) {
+        if (logLevel.value >= this.logLevel.value) {
+            formattedMessage = formattedMessage + "%n";
+            switch (logLevel) {
+                case Debug:
+                case Information:
+                    System.out.printf(formattedMessage, args);
+                    break;
+                case Warning:
+                case Error:
+                case Critical:
+                    System.err.printf(formattedMessage, args);
+                    break;
+            }
+        }
+    }
+}

clients/java/signalr/src/main/java/HubConnection.java

@@ -18,18 +18,22 @@ public class HubConnection {
     private Boolean handshakeReceived = false;
     private static final String RECORD_SEPARATOR = "\u001e";
     private HubConnectionState connectionState = HubConnectionState.DISCONNECTED;
+    private Logger logger;
 
-    public HubConnection(String url, Transport transport) {
+    public HubConnection(String url, Transport transport, Logger logger){
         this.url = url;
         this.protocol = new JsonHubProtocol();
+        this.logger = logger;
         this.callback = (payload) -> {
 
             if (!handshakeReceived) {
                 int handshakeLength = payload.indexOf(RECORD_SEPARATOR) + 1;
                 String handshakeResponseString = payload.substring(0, handshakeLength - 1);
                 HandshakeResponseMessage handshakeResponse = HandshakeProtocol.parseHandshakeResponse(handshakeResponseString);
                 if (handshakeResponse.error != null) {
-                    throw new Exception("Error in handshake " + handshakeResponse.error);
+                    String errorMessage = "Error in handshake " + handshakeResponse.error;
+                    logger.log(LogLevel.Error, errorMessage);
+                    throw new Exception(errorMessage);
                 }
                 handshakeReceived = true;
 
@@ -43,36 +47,41 @@ public HubConnection(String url, Transport transport) {
             HubMessage[] messages = protocol.parseMessages(payload);
 
             for (HubMessage message : messages) {
+                logger.log(LogLevel.Debug,"Received message of type %s", message.getMessageType());
                 switch (message.getMessageType()) {
                     case INVOCATION:
                         InvocationMessage invocationMessage = (InvocationMessage)message;
-                        if (message != null && handlers.containsKey(invocationMessage.target)) {
+                        if (handlers.containsKey(invocationMessage.target)) {
                             ArrayList<Object> args = gson.fromJson((JsonArray)invocationMessage.arguments[0], (new ArrayList<>()).getClass());
                             List<ActionBase> actions = handlers.get(invocationMessage.target);
                             if (actions != null) {
+                                logger.log(LogLevel.Debug, "Invoking handlers for target %s", invocationMessage.target);
                                 for (ActionBase action: actions) {
                                     action.invoke(args.toArray());
                                 }
                             }
+                        } else {
+                            logger.log(LogLevel.Warning, "Failed to find handler for %s method", invocationMessage.target);
                         }
                         break;
                     case STREAM_INVOCATION:
                     case STREAM_ITEM:
                     case CLOSE:
                     case CANCEL_INVOCATION:
                     case COMPLETION:
-                        throw new UnsupportedOperationException("The message type " + message.getMessageType() + " is not supported yet.");
+                        logger.log(LogLevel.Error, "This client does not support %s messages", message.getMessageType());
+
+                        throw new UnsupportedOperationException(String.format("The message type %s is not supported yet.", message.getMessageType()));
                     case PING:
                         // We don't need to do anything in the case of a ping message.
-                        // The other message types aren't supported
                         break;
                 }
             }
         };
 
         if (transport == null){
             try {
-                this.transport = new WebSocketTransport(this.url);
+                this.transport = new WebSocketTransport(this.url, this.logger);
             } catch (URISyntaxException e) {
                 e.printStackTrace();
             }
@@ -81,42 +90,57 @@ public HubConnection(String url, Transport transport) {
         }
     }
 
+    public HubConnection(String url, Transport transport) {
+        this(url, transport, new NullLogger());
+    }
+
     public HubConnection(String url) {
-        this(url, null);
+        this(url, null, new NullLogger());
+    }
+
+    public HubConnection(String url, LogLevel logLevel){
+        this(url, null, new ConsoleLogger(logLevel));
     }
 
     public HubConnectionState getConnectionState() {
         return connectionState;
     }
 
     public void start() throws Exception {
+        logger.log(LogLevel.Debug, "Starting HubConnection");
         transport.setOnReceive(this.callback);
         transport.start();
         String handshake = HandshakeProtocol.createHandshakeRequestMessage(new HandshakeRequestMessage(protocol.getName(), protocol.getVersion()));
         transport.send(handshake);
         connectionState = HubConnectionState.CONNECTED;
+        logger.log(LogLevel.Information, "HubConnected started");
     }
 
     public void stop(){
+        logger.log(LogLevel.Debug, "Stopping HubConnection");
         transport.stop();
         connectionState = HubConnectionState.DISCONNECTED;
+        logger.log(LogLevel.Information, "HubConnection stopped");
     }
 
     public void send(String method, Object... args) throws Exception {
         InvocationMessage invocationMessage = new InvocationMessage(method, args);
         String message = protocol.writeMessage(invocationMessage);
+        logger.log(LogLevel.Debug, "Sending message");
         transport.send(message);
     }
 
     public Subscription on(String target, Action callback) {
         ActionBase action = args -> callback.invoke();
         handlers.put(target, action);
+        logger.log(LogLevel.Trace, "Registering handler for client method: %s", target);
         return new Subscription(handlers, action, target);
     }
 
     public <T1> Subscription on(String target, Action1<T1> callback, Class<T1> param1) {
         ActionBase action = params -> callback.invoke(param1.cast(params[0]));
         handlers.put(target, action);
+        logger.log(LogLevel.Trace, "Registering handler for client method: %s", target);
         return new Subscription(handlers, action, target);
     }
 
@@ -125,6 +149,7 @@ public <T1, T2> Subscription on(String target, Action2<T1, T2> callback, Class<T
             callback.invoke(param1.cast(params[0]), param2.cast(params[1]));
         };
         handlers.put(target, action);
+        logger.log(LogLevel.Trace, "Registering handler for client method: %s", target);
         return new Subscription(handlers, action, target);
     }
 
@@ -134,6 +159,7 @@ public <T1, T2, T3> Subscription on(String target, Action3<T1, T2, T3> callback,
             callback.invoke(param1.cast(params[0]), param2.cast(params[1]), param3.cast(params[2]));
         };
         handlers.put(target, action);
+        logger.log(LogLevel.Trace, "Registering handler for client method: %s", target);
         return new Subscription(handlers, action, target);
     }
 
@@ -143,6 +169,7 @@ public <T1, T2, T3, T4> Subscription on(String target, Action4<T1, T2, T3, T4> c
             callback.invoke(param1.cast(params[0]), param2.cast(params[1]), param3.cast(params[2]), param4.cast(params[3]));
         };
         handlers.put(target, action);
+        logger.log(LogLevel.Trace, "Registering handler for client method: %s", target);
         return new Subscription(handlers, action, target);
     }
 
@@ -153,6 +180,7 @@ public <T1, T2, T3, T4, T5> Subscription on(String target, Action5<T1, T2, T3, T
                     param5.cast(params[4]));
         };
         handlers.put(target, action);
+        logger.log(LogLevel.Trace, "Registering handler for client method: %s", target);
         return new Subscription(handlers, action, target);
     }
 
@@ -163,6 +191,7 @@ public <T1, T2, T3, T4, T5, T6> Subscription on(String target, Action6<T1, T2, T
                     param5.cast(params[4]) ,param6.cast(params[5]));
         };
         handlers.put(target, action);
+        logger.log(LogLevel.Trace, "Registering handler for client method: %s", target);
         return new Subscription(handlers, action, target);
     }
 
@@ -173,6 +202,7 @@ public <T1, T2, T3, T4, T5, T6, T7> Subscription on(String target, Action7<T1, T
                     param5.cast(params[4]) ,param6.cast(params[5]), param7.cast(params[6]));
         };
         handlers.put(target, action);
+        logger.log(LogLevel.Trace, "Registering handler for client method: %s", target);
         return new Subscription(handlers, action, target);
     }
 
@@ -183,10 +213,12 @@ public <T1, T2, T3, T4, T5, T6, T7, T8> Subscription on(String target, Action8<T
                     param5.cast(params[4]) ,param6.cast(params[5]), param7.cast(params[6]), param8.cast(params[7]));
         };
         handlers.put(target, action);
+        logger.log(LogLevel.Trace, "Registering handler for client method: %s", target);
         return new Subscription(handlers, action, target);
     }
 
     public void remove(String name) {
         handlers.remove(name);
+        logger.log(LogLevel.Trace, "Removing handlers for client method %s" , name);
     }
 }

clients/java/signalr/src/main/java/LogLevel.java

@@ -0,0 +1,15 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+public enum LogLevel {
+    Trace(0),
+    Debug(1),
+    Information(2),
+    Warning(3),
+    Error(4),
+    Critical(5),
+    None(6);
+
+    public int value;
+    LogLevel(int id) { this.value = id; }
+}

clients/java/signalr/src/main/java/Logger.java

@@ -0,0 +1,7 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+public interface Logger {
+    void log(LogLevel logLevel, String message);
+    void log(LogLevel logLevel, String formattedMessage, Object ... args);
+}

clients/java/signalr/src/main/java/NullLogger.java

@@ -0,0 +1,10 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+public class NullLogger implements Logger {
+    @Override
+    public void log(LogLevel logLevel, String message) { }
+
+    @Override
+    public void log(LogLevel logLevel, String formattedMessage, Object... args) { }
+}

clients/java/signalr/src/main/java/WebSocketTransport.java

@@ -11,14 +11,16 @@ public class WebSocketTransport implements Transport {
     private WebSocketClient webSocketClient;
     private OnReceiveCallBack onReceiveCallBack;
     private URI url;
+    private Logger logger;
 
     private static final String HTTP = "http";
     private static final String HTTPS = "https";
     private static final String WS = "ws";
     private static final String WSS = "wss";
 
-    public WebSocketTransport(String url) throws URISyntaxException {
+    public WebSocketTransport(String url, Logger logger) throws URISyntaxException {
         this.url = formatUrl(url);
+        this.logger = logger;
     }
 
     public URI getUrl(){
@@ -37,8 +39,10 @@ else if(url.startsWith(HTTP)){
 
     @Override
     public void start() throws InterruptedException {
+        logger.log(LogLevel.Debug, "Starting Websocket connection");
         webSocketClient = createWebSocket();
         webSocketClient.connectBlocking();
+        logger.log(LogLevel.Information, "WebSocket transport connected to: %s", webSocketClient.getURI());
     }
 
     @Override
@@ -49,6 +53,7 @@ public void send(String message) {
     @Override
     public void setOnReceive(OnReceiveCallBack callback) {
         this.onReceiveCallBack = callback;
+        logger.log(LogLevel.Debug, "OnReceived callback has been set");
     }
 
     @Override
@@ -59,6 +64,7 @@ public void onReceive(String message) throws Exception {
     @Override
     public void stop() {
         webSocketClient.closeConnection(0, "HubConnection Stopped");
+        logger.log(LogLevel.Information, "WebSocket connection stopped");
     }
 
     private WebSocketClient createWebSocket() {

clients/java/signalr/src/test/java/WebSocketTransportTest.java

@@ -32,7 +32,7 @@ public static Collection protocols(){
 
     @Test
     public void checkWebsocketUrlProtocol() throws URISyntaxException {
-        WebSocketTransport webSocketTransport = new WebSocketTransport(this.url);
+        WebSocketTransport webSocketTransport = new WebSocketTransport(this.url, new NullLogger());
         assertEquals(this.expectedUrl, webSocketTransport.getUrl().toString());
     }
 }