Moved log.error etc. log messages into their respective runOn... methods, replaced with debug logging and if no callback registered then a debug message noting no callback was registered. Set default logging to disable Jetty logs, since they're super spammy--but I did set logs to default for OBS classes so that clients can see error messages etc. and hopefully get the idea they need to register callbacks and can always turn off those logs by setting it to info or whatever. Closes #2

blorp-goes-the-derp · blorp-goes-the-derp · commit 9920b66ef1d2 · 2020-12-27T15:23:06.000+01:00
diff --git a/src/main/java/net/twasi/obsremotejava/OBSCommunicator.java b/src/main/java/net/twasi/obsremotejava/OBSCommunicator.java
@@ -148,7 +148,8 @@ public void await() throws InterruptedException {
 
     @OnWebSocketError
     public void onError(Session session, Throwable throwable) {
-
+        // do nothing for now, this should at least repress "OnWebsocketError not registered" messages
+        runOnError("Websocket error occurred with session " + session, throwable);
     }
 
     @OnWebSocketClose
@@ -158,7 +159,7 @@ public void onClose(int statusCode, String reason) {
         try {
             this.onDisconnect.run(null);
         } catch (Throwable t) {
-            t.printStackTrace();
+            runOnError("Could not close websocket connection", t);
         }
     }
 
@@ -170,7 +171,7 @@ public void onConnect(Session session) {
             fut = session.getRemote().sendStringByFuture(new Gson().toJson(new GetVersionRequest(this)));
             fut.get(2, TimeUnit.SECONDS);
         } catch (Throwable t) {
-            t.printStackTrace();
+            runOnError("An error occurred while trying to get a session", t);
         }
     }
 
@@ -182,7 +183,7 @@ public void onMessage(String msg) {
         }
 
         if (debug) {
-            log.debug(msg);
+            log.debug("onMessage: " + msg);
         }
 
         try {
@@ -195,8 +196,6 @@ public void onMessage(String msg) {
                 try {
                     processIncomingResponse(responseBase, type);
                 } catch (Throwable t) {
-                    log.error("Failed to process response '" + type.getSimpleName() + "' from websocket.");
-                    t.printStackTrace();
                     runOnError("Failed to process response '" + type.getSimpleName() + "' from websocket", t);
                 }
 
@@ -213,14 +212,10 @@ public void onMessage(String msg) {
                 try {
                     processIncomingEvent(msg, eventType);
                 } catch (Throwable t) {
-                    log.error("Failed to execute callback for event: " + eventType);
-                    t.printStackTrace();
                     runOnError("Failed to execute callback for event: " + eventType, t);
                 }
             }
         } catch (Throwable t) {
-            log.error("Failed to process message from websocket.");
-            t.printStackTrace();
             runOnError("Failed to process message from websocket", t);
         }
     }
@@ -264,8 +259,6 @@ private void processIncomingResponse(ResponseBase responseBase, Class type) {
                 try {
                     callbacks.get(type).run(responseBase);
                 } catch (Throwable t) {
-                    log.error("Failed to execute callback for response: " + type);
-                    t.printStackTrace();
                     runOnError("Failed to execute callback for response: " + type, t);
                 }
         }
@@ -330,7 +323,6 @@ private void processIncomingEvent(String msg, EventType eventType) {
 
     private void authenticateWithServer(String challenge, String salt) {
         if (password == null) {
-            log.error("Authentication required by server but no password set by client");
             runOnConnectionFailed("Authentication required by server but no password set by client");
             return;
         }
@@ -352,8 +344,6 @@ private String generateAuthenticationResponseString(String challenge, String sal
         try {
             digest = MessageDigest.getInstance("SHA-256");
         } catch (NoSuchAlgorithmException e) {
-            log.error("Failed to perform password authentication with server");
-            e.printStackTrace();
             runOnConnectionFailed("Failed to perform password authentication with server");
             return null;
         }
@@ -645,41 +635,44 @@ public void setStudioModeEnabled(boolean enabled, Callback callback) {
     }
 
     private void runOnError(String message, Throwable throwable) {
+        log.debug("Running onError with message: " + message + " and exception:", throwable);
         if (onError == null) {
+            log.debug("No onError callback was registered");
             return;
         }
 
         try {
             onError.run(message, throwable);
         } catch (Throwable t) {
-            log.error("Exception during callback execution for 'onError'");
-            t.printStackTrace();
+            log.error("Unable to run onError callback", t);
         }
     }
 
     private void runOnConnectionFailed(String message) {
+        log.debug("Running onConnectionFailed, with message: " + message);
         if (onConnectionFailed == null) {
+            log.debug("No onConnectionFailed callback was registered");
             return;
         }
 
         try {
             onConnectionFailed.run(message);
         } catch (Throwable t) {
-            log.error("Exception during callback execution for 'onConnectionFailed'");
-            t.printStackTrace();
+            log.error("Unable to run OnConnectionFailed callback", t);
         }
     }
 
     private void runOnConnect(GetVersionResponse versionInfo) {
+        log.debug("Running onConnect with versionInfo: " + versionInfo);
         if (onConnect == null) {
+            log.debug("No onConnect callback was registered");
             return;
         }
 
         try {
             onConnect.run(versionInfo);
         } catch (Throwable t) {
-            log.error("Exception during callback execution for 'onConnect'");
-            t.printStackTrace();
+            log.error("Unable to run OnConnect callback", t);
         }
     }
 }
diff --git a/src/main/java/net/twasi/obsremotejava/OBSRemoteController.java b/src/main/java/net/twasi/obsremotejava/OBSRemoteController.java
@@ -56,8 +56,6 @@ public void connect() {
         try {
             client.start();
         } catch (Exception e) {
-            log.error("Failed to start WebSocketClient.");
-            e.printStackTrace();
             runOnError("Failed to start WebSocketClient", e);
             return;
         }
@@ -66,27 +64,20 @@ public void connect() {
             URI uri = new URI(address);
             ClientUpgradeRequest request = new ClientUpgradeRequest();
             Future<Session> connection = client.connect(communicator, uri, request);
-            log.info(String.format("Connecting to: %s%s.%n", uri, (password != null ? " with password" : "")));
-
+            log.info(String.format("Connecting to: %s%s.%n", uri, (password != null ? " with password" : " (no password)")));
             try {
                 connection.get();
                 failed = false;
             } catch (ExecutionException e) {
                 if (e.getCause() instanceof ConnectException) {
-                    log.error("Failed to connect to OBS.");
-                    e.printStackTrace();
-
                     failed = true;
-
-                    runOnConnectionFailed("Failed to connect to OBS");
+                    runOnConnectionFailed("Failed to connect to OBS! Is it running and is the websocket plugin installed?", e);
                 } else {
                     throw e;
                 }
             }
         } catch (Throwable t) {
-            log.error("Failed to setup connection with OBS.");
-            t.printStackTrace();
-            runOnConnectionFailed("Failed to setup connection with OBS");
+            runOnConnectionFailed("Failed to setup connection with OBS", t);
         }
     }
 
@@ -98,7 +89,6 @@ public void disconnect() {
             }
             communicator.awaitClose(1, TimeUnit.SECONDS);
         } catch (InterruptedException e) {
-            e.printStackTrace();
             runOnError("Error during closing websocket connection", e);
         }
 
@@ -109,7 +99,6 @@ public void disconnect() {
                 }
                 client.stop();
             } catch (Exception e) {
-                e.printStackTrace();
                 runOnError("Error during stopping websocket client", e);
             }
         }
@@ -321,26 +310,31 @@ public void saveReplayBuffer(Callback callback) {
     }
 
     private void runOnError(String message, Throwable throwable) {
+        log.debug("Running onError with message: " + message + " and exception:", throwable);
         if (onError == null) {
+            log.debug("No onError callback was registered");
             return;
         }
 
         try {
             onError.run(message, throwable);
         } catch (Exception e) {
-            e.printStackTrace();
+            log.error("Unable to run OnError callback", e);
         }
     }
 
-    private void runOnConnectionFailed(String message) {
+    private void runOnConnectionFailed(String message, Throwable throwable) {
+        log.debug("Running onConnectionFailed with message: " + message + " with exception:", throwable);
+
         if (onConnectionFailed == null) {
+            log.debug("No onConnectionFailed callback was registered");
             return;
         }
 
         try {
             onConnectionFailed.run(message);
         } catch (Exception e) {
-            e.printStackTrace();
+            log.error("Unable to run OnConnectionFailed callback", e);
         }
     }
 }
diff --git a/src/main/resources/simplelogger.properties b/src/main/resources/simplelogger.properties
@@ -0,0 +1,7 @@
+# Turning off Jetty logging.
+org.eclipse.jetty.util.log.class=org.eclipse.jetty.util.log.Slf4jLog
+org.eclipse.jetty.LEVEL=OFF
+
+# Default levels for the project
+org.slf4j.simpleLogger.defaultLogLevel=info
+org.slf4j.simpleLogger.log.net.twasi.obsremotejava=debug

Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,8 @@ public void await() throws InterruptedException {`
`148`	`148`
`149`	`149`	`@OnWebSocketError`
`150`	`150`	`public void onError(Session session, Throwable throwable) {`
`151`		`-`
	`151`	`+ // do nothing for now, this should at least repress "OnWebsocketError not registered" messages`
	`152`	`+ runOnError("Websocket error occurred with session " + session, throwable);`
`152`	`153`	`}`
`153`	`154`
`154`	`155`	`@OnWebSocketClose`
`@@ -158,7 +159,7 @@ public void onClose(int statusCode, String reason) {`
`158`	`159`	`try {`
`159`	`160`	`this.onDisconnect.run(null);`
`160`	`161`	`} catch (Throwable t) {`
`161`		`- t.printStackTrace();`
	`162`	`+ runOnError("Could not close websocket connection", t);`
`162`	`163`	`}`
`163`	`164`	`}`
`164`	`165`
`@@ -170,7 +171,7 @@ public void onConnect(Session session) {`
`170`	`171`	`fut = session.getRemote().sendStringByFuture(new Gson().toJson(new GetVersionRequest(this)));`
`171`	`172`	`fut.get(2, TimeUnit.SECONDS);`
`172`	`173`	`} catch (Throwable t) {`
`173`		`- t.printStackTrace();`
	`174`	`+ runOnError("An error occurred while trying to get a session", t);`
`174`	`175`	`}`
`175`	`176`	`}`
`176`	`177`
`@@ -182,7 +183,7 @@ public void onMessage(String msg) {`
`182`	`183`	`}`
`183`	`184`
`184`	`185`	`if (debug) {`
`185`		`- log.debug(msg);`
	`186`	`+ log.debug("onMessage: " + msg);`
`186`	`187`	`}`
`187`	`188`
`188`	`189`	`try {`
`@@ -195,8 +196,6 @@ public void onMessage(String msg) {`
`195`	`196`	`try {`
`196`	`197`	`processIncomingResponse(responseBase, type);`
`197`	`198`	`} catch (Throwable t) {`
`198`		`- log.error("Failed to process response '" + type.getSimpleName() + "' from websocket.");`
`199`		`- t.printStackTrace();`
`200`	`199`	`runOnError("Failed to process response '" + type.getSimpleName() + "' from websocket", t);`
`201`	`200`	`}`
`202`	`201`
`@@ -213,14 +212,10 @@ public void onMessage(String msg) {`
`213`	`212`	`try {`
`214`	`213`	`processIncomingEvent(msg, eventType);`
`215`	`214`	`} catch (Throwable t) {`
`216`		`- log.error("Failed to execute callback for event: " + eventType);`
`217`		`- t.printStackTrace();`
`218`	`215`	`runOnError("Failed to execute callback for event: " + eventType, t);`
`219`	`216`	`}`
`220`	`217`	`}`
`221`	`218`	`} catch (Throwable t) {`
`222`		`- log.error("Failed to process message from websocket.");`
`223`		`- t.printStackTrace();`
`224`	`219`	`runOnError("Failed to process message from websocket", t);`
`225`	`220`	`}`
`226`	`221`	`}`
`@@ -264,8 +259,6 @@ private void processIncomingResponse(ResponseBase responseBase, Class type) {`
`264`	`259`	`try {`
`265`	`260`	`callbacks.get(type).run(responseBase);`
`266`	`261`	`} catch (Throwable t) {`
`267`		`- log.error("Failed to execute callback for response: " + type);`
`268`		`- t.printStackTrace();`
`269`	`262`	`runOnError("Failed to execute callback for response: " + type, t);`
`270`	`263`	`}`
`271`	`264`	`}`
`@@ -330,7 +323,6 @@ private void processIncomingEvent(String msg, EventType eventType) {`
`330`	`323`
`331`	`324`	`private void authenticateWithServer(String challenge, String salt) {`
`332`	`325`	`if (password == null) {`
`333`		`- log.error("Authentication required by server but no password set by client");`
`334`	`326`	`runOnConnectionFailed("Authentication required by server but no password set by client");`
`335`	`327`	`return;`
`336`	`328`	`}`
`@@ -352,8 +344,6 @@ private String generateAuthenticationResponseString(String challenge, String sal`
`352`	`344`	`try {`
`353`	`345`	`digest = MessageDigest.getInstance("SHA-256");`
`354`	`346`	`} catch (NoSuchAlgorithmException e) {`
`355`		`- log.error("Failed to perform password authentication with server");`
`356`		`- e.printStackTrace();`
`357`	`347`	`runOnConnectionFailed("Failed to perform password authentication with server");`
`358`	`348`	`return null;`
`359`	`349`	`}`
`@@ -645,41 +635,44 @@ public void setStudioModeEnabled(boolean enabled, Callback callback) {`
`645`	`635`	`}`
`646`	`636`
`647`	`637`	`private void runOnError(String message, Throwable throwable) {`
	`638`	`+ log.debug("Running onError with message: " + message + " and exception:", throwable);`
`648`	`639`	`if (onError == null) {`
	`640`	`+ log.debug("No onError callback was registered");`
`649`	`641`	`return;`
`650`	`642`	`}`
`651`	`643`
`652`	`644`	`try {`
`653`	`645`	`onError.run(message, throwable);`
`654`	`646`	`} catch (Throwable t) {`
`655`		`- log.error("Exception during callback execution for 'onError'");`
`656`		`- t.printStackTrace();`
	`647`	`+ log.error("Unable to run onError callback", t);`
`657`	`648`	`}`
`658`	`649`	`}`
`659`	`650`
`660`	`651`	`private void runOnConnectionFailed(String message) {`
	`652`	`+ log.debug("Running onConnectionFailed, with message: " + message);`
`661`	`653`	`if (onConnectionFailed == null) {`
	`654`	`+ log.debug("No onConnectionFailed callback was registered");`
`662`	`655`	`return;`
`663`	`656`	`}`
`664`	`657`
`665`	`658`	`try {`
`666`	`659`	`onConnectionFailed.run(message);`
`667`	`660`	`} catch (Throwable t) {`
`668`		`- log.error("Exception during callback execution for 'onConnectionFailed'");`
`669`		`- t.printStackTrace();`
	`661`	`+ log.error("Unable to run OnConnectionFailed callback", t);`
`670`	`662`	`}`
`671`	`663`	`}`
`672`	`664`
`673`	`665`	`private void runOnConnect(GetVersionResponse versionInfo) {`
	`666`	`+ log.debug("Running onConnect with versionInfo: " + versionInfo);`
`674`	`667`	`if (onConnect == null) {`
	`668`	`+ log.debug("No onConnect callback was registered");`
`675`	`669`	`return;`
`676`	`670`	`}`
`677`	`671`
`678`	`672`	`try {`
`679`	`673`	`onConnect.run(versionInfo);`
`680`	`674`	`} catch (Throwable t) {`
`681`		`- log.error("Exception during callback execution for 'onConnect'");`
`682`		`- t.printStackTrace();`
	`675`	`+ log.error("Unable to run OnConnect callback", t);`
`683`	`676`	`}`
`684`	`677`	`}`
`685`	`678`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,8 +56,6 @@ public void connect() {`
`56`	`56`	`try {`
`57`	`57`	`client.start();`
`58`	`58`	`} catch (Exception e) {`
`59`		`- log.error("Failed to start WebSocketClient.");`
`60`		`- e.printStackTrace();`
`61`	`59`	`runOnError("Failed to start WebSocketClient", e);`
`62`	`60`	`return;`
`63`	`61`	`}`
`@@ -66,27 +64,20 @@ public void connect() {`
`66`	`64`	`URI uri = new URI(address);`
`67`	`65`	`ClientUpgradeRequest request = new ClientUpgradeRequest();`
`68`	`66`	`Future<Session> connection = client.connect(communicator, uri, request);`
`69`		`- log.info(String.format("Connecting to: %s%s.%n", uri, (password != null ? " with password" : "")));`
`70`		`-`
	`67`	`+ log.info(String.format("Connecting to: %s%s.%n", uri, (password != null ? " with password" : " (no password)")));`
`71`	`68`	`try {`
`72`	`69`	`connection.get();`
`73`	`70`	`failed = false;`
`74`	`71`	`} catch (ExecutionException e) {`
`75`	`72`	`if (e.getCause() instanceof ConnectException) {`
`76`		`- log.error("Failed to connect to OBS.");`
`77`		`- e.printStackTrace();`
`78`		`-`
`79`	`73`	`failed = true;`
`80`		`-`
`81`		`- runOnConnectionFailed("Failed to connect to OBS");`
	`74`	`+ runOnConnectionFailed("Failed to connect to OBS! Is it running and is the websocket plugin installed?", e);`
`82`	`75`	`} else {`
`83`	`76`	`throw e;`
`84`	`77`	`}`
`85`	`78`	`}`
`86`	`79`	`} catch (Throwable t) {`
`87`		`- log.error("Failed to setup connection with OBS.");`
`88`		`- t.printStackTrace();`
`89`		`- runOnConnectionFailed("Failed to setup connection with OBS");`
	`80`	`+ runOnConnectionFailed("Failed to setup connection with OBS", t);`
`90`	`81`	`}`
`91`	`82`	`}`
`92`	`83`
`@@ -98,7 +89,6 @@ public void disconnect() {`
`98`	`89`	`}`
`99`	`90`	`communicator.awaitClose(1, TimeUnit.SECONDS);`
`100`	`91`	`} catch (InterruptedException e) {`
`101`		`- e.printStackTrace();`
`102`	`92`	`runOnError("Error during closing websocket connection", e);`
`103`	`93`	`}`
`104`	`94`
`@@ -109,7 +99,6 @@ public void disconnect() {`
`109`	`99`	`}`
`110`	`100`	`client.stop();`
`111`	`101`	`} catch (Exception e) {`
`112`		`- e.printStackTrace();`
`113`	`102`	`runOnError("Error during stopping websocket client", e);`
`114`	`103`	`}`
`115`	`104`	`}`
`@@ -321,26 +310,31 @@ public void saveReplayBuffer(Callback callback) {`
`321`	`310`	`}`
`322`	`311`
`323`	`312`	`private void runOnError(String message, Throwable throwable) {`
	`313`	`+ log.debug("Running onError with message: " + message + " and exception:", throwable);`
`324`	`314`	`if (onError == null) {`
	`315`	`+ log.debug("No onError callback was registered");`
`325`	`316`	`return;`
`326`	`317`	`}`
`327`	`318`
`328`	`319`	`try {`
`329`	`320`	`onError.run(message, throwable);`
`330`	`321`	`} catch (Exception e) {`
`331`		`- e.printStackTrace();`
	`322`	`+ log.error("Unable to run OnError callback", e);`
`332`	`323`	`}`
`333`	`324`	`}`
`334`	`325`
`335`		`- private void runOnConnectionFailed(String message) {`
	`326`	`+ private void runOnConnectionFailed(String message, Throwable throwable) {`
	`327`	`+ log.debug("Running onConnectionFailed with message: " + message + " with exception:", throwable);`
	`328`	`+`
`336`	`329`	`if (onConnectionFailed == null) {`
	`330`	`+ log.debug("No onConnectionFailed callback was registered");`
`337`	`331`	`return;`
`338`	`332`	`}`
`339`	`333`
`340`	`334`	`try {`
`341`	`335`	`onConnectionFailed.run(message);`
`342`	`336`	`} catch (Exception e) {`
`343`		`- e.printStackTrace();`
	`337`	`+ log.error("Unable to run OnConnectionFailed callback", e);`
`344`	`338`	`}`
`345`	`339`	`}`
`346`	`340`	`}`