Merge pull request #1549 from ballerina-platform/fix-silent-error-handling

niveathika · web-flow · commit 883221bdcca7 · 2026-02-15T09:06:45.000+05:30
Fix silent error handling in FTP listener
diff --git a/changelog.md b/changelog.md
@@ -17,7 +17,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - [Incorporate the csv fail safe support in the FTP listener](https://github.com/ballerina-platform/ballerina-library/issues/8502)
 
 ### Fixed
-
+- [Fix Listener silently fails when errors occur](https://github.com/ballerina-platform/ballerina-library/issues/8655)
 
 ## [2.16.0] - 2025-12-19
 
diff --git a/native/src/main/java/io/ballerina/stdlib/ftp/client/FtpClientHelper.java b/native/src/main/java/io/ballerina/stdlib/ftp/client/FtpClientHelper.java
@@ -99,7 +99,6 @@ static boolean executeGetAction(RemoteFileSystemBaseMessage remoteFileSystemBase
                 balFuture.complete(streamEntry);
             }
         } catch (IOException e) {
-            log.error("{}", FtpConstants.ERR_READING_STREAM, e);
             balFuture.complete(FtpUtil.createError(FtpConstants.ERR_READING_STREAM, e, FTP_ERROR));
         }
         return true;
@@ -130,7 +129,6 @@ private static Object createStreamWithContent(InputStream content, Type streamVa
             return ContentCsvStreamIteratorUtils.createRecordStream(content, streamValueType,
                     laxDataBinding, null);
         } catch (Exception e) {
-            log.error("Failed to create stream with content", e);
             return FtpUtil.createError(FtpConstants.ERR_CREATE_STREAM, e, FTP_ERROR);
         }
     }
diff --git a/native/src/main/java/io/ballerina/stdlib/ftp/client/FtpClientListener.java b/native/src/main/java/io/ballerina/stdlib/ftp/client/FtpClientListener.java
@@ -54,7 +54,6 @@ public boolean onMessage(RemoteFileSystemBaseMessage remoteFileSystemBaseMessage
 
     @Override
     public void onError(Throwable throwable) {
-        log.error(throwable.getMessage(), throwable);
         String errorType = FtpUtil.getErrorTypeForException(throwable);
         balFuture.complete(FtpUtil.createError(throwable.getMessage(), throwable.getCause(), errorType));
     }
diff --git a/native/src/main/java/io/ballerina/stdlib/ftp/server/FormatMethodsHolder.java b/native/src/main/java/io/ballerina/stdlib/ftp/server/FormatMethodsHolder.java
@@ -86,6 +86,8 @@ private void initializeMethodMappings() throws FtpInvalidConfigException {
                 Object patternObj = annotation.get(StringUtils.fromString(ANNOTATION_PATTERN_FIELD));
                 if (patternObj != null) {
                     String pattern = patternObj.toString();
+                    FtpUtil.validateRegexPattern(pattern,
+                            "@ftp:FunctionConfig.fileNamePattern for method '" + methodName + "'");
                     annotationPatternToMethod.put(pattern, method);
                     log.debug("Registered annotation pattern '{}' for method '{}'", pattern, methodName);
                 }
@@ -207,12 +209,9 @@ public Optional<MethodType> getMethod(FileInfo fileInfo) {
     private Optional<MethodType> findMethodByAnnotationPattern(String fileName) {
         for (Map.Entry<String, MethodType> entry : annotationPatternToMethod.entrySet()) {
             String pattern = entry.getKey();
-            try {
-                if (Pattern.matches(pattern, fileName)) {
-                    return Optional.of(entry.getValue());
-                }
-            } catch (Exception e) {
-                log.warn("Invalid regex pattern '{}' in FileConfig annotation: {}", pattern, e.getMessage());
+            // Patterns are validated during initialization, so no try-catch needed
+            if (Pattern.matches(pattern, fileName)) {
+                return Optional.of(entry.getValue());
             }
         }
         return Optional.empty();
diff --git a/native/src/main/java/io/ballerina/stdlib/ftp/server/FtpContentCallbackHandler.java b/native/src/main/java/io/ballerina/stdlib/ftp/server/FtpContentCallbackHandler.java
@@ -121,7 +121,6 @@ public void processContentCallbacks(Environment env, BObject service, RemoteFile
 
                 // Check if content conversion returned an error (ContentBindingError)
                 if (convertedContent instanceof BError bError) {
-                    log.error("Content binding failed for file: {}", fileInfo.getPath());
                     routeToOnError(service, holder, bError, callerObject, fileInfo, listenerPath);
                     continue;
                 }
@@ -139,7 +138,8 @@ public void processContentCallbacks(Environment env, BObject service, RemoteFile
                         fileInfo, callerObject, listenerPath, afterProcess, afterError);
 
             } catch (Exception exception) {
-                log.error("Failed to process file: " + fileInfo.getPath(), exception);
+                FtpUtil.createError("Failed to process file: " + fileInfo.getPath() + " - " + exception.getMessage(),
+                        exception, FtpConstants.FTP_ERROR).printStackTrace();
                 // Continue processing other files even if one fails
             }
         }
@@ -276,11 +276,13 @@ private void routeToOnError(BObject service, FormatMethodsHolder holder, BError
                                 FileInfo fileInfo, String listenerPath) {
         if (!holder.hasOnErrorMethod()) {
             // No onError handler, error is already logged
+            error.printStackTrace();
             return;
         }
 
         Optional<MethodType> onErrorMethodOpt = holder.getOnErrorMethod();
         if (onErrorMethodOpt.isEmpty()) {
+            error.printStackTrace();
             return;
         }
 
@@ -332,7 +334,8 @@ private void invokeOnErrorMethodAsync(BObject service, String methodName, Object
             } catch (BError error) {
                 error.printStackTrace();
             } catch (Exception exception) {
-                log.error("Error invoking onError method: " + methodName, exception);
+                FtpUtil.createError("Error invoking onError method: " + methodName + " - " + exception.getMessage(),
+                        exception, FtpConstants.FTP_ERROR).printStackTrace();
             }
 
             if (isSuccess) {
@@ -372,7 +375,8 @@ private void invokeContentMethodAsync(BObject service, String methodName, Object
                 afterError.ifPresent(action -> executePostProcessAction(action, fileInfo, callerObject,
                         listenerPath, "afterError"));
             } catch (Exception exception) {
-                log.error("Error invoking content method: " + methodName, exception);
+                FtpUtil.createError("Error invoking content method: " + methodName + " - " + exception.getMessage(),
+                        exception, FtpConstants.FTP_ERROR).printStackTrace();
                 // Method threw an exception - execute afterError action
                 afterError.ifPresent(action -> executePostProcessAction(action, fileInfo, callerObject,
                         listenerPath, "afterError"));
@@ -405,7 +409,8 @@ private void executePostProcessAction(PostProcessAction action, FileInfo fileInf
                 executeMoveAction(callerObject, filePath, listenerPath, action, actionContext);
             }
         } catch (Exception e) {
-            log.error("Failed to execute {} action on file: {}", actionContext, filePath, e);
+            FtpUtil.createError("Failed to execute " + actionContext + " action on file: " + filePath +
+                    " - " + e.getMessage(), e, FtpConstants.FTP_ERROR).printStackTrace();
         }
     }
 
@@ -417,13 +422,13 @@ private void executeDeleteAction(BObject callerObject, String filePath, String a
                     StringUtils.fromString(filePath));
 
             if (result instanceof BError) {
-                log.error("Failed to delete file during {}: {} - {}", actionContext, filePath,
-                        ((BError) result).getErrorMessage());
+                ((BError) result).printStackTrace();
             } else {
                 log.debug("Successfully deleted file during {}: {}", actionContext, filePath);
             }
         } catch (Exception e) {
-            log.error("Exception during delete action ({}): {}", actionContext, filePath, e);
+            FtpUtil.createError("Exception during delete action (" + actionContext + "): " + filePath +
+                    " - " + e.getMessage(), e, FtpConstants.FTP_ERROR).printStackTrace();
         }
     }
 
@@ -438,13 +443,13 @@ private void executeMoveAction(BObject callerObject, String filePath, String lis
                     StringUtils.fromString(filePath), StringUtils.fromString(destinationPath));
 
             if (result instanceof BError) {
-                log.error("Failed to move file during {}: {} -> {} - {}", actionContext, filePath,
-                        destinationPath, ((BError) result).getErrorMessage());
+                ((BError) result).printStackTrace();
             } else {
                 log.debug("Successfully moved file during {}: {} -> {}", actionContext, filePath, destinationPath);
             }
         } catch (Exception e) {
-            log.error("Exception during move action ({}): {}", actionContext, filePath, e);
+            FtpUtil.createError("Exception during move action (" + actionContext + "): " + filePath +
+                    " - " + e.getMessage(), e, FtpConstants.FTP_ERROR).printStackTrace();
         }
     }
 
diff --git a/native/src/main/java/io/ballerina/stdlib/ftp/server/FtpListener.java b/native/src/main/java/io/ballerina/stdlib/ftp/server/FtpListener.java
@@ -154,7 +154,8 @@ private void dispatchFileEventToService(Environment env, ServiceContext context,
                 formatMethodHolder = new FormatMethodsHolder(service);
             } catch (FtpInvalidConfigException e) {
                 // This should not happen as validation occurs during attach
-                log.error("Invalid post-process action configuration: {}", e.getMessage());
+                FtpUtil.createError("Invalid post-process action configuration: " + e.getMessage(),
+                        e, FtpConstants.FTP_ERROR).printStackTrace();
                 return;
             }
         }
@@ -170,14 +171,7 @@ private void dispatchFileEventToService(Environment env, ServiceContext context,
         } else {
             // Strategy 3: Fall back to legacy onFileChange handler
             Optional<MethodType> onFileChangeMethodType = getOnFileChangeMethod(service);
-            if (onFileChangeMethodType.isPresent()) {
-                log.debug("Service uses deprecated onFileChange handler for file events.");
-                processMetadataOnlyCallbacks(service, event, onFileChangeMethodType.get(), caller);
-            } else {
-                log.error("Service has no valid handler method. Must have one of: " +
-                        "onFile, onFileText, onFileJson, onFileXml, onFileCsv (format-specific), " +
-                        "onFileDeleted, or onFileChange (deprecated)");
-            }
+            processMetadataOnlyCallbacks(service, event, onFileChangeMethodType.get(), caller);
         }
     }
 
@@ -199,7 +193,8 @@ private void processContentBasedCallbacks(Environment env, BObject service, Remo
                             runtime, fileSystemManager, fileSystemOptions, laxDataBinding, csvFailSafe);
                     contentHandler.processContentCallbacks(env, service, event, holder, caller);
                 } catch (Exception e) {
-                    log.error("Error in content callback processing for added files", e);
+                    FtpUtil.createError("Error in content callback processing for added files: " + e.getMessage(),
+                            e, FtpConstants.FTP_ERROR).printStackTrace();
                 }
             }
         }
@@ -297,11 +292,7 @@ private Object[] getMethodArguments(Parameter[] params, Map<String, Object> watc
             } else if ((params[1].type.isReadOnly() || TypeUtils.getReferredType(params[1].type).getTag() ==
                     RECORD_TYPE_TAG) && TypeUtils.getReferredType(params[0].type).getTag() == OBJECT_TYPE_TAG) {
                 return new Object[] {caller, getWatchEvent(params[1], watchEventParamValues)};
-            } else {
-                log.error("Invalid parameter types in onFileChange method");
             }
-        } else {
-            log.error("Invalid parameter count in onFileChange method");
         }
         return null;
     }
@@ -313,8 +304,6 @@ private Object[] getOnFileDeleteMethodArguments(Parameter[] params, BString dele
         } else if (params.length == 2) {
             // deletedFile and caller parameters
             return new Object[] {deletedFile, caller};
-        } else {
-            log.error("Invalid parameter count in onFileDelete method");
         }
         return null;
     }
@@ -326,8 +315,6 @@ private Object[] getOnFileDeletedMethodArguments(Parameter[] params, BArray dele
         } else if (params.length == 2) {
             // deletedFiles and caller parameters
             return new Object[] {deletedFiles, caller};
-        } else {
-            log.error("Invalid parameter count in onFileDeleted method");
         }
         return null;
     }
diff --git a/native/src/main/java/io/ballerina/stdlib/ftp/util/FtpContentConverter.java b/native/src/main/java/io/ballerina/stdlib/ftp/util/FtpContentConverter.java
@@ -93,13 +93,11 @@ public static Object convertBytesToJson(byte[] content, Type targetType, boolean
 
             Object result = io.ballerina.lib.data.jsondata.json.Native.parseBytes(byteArray, options, typedesc);
             if (result instanceof BError bError) {
-                log.error("Failed to parse JSON content: {}", bError.getMessage());
                 return FtpUtil.createContentBindingError(bError.getErrorMessage().getValue(), bError, filePath, 
                 content);
             }
             return result;
         } catch (Exception e) {
-            log.error("Error converting bytes to JSON", e);
             return FtpUtil.createContentBindingError("Failed to parse JSON content: " + e.getMessage(), e,
                     filePath, content);
         }
@@ -157,14 +155,12 @@ public static Object convertBytesToCsv(Environment env, byte[] content, Type tar
             Object result = parseBytes(env, byteArray, options, typedesc);
 
             if (result instanceof BError bError) {
-                log.error("Failed to parse CSV content: {}", bError.getMessage());
                 return FtpUtil.createContentBindingError("Failed to parse CSV content: " + bError.getErrorMessage(),
                         bError, filePath, content);
             }
 
             return result;
         } catch (Exception e) {
-            log.error("Error converting bytes to CSV", e);
             return FtpUtil.createContentBindingError("Failed to parse CSV content: " + e.getMessage(), e,
                     filePath, content);
         }
diff --git a/native/src/main/java/io/ballerina/stdlib/ftp/util/FtpUtil.java b/native/src/main/java/io/ballerina/stdlib/ftp/util/FtpUtil.java
@@ -458,7 +458,6 @@ public static Throwable findRootCause(Throwable throwable) {
      */
     public static int extractPortValue(long longValue) {
         if (longValue <= 0 || longValue > MAX_PORT) {
-            log.error("Invalid port number given in configuration");
             return -1;
         }
         try {

Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,6 @@ static boolean executeGetAction(RemoteFileSystemBaseMessage remoteFileSystemBase`
`99`	`99`	`balFuture.complete(streamEntry);`
`100`	`100`	`}`
`101`	`101`	`} catch (IOException e) {`
`102`		`- log.error("{}", FtpConstants.ERR_READING_STREAM, e);`
`103`	`102`	`balFuture.complete(FtpUtil.createError(FtpConstants.ERR_READING_STREAM, e, FTP_ERROR));`
`104`	`103`	`}`
`105`	`104`	`return true;`
`@@ -130,7 +129,6 @@ private static Object createStreamWithContent(InputStream content, Type streamVa`
`130`	`129`	`return ContentCsvStreamIteratorUtils.createRecordStream(content, streamValueType,`
`131`	`130`	`laxDataBinding, null);`
`132`	`131`	`} catch (Exception e) {`
`133`		`- log.error("Failed to create stream with content", e);`
`134`	`132`	`return FtpUtil.createError(FtpConstants.ERR_CREATE_STREAM, e, FTP_ERROR);`
`135`	`133`	`}`
`136`	`134`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,6 @@ public boolean onMessage(RemoteFileSystemBaseMessage remoteFileSystemBaseMessage`
`54`	`54`
`55`	`55`	`@Override`
`56`	`56`	`public void onError(Throwable throwable) {`
`57`		`- log.error(throwable.getMessage(), throwable);`
`58`	`57`	`String errorType = FtpUtil.getErrorTypeForException(throwable);`
`59`	`58`	`balFuture.complete(FtpUtil.createError(throwable.getMessage(), throwable.getCause(), errorType));`
`60`	`59`	`}`
Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,6 @@ public void processContentCallbacks(Environment env, BObject service, RemoteFile`
`121`	`121`
`122`	`122`	`// Check if content conversion returned an error (ContentBindingError)`
`123`	`123`	`if (convertedContent instanceof BError bError) {`
`124`		`- log.error("Content binding failed for file: {}", fileInfo.getPath());`
`125`	`124`	`routeToOnError(service, holder, bError, callerObject, fileInfo, listenerPath);`
`126`	`125`	`continue;`
`127`	`126`	`}`
`@@ -139,7 +138,8 @@ public void processContentCallbacks(Environment env, BObject service, RemoteFile`
`139`	`138`	`fileInfo, callerObject, listenerPath, afterProcess, afterError);`
`140`	`139`
`141`	`140`	`} catch (Exception exception) {`
`142`		`- log.error("Failed to process file: " + fileInfo.getPath(), exception);`
	`141`	`+ FtpUtil.createError("Failed to process file: " + fileInfo.getPath() + " - " + exception.getMessage(),`
	`142`	`+ exception, FtpConstants.FTP_ERROR).printStackTrace();`
`143`	`143`	`// Continue processing other files even if one fails`
`144`	`144`	`}`
`145`	`145`	`}`
`@@ -276,11 +276,13 @@ private void routeToOnError(BObject service, FormatMethodsHolder holder, BError`
`276`	`276`	`FileInfo fileInfo, String listenerPath) {`
`277`	`277`	`if (!holder.hasOnErrorMethod()) {`
`278`	`278`	`// No onError handler, error is already logged`
	`279`	`+ error.printStackTrace();`
`279`	`280`	`return;`
`280`	`281`	`}`
`281`	`282`
`282`	`283`	`Optional<MethodType> onErrorMethodOpt = holder.getOnErrorMethod();`
`283`	`284`	`if (onErrorMethodOpt.isEmpty()) {`
	`285`	`+ error.printStackTrace();`
`284`	`286`	`return;`
`285`	`287`	`}`
`286`	`288`
`@@ -332,7 +334,8 @@ private void invokeOnErrorMethodAsync(BObject service, String methodName, Object`
`332`	`334`	`} catch (BError error) {`
`333`	`335`	`error.printStackTrace();`
`334`	`336`	`} catch (Exception exception) {`
`335`		`- log.error("Error invoking onError method: " + methodName, exception);`
	`337`	`+ FtpUtil.createError("Error invoking onError method: " + methodName + " - " + exception.getMessage(),`
	`338`	`+ exception, FtpConstants.FTP_ERROR).printStackTrace();`
`336`	`339`	`}`
`337`	`340`
`338`	`341`	`if (isSuccess) {`
`@@ -372,7 +375,8 @@ private void invokeContentMethodAsync(BObject service, String methodName, Object`
`372`	`375`	`afterError.ifPresent(action -> executePostProcessAction(action, fileInfo, callerObject,`
`373`	`376`	`listenerPath, "afterError"));`
`374`	`377`	`} catch (Exception exception) {`
`375`		`- log.error("Error invoking content method: " + methodName, exception);`
	`378`	`+ FtpUtil.createError("Error invoking content method: " + methodName + " - " + exception.getMessage(),`
	`379`	`+ exception, FtpConstants.FTP_ERROR).printStackTrace();`
`376`	`380`	`// Method threw an exception - execute afterError action`
`377`	`381`	`afterError.ifPresent(action -> executePostProcessAction(action, fileInfo, callerObject,`
`378`	`382`	`listenerPath, "afterError"));`
`@@ -405,7 +409,8 @@ private void executePostProcessAction(PostProcessAction action, FileInfo fileInf`
`405`	`409`	`executeMoveAction(callerObject, filePath, listenerPath, action, actionContext);`
`406`	`410`	`}`
`407`	`411`	`} catch (Exception e) {`
`408`		`- log.error("Failed to execute {} action on file: {}", actionContext, filePath, e);`
	`412`	`+ FtpUtil.createError("Failed to execute " + actionContext + " action on file: " + filePath +`
	`413`	`+ " - " + e.getMessage(), e, FtpConstants.FTP_ERROR).printStackTrace();`
`409`	`414`	`}`
`410`	`415`	`}`
`411`	`416`
`@@ -417,13 +422,13 @@ private void executeDeleteAction(BObject callerObject, String filePath, String a`
`417`	`422`	`StringUtils.fromString(filePath));`
`418`	`423`
`419`	`424`	`if (result instanceof BError) {`
`420`		`- log.error("Failed to delete file during {}: {} - {}", actionContext, filePath,`
`421`		`- ((BError) result).getErrorMessage());`
	`425`	`+ ((BError) result).printStackTrace();`
`422`	`426`	`} else {`
`423`	`427`	`log.debug("Successfully deleted file during {}: {}", actionContext, filePath);`
`424`	`428`	`}`
`425`	`429`	`} catch (Exception e) {`
`426`		`- log.error("Exception during delete action ({}): {}", actionContext, filePath, e);`
	`430`	`+ FtpUtil.createError("Exception during delete action (" + actionContext + "): " + filePath +`
	`431`	`+ " - " + e.getMessage(), e, FtpConstants.FTP_ERROR).printStackTrace();`
`427`	`432`	`}`
`428`	`433`	`}`
`429`	`434`
`@@ -438,13 +443,13 @@ private void executeMoveAction(BObject callerObject, String filePath, String lis`
`438`	`443`	`StringUtils.fromString(filePath), StringUtils.fromString(destinationPath));`
`439`	`444`
`440`	`445`	`if (result instanceof BError) {`
`441`		`- log.error("Failed to move file during {}: {} -> {} - {}", actionContext, filePath,`
`442`		`- destinationPath, ((BError) result).getErrorMessage());`
	`446`	`+ ((BError) result).printStackTrace();`
`443`	`447`	`} else {`
`444`	`448`	`log.debug("Successfully moved file during {}: {} -> {}", actionContext, filePath, destinationPath);`
`445`	`449`	`}`
`446`	`450`	`} catch (Exception e) {`
`447`		`- log.error("Exception during move action ({}): {}", actionContext, filePath, e);`
	`451`	`+ FtpUtil.createError("Exception during move action (" + actionContext + "): " + filePath +`
	`452`	`+ " - " + e.getMessage(), e, FtpConstants.FTP_ERROR).printStackTrace();`
`448`	`453`	`}`
`449`	`454`	`}`
`450`	`455`
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,8 @@ private void dispatchFileEventToService(Environment env, ServiceContext context,`
`154`	`154`	`formatMethodHolder = new FormatMethodsHolder(service);`
`155`	`155`	`} catch (FtpInvalidConfigException e) {`
`156`	`156`	`// This should not happen as validation occurs during attach`
`157`		`- log.error("Invalid post-process action configuration: {}", e.getMessage());`
	`157`	`+ FtpUtil.createError("Invalid post-process action configuration: " + e.getMessage(),`
	`158`	`+ e, FtpConstants.FTP_ERROR).printStackTrace();`
`158`	`159`	`return;`
`159`	`160`	`}`
`160`	`161`	`}`
`@@ -170,14 +171,7 @@ private void dispatchFileEventToService(Environment env, ServiceContext context,`
`170`	`171`	`} else {`
`171`	`172`	`// Strategy 3: Fall back to legacy onFileChange handler`
`172`	`173`	`Optional<MethodType> onFileChangeMethodType = getOnFileChangeMethod(service);`
`173`		`- if (onFileChangeMethodType.isPresent()) {`
`174`		`- log.debug("Service uses deprecated onFileChange handler for file events.");`
`175`		`- processMetadataOnlyCallbacks(service, event, onFileChangeMethodType.get(), caller);`
`176`		`- } else {`
`177`		`- log.error("Service has no valid handler method. Must have one of: " +`
`178`		`- "onFile, onFileText, onFileJson, onFileXml, onFileCsv (format-specific), " +`
`179`		`- "onFileDeleted, or onFileChange (deprecated)");`
`180`		`- }`
	`174`	`+ processMetadataOnlyCallbacks(service, event, onFileChangeMethodType.get(), caller);`
`181`	`175`	`}`
`182`	`176`	`}`
`183`	`177`
`@@ -199,7 +193,8 @@ private void processContentBasedCallbacks(Environment env, BObject service, Remo`
`199`	`193`	`runtime, fileSystemManager, fileSystemOptions, laxDataBinding, csvFailSafe);`
`200`	`194`	`contentHandler.processContentCallbacks(env, service, event, holder, caller);`
`201`	`195`	`} catch (Exception e) {`
`202`		`- log.error("Error in content callback processing for added files", e);`
	`196`	`+ FtpUtil.createError("Error in content callback processing for added files: " + e.getMessage(),`
	`197`	`+ e, FtpConstants.FTP_ERROR).printStackTrace();`
`203`	`198`	`}`
`204`	`199`	`}`
`205`	`200`	`}`
`@@ -297,11 +292,7 @@ private Object[] getMethodArguments(Parameter[] params, Map<String, Object> watc`
`297`	`292`	`} else if ((params[1].type.isReadOnly() \|\| TypeUtils.getReferredType(params[1].type).getTag() ==`
`298`	`293`	`RECORD_TYPE_TAG) && TypeUtils.getReferredType(params[0].type).getTag() == OBJECT_TYPE_TAG) {`
`299`	`294`	`return new Object[] {caller, getWatchEvent(params[1], watchEventParamValues)};`
`300`		`- } else {`
`301`		`- log.error("Invalid parameter types in onFileChange method");`
`302`	`295`	`}`
`303`		`- } else {`
`304`		`- log.error("Invalid parameter count in onFileChange method");`
`305`	`296`	`}`
`306`	`297`	`return null;`
`307`	`298`	`}`
`@@ -313,8 +304,6 @@ private Object[] getOnFileDeleteMethodArguments(Parameter[] params, BString dele`
`313`	`304`	`} else if (params.length == 2) {`
`314`	`305`	`// deletedFile and caller parameters`
`315`	`306`	`return new Object[] {deletedFile, caller};`
`316`		`- } else {`
`317`		`- log.error("Invalid parameter count in onFileDelete method");`
`318`	`307`	`}`
`319`	`308`	`return null;`
`320`	`309`	`}`
`@@ -326,8 +315,6 @@ private Object[] getOnFileDeletedMethodArguments(Parameter[] params, BArray dele`
`326`	`315`	`} else if (params.length == 2) {`
`327`	`316`	`// deletedFiles and caller parameters`
`328`	`317`	`return new Object[] {deletedFiles, caller};`
`329`		`- } else {`
`330`		`- log.error("Invalid parameter count in onFileDeleted method");`
`331`	`318`	`}`
`332`	`319`	`return null;`
`333`	`320`	`}`
Original file line number	Diff line number	Diff line change
`@@ -458,7 +458,6 @@ public static Throwable findRootCause(Throwable throwable) {`
`458`	`458`	`*/`
`459`	`459`	`public static int extractPortValue(long longValue) {`
`460`	`460`	`if (longValue <= 0 \|\| longValue > MAX_PORT) {`
`461`		`- log.error("Invalid port number given in configuration");`
`462`	`461`	`return -1;`
`463`	`462`	`}`
`464`	`463`	`try {`