5608: Include top stack trace frames in errors and exceptions rules

Author: aymane-harmaz

core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/exceptions/ErrorRule.java

@@ -110,10 +110,14 @@ public class ErrorRule extends AbstractRule {
 			IQuantity.class);
 	public static final TypedResult<IQuantity> EXCLUDED_ERRORS = new TypedResult<>("excludedErrors", "Excluded Errors", //$NON-NLS-1$
 			"The number of errors excluded from the rule evaluation.", UnitLookup.NUMBER, IQuantity.class);
+	public static final TypedResult<String> MOST_COMMON_ERROR_STACKTRACE = new TypedResult<>(
+			"mostCommonErrorStacktrace", //$NON-NLS-1$
+			"Most Common Error Stacktrace", "The most common error stacktrace frames.", UnitLookup.PLAIN_TEXT,
+			String.class);
 
 	private static final Collection<TypedResult<?>> RESULT_ATTRIBUTES = Arrays.<TypedResult<?>> asList(
 			TypedResult.SCORE, ERROR_COUNT, EXCLUDED_ERRORS, ERROR_RATE, ERROR_WINDOW, MOST_COMMON_ERROR,
-			MOST_COMMON_ERROR_COUNT);
+			MOST_COMMON_ERROR_COUNT, MOST_COMMON_ERROR_STACKTRACE);
 
 	private static final Map<String, EventAvailability> REQUIRED_EVENTS = RequiredEventsBuilder.create()
 			.addEventType(JdkTypeIDs.ERRORS_THROWN, EventAvailability.AVAILABLE).build();
@@ -173,17 +177,24 @@ public int compare(
 			int errorsThrown = errorGrouping.get(errorGrouping.size() - 1).getValue();
 			double score = RulesToolkit.mapExp100(maxErrorsPerMinute.left.doubleValue(), infoLimit, warnLimit);
 			String longMessage = Messages.getString(Messages.ErrorRule_TEXT_WARN_LONG);
-			// FIXME: List some frames of the most common stack trace
 			if (excludedErrors != null && excludedErrors.longValue() > 0) {
 				longMessage += " " + Messages.getString(Messages.ErrorRule_TEXT_WARN_EXCLUDED_INFO); //$NON-NLS-1$
 			}
+			String stackTraceFrames = ""; //$NON-NLS-1$
+			if (mostCommonError != null) {
+				IItemFilter errorTypeFilter = ItemFilters.equals(JdkAttributes.EXCEPTION_THROWNCLASS, mostCommonError);
+				IItemCollection mostCommonErrorItems = errorItems.apply(errorTypeFilter);
+				stackTraceFrames = RulesToolkit.getTopNFramesInMostCommonTrace(mostCommonErrorItems, 10);
+				longMessage += "\n" + Messages.getString(Messages.ErrorRule_TEXT_WARN_MOST_COMMON_STACKTRACE); //$NON-NLS-1$
+			}
 			return ResultBuilder.createFor(this, vp).setSeverity(Severity.get(score))
 					.setSummary(Messages.getString(Messages.ErrorRule_TEXT_WARN)).setExplanation(longMessage)
 					.addResult(TypedResult.SCORE, UnitLookup.NUMBER_UNITY.quantity(score))
 					.addResult(ERROR_COUNT, errorCount).addResult(ERROR_WINDOW, maxErrorsPerMinute.right)
 					.addResult(ERROR_RATE, maxErrorsPerMinute.left).addResult(MOST_COMMON_ERROR, mostCommonError)
 					.addResult(EXCLUDED_ERRORS, excludedErrors).addResult(TypedResult.ITEM_QUERY, JdkQueries.ERRORS)
-					.addResult(MOST_COMMON_ERROR_COUNT, UnitLookup.NUMBER_UNITY.quantity(errorsThrown)).build();
+					.addResult(MOST_COMMON_ERROR_COUNT, UnitLookup.NUMBER_UNITY.quantity(errorsThrown))
+					.addResult(MOST_COMMON_ERROR_STACKTRACE, stackTraceFrames).build();
 		}
 		return ResultBuilder.createFor(this, vp).setSeverity(Severity.OK)
 				.setSummary(Messages.getString(Messages.ErrorRule_TEXT_OK)).build();

core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/exceptions/ExceptionRule.java

@@ -43,7 +43,11 @@
 import java.util.concurrent.FutureTask;
 import java.util.concurrent.RunnableFuture;
 
+import org.openjdk.jmc.common.IMCType;
+import org.openjdk.jmc.common.collection.MapToolkit.IntEntry;
 import org.openjdk.jmc.common.item.IItemCollection;
+import org.openjdk.jmc.common.item.IItemFilter;
+import org.openjdk.jmc.common.item.ItemFilters;
 import org.openjdk.jmc.common.unit.IQuantity;
 import org.openjdk.jmc.common.unit.IRange;
 import org.openjdk.jmc.common.unit.QuantityRange;
@@ -92,9 +96,15 @@ public class ExceptionRule implements IRule {
 	public static final TypedResult<IRange<IQuantity>> EXCEPTION_WINDOW = new TypedResult<>("exceptionsWindow", //$NON-NLS-1$
 			"Exception Window", "The window during which the highest exception rate was detected.",
 			UnitLookup.TIMERANGE);
+	public static final TypedResult<IMCType> MOST_COMMON_EXCEPTION = new TypedResult<>("mostCommonException", //$NON-NLS-1$
+			"Most Common Exception", "The most common exception thrown.", UnitLookup.CLASS, IMCType.class);
+	public static final TypedResult<String> MOST_COMMON_EXCEPTION_STACKTRACE = new TypedResult<>(
+			"mostCommonExceptionStacktrace", "Most Common Exception Stacktrace", //$NON-NLS-1$
+			"The most common exception stacktrace frames.", UnitLookup.PLAIN_TEXT, String.class);
 
-	private static final Collection<TypedResult<?>> RESULT_ATTRIBUTES = Arrays
-			.<TypedResult<?>> asList(TypedResult.SCORE, EXCEPTION_RATE, EXCEPTION_WINDOW);
+	private static final Collection<TypedResult<?>> RESULT_ATTRIBUTES = Arrays.<TypedResult<?>> asList(
+			TypedResult.SCORE, EXCEPTION_RATE, EXCEPTION_WINDOW, MOST_COMMON_EXCEPTION,
+			MOST_COMMON_EXCEPTION_STACKTRACE);
 
 	private IResult getResult(IItemCollection items, IPreferenceValueProvider vp, IResultValueProvider rp) {
 		long infoLimit = vp.getPreferenceValue(EXCEPTIONS_INFO_LIMIT).clampedLongValueIn(NUMBER_UNITY);
@@ -110,9 +120,31 @@ private IResult getResult(IItemCollection items, IPreferenceValueProvider vp, IR
 			IRange<IQuantity> window = QuantityRange.createWithEnd(
 					UnitLookup.EPOCH_NS.quantity(maxExceptionPeriod.start),
 					UnitLookup.EPOCH_NS.quantity(maxExceptionPeriod.end));
-			return ResultBuilder.createFor(this, vp).setSeverity(Severity.get(score))
-					.setSummary(Messages.getString(Messages.ExceptionRule_TEXT_MESSAGE))
-					.setExplanation(Messages.getString(Messages.ExceptionRule_TEXT_INFO_LONG))
+			ResultBuilder resultBuilder = ResultBuilder.createFor(this, vp);
+			String explanation = Messages.getString(Messages.ExceptionRule_TEXT_INFO_LONG);
+			EventAvailability exceptionsThrownEventAvailability = RulesToolkit.getEventAvailability(items,
+					JdkTypeIDs.EXCEPTIONS_THROWN);
+			if (exceptionsThrownEventAvailability == EventAvailability.AVAILABLE) {
+				IItemCollection exceptionItems = items.apply(JdkFilters.EXCEPTIONS);
+				List<IntEntry<IMCType>> exceptionGrouping = RulesToolkit.calculateGroupingScore(exceptionItems,
+						JdkAttributes.EXCEPTION_THROWNCLASS);
+				IMCType mostCommonException = exceptionGrouping.get(exceptionGrouping.size() - 1).getKey();
+				explanation = Messages.getString(Messages.ExceptionRule_TEXT_MOST_COMMON_EXCEPTION) + explanation;
+				resultBuilder.addResult(MOST_COMMON_EXCEPTION, mostCommonException);
+				String stackTraceFrames = ""; //$NON-NLS-1$
+				if (mostCommonException != null) {
+					IItemFilter exceptionTypeFilter = ItemFilters.equals(JdkAttributes.EXCEPTION_THROWNCLASS,
+							mostCommonException);
+					IItemCollection mostCommonExceptionItems = exceptionItems.apply(exceptionTypeFilter);
+					stackTraceFrames = RulesToolkit.getTopNFramesInMostCommonTrace(mostCommonExceptionItems, 10);
+				}
+				explanation = Messages.getString(Messages.ExceptionRule_TEXT_MOST_COMMON_EXCEPTION) + explanation + "\n" //$NON-NLS-1$
+						+ Messages.getString(Messages.ExceptionRule_TEXT_MOST_COMMON_STACKTRACE);
+				resultBuilder.addResult(MOST_COMMON_EXCEPTION, mostCommonException)
+						.addResult(MOST_COMMON_EXCEPTION_STACKTRACE, stackTraceFrames);
+			}
+			return resultBuilder.setSeverity(Severity.get(score))
+					.setSummary(Messages.getString(Messages.ExceptionRule_TEXT_MESSAGE)).setExplanation(explanation)
 					.addResult(TypedResult.SCORE, UnitLookup.NUMBER_UNITY.quantity(score))
 					.addResult(EXCEPTION_RATE, UnitLookup.NUMBER_UNITY.quantity(exPerSec))
 					.addResult(TypedResult.ITEM_QUERY, JdkQueries.THROWABLES_STATISTICS)

core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/messages/internal/Messages.java

@@ -231,12 +231,15 @@ public class Messages {
 	public static final String ErrorRule_TEXT_WARN = "ErrorRule_TEXT_WARN"; //$NON-NLS-1$
 	public static final String ErrorRule_TEXT_WARN_EXCLUDED_INFO = "ErrorRule_TEXT_WARN_EXCLUDED_INFO"; //$NON-NLS-1$
 	public static final String ErrorRule_TEXT_WARN_LONG = "ErrorRule_TEXT_WARN_LONG"; //$NON-NLS-1$
+	public static final String ErrorRule_TEXT_WARN_MOST_COMMON_STACKTRACE = "ErrorRule_TEXT_WARN_MOST_COMMON_STACKTRACE"; //$NON-NLS-1$
 	public static final String ExceptionRule_CONFIG_INFO_LIMIT = "ExceptionRule_CONFIG_INFO_LIMIT"; //$NON-NLS-1$
 	public static final String ExceptionRule_CONFIG_INFO_LIMIT_LONG = "ExceptionRule_CONFIG_INFO_LIMIT_LONG"; //$NON-NLS-1$
 	public static final String ExceptionRule_CONFIG_WARN_LIMIT = "ExceptionRule_CONFIG_WARN_LIMIT"; //$NON-NLS-1$
 	public static final String ExceptionRule_CONFIG_WARN_LIMIT_LONG = "ExceptionRule_CONFIG_WARN_LIMIT_LONG"; //$NON-NLS-1$
 	public static final String ExceptionRule_RULE_NAME = "ExceptionRule_RULE_NAME"; //$NON-NLS-1$
 	public static final String ExceptionRule_TEXT_INFO_LONG = "ExceptionRule_TEXT_INFO_LONG"; //$NON-NLS-1$
+	public static final String ExceptionRule_TEXT_MOST_COMMON_EXCEPTION = "ExceptionRule_TEXT_MOST_COMMON_EXCEPTION"; //$NON-NLS-1$
+	public static final String ExceptionRule_TEXT_MOST_COMMON_STACKTRACE = "ExceptionRule_TEXT_MOST_COMMON_STACKTRACE"; //$NON-NLS-1$
 	public static final String ExceptionRule_TEXT_MESSAGE = "ExceptionRule_TEXT_MESSAGE"; //$NON-NLS-1$
 	public static final String FatalErrorRule_RULE_NAME = "FatalErrorRule_RULE_NAME"; //$NON-NLS-1$
 	public static final String FatalErrorRule_TEXT_OK = "FatalErrorRule_TEXT_OK"; //$NON-NLS-1$

core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/resources/org/openjdk/jmc/flightrecorder/rules/jdk/messages/internal/messages.properties

@@ -232,14 +232,20 @@ ErrorRule_TEXT_WARN=The program generated an average of {errorRate} errors per m
 ErrorRule_TEXT_WARN_LONG={errorCount} errors were thrown in total. The most common error was ''{mostCommonError}'', which was thrown {mostCommonErrorCount} times. Investigate the thrown errors to see if they can be avoided. Errors indicate that something went wrong with the code execution and should never be used for flow control.
 # {error.exclude.regexp} is a regexp exclude string, {excludedErrors} is a number
 ErrorRule_TEXT_WARN_EXCLUDED_INFO=The following regular expression was used to exclude {excludedErrors} errors from this rule: ''{error.exclude.regexp}''.
+# {mostCommonErrorStacktrace} is a string.
+ErrorRule_TEXT_WARN_MOST_COMMON_STACKTRACE=The most common error stackrace was : \n {mostCommonErrorStacktrace}
 ExceptionRule_CONFIG_INFO_LIMIT=Exception rate info limit
 ExceptionRule_CONFIG_INFO_LIMIT_LONG=The number of thrown exceptions per second needed to trigger an info notice
 ExceptionRule_CONFIG_WARN_LIMIT=Exception rate warning limit
 ExceptionRule_CONFIG_WARN_LIMIT_LONG=The number of thrown exceptions per second needed to trigger a warning
 ExceptionRule_RULE_NAME=Thrown Exceptions
+# {mostCommonException} is an exception class name
+ExceptionRule_TEXT_MOST_COMMON_EXCEPTION=The most common exception was ''{mostCommonException}''.
 ExceptionRule_TEXT_INFO_LONG=Throwing exceptions is more expensive than normal code execution, which means that they should only be used for exceptional situations. Investigate the thrown exceptions to see if any of them can be avoided with a non-exceptional control flow.
 # {exceptionsWindow} is a time range, {exceptionsRate} is a number
 ExceptionRule_TEXT_MESSAGE=The program generated {exceptionsRate} exceptions per second during {exceptionsWindow}.
+{mostCommonExceptionStacktrace} is a string.
+ExceptionRule_TEXT_MOST_COMMON_STACKTRACE=The most common exception stacktrace was : \n {mostCommonExceptionStacktrace}
 FatalErrorRule_RULE_NAME=Fatal Errors
 FatalErrorRule_TEXT_OK=The JVM shut down in a normal way.
 FatalErrorRule_TEXT_INFO=The JVM shut down due to there being no remaining non-daemon Java threads.

core/org.openjdk.jmc.flightrecorder.rules/src/main/java/org/openjdk/jmc/flightrecorder/rules/util/RulesToolkit.java

@@ -1440,33 +1440,46 @@ public void run() {
 	}
 
 	/**
-	 * Gets the second frame in the most common stack trace. Useful when showing what called a
+	 * Gets the top n frame in the most common stack trace. Useful when showing what called a
 	 * interesting method, like for example java.lang.Integer.valueOf (aka autoboxing)
 	 *
 	 * @param items
 	 *            the item collection to build the aggregated stack trace on
-	 * @return a stack trace frame
+	 * @return stack trace frames
 	 */
-	// FIXME: Generalize this a bit, get the top N frames
-	public static String getSecondFrameInMostCommonTrace(IItemCollection items) {
+	public static String getTopNFramesInMostCommonTrace(IItemCollection items, int n) {
 		FrameSeparator sep = new FrameSeparator(FrameSeparator.FrameCategorization.LINE, false);
 		StacktraceModel stacktraceModel = new StacktraceModel(false, sep, items);
-		Branch firstBranch = stacktraceModel.getRootFork().getBranch(0);
-		StacktraceFrame secondFrame = null;
-		if (firstBranch.getTailFrames().length > 0) {
-			secondFrame = firstBranch.getTailFrames()[0];
-		} else if (firstBranch.getEndFork().getBranchCount() > 0) {
-			secondFrame = firstBranch.getEndFork().getBranch(0).getFirstFrame();
-		} else {
-			return null;
+		Branch currentBranch = stacktraceModel.getRootFork().getBranch(0);
+		List<StacktraceFrame> frames = new ArrayList<>();
+		while (currentBranch != null && frames.size() < n) {
+			frames.add(currentBranch.getFirstFrame());
+			for (StacktraceFrame tf : currentBranch.getTailFrames()) {
+				if (frames.size() == n)
+					break;
+				frames.add(tf);
+			}
+			if (frames.size() == n)
+				break;
+			if (currentBranch.getEndFork().getBranchCount() > 0) {
+				currentBranch = currentBranch.getEndFork().getBranch(0);
+			} else {
+				break;
+			}
 		}
-		/*
-		 * FIXME: Consider defining the method formatting based on preferences.
-		 *
-		 * Currently it's a compromise between keeping the length short, but still being able to
-		 * identify the actual method, even if the line number is a bit incorrect.
-		 */
-		return StacktraceFormatToolkit.formatFrame(secondFrame.getFrame(), sep, false, false, true, true, true, false);
+		int countToPrint = Math.min(n, frames.size());
+		List<String> formattedFrames = new ArrayList<>(countToPrint);
+		for (int i = 0; i < countToPrint; i++) {
+			/*
+			 * FIXME: Consider defining the method formatting based on preferences.
+			 *
+			 * Currently it's a compromise between keeping the length short, but still being able to
+			 * identify the actual method, even if the line number is a bit incorrect.
+			 */
+			formattedFrames.add(StacktraceFormatToolkit.formatFrame(frames.get(i).getFrame(), sep, false, false, true,
+					true, true, false));
+		}
+		return String.join("\n", formattedFrames);
 	}
 
 	/**

core/tests/org.openjdk.jmc.flightrecorder.rules.jdk.test/src/main/resources/baseline/JfrRuleBaseline.xml

@@ -6289,7 +6289,18 @@ Enabling the following event types would improve the accuracy of this rule: jdk.
             <id>Errors</id>
             <severity>OK</severity>
             <summary>The program generated an average of 17 errors per minute during 9/24/2015 10:08:14.000 AM – 10:09:14 AM.</summary>
-            <explanation>17 errors were thrown in total. The most common error was ''java.lang.NoSuchMethodError'', which was thrown 13 times. Investigate the thrown errors to see if they can be avoided. Errors indicate that something went wrong with the code execution and should never be used for flow control. The following regular expression was used to exclude 381 errors from this rule: ''(com.sun.el.parser.ELParser\$LookaheadSuccess)''.</explanation>
+            <explanation>17 errors were thrown in total. The most common error was ''java.lang.NoSuchMethodError'', which was thrown 13 times. Investigate the thrown errors to see if they can be avoided. Errors indicate that something went wrong with the code execution and should never be used for flow control. The following regular expression was used to exclude 381 errors from this rule: ''(com.sun.el.parser.ELParser\$LookaheadSuccess)''.
+The most common error stackrace was : 
+ java.lang.Error.&amp;lt;init&amp;gt;(String):71
+java.lang.LinkageError.&amp;lt;init&amp;gt;(String):55
+java.lang.IncompatibleClassChangeError.&amp;lt;init&amp;gt;(String):55
+java.lang.NoSuchMethodError.&amp;lt;init&amp;gt;(String):58
+java.io.ObjectStreamClass.hasStaticInitializer(Class):-1
+java.io.ObjectStreamClass.computeDefaultSUID(Class):1743
+java.io.ObjectStreamClass.access$100(Class):72
+java.io.ObjectStreamClass$1.run():250
+java.io.ObjectStreamClass$1.run():248
+java.security.AccessController.doPrivileged(PrivilegedAction):-1</explanation>
         </rule>
         <rule>
             <id>Exceptions</id>