Consolidate stack trace rendering in Pattern Layout

log4j-core-test/src/test/java/org/apache/logging/log4j/core/impl/ThrowableProxyRendererTest.java

@@ -33,6 +33,7 @@ public void test_formatExtendedStackTraceTo() {
                 new ArrayList<>(),
                 new PlainTextRenderer(),
                 "",
-                System.lineSeparator());
+                System.lineSeparator(),
+                null);
     }
 }

log4j-core/src/main/java/org/apache/logging/log4j/core/impl/ThrowableProxy.java

@@ -297,10 +297,32 @@ public String getCauseStackTraceAsString(
             final String suffix,
             final String lineSeparator) {
         final StringBuilder sb = new StringBuilder();
-        ThrowableProxyRenderer.formatCauseStackTrace(this, sb, ignorePackages, textRenderer, suffix, lineSeparator);
+        ThrowableProxyRenderer.formatCauseStackTraceTo(
+                this, sb, ignorePackages, textRenderer, suffix, lineSeparator, null);
         return sb.toString();
     }
 
+    /**
+     * Formats the stack trace with cause exception.
+     *
+     * @param sb Destination.
+     * @param ignorePackages List of packages to be ignored in the trace.
+     * @param textRenderer The message renderer.
+     * @param suffix Append this to the end of each stack frame.
+     * @param lineSeparator The end-of-line separator.
+     * @param maxLineCount The total line count of final result
+     */
+    public void formatCauseStackTraceTo(
+            final StringBuilder sb,
+            final List<String> ignorePackages,
+            final TextRenderer textRenderer,
+            final String suffix,
+            final String lineSeparator,
+            final Integer maxLineCount) {
+        ThrowableProxyRenderer.formatCauseStackTraceTo(
+                this, sb, ignorePackages, textRenderer, suffix, lineSeparator, maxLineCount);
+    }
+
     /**
      * Returns the number of elements that are being omitted because they are common with the parent Throwable's stack
      * trace.
@@ -389,7 +411,7 @@ public String getExtendedStackTraceAsString(
             final String suffix,
             final String lineSeparator) {
         final StringBuilder sb = new StringBuilder(1024);
-        formatExtendedStackTraceTo(sb, ignorePackages, textRenderer, suffix, lineSeparator);
+        formatExtendedStackTraceTo(sb, ignorePackages, textRenderer, suffix, lineSeparator, null);
         return sb.toString();
     }
 
@@ -401,15 +423,17 @@ public String getExtendedStackTraceAsString(
      * @param textRenderer The message renderer.
      * @param suffix Append this to the end of each stack frame.
      * @param lineSeparator The end-of-line separator.
+     * @param maxLineCount The total line count of final result
      */
     public void formatExtendedStackTraceTo(
             final StringBuilder sb,
             final List<String> ignorePackages,
             final TextRenderer textRenderer,
             final String suffix,
-            final String lineSeparator) {
+            final String lineSeparator,
+            final Integer maxLineCount) {
         ThrowableProxyRenderer.formatExtendedStackTraceTo(
-                this, sb, ignorePackages, textRenderer, suffix, lineSeparator);
+                this, sb, ignorePackages, textRenderer, suffix, lineSeparator, maxLineCount);
     }
 
     public String getLocalizedMessage() {

log4j-core/src/main/java/org/apache/logging/log4j/core/impl/ThrowableProxyRenderer.java

@@ -240,10 +240,9 @@ static void formatExtendedStackTraceTo(
             final List<String> ignorePackages,
             final TextRenderer textRenderer,
             final String suffix,
-            final String lineSeparator) {
-        textRenderer.render(src.getName(), sb, "Name");
-        textRenderer.render(": ", sb, "NameMessageSeparator");
-        textRenderer.render(src.getMessage(), sb, "Message");
+            final String lineSeparator,
+            final Integer maxLineCount) {
+        renderOn(src, sb, textRenderer);
         renderSuffix(suffix, sb, textRenderer);
         textRenderer.render(lineSeparator, sb, "Text");
         final StackTraceElement[] causedTrace =
@@ -260,6 +259,7 @@ static void formatExtendedStackTraceTo(
                 lineSeparator);
         formatSuppressed(sb, TAB, src.getSuppressedProxies(), ignorePackages, textRenderer, suffix, lineSeparator);
         formatCause(sb, Strings.EMPTY, src.getCauseProxy(), ignorePackages, textRenderer, suffix, lineSeparator);
+        truncateLines(sb, lineSeparator, maxLineCount, textRenderer);
     }
 
     /**
@@ -272,23 +272,24 @@ static void formatExtendedStackTraceTo(
      * @param suffix         Append this to the end of each stack frame.
      * @param lineSeparator  The end-of-line separator.
      */
-    static void formatCauseStackTrace(
+    static void formatCauseStackTraceTo(
             final ThrowableProxy src,
             final StringBuilder sb,
             final List<String> ignorePackages,
             final TextRenderer textRenderer,
             final String suffix,
-            final String lineSeparator) {
+            final String lineSeparator,
+            final Integer maxLineCount) {
         final ThrowableProxy causeProxy = src.getCauseProxy();
         if (causeProxy != null) {
             formatWrapper(sb, causeProxy, ignorePackages, textRenderer, suffix, lineSeparator);
             sb.append(WRAPPED_BY_LABEL);
-            ThrowableProxyRenderer.renderSuffix(suffix, sb, textRenderer);
+            renderSuffix(suffix, sb, textRenderer);
         }
         renderOn(src, sb, textRenderer);
-        ThrowableProxyRenderer.renderSuffix(suffix, sb, textRenderer);
+        renderSuffix(suffix, sb, textRenderer);
         textRenderer.render(lineSeparator, sb, "Text");
-        ThrowableProxyRenderer.formatElements(
+        formatElements(
                 sb,
                 Strings.EMPTY,
                 0,
@@ -298,6 +299,7 @@ static void formatCauseStackTrace(
                 textRenderer,
                 suffix,
                 lineSeparator);
+        truncateLines(sb, lineSeparator, maxLineCount, textRenderer);
     }
 
     private static void renderOn(
@@ -309,4 +311,27 @@ private static void renderOn(
             textRenderer.render(msg, output, "Message");
         }
     }
+
+    private static void truncateLines(
+            final StringBuilder sb,
+            final String lineSeparator,
+            final Integer maxLineCount,
+            final TextRenderer textRenderer) {
+        if (maxLineCount == null) {
+            return;
+        }
+
+        String content = sb.toString();
+        String[] lines = content.split(lineSeparator);
+
+        if (lines.length <= maxLineCount) {
+            return;
+        }
+
+        sb.setLength(0);
+        for (int i = 0; i < maxLineCount; i++) {
+            sb.append(lines[i]);
+            textRenderer.render(lineSeparator, sb, "Text");
+        }
+    }
 }

log4j-core/src/main/java/org/apache/logging/log4j/core/package-info.java

@@ -18,7 +18,7 @@
  * Implementation of Log4j 2.
  */
 @Export
-@Version("2.24.0")
+@Version("3.0.0")
 package org.apache.logging.log4j.core;
 
 import org.osgi.annotation.bundle.Export;

log4j-core/src/main/java/org/apache/logging/log4j/core/pattern/ExtendedThrowablePatternConverter.java

@@ -76,7 +76,8 @@ public void format(final LogEvent event, final StringBuilder toAppendTo) {
                     options.getIgnorePackages(),
                     options.getTextRenderer(),
                     getSuffix(event),
-                    options.getSeparator());
+                    options.getSeparator(),
+                    options.allLines() ? null : options.getLines());
         }
     }
 }

log4j-core/src/main/java/org/apache/logging/log4j/core/pattern/RootThrowablePatternConverter.java

@@ -20,7 +20,6 @@
 import org.apache.logging.log4j.core.config.Configuration;
 import org.apache.logging.log4j.core.config.plugins.Plugin;
 import org.apache.logging.log4j.core.impl.ThrowableProxy;
-import org.apache.logging.log4j.util.Strings;
 
 /**
  * Outputs the Throwable portion of the LoggingEvent as a full stack trace
@@ -68,27 +67,17 @@ public void format(final LogEvent event, final StringBuilder toAppendTo) {
                 super.format(event, toAppendTo);
                 return;
             }
-            final String trace = proxy.getCauseStackTraceAsString(
-                    options.getIgnorePackages(), options.getTextRenderer(), getSuffix(event), options.getSeparator());
             final int len = toAppendTo.length();
             if (len > 0 && !Character.isWhitespace(toAppendTo.charAt(len - 1))) {
                 toAppendTo.append(' ');
             }
-            if (!options.allLines() || !Strings.LINE_SEPARATOR.equals(options.getSeparator())) {
-                final StringBuilder sb = new StringBuilder();
-                final String[] array = trace.split(Strings.LINE_SEPARATOR);
-                final int limit = options.minLines(array.length) - 1;
-                for (int i = 0; i <= limit; ++i) {
-                    sb.append(array[i]);
-                    if (i < limit) {
-                        sb.append(options.getSeparator());
-                    }
-                }
-                toAppendTo.append(sb.toString());
-
-            } else {
-                toAppendTo.append(trace);
-            }
+            proxy.formatCauseStackTraceTo(
+                    toAppendTo,
+                    options.getIgnorePackages(),
+                    options.getTextRenderer(),
+                    getSuffix(event),
+                    options.getSeparator(),
+                    options.allLines() ? null : options.getLines());
         }
     }
 }

log4j-core/src/main/java/org/apache/logging/log4j/core/pattern/ThrowablePatternConverter.java

@@ -18,7 +18,6 @@
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import java.io.PrintWriter;
-import java.io.StringWriter;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -188,23 +187,24 @@ private void formatOption(final Throwable throwable, final String suffix, final
         if (len > 0 && !Character.isWhitespace(buffer.charAt(len - 1))) {
             buffer.append(' ');
         }
-        if (!options.allLines() || nonStandardLineSeparator || Strings.isNotBlank(suffix)) {
-            final StringWriter w = new StringWriter();
-            throwable.printStackTrace(new PrintWriter(w));
-
-            final String[] array = w.toString().split(Strings.LINE_SEPARATOR);
-            final int limit = options.minLines(array.length) - 1;
-            final boolean suffixNotBlank = Strings.isNotBlank(suffix);
-            for (int i = 0; i <= limit; ++i) {
-                buffer.append(array[i]);
-                if (suffixNotBlank) {
-                    buffer.append(' ');
-                    buffer.append(suffix);
-                }
-                if (i < limit) {
-                    buffer.append(options.getSeparator());
+        if (requireAdditionalFormatting(suffix)) {
+            StackTraceElement[] stackTrace = throwable.getStackTrace();
+            int ignoredCount = 0;
+            for (StackTraceElement stackTraceElement : stackTrace) {
+                if (!ignoreElement(stackTraceElement, options.getIgnorePackages())) {
+                    if (ignoredCount > 0) {
+                        appendSuppressedCount(buffer, ignoredCount, suffix, options.getSeparator());
+                        ignoredCount = 0;
+                    }
+                    appendEntry(stackTraceElement, buffer, suffix, options.getSeparator());
+                } else {
+                    ++ignoredCount;
                 }
             }
+            if (ignoredCount > 0) {
+                appendSuppressedCount(buffer, ignoredCount, suffix, options.getSeparator());
+            }
+            truncateLines(buffer, options.getSeparator(), options.allLines() ? null : options.getLines());
         } else {
             throwable.printStackTrace(new PrintWriter(new StringBuilderWriter(buffer)));
         }
@@ -235,4 +235,69 @@ protected String getSuffix(final LogEvent event) {
     public ThrowableFormatOptions getOptions() {
         return options;
     }
+
+    private boolean requireAdditionalFormatting(final String suffix) {
+        return !options.allLines() || nonStandardLineSeparator || Strings.isNotBlank(suffix) || options.hasPackages();
+    }
+
+    private boolean ignoreElement(final StackTraceElement element, final List<String> ignorePackages) {
+        if (ignorePackages != null) {
+            final String className = element.getClassName();
+            for (final String pkg : ignorePackages) {
+                if (className.startsWith(pkg)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private void appendSuppressedCount(
+            final StringBuilder sb, final int count, final String suffix, final String lineSeparator) {
+        if (count == 1) {
+            sb.append("\t... ");
+        } else {
+            sb.append("\t... suppressed ");
+            sb.append(count);
+            sb.append(" lines");
+        }
+        appendSuffix(sb, suffix);
+        sb.append(lineSeparator);
+    }
+
+    private void appendEntry(
+            final StackTraceElement stackTraceElement,
+            final StringBuilder sb,
+            final String suffix,
+            final String lineSeparator) {
+        sb.append(stackTraceElement.toString());
+        appendSuffix(sb, suffix);
+        sb.append(lineSeparator);
+    }
+
+    private void appendSuffix(final StringBuilder buffer, final String suffix) {
+        if (Strings.isNotBlank(suffix)) {
+            buffer.append(' ');
+            buffer.append(suffix);
+        }
+    }
+
+    private void truncateLines(final StringBuilder sb, final String lineSeparator, final Integer maxLineCount) {
+        if (maxLineCount == null) {
+            return;
+        }
+
+        String content = sb.toString();
+        String[] lines = content.split(lineSeparator);
+
+        if (lines.length <= maxLineCount) {
+            return;
+        }
+
+        sb.setLength(0);
+        for (int i = 0; i < maxLineCount; i++) {
+            sb.append(lines[i]);
+            sb.append(lineSeparator);
+        }
+    }
 }