From 65d00730c3515cfedd2a15500ab534023c149dd8 Mon Sep 17 00:00:00 2001
From: Phil Clay <philsttr@users.noreply.github.com>
Date: Sat, 23 Nov 2019 11:41:47 -0800
Subject: [PATCH] Fixes #364 Switch FastDateFormat to DateTimeFormatter

Remove dependency on apache commons-lang3 (since FastDateFormat was the only thing being used).

Switch default timestamp format to DateTimeFormatter.ISO_OFFSET_DATE_TIME

Added the ability to specify DateTimeFormatter constant names as patterns.

This change is NOT fully backwards compatible, since:
* the default timestamp pattern changed to DateTimeFormatter.ISO_OFFSET_DATE_TIME
* the pattern strings supported by DateTimeFormatter are not exactly the same as those supported by FastDateFormat
---
 README.md                                     |  45 +++----
 pom.xml                                       |  12 +-
 ...FailureSummaryLoggingAppenderListener.java |   6 +-
 .../FormattedTimestampJsonProvider.java       |  61 ++++++---
 ...entFormattedTimestampJsonProviderTest.java | 123 ++++++++++++++++++
 .../encoder/LogstashAccessEncoderTest.java    |  11 +-
 .../logback/encoder/LogstashEncoderTest.java  |  26 ++--
 7 files changed, 206 insertions(+), 78 deletions(-)
 create mode 100644 src/test/java/net/logstash/logback/composite/loggingevent/LoggingEventFormattedTimestampJsonProviderTest.java

diff --git a/README.md b/README.md
index 4e3183f0..60e179ad 100644
--- a/README.md
+++ b/README.md
@@ -1271,19 +1271,11 @@ The value can be written as a number (instead of a string) like this:
 
 ## Customizing Timestamp
 
-By default, timestamps are written as string values in the format `yyyy-MM-dd'T'HH:mm:ss.SSSZZ` (e.g. `2018-04-28T22:23:59.164-07:00`), in the default TimeZone of the host Java platform.
+By default, timestamps are written as string values in the format specified by
+[`DateTimeFormatter.ISO_OFFSET_DATE_TIME`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/format/DateTimeFormatter.html#ISO_OFFSET_DATE_TIME)
+(e.g. `2019-11-03T10:15:30.123+01:00`), in the default TimeZone of the host Java platform.
 
-You can change the timezone like this:
-
-```xml
-<encoder class="net.logstash.logback.encoder.LogstashEncoder">
-  <timeZone>UTC</timeZone>
-</encoder>
-```
-
-The value of the `timeZone` element can be any string accepted by java's  `TimeZone.getTimeZone(String id)` method.
-
-You can change the pattern used like this:
+You can change the pattern like this:
 
 ```xml
 <encoder class="net.logstash.logback.encoder.LogstashEncoder">
@@ -1291,19 +1283,24 @@ You can change the pattern used like this:
 </encoder>
 ```
 
-Use these timestamp pattern values to output the timestamp as a unix timestamp (number of milliseconds since unix epoch).
+The value of the `timestampPattern` can be any of the following:
 
-* `[UNIX_TIMESTAMP_AS_NUMBER]` - write the timestamp value as a numeric unix timestamp
-* `[UNIX_TIMESTAMP_AS_STRING]` - write the timestamp value as a string verion of the numeric unix timestamp
+* `[UNIX_TIMESTAMP_AS_NUMBER]` - timestamp written as a JSON number value of the milliseconds since unix epoch
+* `[UNIX_TIMESTAMP_AS_STRING]` - timestamp written as a JSON string value of the milliseconds since unix epoch
+* `[` _`constant`_ `]` - (e.g. `[ISO_OFFSET_DATE_TIME]`) timestamp written using the given `DateTimeFormatter` constant
+* any other value - (e.g. `yyyy-MM-dd'T'HH:mm:ss.SSS`) timestamp written using a `DateTimeFormatter` created from the given pattern
 
-For example:
+
+You can change the timezone like this:
 
 ```xml
 <encoder class="net.logstash.logback.encoder.LogstashEncoder">
-  <timestampPattern>[UNIX_TIMESTAMP_AS_NUMBER]</timestampPattern>
+  <timeZone>UTC</timeZone>
 </encoder>
 ```
 
+The value of the `timeZone` element can be any string accepted by java's  `TimeZone.getTimeZone(String id)` method.
+
 
 ## Customizing JSON Factory and Generator
 
@@ -1607,12 +1604,7 @@ For LoggingEvents, the available providers and their configuration properties (d
       <td><p>Event timestamp</p>
         <ul>
           <li><tt>fieldName</tt> - Output field name (<tt>@timestamp</tt>)</li>
-          <li><tt>pattern</tt> - Output format (<tt>yyyy-MM-dd'T'HH:mm:ss.SSSZZ</tt>)
-          <ul>
-            <li>If set to <tt>[UNIX_TIMESTAMP_AS_NUMBER]</tt>, then the timestamp will be written as a numeric unix timestamp value</li>
-            <li>If set to <tt>[UNIX_TIMESTAMP_AS_STRING]</tt>, then the timestamp will be written as a string unix timestamp value</li>
-          </ul>
-          </li>
+          <li><tt>pattern</tt> - Output format (<tt>[ISO_OFFSET_DATE_TIME]</tt>)  See <a href="#customizing-timestamp">above</a> for possible values.</li>
           <li><tt>timeZone</tt> - Timezone (local timezone)</li>
         </ul>
       </td>
@@ -1863,12 +1855,7 @@ For AccessEvents, the available providers and their configuration properties (de
       <td><p>Event timestamp</p>
         <ul>
           <li><tt>fieldName</tt> - Output field name (<tt>@timestamp</tt>)</li>
-          <li><tt>pattern</tt> - Output format (<tt>yyyy-MM-dd'T'HH:mm:ss.SSSZZ</tt>)
-          <ul>
-            <li>If set to <tt>[UNIX_TIMESTAMP_AS_NUMBER]</tt>, then the timestamp will be written as a numeric unix timestamp value</li>
-            <li>If set to <tt>[UNIX_TIMESTAMP_AS_STRING]</tt>, then the timestamp will be written as a string unix timestamp value</li>
-          </ul>
-          </li>
+          <li><tt>pattern</tt> - Output format (<tt>[ISO_OFFSET_DATE_TIME]</tt>)  See <a href="#customizing-timestamp">above</a> for possible values.</li>
           <li><tt>timeZone</tt> - Timezone (local timezone)</li>
         </ul>
       </td>
diff --git a/pom.xml b/pom.xml
index a753cd08..2707c6dc 100644
--- a/pom.xml
+++ b/pom.xml
@@ -33,7 +33,6 @@
 
         <!-- shaded runtime dependencies -->
         <com.lmax.disruptor.version>3.4.2</com.lmax.disruptor.version>
-        <commons-lang3.version>3.9</commons-lang3.version>
 
         <!-- test dependencies -->
         <junit.version>4.12</junit.version>
@@ -173,11 +172,6 @@
             -->
             <optional>true</optional>
         </dependency>
-        <dependency>
-            <groupId>org.apache.commons</groupId>
-            <artifactId>commons-lang3</artifactId>
-            <version>${commons-lang3.version}</version>
-        </dependency>
         <dependency>
             <groupId>com.lmax</groupId>
             <artifactId>disruptor</artifactId>
@@ -336,7 +330,7 @@
                         <!-- attach to Logback bundle as fragment -->
                         <Fragment-Host>ch.qos.logback.classic</Fragment-Host>
                         <!-- exclude following imports as required classes are relocated by shade plugin and ignore ch.qos.logback.[core,classic] because this is a fragment and gets them from parent. -->
-                        <Import-Package>!org.apache.commons.*,!com.lmax.disruptor.*,!ch.qos.logback.classic.*,!ch.qos.logback.core.*,!org.slf4j.*,*</Import-Package>
+                        <Import-Package>!com.lmax.disruptor.*,!ch.qos.logback.classic.*,!ch.qos.logback.core.*,!org.slf4j.*,*</Import-Package>
                     </instructions>
                 </configuration>
             </plugin>
@@ -406,10 +400,6 @@
                             </excludes>
                         </artifactSet>
                         <relocations>
-                            <relocation>
-                                <pattern>org.apache.commons.lang3</pattern>
-                                <shadedPattern>${project.groupId}.encoder.org.apache.commons.lang3</shadedPattern>
-                            </relocation>
                             <relocation>
                                 <pattern>com.lmax.disruptor</pattern>
                                 <shadedPattern>${project.groupId}.encoder.com.lmax.disruptor</shadedPattern>
diff --git a/src/main/java/net/logstash/logback/appender/listener/FailureSummaryLoggingAppenderListener.java b/src/main/java/net/logstash/logback/appender/listener/FailureSummaryLoggingAppenderListener.java
index a509385f..22318f87 100644
--- a/src/main/java/net/logstash/logback/appender/listener/FailureSummaryLoggingAppenderListener.java
+++ b/src/main/java/net/logstash/logback/appender/listener/FailureSummaryLoggingAppenderListener.java
@@ -14,11 +14,13 @@
 package net.logstash.logback.appender.listener;
 
 import java.time.Duration;
+import java.time.Instant;
+import java.time.format.DateTimeFormatter;
 import java.util.Objects;
+import java.util.TimeZone;
 
 import ch.qos.logback.core.spi.DeferredProcessingAware;
 import net.logstash.logback.argument.StructuredArguments;
-import org.apache.commons.lang3.time.DateFormatUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -52,7 +54,7 @@ protected void handleFailureSummary(FailureSummary failureSummary, CallbackType
             logger.warn("{} {} failures since {} for {}.",
                     StructuredArguments.value("failEventCount", failureSummary.getConsecutiveFailures()),
                     StructuredArguments.value("failType", callbackType.name().toLowerCase()),
-                    StructuredArguments.value("failStartTime", DateFormatUtils.ISO_8601_EXTENDED_DATETIME_FORMAT.format(failureSummary.getFirstFailureTime())),
+                    StructuredArguments.value("failStartTime", DateTimeFormatter.ISO_OFFSET_DATE_TIME.withZone(TimeZone.getDefault().toZoneId()).format(Instant.ofEpochMilli(failureSummary.getFirstFailureTime()))),
                     StructuredArguments.value("failDuration", Duration.ofMillis(System.currentTimeMillis() - failureSummary.getFirstFailureTime()).toString()),
                     failureSummary.getMostRecentFailure());
         }
diff --git a/src/main/java/net/logstash/logback/composite/FormattedTimestampJsonProvider.java b/src/main/java/net/logstash/logback/composite/FormattedTimestampJsonProvider.java
index a370775d..fde60ca5 100644
--- a/src/main/java/net/logstash/logback/composite/FormattedTimestampJsonProvider.java
+++ b/src/main/java/net/logstash/logback/composite/FormattedTimestampJsonProvider.java
@@ -14,20 +14,21 @@
 package net.logstash.logback.composite;
 
 import java.io.IOException;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.time.Instant;
+import java.time.format.DateTimeFormatter;
 import java.util.TimeZone;
 
-import net.logstash.logback.fieldnames.LogstashCommonFieldNames;
-
-import org.apache.commons.lang3.time.FastDateFormat;
-
 import ch.qos.logback.core.spi.DeferredProcessingAware;
+import net.logstash.logback.fieldnames.LogstashCommonFieldNames;
 
 import com.fasterxml.jackson.core.JsonGenerator;
 
 /**
  * Writes the timestamp field as either:
  * <ul>
- *      <li>A string value formatted by a {@link FastDateFormat} pattern</li>
+ *      <li>A string value formatted by a {@link DateTimeFormatter} pattern</li>
  *      <li>A string value representing the number of milliseconds since unix epoch  (designated by specifying the pattern value as {@value #UNIX_TIMESTAMP_AS_STRING})</li>
  *      <li>A number value of the milliseconds since unix epoch  (designated by specifying the pattern value as {@value #UNIX_TIMESTAMP_AS_NUMBER})</li>
  * </ul>
@@ -48,14 +49,20 @@ public abstract class FormattedTimestampJsonProvider<Event extends DeferredProce
      */
     public static final String UNIX_TIMESTAMP_AS_STRING = "[UNIX_TIMESTAMP_AS_STRING]";
     
-    private static final String DEFAULT_PATTERN = "yyyy-MM-dd'T'HH:mm:ss.SSSZZ";
-    private static final TimeZone DEFAULT_TIMEZONE = null;
+    private static final String DEFAULT_PATTERN = "[ISO_OFFSET_DATE_TIME]";
+    private static final TimeZone DEFAULT_TIMEZONE = TimeZone.getDefault();
     
     /**
      * The pattern in which to format the timestamp.
-     * Setting this value to {@value #UNIX_TIMESTAMP_AS_NUMBER} will cause the timestamp to be written as a number value of the milliseconds since unix epoch. 
-     * Setting this value to {@value #UNIX_TIMESTAMP_AS_STRING} will cause the timestamp to be written as a string value representing the number value of the milliseconds since unix epoch.
-     * Any other value will be used as a pattern for formatting the timestamp by a {@link FastDateFormat} 
+     *
+     * <p>Possible values:</p>
+     *
+     * <ul>
+     *     <li>{@value #UNIX_TIMESTAMP_AS_NUMBER} - timestamp written as a JSON number value of the milliseconds since unix epoch</li>
+     *     <li>{@value #UNIX_TIMESTAMP_AS_STRING} - timestamp written as a JSON string value of the milliseconds since unix epoch</li>
+     *     <li><code>[<em>constant</em>]</code> - timestamp written using the {@link DateTimeFormatter} constant specified by <code><em>constant</em></code> (e.g. {@code [ISO_OFFSET_DATE_TIME]})</li>
+     *     <li>any other value - timestamp written by a {@link DateTimeFormatter} created from the pattern string specified
+     * </ul>
      */
     private String pattern = DEFAULT_PATTERN;
     
@@ -68,12 +75,12 @@ public abstract class FormattedTimestampJsonProvider<Event extends DeferredProce
     /**
      * Writes the timestamp to the JsonGenerator.
      */
-    private TimestampWriter timestampWriter = new PatternTimestampWriter(FastDateFormat.getInstance(pattern, timeZone));
+    private TimestampWriter timestampWriter;
     
     /**
      * Writes the timestamp to the JsonGenerator
      */
-    private static interface TimestampWriter {
+    private interface TimestampWriter {
         void writeTo(JsonGenerator generator, String fieldName, long timestampInMillis) throws IOException;
         
         String getTimestampAsString(long timestampInMillis);
@@ -84,9 +91,9 @@ private static interface TimestampWriter {
      */
     private static class PatternTimestampWriter implements TimestampWriter {
 
-        private final FastDateFormat formatter;
-        
-        public PatternTimestampWriter(FastDateFormat formatter) {
+        private final DateTimeFormatter formatter;
+
+        public PatternTimestampWriter(DateTimeFormatter formatter) {
             this.formatter = formatter;
         }
 
@@ -98,7 +105,7 @@ public void writeTo(JsonGenerator generator, String fieldName, long timestampInM
 
         @Override
         public String getTimestampAsString(long timestampInMillis) {
-            return formatter.format(timestampInMillis);
+            return formatter.format(Instant.ofEpochMilli(timestampInMillis));
         }
     }
     
@@ -137,6 +144,7 @@ public String getTimestampAsString(long timestampInMillis) {
     
     public FormattedTimestampJsonProvider() {
         setFieldName(FIELD_TIMESTAMP);
+        updateTimestampWriter();
     }
     
     @Override
@@ -163,8 +171,27 @@ private void updateTimestampWriter() {
             timestampWriter = new NumberTimestampWriter();
         } else if (UNIX_TIMESTAMP_AS_STRING.equals(pattern)) {
             timestampWriter = new StringTimestampWriter();
+        } else if (pattern.startsWith("[") && pattern.endsWith("]")) {
+            String constant = pattern.substring("[".length(), pattern.length() - "]".length());
+            try {
+                Field field = DateTimeFormatter.class.getField(constant);
+                if (Modifier.isStatic(field.getModifiers())
+                        && Modifier.isFinal(field.getModifiers())
+                        && field.getType().equals(DateTimeFormatter.class)) {
+                    try {
+                        DateTimeFormatter formatter = (DateTimeFormatter) field.get(null);
+                        timestampWriter = new PatternTimestampWriter(formatter.withZone(timeZone.toZoneId()));
+                    } catch (IllegalAccessException e) {
+                        throw new IllegalArgumentException(String.format("Unable to get value of constant named %s in %s", constant, DateTimeFormatter.class), e);
+                    }
+                } else {
+                    throw new IllegalArgumentException(String.format("Field named %s in %s is not a constant %s", constant, DateTimeFormatter.class, DateTimeFormatter.class));
+                }
+            } catch (NoSuchFieldException e) {
+                throw new IllegalArgumentException(String.format("No constant named %s found in %s", constant, DateTimeFormatter.class), e);
+            }
         } else {
-            timestampWriter = new PatternTimestampWriter(FastDateFormat.getInstance(pattern, timeZone));
+            timestampWriter = new PatternTimestampWriter(DateTimeFormatter.ofPattern(pattern).withZone(timeZone.toZoneId()));
         }
     }
     
diff --git a/src/test/java/net/logstash/logback/composite/loggingevent/LoggingEventFormattedTimestampJsonProviderTest.java b/src/test/java/net/logstash/logback/composite/loggingevent/LoggingEventFormattedTimestampJsonProviderTest.java
new file mode 100644
index 00000000..cbe4ab2f
--- /dev/null
+++ b/src/test/java/net/logstash/logback/composite/loggingevent/LoggingEventFormattedTimestampJsonProviderTest.java
@@ -0,0 +1,123 @@
+/**
+ * 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 net.logstash.logback.composite.loggingevent;
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.TimeZone;
+
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import net.logstash.logback.composite.FormattedTimestampJsonProvider;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+
+public class LoggingEventFormattedTimestampJsonProviderTest {
+
+    @Rule
+    public final MockitoRule mockitoRule = MockitoJUnit.rule();
+
+    @Mock
+    private JsonGenerator generator;
+
+    @Mock
+    private ILoggingEvent event;
+
+    @Test
+    public void withDefaults() throws IOException {
+        LoggingEventFormattedTimestampJsonProvider provider = new LoggingEventFormattedTimestampJsonProvider();
+        when(event.getTimeStamp()).thenReturn(0L);
+
+        provider.writeTo(generator, event);
+
+        String expectedValue = DateTimeFormatter.ISO_OFFSET_DATE_TIME.withZone(TimeZone.getDefault().toZoneId()).format(Instant.ofEpochMilli(0));
+        verify(generator).writeStringField(FormattedTimestampJsonProvider.FIELD_TIMESTAMP, expectedValue);
+    }
+
+    @Test
+    public void customTimeZone() throws IOException {
+        LoggingEventFormattedTimestampJsonProvider provider = new LoggingEventFormattedTimestampJsonProvider();
+        provider.setTimeZone("UTC");
+        when(event.getTimeStamp()).thenReturn(0L);
+
+        provider.writeTo(generator, event);
+
+        String expectedValue = DateTimeFormatter.ISO_OFFSET_DATE_TIME.withZone(ZoneId.of("UTC")).format(Instant.ofEpochMilli(0));
+        verify(generator).writeStringField(FormattedTimestampJsonProvider.FIELD_TIMESTAMP, expectedValue);
+    }
+
+    @Test
+    public void constant() throws IOException {
+        LoggingEventFormattedTimestampJsonProvider provider = new LoggingEventFormattedTimestampJsonProvider();
+        provider.setPattern("[ISO_DATE_TIME]");
+        when(event.getTimeStamp()).thenReturn(0L);
+
+        provider.writeTo(generator, event);
+
+        String expectedValue = DateTimeFormatter.ISO_DATE_TIME.withZone(TimeZone.getDefault().toZoneId()).format(Instant.ofEpochMilli(0));
+        verify(generator).writeStringField(FormattedTimestampJsonProvider.FIELD_TIMESTAMP, expectedValue);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void unknownConstant() throws IOException {
+        LoggingEventFormattedTimestampJsonProvider provider = new LoggingEventFormattedTimestampJsonProvider();
+        provider.setPattern("[foo]");
+    }
+
+    @Test
+    public void customPattern() throws IOException {
+        LoggingEventFormattedTimestampJsonProvider provider = new LoggingEventFormattedTimestampJsonProvider();
+        String pattern = "yyyy-MM-dd'T'HH:mm:ss.SSS";
+        provider.setPattern(pattern);
+        when(event.getTimeStamp()).thenReturn(0L);
+
+        provider.writeTo(generator, event);
+
+        String expectedValue = DateTimeFormatter.ofPattern(pattern).withZone(TimeZone.getDefault().toZoneId()).format(Instant.ofEpochMilli(0));
+        verify(generator).writeStringField(FormattedTimestampJsonProvider.FIELD_TIMESTAMP, expectedValue);
+    }
+
+    @Test
+    public void unixEpochAsNumber() throws IOException {
+        LoggingEventFormattedTimestampJsonProvider provider = new LoggingEventFormattedTimestampJsonProvider();
+        provider.setPattern(FormattedTimestampJsonProvider.UNIX_TIMESTAMP_AS_NUMBER);
+        when(event.getTimeStamp()).thenReturn(0L);
+
+        provider.writeTo(generator, event);
+
+        verify(generator).writeNumberField(FormattedTimestampJsonProvider.FIELD_TIMESTAMP, 0);
+    }
+
+    @Test
+    public void unixEpochAsString() throws IOException {
+        LoggingEventFormattedTimestampJsonProvider provider = new LoggingEventFormattedTimestampJsonProvider();
+        provider.setPattern(FormattedTimestampJsonProvider.UNIX_TIMESTAMP_AS_STRING);
+        when(event.getTimeStamp()).thenReturn(0L);
+
+        provider.writeTo(generator, event);
+
+        verify(generator).writeStringField(FormattedTimestampJsonProvider.FIELD_TIMESTAMP, "0");
+    }
+
+
+}
\ No newline at end of file
diff --git a/src/test/java/net/logstash/logback/encoder/LogstashAccessEncoderTest.java b/src/test/java/net/logstash/logback/encoder/LogstashAccessEncoderTest.java
index 235b27bb..a3a25367 100644
--- a/src/test/java/net/logstash/logback/encoder/LogstashAccessEncoderTest.java
+++ b/src/test/java/net/logstash/logback/encoder/LogstashAccessEncoderTest.java
@@ -19,10 +19,12 @@
 import static org.mockito.Mockito.when;
 
 import java.io.ByteArrayOutputStream;
+import java.time.Instant;
+import java.time.format.DateTimeFormatter;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.TimeZone;
 
-import org.apache.commons.lang3.time.FastDateFormat;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
@@ -89,12 +91,11 @@ public void basicsAreIncluded_logback12OrLater() throws Exception {
     }
     
     protected void verifyBasics(final long timestamp, IAccessEvent event, JsonNode node) {
-        assertThat(node.get("timestamp").textValue()).isEqualTo(FastDateFormat.getInstance("yyyy-MM-dd'T'HH:mm:ss.SSSZZ").format
-                (timestamp));
+        assertThat(node.get("timestamp").textValue()).isEqualTo(DateTimeFormatter.ISO_OFFSET_DATE_TIME.withZone(TimeZone.getDefault().toZoneId()).format(Instant.ofEpochMilli(timestamp)));
         assertThat(node.get("@version").textValue()).isEqualTo("1");
         assertThat(node.get("message").textValue()).isEqualTo(String.format("%s - %s [%s] \"%s\" %s %s", event.getRemoteHost(), event.getRemoteUser(),
-                FastDateFormat.getInstance("yyyy-MM-dd'T'HH:mm:ss.SSSZZ").format
-                        (event.getTimeStamp()), event.getRequestURL(), event.getStatusCode(),
+                DateTimeFormatter.ISO_OFFSET_DATE_TIME.withZone(TimeZone.getDefault().toZoneId())
+                        .format(Instant.ofEpochMilli(event.getTimeStamp())), event.getRequestURL(), event.getStatusCode(),
                 event.getContentLength()));
         
         assertThat(node.get("method").textValue()).isEqualTo(event.getMethod());
diff --git a/src/test/java/net/logstash/logback/encoder/LogstashEncoderTest.java b/src/test/java/net/logstash/logback/encoder/LogstashEncoderTest.java
index a41f287e..8e6cfa23 100644
--- a/src/test/java/net/logstash/logback/encoder/LogstashEncoderTest.java
+++ b/src/test/java/net/logstash/logback/encoder/LogstashEncoderTest.java
@@ -25,6 +25,8 @@
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.nio.charset.StandardCharsets;
+import java.time.Instant;
+import java.time.format.DateTimeFormatter;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
@@ -38,7 +40,6 @@
 import net.logstash.logback.fieldnames.LogstashCommonFieldNames;
 import net.logstash.logback.fieldnames.ShortenedFieldNames;
 
-import org.apache.commons.lang3.time.FastDateFormat;
 import org.assertj.core.util.Files;
 import org.junit.Assert;
 import org.junit.Test;
@@ -120,7 +121,7 @@ public void basicsAreIncluded_logback12() throws Exception {
     }
 
     protected void verifyBasics(final long timestamp, JsonNode node) {
-        assertThat(node.get("@timestamp").textValue()).isEqualTo(FastDateFormat.getInstance("yyyy-MM-dd'T'HH:mm:ss.SSSZZ").format(timestamp));
+        assertThat(node.get("@timestamp").textValue()).isEqualTo(DateTimeFormatter.ISO_OFFSET_DATE_TIME.withZone(TimeZone.getDefault().toZoneId()).format(Instant.ofEpochMilli(timestamp)));
         assertThat(node.get("@version").textValue()).isEqualTo("1");
         assertThat(node.get("logger_name").textValue()).isEqualTo("LoggerName");
         assertThat(node.get("thread_name").textValue()).isEqualTo("ThreadName");
@@ -141,9 +142,8 @@ public void basicsAreIncludedWithShortenedNames() throws Exception {
         byte[] encoded = encoder.encode(event);
         
         JsonNode node = MAPPER.readTree(encoded);
-        
-        assertThat(node.get("@timestamp").textValue()).isEqualTo(FastDateFormat.getInstance("yyyy-MM-dd'T'HH:mm:ss.SSSZZ").format
-                (timestamp));
+
+        assertThat(node.get("@timestamp").textValue()).isEqualTo(DateTimeFormatter.ISO_OFFSET_DATE_TIME.withZone(TimeZone.getDefault().toZoneId()).format(Instant.ofEpochMilli(timestamp)));
         assertThat(node.get("@version").textValue()).isEqualTo("1");
         assertThat(node.get("logger").textValue()).isEqualTo("LoggerName");
         assertThat(node.get("thread").textValue()).isEqualTo("ThreadName");
@@ -180,10 +180,10 @@ public JsonGenerator decorate(JsonGenerator generator) {
         byte[] encoded = encoder.encode(event);
         
         String output = new String(encoded, "UTF-8");
-        
+
         assertThat(output).isEqualTo(String.format(
                 "{%n"
-                + "  @timestamp : \"" + FastDateFormat.getInstance("yyyy-MM-dd'T'HH:mm:ss.SSSZZ").format(timestamp) + "\",%n"
+                + "  @timestamp : \"" + DateTimeFormatter.ISO_OFFSET_DATE_TIME.withZone(TimeZone.getDefault().toZoneId()).format(Instant.ofEpochMilli(timestamp)) + "\",%n"
                 + "  @version : \"1\",%n"
                 + "  message : \"My message\",%n"
                 + "  logger_name : \"LoggerName\",%n"
@@ -198,10 +198,10 @@ public JsonGenerator decorate(JsonGenerator generator) {
     public void loggerNameIsShortenedProperly() throws Exception {
         final long timestamp = System.currentTimeMillis();
         final int length = 36;
-        final String shortenedLoggerName = new TargetLengthBasedClassNameAbbreviator(length).abbreviate(FastDateFormat.class.getCanonicalName());
+        final String shortenedLoggerName = new TargetLengthBasedClassNameAbbreviator(length).abbreviate(DateTimeFormatter.class.getCanonicalName());
 
         ILoggingEvent event = mockBasicILoggingEvent(Level.ERROR);
-        when(event.getLoggerName()).thenReturn(FastDateFormat.class.getCanonicalName());
+        when(event.getLoggerName()).thenReturn(DateTimeFormatter.class.getCanonicalName());
 
         when(event.getTimeStamp()).thenReturn(timestamp);
         encoder.setFieldNames(new ShortenedFieldNames());
@@ -211,8 +211,7 @@ public void loggerNameIsShortenedProperly() throws Exception {
         
         JsonNode node = MAPPER.readTree(encoded);
 
-        assertThat(node.get("@timestamp").textValue()).isEqualTo(FastDateFormat.getInstance("yyyy-MM-dd'T'HH:mm:ss.SSSZZ").format
-                (timestamp));
+        assertThat(node.get("@timestamp").textValue()).isEqualTo(DateTimeFormatter.ISO_OFFSET_DATE_TIME.withZone(TimeZone.getDefault().toZoneId()).format(Instant.ofEpochMilli(timestamp)));
         assertThat(node.get("@version").textValue()).isEqualTo("1");
         assertThat(node.get("logger").textValue()).isEqualTo(shortenedLoggerName);
         assertThat(node.get("thread").textValue()).isEqualTo("ThreadName");
@@ -619,9 +618,8 @@ public void customTimeZone() throws Exception {
         byte[] encoded = encoder.encode(event);
         
         JsonNode node = MAPPER.readTree(encoded);
-        
-        assertThat(node.get("@timestamp").textValue()).isEqualTo(FastDateFormat.getInstance("yyyy-MM-dd'T'HH:mm:ss.SSSZZ", TimeZone.getTimeZone("UTC")).format
-                (timestamp));
+
+        assertThat(node.get("@timestamp").textValue()).isEqualTo(DateTimeFormatter.ISO_OFFSET_DATE_TIME.withZone(TimeZone.getTimeZone("UTC").toZoneId()).format(Instant.ofEpochMilli(timestamp)));
         assertThat(node.get("@version").textValue()).isEqualTo("1");
         assertThat(node.get("logger_name").textValue()).isEqualTo("LoggerName");
         assertThat(node.get("thread_name").textValue()).isEqualTo("ThreadName");