fix 4x exception logging

gradle.properties

@@ -59,7 +59,7 @@ micronautPlatformVersion=4.9.4
 
 # Libraries only specific to test apps, these should not be exposed
 ersatzVersion=4.0.1
-grailsSpringSecurityVersion=7.0.2-SNAPSHOT
+grailsSpringSecurityVersion=7.0.3-SNAPSHOT
 jbossTransactionApiVersion=2.0.0.Final
 # Note: we do not import the micronaut bom in our tests to avoid spring version mismatches
 micronautHttpClientVersion=4.9.9

grails-bootstrap/src/main/groovy/org/grails/exceptions/reporting/DefaultStackTraceFilterer.java

@@ -33,6 +33,15 @@
  */
 public class DefaultStackTraceFilterer implements StackTraceFilterer {
     public static final String STACK_LOG_NAME = "StackTrace";
+    /**
+     * Dedicated logger for exception stack traces. The filterer emits the unfiltered
+     * trace to this logger as a side effect of {@link #filter(Throwable)} — before the
+     * trace is trimmed in place — when {@link #logFullStackTraceOnFilter} is {@code true}
+     * (the default). {@code GrailsExceptionResolver} also emits to this logger when
+     * {@code grails.exceptionresolver.logFullStackTrace} is enabled. Exposed as a public
+     * constant so that subclasses and logback configurations can reference the logger
+     * name symbolically.
+     */
     public static final Log STACK_LOG = LogFactory.getLog(STACK_LOG_NAME);
 
     private static final String[] DEFAULT_INTERNAL_PACKAGES = new String[] {
@@ -58,6 +67,7 @@ public class DefaultStackTraceFilterer implements StackTraceFilterer {
     private List<String> packagesToFilter = new ArrayList<>();
     private boolean shouldFilter;
     private String cutOffPackage = null;
+    private boolean logFullStackTraceOnFilter = true;
 
     public DefaultStackTraceFilterer() {
         this(!Boolean.getBoolean(SYS_PROP_DISPLAY_FULL_STACKTRACE));
@@ -77,36 +87,52 @@ public void setCutOffPackage(String cutOffPackage) {
         this.cutOffPackage = cutOffPackage;
     }
 
+    /**
+     * Controls whether {@link #filter(Throwable)} emits the unfiltered stack trace
+     * to {@link #STACK_LOG} as a side effect before trimming the trace in place.
+     * Defaults to {@code true} for backwards compatibility with pre-7.1 behaviour;
+     * set to {@code false} to disable the side-effect emission. The exception
+     * resolver wires this from {@code grails.exceptionresolver.logFullStackTraceOnFilter}.
+     */
+    public void setLogFullStackTraceOnFilter(boolean logFullStackTraceOnFilter) {
+        this.logFullStackTraceOnFilter = logFullStackTraceOnFilter;
+    }
+
     public Throwable filter(Throwable source, boolean recursive) {
         if (recursive) {
             Throwable current = source;
             while (current != null) {
-                current = filter(current);
+                filter(current);
                 current = current.getCause();
             }
+            return source;
         }
         return filter(source);
     }
 
     public Throwable filter(Throwable source) {
-        if (shouldFilter) {
-            StackTraceElement[] trace = source.getStackTrace();
-            List<StackTraceElement> newTrace = filterTraceWithCutOff(trace, cutOffPackage);
+        if (!shouldFilter) {
+            return source;
+        }
+        StackTraceElement[] trace = source.getStackTrace();
+        List<StackTraceElement> newTrace = filterTraceWithCutOff(trace, cutOffPackage);
 
-            if (newTrace.isEmpty()) {
-                // filter with no cut-off so at least there is some trace
-                newTrace = filterTraceWithCutOff(trace, null);
-            }
+        if (newTrace.isEmpty()) {
+            // filter with no cut-off so at least there is some trace
+            newTrace = filterTraceWithCutOff(trace, null);
+        }
 
-            // Only trim the trace if there was some application trace on the stack
-            // if not we will just skip sanitizing and leave it as is
-            if (!newTrace.isEmpty()) {
-                // We don't want to lose anything, so log it
+        // Only trim the trace if there was some application trace on the stack
+        // if not we will just skip sanitizing and leave it as is
+        if (!newTrace.isEmpty()) {
+            if (logFullStackTraceOnFilter) {
+                // emit the unfiltered trace before mutating in place; once setStackTrace(clean)
+                // runs the original frames are gone
                 STACK_LOG.error(FULL_STACK_TRACE_MESSAGE, source);
-                StackTraceElement[] clean = new StackTraceElement[newTrace.size()];
-                newTrace.toArray(clean);
-                source.setStackTrace(clean);
             }
+            StackTraceElement[] clean = new StackTraceElement[newTrace.size()];
+            newTrace.toArray(clean);
+            source.setStackTrace(clean);
         }
         return source;
     }

grails-bootstrap/src/main/groovy/org/grails/exceptions/reporting/StackTraceFilterer.java

@@ -26,6 +26,12 @@
  */
 public interface StackTraceFilterer {
 
+    /**
+     * Message used as the header for full stack trace log entries emitted on the
+     * dedicated {@code StackTrace} logger. The filterer itself does not log;
+     * {@code GrailsExceptionResolver} writes the entry when
+     * {@code grails.exceptionresolver.logFullStackTrace} is enabled.
+     */
     String FULL_STACK_TRACE_MESSAGE = "Full Stack Trace:";
     String SYS_PROP_DISPLAY_FULL_STACKTRACE = "grails.full.stacktrace";
 

grails-core/src/main/groovy/grails/config/Settings.groovy

@@ -292,6 +292,41 @@ interface Settings {
      * The parameters to exclude from logging
      */
     String SETTING_EXCEPTION_RESOLVER_PARAM_EXCLUDES = 'grails.exceptionresolver.params.exclude'
+    /**
+     * Whether the exception resolver should also emit the exception on the separate
+     * {@code StackTrace} logger in addition to its own request-context log entry.
+     * Defaults to {@code false}; set to {@code true} to restore the historical two-logger
+     * behaviour, which allows routing the trace to a separate appender via logback config.
+     */
+    String SETTING_LOG_FULL_STACKTRACE = 'grails.exceptionresolver.logFullStackTrace'
+    /**
+     * Whether the exception resolver should append the current auditor (resolved via a
+     * registered {@code org.grails.datastore.gorm.timestamp.AuditorAware} bean) to the
+     * exception log line. Defaults to {@code true}; set to {@code false} to keep user
+     * identifiers out of exception logs. When no {@code AuditorAware} bean is registered
+     * the log line is unchanged regardless of this setting.
+     */
+    String SETTING_LOG_AUDITOR = 'grails.exceptionresolver.logAuditor'
+    /**
+     * Whether the exception resolver should append the remote client address
+     * ({@link jakarta.servlet.http.HttpServletRequest#getRemoteAddr()}) to the exception
+     * log line. Defaults to {@code false}; set to {@code true} to include client addresses
+     * in exception logs. Behind a reverse proxy, configure the servlet container
+     * (for example Spring Boot's {@code server.forward-headers-strategy}) so that
+     * {@code remoteAddr} reflects the real client IP.
+     */
+    String SETTING_LOG_REMOTE_ADDR = 'grails.exceptionresolver.logRemoteAddr'
+    /**
+     * Whether {@link org.grails.exceptions.reporting.DefaultStackTraceFilterer#filter(Throwable)}
+     * should emit the unfiltered stack trace to the dedicated {@code StackTrace} logger as a
+     * side effect, before trimming the trace in place. Defaults to {@code true} to preserve
+     * historical behaviour — non-resolver callers (for example {@code GrailsUtil.sanitizeRootCause},
+     * {@code GroovyPageView.deepSanitize}, custom plugin code) that previously relied on this
+     * side-effect emission continue to produce {@code StackTrace} entries. Set to {@code false}
+     * to disable the side-effect emission and rely solely on {@link #SETTING_LOG_FULL_STACKTRACE}
+     * for resolver-driven emission.
+     */
+    String SETTING_LOG_FULL_STACKTRACE_ON_FILTER = 'grails.exceptionresolver.logFullStackTraceOnFilter'
     /**
      * The class to use for stacktrace filtering. Should be an instanceof {@link org.grails.exceptions.reporting.StackTraceFilterer}
      */