JamonPerformanceMonitorInterceptor tracks exceptions as well (consistent with JAMon's other interceptors)

Issue: SPR-12068

build.gradle

@@ -407,7 +407,7 @@ project("spring-aop") {
 		compile("aopalliance:aopalliance:1.0")
 		optional("org.aspectj:aspectjweaver:${aspectjVersion}")
 		optional("commons-pool:commons-pool:1.6")
-		optional("com.jamonapi:jamon:2.76")
+		optional("com.jamonapi:jamon:2.78")
 	}
 }
 

spring-aop/src/main/java/org/springframework/aop/interceptor/JamonPerformanceMonitorInterceptor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2014 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,21 +16,26 @@
 
 package org.springframework.aop.interceptor;
 
+import com.jamonapi.MonKey;
+import com.jamonapi.MonKeyImp;
 import com.jamonapi.Monitor;
 import com.jamonapi.MonitorFactory;
+import com.jamonapi.utils.Misc;
 import org.aopalliance.intercept.MethodInvocation;
 import org.apache.commons.logging.Log;
 
 /**
- * Performance monitor interceptor that uses <b>JAMon</b> library
- * to perform the performance measurement on the intercepted method
- * and output the stats.
+ * Performance monitor interceptor that uses <b>JAMon</b> library to perform the
+ * performance measurement on the intercepted method and output the stats.
+ * In addition, it tracks/counts exceptions thrown by the intercepted method.
+ * The stack traces can be viewed in the JAMon web application.
  *
  * <p>This code is inspired by Thierry Templier's blog.
  *
  * @author Dmitriy Kopylenko
  * @author Juergen Hoeller
  * @author Rob Harrop
+ * @author Steve Souza
  * @since 1.1.3
  * @see com.jamonapi.MonitorFactory
  * @see PerformanceMonitorInterceptor
@@ -103,10 +108,16 @@ public class JamonPerformanceMonitorInterceptor extends AbstractMonitoringInterc
 	@Override
 	protected Object invokeUnderTrace(MethodInvocation invocation, Log logger) throws Throwable {
 		String name = createInvocationTraceName(invocation);
-		Monitor monitor = MonitorFactory.start(name);
+		MonKey key = new MonKeyImp(name, name, "ms.");
+
+		Monitor monitor = MonitorFactory.start(key);
 		try {
 			return invocation.proceed();
 		}
+		catch (Throwable ex) {
+			trackException(key, ex);
+			throw ex;
+		}
 		finally {
 			monitor.stop();
 			if (!this.trackAllInvocations || isLogEnabled(logger)) {
@@ -115,4 +126,19 @@ public class JamonPerformanceMonitorInterceptor extends AbstractMonitoringInterc
 		}
 	}
 
+	/**
+	 * Count the thrown exception and put the stack trace in the details portion of the key.
+	 * This will allow the stack trace to be viewed in the JAMon web application.
+	 */
+	protected void trackException(MonKey key, Throwable ex) {
+		String stackTrace = "stackTrace=" + Misc.getExceptionTrace(ex);
+		key.setDetails(stackTrace);
+
+		// Specific exception counter. Example: java.lang.RuntimeException
+		MonitorFactory.add(new MonKeyImp(ex.getClass().getName(), stackTrace, "Exception"), 1);
+
+		// General exception counter which is a total for all exceptions thrown
+		MonitorFactory.add(new MonKeyImp(MonitorFactory.EXCEPTIONS_LABEL, stackTrace, "Exception"), 1);
+	}
+
 }

spring-aop/src/test/java/org/springframework/aop/interceptor/JamonPerformanceMonitorInterceptorTests.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2002-2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.interceptor;
+
+import com.jamonapi.MonitorFactory;
+import org.aopalliance.intercept.MethodInvocation;
+import org.apache.commons.logging.Log;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+import static org.mockito.BDDMockito.*;
+
+/**
+ * @author Steve Souza
+ * @since 4.1
+ */
+public class JamonPerformanceMonitorInterceptorTests {
+
+    private JamonPerformanceMonitorInterceptor interceptor = new JamonPerformanceMonitorInterceptor();
+
+    private MethodInvocation mi = mock(MethodInvocation.class);
+
+    private Log log = mock(Log.class);
+
+
+    @Before
+    public void setUp() {
+       MonitorFactory.reset();
+    }
+
+    @After
+    public void tearDown() {
+        MonitorFactory.reset();
+    }
+
+
+    @Test
+    public void testInvokeUnderTraceWithNormalProcessing() throws Throwable {
+        given(mi.getMethod()).willReturn(String.class.getMethod("toString"));
+
+        interceptor.invokeUnderTrace(mi, log);
+
+        assertEquals("jamon must track the method being invoked", 1, MonitorFactory.getNumRows());
+        assertTrue("The jamon report must contain the toString method that was invoked", MonitorFactory.getReport().contains("toString"));
+    }
+
+    @Test
+    public void testInvokeUnderTraceWithExceptionTracking() throws Throwable {
+        given(mi.getMethod()).willReturn(String.class.getMethod("toString"));
+        given(mi.proceed()).willThrow(new IllegalArgumentException());
+
+        try {
+            interceptor.invokeUnderTrace(mi, log);
+            fail("Must have propagated the IllegalArgumentException");
+        }
+		catch (IllegalArgumentException expected) {
+        }
+
+        assertEquals("Monitors must exist for the method invocation and 2 exceptions", 3, MonitorFactory.getNumRows());
+        assertTrue("The jamon report must contain the toString method that was invoked", MonitorFactory.getReport().contains("toString"));
+        assertTrue("The jamon report must contain the generic exception: " + MonitorFactory.EXCEPTIONS_LABEL,  MonitorFactory.getReport().contains(MonitorFactory.EXCEPTIONS_LABEL));
+        assertTrue("The jamon report must contain the specific exception: IllegalArgumentException'",  MonitorFactory.getReport().contains("IllegalArgumentException"));
+    }
+
+}