root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 6 Packages Projects Releases Wiki Activity

AbstractTraceInterceptor provides logExceptionStackTrace flag and writeToLog delegates 

Issue: SPR-15763
This commit is contained in:
Juergen Hoeller 2017-07-13 13:01:35 +02:00
parent e138d7d29f
commit aa0d7a61b6
6 changed files with 70 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
spring-aop/src/main/java/org/springframework/aop/interceptor/AbstractMonitoringInterceptor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2017 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.
@ -22,12 +22,12 @@ import org.aopalliance.intercept.MethodInvocation;
/**
* Base class for monitoring interceptors, such as performance monitors.
* Provides {@code prefix} and {@code suffix} properties
* that help to classify/group performance monitoring results.
* Provides configurable "prefix and "suffix" properties that help to
* classify/group performance monitoring results.
*
* <p>Subclasses should call the {@code createInvocationTraceName(MethodInvocation)}
* method to create a name for the given trace that includes information about the
* method invocation under trace along with the prefix and suffix added as appropriate.
* <p>In their {@link #invokeUnderTrace} implementation, subclasses should call the
* {@link #createInvocationTraceName} method to create a name for the given trace,
* including information about the method invocation along with a prefix/suffix.
*
* @author Rob Harrop
* @author Juergen Hoeller

59
spring-aop/src/main/java/org/springframework/aop/interceptor/AbstractTraceInterceptor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2017 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.
@ -58,6 +58,12 @@ public abstract class AbstractTraceInterceptor implements MethodInterceptor, Ser
*/
private boolean hideProxyClassNames = false;
/**
* Indicates whether to pass an exception to the logger.
* @see #writeToLog(Log, String, Throwable)
*/
private boolean logExceptionStackTrace = true;
/**
* Set whether to use a dynamic logger or a static logger.
@ -98,6 +104,17 @@ public abstract class AbstractTraceInterceptor implements MethodInterceptor, Ser
this.hideProxyClassNames = hideProxyClassNames;
}
/**
* Set whether to pass an exception to the logger, suggesting inclusion
* of its stack trace into the log. Default is "true"; set this to "false"
* in order to reduce the log output to just the trace message (which may
* include the exception class name and exception message, if applicable).
* @since 4.3.10
*/
public void setLogExceptionStackTrace(boolean logExceptionStackTrace) {
this.logExceptionStackTrace = logExceptionStackTrace;
}
/**
* Determines whether or not logging is enabled for the particular {@code MethodInvocation}.
@ -171,6 +188,40 @@ public abstract class AbstractTraceInterceptor implements MethodInterceptor, Ser
return logger.isTraceEnabled();
}
/**
* Write the supplied trace message to the supplied {@code Log} instance.
* <p>To be called by {@link #invokeUnderTrace} for enter/exit messages.
* <p>Delegates to {@link #writeToLog(Log, String, Throwable)} as the
* ultimate delegate that controls the underlying logger invocation.
* @since 4.3.10
* @see #writeToLog(Log, String, Throwable)
*/
protected void writeToLog(Log logger, String message) {
writeToLog(logger, message, null);
}
/**
* Write the supplied trace message and {@link Throwable} to the
* supplied {@code Log} instance.
* <p>To be called by {@link #invokeUnderTrace} for enter/exit outcomes,
* potentially including an exception. Note that an exception's stack trace
* won't get logged when {@link #setLogExceptionStackTrace} is "false".
* <p>By default messages are written at {@code TRACE} level. Subclasses
* can override this method to control which level the message is written
* at, typically also overriding {@link #isLogEnabled} accordingly.
* @since 4.3.10
* @see #setLogExceptionStackTrace
* @see #isLogEnabled
*/
protected void writeToLog(Log logger, String message, Throwable ex) {
if (ex != null && this.logExceptionStackTrace) {
logger.trace(message, ex);
}
else {
logger.trace(message);
}
}
/**
* Subclasses must override this method to perform any tracing around the
@ -180,13 +231,15 @@ public abstract class AbstractTraceInterceptor implements MethodInterceptor, Ser
* <p>By default, the passed-in {@code Log} instance will have log level
* "trace" enabled. Subclasses do not have to check for this again, unless
* they overwrite the {@code isInterceptorEnabled} method to modify
* the default behavior.
* the default behavior, and may delegate to {@code writeToLog} for actual
* messages to be written.
* @param logger the {@code Log} to write trace messages to
* @return the result of the call to {@code MethodInvocation.proceed()}
* @throws Throwable if the call to {@code MethodInvocation.proceed()}
* encountered any errors
* @see #isInterceptorEnabled
* @see #isLogEnabled
* @see #writeToLog(Log, String)
* @see #writeToLog(Log, String, Throwable)
*/
protected abstract Object invokeUnderTrace(MethodInvocation invocation, Log logger) throws Throwable;

23
spring-aop/src/main/java/org/springframework/aop/interceptor/CustomizableTraceInterceptor.java
View File

@ -275,29 +275,6 @@ public class CustomizableTraceInterceptor extends AbstractTraceInterceptor {
}
}
/**
* Writes the supplied message to the supplied {@code Log} instance.
* @see #writeToLog(org.apache.commons.logging.Log, String, Throwable)
*/
protected void writeToLog(Log logger, String message) {
writeToLog(logger, message, null);
}
/**
* Writes the supplied message and {@link Throwable} to the
* supplied {@code Log} instance. By default messages are written
* at {@code TRACE} level. Sub-classes can override this method
* to control which level the message is written at.
*/
protected void writeToLog(Log logger, String message, Throwable ex) {
if (ex != null) {
logger.trace(message, ex);
}
else {
logger.trace(message);
}
}
/**
* Replace the placeholders in the given message with the supplied values,
* or values derived from those supplied.

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

@ -1,5 +1,5 @@
/*
* Copyright 2002-2014 the original author or authors.
* Copyright 2002-2017 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.
@ -121,7 +121,7 @@ public class JamonPerformanceMonitorInterceptor extends AbstractMonitoringInterc
finally {
monitor.stop();
if (!this.trackAllInvocations || isLogEnabled(logger)) {
logger.trace("JAMon performance statistics for method [" + name + "]:\n" + monitor);
writeToLog(logger, "JAMon performance statistics for method [" + name + "]:\n" + monitor);
}
}
}

4
spring-aop/src/main/java/org/springframework/aop/interceptor/PerformanceMonitorInterceptor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2017 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.
@ -63,7 +63,7 @@ public class PerformanceMonitorInterceptor extends AbstractMonitoringInterceptor
}
finally {
stopWatch.stop();
logger.trace(stopWatch.shortSummary());
writeToLog(logger, stopWatch.shortSummary());
}
}

8
spring-aop/src/main/java/org/springframework/aop/interceptor/SimpleTraceInterceptor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2017 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.
@ -55,14 +55,14 @@ public class SimpleTraceInterceptor extends AbstractTraceInterceptor {
@Override
protected Object invokeUnderTrace(MethodInvocation invocation, Log logger) throws Throwable {
String invocationDescription = getInvocationDescription(invocation);
logger.trace("Entering " + invocationDescription);
writeToLog(logger, "Entering " + invocationDescription);
try {
Object rval = invocation.proceed();
logger.trace("Exiting " + invocationDescription);
writeToLog(logger, "Exiting " + invocationDescription);
return rval;
}
catch (Throwable ex) {
logger.trace("Exception thrown in " + invocationDescription, ex);
writeToLog(logger, "Exception thrown in " + invocationDescription, ex);
throw ex;
}
}