Implement ability to configure a throwable converter (#127)

Author: michaelmcfadyensky

ecs-logging-core/src/main/java/co/elastic/logging/EcsJsonSerializer.java

@@ -11,9 +11,9 @@
  * 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
@@ -34,7 +34,7 @@ public class EcsJsonSerializer {
 
     private static final TimestampSerializer TIMESTAMP_SERIALIZER = new TimestampSerializer();
     private static final ThreadLocal<StringBuilder> messageStringBuilder = new ThreadLocal<StringBuilder>();
-    private static final  String NEW_LINE = System.getProperty("line.separator");
+    private static final String NEW_LINE = System.getProperty("line.separator");
     private static final Pattern NEW_LINE_PATTERN = Pattern.compile("\\n");
 
     public static CharSequence toNullSafeString(final CharSequence s) {
@@ -79,6 +79,7 @@ public static void serializeThreadId(StringBuilder builder, long threadId) {
         builder.append(threadId);
         builder.append(",");
     }
+
     public static void serializeFormattedMessage(StringBuilder builder, String message) {
         builder.append("\"message\":\"");
         JsonUtils.quoteAsString(message, builder);
@@ -214,14 +215,15 @@ public static void serializeException(StringBuilder builder, String exceptionCla
         builder.append("\"error.type\":\"");
         JsonUtils.quoteAsString(exceptionClassName, builder);
         builder.append("\",");
-        builder.append("\"error.message\":\"");
-        JsonUtils.quoteAsString(exceptionMessage, builder);
-        builder.append("\",");
+
+        if (exceptionMessage != null) {
+            builder.append("\"error.message\":\"");
+            JsonUtils.quoteAsString(exceptionMessage, builder);
+            builder.append("\",");
+        }
         if (stackTraceAsArray) {
-            builder.append("\"error.stack_trace\":[").append(NEW_LINE);
-            for (String line : NEW_LINE_PATTERN.split(stackTrace)) {
-                appendQuoted(builder, line);
-            }
+            builder.append("\"error.stack_trace\":[");
+            formatStackTraceAsArray(builder, stackTrace);
             builder.append("]");
         } else {
             builder.append("\"error.stack_trace\":\"");
@@ -230,12 +232,6 @@ public static void serializeException(StringBuilder builder, String exceptionCla
         }
     }
 
-    private static void appendQuoted(StringBuilder builder, CharSequence content) {
-        builder.append('"');
-        JsonUtils.quoteAsString(content, builder);
-        builder.append('"');
-    }
-
     private static CharSequence formatThrowable(final Throwable throwable) {
         StringBuilder buffer = getMessageStringBuilder();
         final PrintWriter pw = new PrintWriter(new StringBuilderWriter(buffer));
@@ -262,6 +258,18 @@ public void println() {
         removeIfEndsWith(jsonBuilder, ",");
     }
 
+    private static void formatStackTraceAsArray(StringBuilder builder, String stackTrace) {
+        builder.append(NEW_LINE);
+        for (String line : NEW_LINE_PATTERN.split(stackTrace)) {
+            builder.append("\t\"");
+            JsonUtils.quoteAsString(line, builder);
+            builder.append("\",");
+            builder.append(NEW_LINE);
+        }
+        removeIfEndsWith(builder, NEW_LINE);
+        removeIfEndsWith(builder, ",");
+    }
+
     public static void removeIfEndsWith(StringBuilder sb, String ending) {
         if (endsWith(sb, ending)) {
             sb.setLength(sb.length() - ending.length());

ecs-logging-core/src/test/java/co/elastic/logging/AbstractEcsLoggingTest.java

@@ -45,7 +45,7 @@
 public abstract class AbstractEcsLoggingTest {
 
     protected ObjectMapper objectMapper = new ObjectMapper();
-    private JsonNode spec;
+    protected JsonNode spec;
 
     @BeforeEach
     final void setUpSpec() throws Exception {

ecs-logging-core/src/test/java/co/elastic/logging/EcsJsonSerializerTest.java

@@ -11,9 +11,9 @@
  * 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
@@ -40,20 +40,25 @@
 
 class EcsJsonSerializerTest {
 
+    private static final String ERROR_TYPE = "error.type";
+    private static final String ERROR_STACK_TRACE = "error.stack_trace";
+    private static final String ERROR_MESSAGE = "error.message";
+    private ObjectMapper objectMapper = new ObjectMapper();
+
     @Test
     void serializeExceptionAsString() throws IOException {
         Exception exception = new Exception("foo");
         StringBuilder jsonBuilder = new StringBuilder();
         jsonBuilder.append('{');
         EcsJsonSerializer.serializeException(jsonBuilder, exception, false);
         jsonBuilder.append('}');
-        JsonNode jsonNode = new ObjectMapper().readTree(jsonBuilder.toString());
+        JsonNode jsonNode = objectMapper.readTree(jsonBuilder.toString());
 
-        assertThat(jsonNode.get("error.type").textValue()).isEqualTo(exception.getClass().getName());
-        assertThat(jsonNode.get("error.message").textValue()).isEqualTo("foo");
+        assertThat(jsonNode.get(ERROR_TYPE).textValue()).isEqualTo(exception.getClass().getName());
+        assertThat(jsonNode.get(ERROR_MESSAGE).textValue()).isEqualTo("foo");
         StringWriter stringWriter = new StringWriter();
         exception.printStackTrace(new PrintWriter(stringWriter));
-        assertThat(jsonNode.get("error.stack_trace").textValue()).isEqualTo(stringWriter.toString());
+        assertThat(jsonNode.get(ERROR_STACK_TRACE).textValue()).isEqualTo(stringWriter.toString());
     }
 
     @Test
@@ -102,13 +107,13 @@ void serializeExceptionAsArray() throws IOException {
         EcsJsonSerializer.serializeException(jsonBuilder, exception, true);
         jsonBuilder.append('}');
         System.out.println(jsonBuilder);
-        JsonNode jsonNode = new ObjectMapper().readTree(jsonBuilder.toString());
+        JsonNode jsonNode = objectMapper.readTree(jsonBuilder.toString());
 
-        assertThat(jsonNode.get("error.type").textValue()).isEqualTo(exception.getClass().getName());
-        assertThat(jsonNode.get("error.message").textValue()).isEqualTo("foo");
+        assertThat(jsonNode.get(ERROR_TYPE).textValue()).isEqualTo(exception.getClass().getName());
+        assertThat(jsonNode.get(ERROR_MESSAGE).textValue()).isEqualTo("foo");
         StringWriter stringWriter = new StringWriter();
         exception.printStackTrace(new PrintWriter(stringWriter));
-        assertThat(StreamSupport.stream(jsonNode.get("error.stack_trace").spliterator(), false)
+        assertThat(StreamSupport.stream(jsonNode.get(ERROR_STACK_TRACE).spliterator(), false)
                 .map(JsonNode::textValue)
                 .collect(Collectors.joining(System.lineSeparator(), "", System.lineSeparator())))
                 .isEqualTo(stringWriter.toString());
@@ -121,6 +126,48 @@ void testRemoveIfEndsWith() {
         assertRemoveIfEndsWith("barfoo", "foo", "bar");
     }
 
+    @Test
+    void serializeException() throws JsonProcessingException {
+        StringBuilder jsonBuilder = new StringBuilder();
+        jsonBuilder.append('{');
+        EcsJsonSerializer.serializeException(jsonBuilder, "className", "message", "stacktrace\ncaused by error", false);
+        jsonBuilder.append('}');
+
+        JsonNode jsonNode = objectMapper.readTree(jsonBuilder.toString());
+        assertThat(jsonNode.get(ERROR_TYPE).textValue()).isEqualTo("className");
+        assertThat(jsonNode.get(ERROR_STACK_TRACE).isArray()).isFalse();
+        assertThat(jsonNode.get(ERROR_STACK_TRACE).textValue()).isEqualTo("stacktrace\ncaused by error");
+        assertThat(jsonNode.get(ERROR_MESSAGE).textValue()).isEqualTo("message");
+    }
+
+    @Test
+    void serializeExceptionWithStackTraceAsArray() throws JsonProcessingException {
+        StringBuilder jsonBuilder = new StringBuilder();
+        jsonBuilder.append('{');
+        EcsJsonSerializer.serializeException(jsonBuilder, "className", "message", "stacktrace\ncaused by error", true);
+        jsonBuilder.append('}');
+
+        JsonNode jsonNode = objectMapper.readTree(jsonBuilder.toString());
+        assertThat(jsonNode.get(ERROR_TYPE).textValue()).isEqualTo("className");
+        assertThat(jsonNode.get(ERROR_STACK_TRACE).isArray()).isTrue();
+        assertThat(jsonNode.get(ERROR_STACK_TRACE).get(0).textValue()).isEqualTo("stacktrace");
+        assertThat(jsonNode.get(ERROR_STACK_TRACE).get(1).textValue()).isEqualTo("caused by error");
+        assertThat(jsonNode.get(ERROR_MESSAGE).textValue()).isEqualTo("message");
+    }
+
+    @Test
+    void serializeExceptionWithNullMessage() throws JsonProcessingException {
+        StringBuilder jsonBuilder = new StringBuilder();
+        jsonBuilder.append('{');
+        EcsJsonSerializer.serializeException(jsonBuilder, "className", null, "stacktrace", false);
+        jsonBuilder.append('}');
+
+        JsonNode jsonNode = objectMapper.readTree(jsonBuilder.toString());
+        assertThat(jsonNode.get(ERROR_TYPE).textValue()).isEqualTo("className");
+        assertThat(jsonNode.get(ERROR_STACK_TRACE).textValue()).isEqualTo("stacktrace");
+        assertThat(jsonNode.get(ERROR_MESSAGE)).isNull();
+    }
+
     private void assertRemoveIfEndsWith(String builder, String ending, String expected) {
         StringBuilder sb = new StringBuilder(builder);
         EcsJsonSerializer.removeIfEndsWith(sb, ending);

logback-ecs-encoder/src/main/java/co/elastic/logging/logback/EcsEncoder.java

@@ -11,9 +11,9 @@
  * 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
@@ -24,13 +24,14 @@
  */
 package co.elastic.logging.logback;
 
+import ch.qos.logback.classic.pattern.ThrowableHandlingConverter;
 import ch.qos.logback.classic.pattern.ThrowableProxyConverter;
 import ch.qos.logback.classic.spi.ILoggingEvent;
 import ch.qos.logback.classic.spi.IThrowableProxy;
 import ch.qos.logback.classic.spi.ThrowableProxy;
 import ch.qos.logback.core.encoder.EncoderBase;
-import co.elastic.logging.EcsJsonSerializer;
 import co.elastic.logging.AdditionalField;
+import co.elastic.logging.EcsJsonSerializer;
 import org.slf4j.Marker;
 
 import java.io.IOException;
@@ -48,7 +49,8 @@ public class EcsEncoder extends EncoderBase<ILoggingEvent> {
     private String serviceNodeName;
     private String eventDataset;
     private boolean includeMarkers = false;
-    private ThrowableProxyConverter throwableProxyConverter;
+    private ThrowableHandlingConverter throwableConverter = null;
+    private final ThrowableProxyConverter throwableProxyConverter = new ThrowableProxyConverter();
     private boolean includeOrigin;
     private final List<AdditionalField> additionalFields = new ArrayList<AdditionalField>();
     private OutputStream os;
@@ -61,10 +63,13 @@ public byte[] headerBytes() {
     @Override
     public void start() {
         super.start();
-        throwableProxyConverter = new ThrowableProxyConverter();
         throwableProxyConverter.start();
+        if (throwableConverter != null) {
+            throwableConverter.start();
+        }
         eventDataset = EcsJsonSerializer.computeEventDataset(eventDataset, serviceName);
     }
+
     /**
      * This method has been removed in logback 1.2.
      * To make this lib backwards compatible with logback 1.1 we have implement this method.
@@ -117,10 +122,14 @@ public byte[] encode(ILoggingEvent event) {
         // Allow subclasses to add custom fields. Calling this before the throwable serialization so we don't need to check for presence/absence of an ending comma.
         addCustomFields(event, builder);
         IThrowableProxy throwableProxy = event.getThrowableProxy();
-        if (throwableProxy instanceof ThrowableProxy) {
-            EcsJsonSerializer.serializeException(builder, ((ThrowableProxy) throwableProxy).getThrowable(), stackTraceAsArray);
-        } else if (throwableProxy != null) {
-            EcsJsonSerializer.serializeException(builder, throwableProxy.getClassName(), throwableProxy.getMessage(), throwableProxyConverter.convert(event), stackTraceAsArray);
+        if (throwableProxy != null) {
+            if (throwableConverter != null) {
+                EcsJsonSerializer.serializeException(builder, throwableProxy.getClassName(), throwableProxy.getMessage(), throwableConverter.convert(event), stackTraceAsArray);
+            } else if (throwableProxy instanceof ThrowableProxy) {
+                EcsJsonSerializer.serializeException(builder, ((ThrowableProxy) throwableProxy).getThrowable(), stackTraceAsArray);
+            } else {
+                EcsJsonSerializer.serializeException(builder, throwableProxy.getClassName(), throwableProxy.getMessage(), throwableProxyConverter.convert(event), stackTraceAsArray);
+            }
         }
         EcsJsonSerializer.serializeObjectEnd(builder);
         // all these allocations kinda hurt
@@ -186,4 +195,7 @@ public void setEventDataset(String eventDataset) {
         this.eventDataset = eventDataset;
     }
 
+    public void setThrowableConverter(ThrowableHandlingConverter throwableConverter) {
+        this.throwableConverter = throwableConverter;
+    }
 }

logback-ecs-encoder/src/test/java/co/elastic/logging/logback/EcsEncoderWithCustomThrowableConverterIntegrationTest.java

@@ -0,0 +1,64 @@
+/*-
+ * #%L
+ * Java ECS logging
+ * %%
+ * Copyright (C) 2019 - 2021 Elastic and contributors
+ * %%
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. 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.
+ * #L%
+ */
+package co.elastic.logging.logback;
+
+import ch.qos.logback.classic.LoggerContext;
+import ch.qos.logback.classic.util.ContextInitializer;
+import ch.qos.logback.core.joran.spi.JoranException;
+import com.fasterxml.jackson.databind.JsonNode;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class EcsEncoderWithCustomThrowableConverterIntegrationTest extends AbstractEcsEncoderTest {
+    private OutputStreamAppender appender;
+
+    @BeforeEach
+    void setUp() throws JoranException {
+        LoggerContext context = new LoggerContext();
+        ContextInitializer contextInitializer = new ContextInitializer(context);
+        contextInitializer.configureByResource(this.getClass().getResource("/logback-config-with-nop-throwable-converter.xml"));
+        logger = context.getLogger("root");
+        appender = (OutputStreamAppender) logger.getAppender("out");
+    }
+
+    @Override
+    public JsonNode getLastLogLine() throws IOException {
+        return objectMapper.readTree(appender.getBytes());
+    }
+
+    @Test
+    void testLogException() throws Exception {
+        error("test", new RuntimeException("test"));
+        JsonNode log = getAndValidateLastLogLine();
+        assertThat(log.get("log.level").textValue()).isIn("ERROR", "SEVERE");
+        assertThat(log.get("error.message").textValue()).isEqualTo("test");
+        assertThat(log.get("error.type").textValue()).isEqualTo(RuntimeException.class.getName());
+        assertThat(log.get("error.stack_trace").textValue()).contains("");
+    }
+}