Improve logging performance (#649)

valfirst · web-flow · commit 5b15c4618e4d · 2023-02-02T19:22:43.000-05:00
diff --git a/src/main/java/com/networknt/schema/AdditionalPropertiesValidator.java b/src/main/java/com/networknt/schema/AdditionalPropertiesValidator.java
@@ -77,7 +77,7 @@ private void addToEvaluatedProperties(String propertyPath) {
     }
 
     public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String at) {
-        if (logger.isDebugEnabled()) debug(logger, node, rootNode, at);
+        debug(logger, node, rootNode, at);
 
         Set<ValidationMessage> errors = new LinkedHashSet<ValidationMessage>();
         if (!node.isObject()) {
diff --git a/src/main/java/com/networknt/schema/BaseJsonValidator.java b/src/main/java/com/networknt/schema/BaseJsonValidator.java
@@ -151,9 +151,7 @@ protected ValidationMessage buildValidationMessage(String at, String... argument
     }
 
     protected void debug(Logger logger, JsonNode node, JsonNode rootNode, String at) {
-        if (logger.isDebugEnabled()) {
-            logger.debug("validate( " + node + ", " + rootNode + ", " + at + ")");
-        }
+        logger.debug("validate( {}, {}, {})", node, rootNode, at);
     }
 
     protected ValidatorTypeCode getValidatorType() {
diff --git a/src/main/java/com/networknt/schema/DateTimeValidator.java b/src/main/java/com/networknt/schema/DateTimeValidator.java
@@ -79,7 +79,7 @@ private boolean tryParse(Runnable parser) {
             parser.run();
             return true;
         } catch (Exception ex) {
-            logger.error("Invalid " + formatName + ": " + ex.getMessage());
+            logger.error("Invalid {}: {}", formatName, ex.getMessage());
             return false;
         }
     }
diff --git a/src/main/java/com/networknt/schema/FormatValidator.java b/src/main/java/com/networknt/schema/FormatValidator.java
@@ -63,7 +63,7 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String
                 }
             } catch (PatternSyntaxException pse) {
                 // String is considered valid if pattern is invalid
-                logger.error("Failed to apply pattern on " + at + ": Invalid RE syntax [" + format.getName() + "]", pse);
+                logger.error("Failed to apply pattern on {}: Invalid RE syntax [{}]", at, format.getName(), pse);
             }
         }
 
diff --git a/src/main/java/com/networknt/schema/JsonMetaSchema.java b/src/main/java/com/networknt/schema/JsonMetaSchema.java
@@ -278,7 +278,7 @@ public JsonValidator newValidator(ValidationContext validationContext, String sc
             Keyword kw = keywords.get(keyword);
             if (kw == null) {
                 if (UNKNOWN_KEYWORDS.put(keyword, keyword) == null) {
-                    logger.warn("Unknown keyword " + keyword + " - you should define your own Meta Schema. If the keyword is irrelevant for validation, just use a NonValidationKeyword");
+                    logger.warn("Unknown keyword {} - you should define your own Meta Schema. If the keyword is irrelevant for validation, just use a NonValidationKeyword", keyword);
                 }
                 return null;
             }
@@ -289,13 +289,13 @@ public JsonValidator newValidator(ValidationContext validationContext, String sc
                 logger.error("Error:", e);
                 throw (JsonSchemaException) e.getTargetException();
             } else {
-                logger.warn("Could not load validator " + keyword);
+                logger.warn("Could not load validator {}", keyword);
                 throw new JsonSchemaException(e.getTargetException());
             }
         } catch (JsonSchemaException e) {
             throw e;
         } catch (Exception e) {
-            logger.warn("Could not load validator " + keyword);
+            logger.warn("Could not load validator {}", keyword);
             throw new JsonSchemaException(e);
         }
     }
diff --git a/src/main/java/com/networknt/schema/JsonSchemaFactory.java b/src/main/java/com/networknt/schema/JsonSchemaFactory.java
@@ -424,9 +424,7 @@ private boolean idMatchesSourceUri(final JsonMetaSchema metaSchema, final JsonNo
             return false;
         }
         boolean result = id.equals(schemaUri.toString());
-        if (logger.isDebugEnabled()) {
-            logger.debug("Matching " + id + " to " + schemaUri.toString() + ": " + result);
-        }
+        logger.debug("Matching {} to {}: {}", id, schemaUri, result);
         return result;
     }
 
diff --git a/src/main/java/com/networknt/schema/PatternValidator.java b/src/main/java/com/networknt/schema/PatternValidator.java
@@ -75,7 +75,7 @@ public PatternValidatorJava(String schemaPath, JsonNode schemaNode, JsonSchema p
                 try {
                     compiledPattern = Pattern.compile(pattern);
                 } catch (PatternSyntaxException pse) {
-                    logger.error("Failed to compile pattern : Invalid syntax [" + pattern + "]", pse);
+                    logger.error("Failed to compile pattern : Invalid syntax [{}]", pattern, pse);
                     throw pse;
                 }
             }
@@ -100,7 +100,7 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String
                     return Collections.singleton(buildValidationMessage(at, pattern));
                 }
             } catch (PatternSyntaxException pse) {
-                logger.error("Failed to apply pattern on " + at + ": Invalid syntax [" + pattern + "]", pse);
+                logger.error("Failed to apply pattern on {}: Invalid syntax [{}]", at, pattern, pse);
             }
 
             return Collections.emptySet();
@@ -121,7 +121,7 @@ public PatternValidatorEcma262(String schemaPath, JsonNode schemaNode, JsonSchem
                 try {
                     compileRegexPattern(pattern, validationContext.getConfig() != null && validationContext.getConfig().isEcma262Validator());
                 } catch (SyntaxException se) {
-                    logger.error("Failed to compile pattern : Invalid syntax [" + pattern + "]", se);
+                    logger.error("Failed to compile pattern : Invalid syntax [{}]", pattern, se);
                     throw se;
                 }
             }
@@ -156,7 +156,7 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String
                     return Collections.singleton(buildValidationMessage(at, pattern));
                 }
             } catch (PatternSyntaxException pse) {
-                logger.error("Failed to apply pattern on " + at + ": Invalid syntax [" + pattern + "]", pse);
+                logger.error("Failed to apply pattern on {}: Invalid syntax [{}]", at, pattern, pse);
             }
 
             return Collections.emptySet();

Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ private void addToEvaluatedProperties(String propertyPath) {`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String at) {`
`80`		`- if (logger.isDebugEnabled()) debug(logger, node, rootNode, at);`
	`80`	`+ debug(logger, node, rootNode, at);`
`81`	`81`
`82`	`82`	`Set<ValidationMessage> errors = new LinkedHashSet<ValidationMessage>();`
`83`	`83`	`if (!node.isObject()) {`
Original file line number	Diff line number	Diff line change
`@@ -151,9 +151,7 @@ protected ValidationMessage buildValidationMessage(String at, String... argument`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`protected void debug(Logger logger, JsonNode node, JsonNode rootNode, String at) {`
`154`		`- if (logger.isDebugEnabled()) {`
`155`		`- logger.debug("validate( " + node + ", " + rootNode + ", " + at + ")");`
`156`		`- }`
	`154`	`+ logger.debug("validate( {}, {}, {})", node, rootNode, at);`
`157`	`155`	`}`
`158`	`156`
`159`	`157`	`protected ValidatorTypeCode getValidatorType() {`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ private boolean tryParse(Runnable parser) {`
`79`	`79`	`parser.run();`
`80`	`80`	`return true;`
`81`	`81`	`} catch (Exception ex) {`
`82`		`- logger.error("Invalid " + formatName + ": " + ex.getMessage());`
	`82`	`+ logger.error("Invalid {}: {}", formatName, ex.getMessage());`
`83`	`83`	`return false;`
`84`	`84`	`}`
`85`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String`
`63`	`63`	`}`
`64`	`64`	`} catch (PatternSyntaxException pse) {`
`65`	`65`	`// String is considered valid if pattern is invalid`
`66`		`- logger.error("Failed to apply pattern on " + at + ": Invalid RE syntax [" + format.getName() + "]", pse);`
	`66`	`+ logger.error("Failed to apply pattern on {}: Invalid RE syntax [{}]", at, format.getName(), pse);`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
Original file line number	Diff line number	Diff line change
`@@ -278,7 +278,7 @@ public JsonValidator newValidator(ValidationContext validationContext, String sc`
`278`	`278`	`Keyword kw = keywords.get(keyword);`
`279`	`279`	`if (kw == null) {`
`280`	`280`	`if (UNKNOWN_KEYWORDS.put(keyword, keyword) == null) {`
`281`		`- logger.warn("Unknown keyword " + keyword + " - you should define your own Meta Schema. If the keyword is irrelevant for validation, just use a NonValidationKeyword");`
	`281`	`+ logger.warn("Unknown keyword {} - you should define your own Meta Schema. If the keyword is irrelevant for validation, just use a NonValidationKeyword", keyword);`
`282`	`282`	`}`
`283`	`283`	`return null;`
`284`	`284`	`}`
`@@ -289,13 +289,13 @@ public JsonValidator newValidator(ValidationContext validationContext, String sc`
`289`	`289`	`logger.error("Error:", e);`
`290`	`290`	`throw (JsonSchemaException) e.getTargetException();`
`291`	`291`	`} else {`
`292`		`- logger.warn("Could not load validator " + keyword);`
	`292`	`+ logger.warn("Could not load validator {}", keyword);`
`293`	`293`	`throw new JsonSchemaException(e.getTargetException());`
`294`	`294`	`}`
`295`	`295`	`} catch (JsonSchemaException e) {`
`296`	`296`	`throw e;`
`297`	`297`	`} catch (Exception e) {`
`298`		`- logger.warn("Could not load validator " + keyword);`
	`298`	`+ logger.warn("Could not load validator {}", keyword);`
`299`	`299`	`throw new JsonSchemaException(e);`
`300`	`300`	`}`
`301`	`301`	`}`
Original file line number	Diff line number	Diff line change
`@@ -424,9 +424,7 @@ private boolean idMatchesSourceUri(final JsonMetaSchema metaSchema, final JsonNo`
`424`	`424`	`return false;`
`425`	`425`	`}`
`426`	`426`	`boolean result = id.equals(schemaUri.toString());`
`427`		`- if (logger.isDebugEnabled()) {`
`428`		`- logger.debug("Matching " + id + " to " + schemaUri.toString() + ": " + result);`
`429`		`- }`
	`427`	`+ logger.debug("Matching {} to {}: {}", id, schemaUri, result);`
`430`	`428`	`return result;`
`431`	`429`	`}`
`432`	`430`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ public PatternValidatorJava(String schemaPath, JsonNode schemaNode, JsonSchema p`
`75`	`75`	`try {`
`76`	`76`	`compiledPattern = Pattern.compile(pattern);`
`77`	`77`	`} catch (PatternSyntaxException pse) {`
`78`		`- logger.error("Failed to compile pattern : Invalid syntax [" + pattern + "]", pse);`
	`78`	`+ logger.error("Failed to compile pattern : Invalid syntax [{}]", pattern, pse);`
`79`	`79`	`throw pse;`
`80`	`80`	`}`
`81`	`81`	`}`
`@@ -100,7 +100,7 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String`
`100`	`100`	`return Collections.singleton(buildValidationMessage(at, pattern));`
`101`	`101`	`}`
`102`	`102`	`} catch (PatternSyntaxException pse) {`
`103`		`- logger.error("Failed to apply pattern on " + at + ": Invalid syntax [" + pattern + "]", pse);`
	`103`	`+ logger.error("Failed to apply pattern on {}: Invalid syntax [{}]", at, pattern, pse);`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`return Collections.emptySet();`
`@@ -121,7 +121,7 @@ public PatternValidatorEcma262(String schemaPath, JsonNode schemaNode, JsonSchem`
`121`	`121`	`try {`
`122`	`122`	`compileRegexPattern(pattern, validationContext.getConfig() != null && validationContext.getConfig().isEcma262Validator());`
`123`	`123`	`} catch (SyntaxException se) {`
`124`		`- logger.error("Failed to compile pattern : Invalid syntax [" + pattern + "]", se);`
	`124`	`+ logger.error("Failed to compile pattern : Invalid syntax [{}]", pattern, se);`
`125`	`125`	`throw se;`
`126`	`126`	`}`
`127`	`127`	`}`
`@@ -156,7 +156,7 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String`
`156`	`156`	`return Collections.singleton(buildValidationMessage(at, pattern));`
`157`	`157`	`}`
`158`	`158`	`} catch (PatternSyntaxException pse) {`
`159`		`- logger.error("Failed to apply pattern on " + at + ": Invalid syntax [" + pattern + "]", pse);`
	`159`	`+ logger.error("Failed to apply pattern on {}: Invalid syntax [{}]", at, pattern, pse);`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`return Collections.emptySet();`