log error messages in log.error(object,throwable) format and change the position of some log messages

asankasan · asankasan · commit 12504129ddc7 · 2015-08-11T12:44:44.000+05:30
diff --git a/extensions/load-balancer/gce-extension/src/main/java/org/apache/stratos/gce/extension/GCELoadBalancer.java b/extensions/load-balancer/gce-extension/src/main/java/org/apache/stratos/gce/extension/GCELoadBalancer.java
@@ -228,7 +228,6 @@ public boolean configure(Topology topology) throws LoadBalancerExtensionExceptio
             }
         }
         activeClusterIdList.clear();
-
         log.info("Load balancer was configured as given topology");
         return true;
     }
diff --git a/extensions/load-balancer/gce-extension/src/main/java/org/apache/stratos/gce/extension/util/GCEOperations.java b/extensions/load-balancer/gce-extension/src/main/java/org/apache/stratos/gce/extension/util/GCEOperations.java
@@ -103,11 +103,11 @@ private void buildComputeEngineObject() throws IOException, GeneralSecurityExcep
             }
         } catch (GeneralSecurityException e) {
             //Security exception occurred. Cant proceed further
-            log.fatal("Could not authenticate and build compute object");
+            log.error("Could not authenticate and build compute object");
             throw new GeneralSecurityException(e);
         } catch (IOException e) {
             //IO exception occurred. Cant proceed further
-            log.fatal("Could not authenticate and build compute object");
+            log.error("Could not authenticate and build compute object");
             throw new IOException(e);
         }
     }
@@ -132,7 +132,7 @@ public static InstanceList getInstanceList(String zoneName, String filter) {
                 return instanceList;
             }
         } catch (IOException e) {
-            log.warn("Could not get instance list from GCE ", e);
+            log.error("Could not get instance list from GCE ", e);
             return null;
         }
     }
@@ -215,7 +215,7 @@ private static HttpHealthCheckList getHealthCheckList() {
                 return healthCheckList;
             }
         } catch (IOException e) {
-            log.warn("Could not get health check list from GCE", e);
+            log.error("Could not get health check list from GCE", e);
             return null;
         }
     }
@@ -248,11 +248,10 @@ public void createTargetPool(String targetPoolName, String healthCheckName) {
             Operation operation =
                     compute.targetPools().insert(PROJECT_ID, REGION_NAME, targetPool).execute();
             waitForRegionOperationCompletion(operation.getName());
-
+            log.info("Target pool " + targetPoolName + " was created");
         } catch (Exception e) {
-            log.warn("Could not create target pool: " + targetPoolName + " " + e);
+            log.error("Could not create target pool: " + targetPoolName, e);
         }
-        log.info("Target pool " + targetPoolName + " was created");
     }
 
     /**
@@ -265,11 +264,10 @@ public void deleteTargetPool(String targetPoolName) {
         try {
             Operation operation = compute.targetPools().delete(PROJECT_ID, REGION_NAME, targetPoolName).execute();
             waitForRegionOperationCompletion(operation.getName());
-
+            log.info("Target pool: " + targetPoolName + " was deleted");
         } catch (Exception e) {
-            log.warn("Could not delete target pool " + targetPoolName + " " + e);
+            log.error("Could not delete target pool " + targetPoolName, e);
         }
-        log.info("Target pool: " + targetPoolName + " was deleted");
     }
 
     /**
@@ -295,10 +293,10 @@ public void createForwardingRule(String forwardingRuleName, String targetPoolNam
         try {
             Operation operation = compute.forwardingRules().insert(PROJECT_ID, REGION_NAME, forwardingRule).execute();
             waitForRegionOperationCompletion(operation.getName());
+            log.info("Forwarding rule: " + forwardingRuleName + " was created");
         } catch (Exception e) {
-            log.warn("Could not create a forwarding rule " + forwardingRuleName + " " + e);
+            log.error("Could not create a forwarding rule " + forwardingRuleName, e);
         }
-        log.info("Forwarding rule: " + forwardingRuleName + " was created");
     }
 
     /**
@@ -312,10 +310,10 @@ public void deleteForwardingRule(String forwardingRuleName) {
             Operation operation = compute.forwardingRules().
                     delete(PROJECT_ID, REGION_NAME, forwardingRuleName).execute();
             waitForRegionOperationCompletion(operation.getName());
+            log.info("Forwarding rule " + forwardingRuleName + " was deleted");
         } catch (Exception e) {
-            log.warn("Could not delete forwarding rule " + forwardingRuleName + " " + e);
+            log.error("Could not delete forwarding rule " + forwardingRuleName, e);
         }
-        log.info("Forwarding rule " + forwardingRuleName + " was deleted");
     }
 
     /**
@@ -339,7 +337,7 @@ public boolean isTargetPoolExists(String targetPoolName) {
                 }
             }
         } catch (IOException e) {
-            log.warn("Could not check whether the target pool " + targetPoolName + " exists or not " + e);
+            log.error("Could not check whether the target pool " + targetPoolName + " exists or not ", e);
         }
         if (log.isDebugEnabled()) {
             log.debug("Target pool " + targetPoolName + " does not exist");
@@ -365,7 +363,7 @@ public TargetPool getTargetPool(String targetPoolName) {
             }
             return null;
         } catch (IOException e) {
-            log.warn("Could not get target pool " + targetPoolName + " " + e);
+            log.error("Could not get target pool " + targetPoolName, e);
         }
         return null;
     }
@@ -407,11 +405,10 @@ public void removeInstancesFromTargetPool(List<String> instancesIdsList, String
             Operation operation = compute.targetPools().removeInstance(PROJECT_ID, REGION_NAME,
                     targetPoolName, targetPoolsRemoveInstanceRequest).execute();
             waitForRegionOperationCompletion(operation.getName());
-
+            log.info("Instances are removed from target pool: " + targetPoolName);
         } catch (Exception e) {
-            log.warn("Could not remove instances from target pool " + targetPoolName + " " + e);
+            log.error("Could not remove instances from target pool " + targetPoolName, e);
         }
-        log.info("Instances are removed from target pool: " + targetPoolName);
     }
 
     /**
@@ -457,11 +454,10 @@ public void addInstancesToTargetPool(List<String> instancesIdsList, String targe
             Operation operation = compute.targetPools().addInstance(PROJECT_ID, REGION_NAME,
                     targetPoolName, targetPoolsAddInstanceRequest).execute();
             waitForRegionOperationCompletion(operation.getName());
-
+            log.info("Added instances to target pool: " + targetPoolName);
         } catch (Exception e) {
-            log.warn("Could not add instance to target pool" + targetPoolName + " " + e);
+            log.error("Could not add instance to target pool" + targetPoolName, e);
         }
-        log.info("Added instances to target pool: " + targetPoolName);
     }
 
     /**
@@ -484,23 +480,21 @@ public void createHealthCheck(String healthCheckName) {
         try {
             Operation operation = compute.httpHealthChecks().insert(PROJECT_ID, httpHealthCheck).execute();
             waitForGlobalOperationCompletion(operation.getName());
-
+            log.info("Health check " + healthCheckName + " was created");
         } catch (Exception e) {
-            log.error("Could not create health check " + healthCheckName + " " + e);
+            log.error("Could not create health check " + healthCheckName, e);
         }
-        log.info("Health check " + healthCheckName + " was created");
     }
 
     public void deleteHealthCheck(String healthCheckName) {
         log.info("Deleting Health Check: " + healthCheckName);
         try {
             Operation operation = compute.httpHealthChecks().delete(PROJECT_ID, healthCheckName).execute();
             waitForGlobalOperationCompletion(operation.getName());
-
+            log.info("Health check: " + healthCheckName + " was deleted");
         } catch (Exception e) {
-            log.warn("Could not get delete health check " + healthCheckName + " " + e);
+            log.error("Could not get delete health check " + healthCheckName, e);
         }
-        log.info("Health check: " + healthCheckName + " was deleted");
     }
 
     /**
@@ -535,7 +529,7 @@ private void waitForGlobalOperationCompletion(String operationName) throws LoadB
                 timeout += 1000;
             }
         } catch (Exception e) {
-            log.error("Could not wait for global operation completion " + operationName);
+            log.error("Could not wait for global operation completion " + operationName , e);
             throw new LoadBalancerExtensionException(e);
         }
     }
@@ -570,7 +564,7 @@ private void waitForRegionOperationCompletion(String operationName) throws LoadB
                 timeout += 1000;
             }
         } catch (Exception e) {
-            log.error("Could not wait for region operation completion " + operationName);
+            log.error("Could not wait for region operation completion " + operationName , e);
             throw new LoadBalancerExtensionException(e);
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -228,7 +228,6 @@ public boolean configure(Topology topology) throws LoadBalancerExtensionExceptio`
`228`	`228`	`}`
`229`	`229`	`}`
`230`	`230`	`activeClusterIdList.clear();`
`231`		`-`
`232`	`231`	`log.info("Load balancer was configured as given topology");`
`233`	`232`	`return true;`
`234`	`233`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,11 +103,11 @@ private void buildComputeEngineObject() throws IOException, GeneralSecurityExcep`
`103`	`103`	`}`
`104`	`104`	`} catch (GeneralSecurityException e) {`
`105`	`105`	`//Security exception occurred. Cant proceed further`
`106`		`- log.fatal("Could not authenticate and build compute object");`
	`106`	`+ log.error("Could not authenticate and build compute object");`
`107`	`107`	`throw new GeneralSecurityException(e);`
`108`	`108`	`} catch (IOException e) {`
`109`	`109`	`//IO exception occurred. Cant proceed further`
`110`		`- log.fatal("Could not authenticate and build compute object");`
	`110`	`+ log.error("Could not authenticate and build compute object");`
`111`	`111`	`throw new IOException(e);`
`112`	`112`	`}`
`113`	`113`	`}`
`@@ -132,7 +132,7 @@ public static InstanceList getInstanceList(String zoneName, String filter) {`
`132`	`132`	`return instanceList;`
`133`	`133`	`}`
`134`	`134`	`} catch (IOException e) {`
`135`		`- log.warn("Could not get instance list from GCE ", e);`
	`135`	`+ log.error("Could not get instance list from GCE ", e);`
`136`	`136`	`return null;`
`137`	`137`	`}`
`138`	`138`	`}`
`@@ -215,7 +215,7 @@ private static HttpHealthCheckList getHealthCheckList() {`
`215`	`215`	`return healthCheckList;`
`216`	`216`	`}`
`217`	`217`	`} catch (IOException e) {`
`218`		`- log.warn("Could not get health check list from GCE", e);`
	`218`	`+ log.error("Could not get health check list from GCE", e);`
`219`	`219`	`return null;`
`220`	`220`	`}`
`221`	`221`	`}`
`@@ -248,11 +248,10 @@ public void createTargetPool(String targetPoolName, String healthCheckName) {`
`248`	`248`	`Operation operation =`
`249`	`249`	`compute.targetPools().insert(PROJECT_ID, REGION_NAME, targetPool).execute();`
`250`	`250`	`waitForRegionOperationCompletion(operation.getName());`
`251`		`-`
	`251`	`+ log.info("Target pool " + targetPoolName + " was created");`
`252`	`252`	`} catch (Exception e) {`
`253`		`- log.warn("Could not create target pool: " + targetPoolName + " " + e);`
	`253`	`+ log.error("Could not create target pool: " + targetPoolName, e);`
`254`	`254`	`}`
`255`		`- log.info("Target pool " + targetPoolName + " was created");`
`256`	`255`	`}`
`257`	`256`
`258`	`257`	`/**`
`@@ -265,11 +264,10 @@ public void deleteTargetPool(String targetPoolName) {`
`265`	`264`	`try {`
`266`	`265`	`Operation operation = compute.targetPools().delete(PROJECT_ID, REGION_NAME, targetPoolName).execute();`
`267`	`266`	`waitForRegionOperationCompletion(operation.getName());`
`268`		`-`
	`267`	`+ log.info("Target pool: " + targetPoolName + " was deleted");`
`269`	`268`	`} catch (Exception e) {`
`270`		`- log.warn("Could not delete target pool " + targetPoolName + " " + e);`
	`269`	`+ log.error("Could not delete target pool " + targetPoolName, e);`
`271`	`270`	`}`
`272`		`- log.info("Target pool: " + targetPoolName + " was deleted");`
`273`	`271`	`}`
`274`	`272`
`275`	`273`	`/**`
`@@ -295,10 +293,10 @@ public void createForwardingRule(String forwardingRuleName, String targetPoolNam`
`295`	`293`	`try {`
`296`	`294`	`Operation operation = compute.forwardingRules().insert(PROJECT_ID, REGION_NAME, forwardingRule).execute();`
`297`	`295`	`waitForRegionOperationCompletion(operation.getName());`
	`296`	`+ log.info("Forwarding rule: " + forwardingRuleName + " was created");`
`298`	`297`	`} catch (Exception e) {`
`299`		`- log.warn("Could not create a forwarding rule " + forwardingRuleName + " " + e);`
	`298`	`+ log.error("Could not create a forwarding rule " + forwardingRuleName, e);`
`300`	`299`	`}`
`301`		`- log.info("Forwarding rule: " + forwardingRuleName + " was created");`
`302`	`300`	`}`
`303`	`301`
`304`	`302`	`/**`
`@@ -312,10 +310,10 @@ public void deleteForwardingRule(String forwardingRuleName) {`
`312`	`310`	`Operation operation = compute.forwardingRules().`
`313`	`311`	`delete(PROJECT_ID, REGION_NAME, forwardingRuleName).execute();`
`314`	`312`	`waitForRegionOperationCompletion(operation.getName());`
	`313`	`+ log.info("Forwarding rule " + forwardingRuleName + " was deleted");`
`315`	`314`	`} catch (Exception e) {`
`316`		`- log.warn("Could not delete forwarding rule " + forwardingRuleName + " " + e);`
	`315`	`+ log.error("Could not delete forwarding rule " + forwardingRuleName, e);`
`317`	`316`	`}`
`318`		`- log.info("Forwarding rule " + forwardingRuleName + " was deleted");`
`319`	`317`	`}`
`320`	`318`
`321`	`319`	`/**`
`@@ -339,7 +337,7 @@ public boolean isTargetPoolExists(String targetPoolName) {`
`339`	`337`	`}`
`340`	`338`	`}`
`341`	`339`	`} catch (IOException e) {`
`342`		`- log.warn("Could not check whether the target pool " + targetPoolName + " exists or not " + e);`
	`340`	`+ log.error("Could not check whether the target pool " + targetPoolName + " exists or not ", e);`
`343`	`341`	`}`
`344`	`342`	`if (log.isDebugEnabled()) {`
`345`	`343`	`log.debug("Target pool " + targetPoolName + " does not exist");`
`@@ -365,7 +363,7 @@ public TargetPool getTargetPool(String targetPoolName) {`
`365`	`363`	`}`
`366`	`364`	`return null;`
`367`	`365`	`} catch (IOException e) {`
`368`		`- log.warn("Could not get target pool " + targetPoolName + " " + e);`
	`366`	`+ log.error("Could not get target pool " + targetPoolName, e);`
`369`	`367`	`}`
`370`	`368`	`return null;`
`371`	`369`	`}`
`@@ -407,11 +405,10 @@ public void removeInstancesFromTargetPool(List<String> instancesIdsList, String`
`407`	`405`	`Operation operation = compute.targetPools().removeInstance(PROJECT_ID, REGION_NAME,`
`408`	`406`	`targetPoolName, targetPoolsRemoveInstanceRequest).execute();`
`409`	`407`	`waitForRegionOperationCompletion(operation.getName());`
`410`		`-`
	`408`	`+ log.info("Instances are removed from target pool: " + targetPoolName);`
`411`	`409`	`} catch (Exception e) {`
`412`		`- log.warn("Could not remove instances from target pool " + targetPoolName + " " + e);`
	`410`	`+ log.error("Could not remove instances from target pool " + targetPoolName, e);`
`413`	`411`	`}`
`414`		`- log.info("Instances are removed from target pool: " + targetPoolName);`
`415`	`412`	`}`
`416`	`413`
`417`	`414`	`/**`
`@@ -457,11 +454,10 @@ public void addInstancesToTargetPool(List<String> instancesIdsList, String targe`
`457`	`454`	`Operation operation = compute.targetPools().addInstance(PROJECT_ID, REGION_NAME,`
`458`	`455`	`targetPoolName, targetPoolsAddInstanceRequest).execute();`
`459`	`456`	`waitForRegionOperationCompletion(operation.getName());`
`460`		`-`
	`457`	`+ log.info("Added instances to target pool: " + targetPoolName);`
`461`	`458`	`} catch (Exception e) {`
`462`		`- log.warn("Could not add instance to target pool" + targetPoolName + " " + e);`
	`459`	`+ log.error("Could not add instance to target pool" + targetPoolName, e);`
`463`	`460`	`}`
`464`		`- log.info("Added instances to target pool: " + targetPoolName);`
`465`	`461`	`}`
`466`	`462`
`467`	`463`	`/**`
`@@ -484,23 +480,21 @@ public void createHealthCheck(String healthCheckName) {`
`484`	`480`	`try {`
`485`	`481`	`Operation operation = compute.httpHealthChecks().insert(PROJECT_ID, httpHealthCheck).execute();`
`486`	`482`	`waitForGlobalOperationCompletion(operation.getName());`
`487`		`-`
	`483`	`+ log.info("Health check " + healthCheckName + " was created");`
`488`	`484`	`} catch (Exception e) {`
`489`		`- log.error("Could not create health check " + healthCheckName + " " + e);`
	`485`	`+ log.error("Could not create health check " + healthCheckName, e);`
`490`	`486`	`}`
`491`		`- log.info("Health check " + healthCheckName + " was created");`
`492`	`487`	`}`
`493`	`488`
`494`	`489`	`public void deleteHealthCheck(String healthCheckName) {`
`495`	`490`	`log.info("Deleting Health Check: " + healthCheckName);`
`496`	`491`	`try {`
`497`	`492`	`Operation operation = compute.httpHealthChecks().delete(PROJECT_ID, healthCheckName).execute();`
`498`	`493`	`waitForGlobalOperationCompletion(operation.getName());`
`499`		`-`
	`494`	`+ log.info("Health check: " + healthCheckName + " was deleted");`
`500`	`495`	`} catch (Exception e) {`
`501`		`- log.warn("Could not get delete health check " + healthCheckName + " " + e);`
	`496`	`+ log.error("Could not get delete health check " + healthCheckName, e);`
`502`	`497`	`}`
`503`		`- log.info("Health check: " + healthCheckName + " was deleted");`
`504`	`498`	`}`
`505`	`499`
`506`	`500`	`/**`
`@@ -535,7 +529,7 @@ private void waitForGlobalOperationCompletion(String operationName) throws LoadB`
`535`	`529`	`timeout += 1000;`
`536`	`530`	`}`
`537`	`531`	`} catch (Exception e) {`
`538`		`- log.error("Could not wait for global operation completion " + operationName);`
	`532`	`+ log.error("Could not wait for global operation completion " + operationName , e);`
`539`	`533`	`throw new LoadBalancerExtensionException(e);`
`540`	`534`	`}`
`541`	`535`	`}`
`@@ -570,7 +564,7 @@ private void waitForRegionOperationCompletion(String operationName) throws LoadB`
`570`	`564`	`timeout += 1000;`
`571`	`565`	`}`
`572`	`566`	`} catch (Exception e) {`
`573`		`- log.error("Could not wait for region operation completion " + operationName);`
	`567`	`+ log.error("Could not wait for region operation completion " + operationName , e);`
`574`	`568`	`throw new LoadBalancerExtensionException(e);`
`575`	`569`	`}`
`576`	`570`	`}`