Coverage Report

Coverage Report - org.kuali.spring.util.PropertyLogger

Classes in this File

Line Coverage

Branch Coverage

Complexity

PropertyLogger

71%

53/74

42%

11/26

1.792

 package org.kuali.spring.util;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Properties;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class PropertyLogger {
         final Logger logger = LoggerFactory.getLogger(PropertyLogger.class);
 
         // Matches any string containing "password" (case insensitive)
         public static final String DEFAULT_MASK_EXPRESSION = ".*((?i)password).*";
         public static final String DEFAULT_MASKED_VALUE = "******";
         public static final boolean DEFAULT_IS_MASK_PROPERTY_VALUES = true;
         public static final boolean DEFAULT_IS_FLATTEN_PROPERTY_VALUES = false;
         public static final boolean DEFAULT_IS_TRIM_PROPERTY_VALUES = false;
         public static final boolean DEFAULT_IS_LOG_IN_SORTED_ORDER = true;
         // Space
         public static final String DEFAULT_REPLACEMENT_STRING = " ";
         // Carriage return
         public static final String CR = "\r";
         // Line feed
         public static final String LF = "\n";
 
         // If true, log entries from a Properties object sorted by key
         boolean logInSortedOrder = DEFAULT_IS_LOG_IN_SORTED_ORDER;
         // If true, replace \n and \r when logging values
         boolean flattenPropertyValues = DEFAULT_IS_FLATTEN_PROPERTY_VALUES;
         // The value to replace linefeeds with
         String linefeedReplacement = DEFAULT_REPLACEMENT_STRING;
         // The value to replace carriage returns with
         String carriageReturnReplacement = DEFAULT_REPLACEMENT_STRING;
         // If true, call trim() on property values before logging them
         boolean trimPropertyValues = DEFAULT_IS_TRIM_PROPERTY_VALUES;
         // If true, mask values for keys that match any of the maskExpressions
         boolean maskPropertyValues = DEFAULT_IS_MASK_PROPERTY_VALUES;
         // Regular expressions to compare property keys against
         String[] maskExpressions;
         // The value to log in place of the actual value if we need to mask it
         String maskValue = DEFAULT_MASKED_VALUE;
         // Compiled representation of the regular expression
         Pattern[] patterns;
 
         public PropertyLogger() {
                 super();
                 setMaskExpression(DEFAULT_MASK_EXPRESSION);
         }
 
         /**
          * This setter invokes setMaskExpressions() - plural
          * 
          * @param maskExpression
          */
         public void setMaskExpression(String maskExpression) {
                 setMaskExpressions(new String[] { maskExpression });
         }
 
         /**
          * This setter invokes Pattern.compile() for each maskExpression
          * 
          * @param maskExpressions
          */
         public void setMaskExpressions(String[] maskExpressions) {
                 this.maskExpressions = maskExpressions;
                 this.patterns = new Pattern[maskExpressions.length];
                 for (int i = 0; i < patterns.length; i++) {
                         patterns[i] = Pattern.compile(maskExpressions[i]);
                 }
         }
 
         public String getLogEntry(String key, String value) {
                 return key + "=" + getLogValue(key, value);
         }
 
         protected boolean isEmpty(String s) {
                 if (s == null) {
                         return true;
                 }
                 if (s.trim().length() == 0) {
                         return true;
                 }
                 return false;
         }
 
         public String getLogEntry(Properties properties) {
                 if (properties == null || properties.size() == 0) {
                         return "No properties to log";
                 }
                 StringBuilder sb = new StringBuilder();
                 List<String> keys = new ArrayList<String>(properties.stringPropertyNames());
                 if (isLogInSortedOrder()) {
                         Collections.sort(keys);
                 }
                 for (String key : keys) {
                         String value = properties.getProperty(key);
                         sb.append(getLogEntry(key, value) + "\n");
                 }
                 return sb.toString();
         }
 
         protected boolean isMatch(Pattern[] patterns, String key) {
                 for (Pattern pattern : patterns) {
                         Matcher matcher = pattern.matcher(key);
                         if (matcher.matches()) {
                                 return true;
                         }
                 }
                 return false;
         }
 
         public String getLogValue(String key, String value) {
                 if (isFlattenPropertyValues()) {
                         value = value.replace(LF, getLinefeedReplacement());
                         value = value.replace(CR, getCarriageReturnReplacement());
                 }
                 if (isTrimPropertyValues()) {
                         value = value.trim();
                 }
                 if (!isMaskPropertyValues()) {
                         return value;
                 }
                 boolean match = isMatch(getPatterns(), key);
                 if (match) {
                         return getMaskValue();
                 } else {
                         return value;
                 }
         }
 
         public boolean isFlattenPropertyValues() {
                 return flattenPropertyValues;
         }
 
         public void setFlattenPropertyValues(boolean flattenPropertyValues) {
                 this.flattenPropertyValues = flattenPropertyValues;
         }
 
         public boolean isMaskPropertyValues() {
                 return maskPropertyValues;
         }
 
         public void setMaskPropertyValues(boolean maskPropertyValues) {
                 this.maskPropertyValues = maskPropertyValues;
         }
 
         public String getMaskValue() {
                 return maskValue;
         }
 
         public void setMaskValue(String maskValue) {
                 this.maskValue = maskValue;
         }
 
         public String getLinefeedReplacement() {
                 return linefeedReplacement;
         }
 
         public void setLinefeedReplacement(String linefeedReplacement) {
                 this.linefeedReplacement = linefeedReplacement;
         }
 
         public String getCarriageReturnReplacement() {
                 return carriageReturnReplacement;
         }
 
         public void setCarriageReturnReplacement(String carriageReturnReplacement) {
                 this.carriageReturnReplacement = carriageReturnReplacement;
         }
 
         public boolean isTrimPropertyValues() {
                 return trimPropertyValues;
         }
 
         public void setTrimPropertyValues(boolean trimPropertyValues) {
                 this.trimPropertyValues = trimPropertyValues;
         }
 
         public String[] getMaskExpressions() {
                 return maskExpressions;
         }
 
         public Pattern[] getPatterns() {
                 return patterns;
         }
 
         public boolean isLogInSortedOrder() {
                 return logInSortedOrder;
         }
 
         public void setLogInSortedOrder(boolean logInSortedOrder) {
                 this.logInSortedOrder = logInSortedOrder;
         }
 
 }

1		package org.kuali.spring.util;
2
3		import java.util.ArrayList;
4		import java.util.Collections;
5		import java.util.List;
6		import java.util.Properties;
7		import java.util.regex.Matcher;
8		import java.util.regex.Pattern;
9
10		import org.slf4j.Logger;
11		import org.slf4j.LoggerFactory;
12
13		public class PropertyLogger {
14	26	final Logger logger = LoggerFactory.getLogger(PropertyLogger.class);
15
16		// Matches any string containing "password" (case insensitive)
17		public static final String DEFAULT_MASK_EXPRESSION = ".((?i)password).";
18		public static final String DEFAULT_MASKED_VALUE = "******";
19		public static final boolean DEFAULT_IS_MASK_PROPERTY_VALUES = true;
20		public static final boolean DEFAULT_IS_FLATTEN_PROPERTY_VALUES = false;
21		public static final boolean DEFAULT_IS_TRIM_PROPERTY_VALUES = false;
22		public static final boolean DEFAULT_IS_LOG_IN_SORTED_ORDER = true;
23		// Space
24		public static final String DEFAULT_REPLACEMENT_STRING = " ";
25		// Carriage return
26		public static final String CR = "\r";
27		// Line feed
28		public static final String LF = "\n";
29
30		// If true, log entries from a Properties object sorted by key
31	26	boolean logInSortedOrder = DEFAULT_IS_LOG_IN_SORTED_ORDER;
32		// If true, replace \n and \r when logging values
33	26	boolean flattenPropertyValues = DEFAULT_IS_FLATTEN_PROPERTY_VALUES;
34		// The value to replace linefeeds with
35	26	String linefeedReplacement = DEFAULT_REPLACEMENT_STRING;
36		// The value to replace carriage returns with
37	26	String carriageReturnReplacement = DEFAULT_REPLACEMENT_STRING;
38		// If true, call trim() on property values before logging them
39	26	boolean trimPropertyValues = DEFAULT_IS_TRIM_PROPERTY_VALUES;
40		// If true, mask values for keys that match any of the maskExpressions
41	26	boolean maskPropertyValues = DEFAULT_IS_MASK_PROPERTY_VALUES;
42		// Regular expressions to compare property keys against
43		String[] maskExpressions;
44		// The value to log in place of the actual value if we need to mask it
45	26	String maskValue = DEFAULT_MASKED_VALUE;
46		// Compiled representation of the regular expression
47		Pattern[] patterns;
48
49		public PropertyLogger() {
50	26	super();
51	26	setMaskExpression(DEFAULT_MASK_EXPRESSION);
52	26	}
53
54		/**
55		* This setter invokes setMaskExpressions() - plural
56		*
57		* @param maskExpression
58		*/
59		public void setMaskExpression(String maskExpression) {
60	26	setMaskExpressions(new String[] { maskExpression });
61	26	}
62
63		/**
64		* This setter invokes Pattern.compile() for each maskExpression
65		*
66		* @param maskExpressions
67		*/
68		public void setMaskExpressions(String[] maskExpressions) {
69	29	this.maskExpressions = maskExpressions;
70	29	this.patterns = new Pattern[maskExpressions.length];
71	58	for (int i = 0; i < patterns.length; i++) {
72	29	patterns[i] = Pattern.compile(maskExpressions[i]);
73		}
74	29	}
75
76		public String getLogEntry(String key, String value) {
77	0	return key + "=" + getLogValue(key, value);
78		}
79
80		protected boolean isEmpty(String s) {
81	0	if (s == null) {
82	0	return true;
83		}
84	0	if (s.trim().length() == 0) {
85	0	return true;
86		}
87	0	return false;
88		}
89
90		public String getLogEntry(Properties properties) {
91	0	if (properties == null \|\| properties.size() == 0) {
92	0	return "No properties to log";
93		}
94	0	StringBuilder sb = new StringBuilder();
95	0	List<String> keys = new ArrayList<String>(properties.stringPropertyNames());
96	0	if (isLogInSortedOrder()) {
97	0	Collections.sort(keys);
98		}
99	0	for (String key : keys) {
100	0	String value = properties.getProperty(key);
101	0	sb.append(getLogEntry(key, value) + "\n");
102	0	}
103	0	return sb.toString();
104		}
105
106		protected boolean isMatch(Pattern[] patterns, String key) {
107	541	for (Pattern pattern : patterns) {
108	272	Matcher matcher = pattern.matcher(key);
109	272	if (matcher.matches()) {
110	3	return true;
111		}
112		}
113	269	return false;
114		}
115
116		public String getLogValue(String key, String value) {
117	272	if (isFlattenPropertyValues()) {
118	0	value = value.replace(LF, getLinefeedReplacement());
119	0	value = value.replace(CR, getCarriageReturnReplacement());
120		}
121	272	if (isTrimPropertyValues()) {
122	0	value = value.trim();
123		}
124	272	if (!isMaskPropertyValues()) {
125	0	return value;
126		}
127	272	boolean match = isMatch(getPatterns(), key);
128	272	if (match) {
129	3	return getMaskValue();
130		} else {
131	269	return value;
132		}
133		}
134
135		public boolean isFlattenPropertyValues() {
136	275	return flattenPropertyValues;
137		}
138
139		public void setFlattenPropertyValues(boolean flattenPropertyValues) {
140	3	this.flattenPropertyValues = flattenPropertyValues;
141	3	}
142
143		public boolean isMaskPropertyValues() {
144	275	return maskPropertyValues;
145		}
146
147		public void setMaskPropertyValues(boolean maskPropertyValues) {
148	3	this.maskPropertyValues = maskPropertyValues;
149	3	}
150
151		public String getMaskValue() {
152	6	return maskValue;
153		}
154
155		public void setMaskValue(String maskValue) {
156	3	this.maskValue = maskValue;
157	3	}
158
159		public String getLinefeedReplacement() {
160	3	return linefeedReplacement;
161		}
162
163		public void setLinefeedReplacement(String linefeedReplacement) {
164	3	this.linefeedReplacement = linefeedReplacement;
165	3	}
166
167		public String getCarriageReturnReplacement() {
168	3	return carriageReturnReplacement;
169		}
170
171		public void setCarriageReturnReplacement(String carriageReturnReplacement) {
172	3	this.carriageReturnReplacement = carriageReturnReplacement;
173	3	}
174
175		public boolean isTrimPropertyValues() {
176	275	return trimPropertyValues;
177		}
178
179		public void setTrimPropertyValues(boolean trimPropertyValues) {
180	3	this.trimPropertyValues = trimPropertyValues;
181	3	}
182
183		public String[] getMaskExpressions() {
184	3	return maskExpressions;
185		}
186
187		public Pattern[] getPatterns() {
188	272	return patterns;
189		}
190
191		public boolean isLogInSortedOrder() {
192	3	return logInSortedOrder;
193		}
194
195		public void setLogInSortedOrder(boolean logInSortedOrder) {
196	3	this.logInSortedOrder = logInSortedOrder;
197	3	}
198
199		}