Add support for serializing ObjectMessage with Jackson (#37)

Author: felixbarny

log4j2-ecs-layout/README.md

@@ -72,6 +72,18 @@ logger.info(new StringMapMessage()
     .with("foo", "bar"));
 ``` 
 
+If Jackson is on the classpath, you can also use an `ObjectMessage` to add a custom object the resulting JSON.
+
+```java
+logger.info(new ObjectMessage(myObject));
+```
+
+The `myObject` variable refers to a custom object which can be serialized by a Jackson `ObjectMapper`.
+
+Using either will merge the object at the top-level (not nested under `message`) of the log event if it is a JSON object.
+If it's a string, number boolean or an array, it will be converted into a string and added as the `message` property.
+The conversion is done in order to avoid mapping conflicts as `message` is typed as a string in the Elasticsearch mapping.
+
 ### Tips
 It's recommended to use existing [ECS fields](https://www.elastic.co/guide/en/ecs/current/ecs-field-reference.html).
 

log4j2-ecs-layout/pom.xml

@@ -48,9 +48,15 @@
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-core</artifactId>
-            <version>2.12.0</version>
+            <version>${version.log4j}</version>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>2.9.10</version>
+            <optional>true</optional>
+        </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
             <artifactId>ecs-logging-core</artifactId>
@@ -61,7 +67,7 @@
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-core</artifactId>
-            <version>2.12.0</version>
+            <version>${version.log4j}</version>
             <type>test-jar</type>
             <scope>test</scope>
         </dependency>

log4j2-ecs-layout/src/main/java/co/elastic/logging/log4j2/EcsLayout.java

@@ -45,6 +45,7 @@
 import org.apache.logging.log4j.core.util.KeyValuePair;
 import org.apache.logging.log4j.message.Message;
 import org.apache.logging.log4j.message.MultiformatMessage;
+import org.apache.logging.log4j.message.ObjectMessage;
 import org.apache.logging.log4j.util.MultiFormatStringBuilderFormattable;
 import org.apache.logging.log4j.util.StringBuilderFormattable;
 import org.apache.logging.log4j.util.TriConsumer;
@@ -86,6 +87,7 @@ public void accept(final String key, final Object value, final StringBuilder str
     private final boolean includeMarkers;
     private final boolean includeOrigin;
     private final ConcurrentMap<Class<? extends MultiformatMessage>, Boolean> supportsJson = new ConcurrentHashMap<Class<? extends MultiformatMessage>, Boolean>();
+    private final ObjectMessageJacksonSerializer objectMessageJacksonSerializer = ObjectMessageJacksonSerializer.Resolver.INSTANCE.resolve();
 
     private EcsLayout(Configuration config, String serviceName, boolean includeMarkers, KeyValuePair[] additionalFields, Collection<String> topLevelLabels, boolean includeOrigin, boolean stackTraceAsArray) {
         super(config, UTF_8, null, null);
@@ -235,26 +237,41 @@ private void serializeMessage(StringBuilder builder, boolean gcFree, Message mes
             } else {
                 serializeSimpleMessage(builder, gcFree, message, thrown);
             }
+        } else if (objectMessageJacksonSerializer != null && message instanceof ObjectMessage) {
+            final StringBuilder jsonBuffer = EcsJsonSerializer.getMessageStringBuilder();
+            objectMessageJacksonSerializer.formatTo(jsonBuffer, (ObjectMessage) message);
+            addJson(builder, jsonBuffer);
         } else {
             serializeSimpleMessage(builder, gcFree, message, thrown);
         }
     }
 
-    private void serializeJsonMessage(StringBuilder builder, MultiformatMessage message) {
+    private static void serializeJsonMessage(StringBuilder builder, MultiformatMessage message) {
         final StringBuilder messageBuffer = EcsJsonSerializer.getMessageStringBuilder();
         if (message instanceof MultiFormatStringBuilderFormattable) {
             ((MultiFormatStringBuilderFormattable) message).formatTo(JSON_FORMAT, messageBuffer);
         } else {
             messageBuffer.append(message.getFormattedMessage(JSON_FORMAT));
         }
-        if (isObject(messageBuffer)) {
-            moveToRoot(messageBuffer);
-            builder.append(messageBuffer);
-            builder.append(", ");
+        addJson(builder, messageBuffer);
+    }
+
+    private static void addJson(StringBuilder buffer, StringBuilder jsonBuffer) {
+        if (isObject(jsonBuffer)) {
+            moveToRoot(jsonBuffer);
+            buffer.append(jsonBuffer);
+            buffer.append(", ");
         } else {
-            builder.append("\"message\":");
-            builder.append(messageBuffer);
-            builder.append(", ");
+            buffer.append("\"message\":");
+            if (isString(jsonBuffer)) {
+                buffer.append(jsonBuffer);
+            } else {
+                // message always has to be a string to avoid mapping conflicts
+                buffer.append('"');
+                JsonUtils.quoteAsString(jsonBuffer, buffer);
+                buffer.append('"');
+            }
+            buffer.append(", ");
         }
     }
 
@@ -276,11 +293,15 @@ private void serializeSimpleMessage(StringBuilder builder, boolean gcFree, Messa
         builder.append("\", ");
     }
 
-    private boolean isObject(StringBuilder messageBuffer) {
+    private static boolean isObject(StringBuilder messageBuffer) {
         return messageBuffer.length() > 1 && messageBuffer.charAt(0) == '{' && messageBuffer.charAt(messageBuffer.length() -1) == '}';
     }
 
-    private void moveToRoot(StringBuilder messageBuffer) {
+    private static boolean isString(StringBuilder messageBuffer) {
+        return messageBuffer.length() > 1 && messageBuffer.charAt(0) == '"' && messageBuffer.charAt(messageBuffer.length() -1) == '"';
+    }
+
+    private static void moveToRoot(StringBuilder messageBuffer) {
         messageBuffer.setCharAt(0, ' ');
         messageBuffer.setCharAt(messageBuffer.length() -1, ' ');
     }

log4j2-ecs-layout/src/main/java/co/elastic/logging/log4j2/ObjectMapperFactory.java

@@ -0,0 +1,35 @@
+/*-
+ * #%L
+ * Java ECS logging
+ * %%
+ * Copyright (C) 2019 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.log4j2;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * To customize the {@link ObjectMapper} used to serialize the {@link org.apache.logging.log4j.message.ObjectMessage#obj} implement this
+ * interface and add the fully qualified class name to {@code src/main/resources/META-INF/services/co.elastic.logging.log4j2.ObjectMapperFactory}.
+ */
+public interface ObjectMapperFactory {
+    ObjectMapper create();
+}

log4j2-ecs-layout/src/main/java/co/elastic/logging/log4j2/ObjectMessageJacksonSerializer.java

@@ -0,0 +1,88 @@
+/*-
+ * #%L
+ * Java ECS logging
+ * %%
+ * Copyright (C) 2019 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.log4j2;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import org.apache.logging.log4j.core.util.StringBuilderWriter;
+import org.apache.logging.log4j.message.ObjectMessage;
+import org.apache.logging.log4j.status.StatusLogger;
+
+import java.io.IOException;
+import java.util.ServiceLoader;
+
+interface ObjectMessageJacksonSerializer {
+
+    void formatTo(StringBuilder buffer, ObjectMessage objectMessage);
+
+    enum Resolver {
+        INSTANCE;
+
+        ObjectMessageJacksonSerializer resolve() {
+            ObjectMessageJacksonSerializer localDelegate = null;
+            try {
+                // safely discovers if Jackson is available
+                Class.forName("com.fasterxml.jackson.databind.ObjectMapper");
+                // this method has been introduced in 2.7
+                Class.forName("org.apache.logging.log4j.message.ObjectMessage").getMethod("getParameter");
+                // avoid initializing ObjectMessageSerializer$WithJackson if Jackson is not on the classpath to avoid linkage errors
+                return  (ObjectMessageJacksonSerializer) Class.forName("co.elastic.logging.log4j2.ObjectMessageJacksonSerializer$Available").getEnumConstants()[0];
+            } catch (Exception e) {
+                return null;
+            } catch (LinkageError e) {
+                // we should not cause linkage errors but just in case...
+                return null;
+            }
+        }
+    }
+
+    enum Available implements ObjectMessageJacksonSerializer {
+        INSTANCE;
+
+        private final ObjectMapper objectMapper;
+
+        Available() {
+            ObjectMapper mapper = null;
+            for (ObjectMapperFactory objectMapperFactory : ServiceLoader.load(ObjectMapperFactory.class, ObjectMessageJacksonSerializer.class.getClassLoader())) {
+                mapper = objectMapperFactory.create();
+                break;
+            }
+            if (mapper == null) {
+                mapper = new ObjectMapper().disable(SerializationFeature.FAIL_ON_EMPTY_BEANS).findAndRegisterModules();
+            }
+            objectMapper = mapper;
+        }
+
+        @Override
+        public void formatTo(StringBuilder buffer, ObjectMessage objectMessage) {
+            try {
+                objectMapper.writeValue(new StringBuilderWriter(buffer), objectMessage.getParameter());
+            } catch (IOException e) {
+                StatusLogger.getLogger().catching(e);
+                objectMessage.formatTo(buffer);
+            }
+        }
+    }
+}

log4j2-ecs-layout/src/test/java/co/elastic/logging/log4j2/AbstractLog4j2EcsLayoutTest.java

@@ -31,11 +31,14 @@
 import org.apache.logging.log4j.MarkerManager;
 import org.apache.logging.log4j.ThreadContext;
 import org.apache.logging.log4j.core.Logger;
+import org.apache.logging.log4j.message.ObjectMessage;
 import org.apache.logging.log4j.message.StringMapMessage;
 import org.apache.logging.log4j.test.appender.ListAppender;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
+
 import static org.assertj.core.api.Assertions.assertThat;
 
 abstract class AbstractLog4j2EcsLayoutTest extends AbstractEcsLoggingTest {
@@ -97,6 +100,85 @@ void testCustomPatternConverter() throws Exception {
         assertThat(getLastLogLine().get("custom").textValue()).isEqualTo("foo");
     }
 
+    @Test
+    void testJsonMessageObject() throws Exception {
+        root.info(new ObjectMessage(new TestClass("foo", 42, true)));
+
+        assertThat(getLastLogLine().get("foo").textValue()).isEqualTo("foo");
+        assertThat(getLastLogLine().get("bar").intValue()).isEqualTo(42);
+        assertThat(getLastLogLine().get("baz").booleanValue()).isEqualTo(true);
+    }
+
+    @Test
+    void testJsonMessageArray() throws Exception {
+        root.info(new ObjectMessage(List.of("foo", "bar")));
+
+        assertThat(getLastLogLine().get("message").isArray()).isFalse();
+        assertThat(getLastLogLine().get("message").textValue()).isEqualTo("[\"foo\",\"bar\"]");
+    }
+
+    @Test
+    void testJsonMessageString() throws Exception {
+        root.info(new ObjectMessage("foo"));
+
+        assertThat(getLastLogLine().get("message").textValue()).isEqualTo("foo");
+    }
+
+    @Test
+    void testJsonMessageNumber() throws Exception {
+        root.info(new ObjectMessage(42));
+
+        assertThat(getLastLogLine().get("message").isNumber()).isFalse();
+        assertThat(getLastLogLine().get("message").textValue()).isEqualTo("42");
+    }
+
+    @Test
+    void testJsonMessageBoolean() throws Exception {
+        root.info(new ObjectMessage(true));
+
+        assertThat(getLastLogLine().get("message").isBoolean()).isFalse();
+        assertThat(getLastLogLine().get("message").textValue()).isEqualTo("true");
+    }
+
+    public static class TestClass {
+        String foo;
+        int bar;
+        boolean baz;
+
+        private TestClass() {
+        }
+
+        private TestClass(String foo, int bar, boolean baz) {
+            this.foo = foo;
+            this.bar = bar;
+            this.baz = baz;
+        }
+
+        public String getFoo() {
+            return foo;
+        }
+
+        public void setFoo(String foo) {
+            this.foo = foo;
+        }
+
+        public int getBar() {
+            return bar;
+        }
+
+        public void setBar(int bar) {
+            this.bar = bar;
+        }
+
+        public boolean isBaz() {
+            return baz;
+        }
+
+        public void setBaz(boolean baz) {
+            this.baz = baz;
+        }
+    }
+
     @Override
     public void putMdc(String key, String value) {
         ThreadContext.put(key, value);

log4j2-ecs-layout/src/test/java/co/elastic/logging/log4j2/ParameterizedStructuredMessage.java

@@ -1,3 +1,27 @@
+/*-
+ * #%L
+ * Java ECS logging
+ * %%
+ * Copyright (C) 2019 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.log4j2;
 
 import org.apache.logging.log4j.message.MapMessage;

pom.xml

@@ -52,6 +52,7 @@
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
         <parent.base.dir>${project.basedir}</parent.base.dir>
+        <version.log4j>2.12.0</version.log4j>
     </properties>
 
     <distributionManagement>