implemented @ppkarwasz & @vy chamges regarding FixedDateFormat.FixedFormat

Author: ashr123

log4j-core-test/src/test/java/org/apache/logging/log4j/core/pattern/DatePatternConverterTestBase.java

@@ -331,7 +331,7 @@ void testNewInstanceAllowsNullParameter() {
     }
 
     private static final String[] PATTERN_NAMES =
-            Stream.of(NamedDatePattern.values()).map(Enum::name).toArray(String[]::new);
+            Stream.of(NamedInstantPattern.values()).map(Enum::name).toArray(String[]::new);
 
     @Test
     void testPredefinedFormatWithoutTimezone() {

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

@@ -63,7 +63,7 @@ private static InstantFormatter createFormatter(@Nullable final String[] options
             logOptionReadFailure(options, error, "failed for options: {}, falling back to the default instance");
         }
         return InstantPatternFormatter.newBuilder()
-                .setPattern(NamedDatePattern.DEFAULT.getPattern())
+                .setPattern(NamedInstantPattern.DEFAULT.getPattern())
                 .build();
     }
 
@@ -94,7 +94,7 @@ private static InstantFormatter createFormatterUnsafely(@Nullable final String[]
     private static String readPattern(@Nullable final String[] options) {
         return options != null && options.length > 0 && options[0] != null
                 ? decodeNamedPattern(options[0])
-                : NamedDatePattern.DEFAULT.getPattern();
+                : NamedInstantPattern.DEFAULT.getPattern();
     }
 
     /**
@@ -109,8 +109,40 @@ private static String readPattern(@Nullable final String[] options) {
      * @since 2.25.0
      */
     static String decodeNamedPattern(final String pattern) {
+        // If legacy formatters are enabled, we need to produce output aimed for `FixedDateFormat` and `FastDateFormat`.
+        // Otherwise, we need to produce output aimed for `DateTimeFormatter`.
+        // In conclusion, we need to check if legacy formatters enabled and apply following transformations.
+        //
+        //                               | Microseconds | Nanoseconds | Time-zone
+        // ------------------------------+--------------+-------------+-----------
+        // Legacy formatter directive    | nnnnnn       | nnnnnnnnn   | X, XX, XXX
+        // `DateTimeFormatter` directive | SSSSSS       | SSSSSSSSS   | x, xx, xxx
+        //
+        // Enabling legacy formatters mean that user requests the pattern to be formatted using deprecated
+        // `FixedDateFormat` and `FastDateFormat`.
+        // These two have, let's not say _bogus_, but an _interesting_ way of handling certain pattern directives:
+        //
+        // - They say they adhere to `SimpleDateFormat` specification, but use `n` directive.
+        //   `n` is neither defined by `SimpleDateFormat`, nor `SimpleDateFormat` supports sub-millisecond precisions.
+        //   `n` is probably manually introduced by Log4j to support sub-millisecond precisions.
+        //
+        // - `n` denotes nano-of-second for `DateTimeFormatter`.
+        //   In Java 17, `n` and `N` (nano-of-day) always output nanosecond precision.
+        //   This is independent of how many times they occur consequently.
+        //   Yet legacy formatters use repeated `n` to denote sub-milliseconds precision of certain length.
+        //   This doesn't work for `DateTimeFormatter`, which needs
+        //
+        //   - `SSSSSS` for 6-digit microsecond precision
+        //   - `SSSSSSSSS` for 9-digit nanosecond precision
+        //
+        // - Legacy formatters use `X`, `XX,` and `XXX` to choose between `+00`, `+0000`, or `+00:00`.
+        //   This is the correct behaviour for `SimpleDateFormat`.
+        //   Though `X` in `DateTimeFormatter` produces `Z` for zero-offset.
+        //   To avoid the `Z` output, one needs to use `x` with `DateTimeFormatter`.
         try {
-            return NamedDatePattern.valueOf(pattern).getPattern();
+            return InstantPatternFormatter.LEGACY_FORMATTERS_ENABLED
+                    ? FixedDateFormat.FixedFormat.valueOf(pattern).getPattern()
+                    : NamedInstantPattern.valueOf(pattern).getPattern();
         } catch (IllegalArgumentException ignored) {
             return pattern;
         }

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

@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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.apache.logging.log4j.core.pattern;
+
+/**
+ * Represents named date & time patterns for formatting log timestamps.
+ *
+ * @see DatePatternConverter
+ * @since 2.26.0
+ */
+public enum NamedInstantPattern {
+
+    ABSOLUTE("HH:mm:ss,SSS"),
+
+    ABSOLUTE_MICROS("HH:mm:ss,SSSSSS"),
+
+    ABSOLUTE_NANOS("HH:mm:ss,SSSSSSSSS"),
+
+    ABSOLUTE_PERIOD("HH:mm:ss.SSS"),
+
+    COMPACT("yyyyMMddHHmmssSSS"),
+
+    DATE("dd MMM yyyy HH:mm:ss,SSS"),
+
+    DATE_PERIOD("dd MMM yyyy HH:mm:ss.SSS"),
+
+    DEFAULT("yyyy-MM-dd HH:mm:ss,SSS"),
+
+    DEFAULT_MICROS("yyyy-MM-dd HH:mm:ss,SSSSSS"),
+
+    DEFAULT_NANOS("yyyy-MM-dd HH:mm:ss,SSSSSSSSS"),
+
+    DEFAULT_PERIOD("yyyy-MM-dd HH:mm:ss.SSS"),
+
+    ISO8601_BASIC("yyyyMMdd'T'HHmmss,SSS"),
+
+    ISO8601_BASIC_PERIOD("yyyyMMdd'T'HHmmss.SSS"),
+
+    ISO8601("yyyy-MM-dd'T'HH:mm:ss,SSS"),
+
+    ISO8601_OFFSET_DATE_TIME_HH("yyyy-MM-dd'T'HH:mm:ss,SSSx"),
+
+    ISO8601_OFFSET_DATE_TIME_HHMM("yyyy-MM-dd'T'HH:mm:ss,SSSxx"),
+
+    ISO8601_OFFSET_DATE_TIME_HHCMM("yyyy-MM-dd'T'HH:mm:ss,SSSxxx"),
+
+    ISO8601_PERIOD("yyyy-MM-dd'T'HH:mm:ss.SSS"),
+
+    ISO8601_PERIOD_MICROS("yyyy-MM-dd'T'HH:mm:ss.SSSSSS"),
+
+    US_MONTH_DAY_YEAR2_TIME("dd/MM/yy HH:mm:ss.SSS"),
+
+    US_MONTH_DAY_YEAR4_TIME("dd/MM/yyyy HH:mm:ss.SSS");
+
+    private final String pattern;
+
+    NamedInstantPattern(String pattern) {
+        this.pattern = pattern;
+    }
+
+    public String getPattern() {
+        return pattern;
+    }
+}

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

@@ -4,5 +4,5 @@
        xsi:schemaLocation="https://logging.apache.org/xml/ns https://logging.apache.org/xml/ns/log4j-changelog-0.xsd"
        type="added">
   <issue id="3789" link="https://github.com/apache/logging-log4j2/pull/3789"/>
-  <description format="asciidoc">Add and export `org.apache.logging.log4j.core.pattern.NamedDatePattern` enabling users to programmatically access named date &amp; time patterns supported by Pattern Layout</description>
+  <description format="asciidoc">Add and export `org.apache.logging.log4j.core.pattern.NamedInstantPattern` enabling users to programmatically access named date &amp; time patterns supported by Pattern Layout</description>
 </entry>