Add custom JSON logging support with unescaped data and plain message fields

- Ensured `data` field is unescaped JSON, while `message` remains a simple String
- Updated `EcsLayout.json` to include `message`, `data`, and `context` fields (or add a new template)
- `context` is populated via MDC (`ThreadContext.put`) and supports simple key-value pairs

(cherry picked from commit c6c58e5)

Author: mrodbratschi

common/src/main/java/com/genexus/diagnostics/UserLog.java

@@ -120,4 +120,17 @@ public static void debug(String message, String topic) {
 	public static void debug(String message, String topic, Throwable ex) {
 		getLogger(topic).debug(message, ex);
 	}
+
+
+	/******* Log Improvements *****/
+
+	public static void setContext(String key, Object value) {
+		// Topic is ignored, also if you put something
+		getLogger("$").setContext(key, value);
+	}
+
+	public static void write(String message, String topic, int logLevel, Object data, boolean stackTrace) {
+		getLogger(topic).write(message, logLevel, data, stackTrace);
+	}
+
 }

common/src/main/java/com/genexus/diagnostics/core/ILogger.java

@@ -65,5 +65,15 @@ public interface ILogger {
 	 * msg); } }
 	 */
 
-	
+
+	/******* START - Log Improvements *****/
+	// A default implementation is added for AndroidLogger because it fails, it needs an
+	// implementation, another solution is to declare the class as abstract, but it is
+	// not possible because of the way the class is made.
+
+	default void setContext(String key, Object value) {}
+
+	default void write(String message, int logLevel, Object data, boolean stackTrace) {}
+
+	/******* END - Log Improvements *****/
 }

wrappercommon/pom.xml

@@ -56,9 +56,22 @@
                 </exclusion>
             </exclusions>
         </dependency>
-
-
-
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.12.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.genexus</groupId>
+            <artifactId>gxclassR</artifactId>
+            <version>104.6-trunk.20240524121701-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-layout-template-json</artifactId>
+            <version>2.24.3</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -86,4 +99,4 @@
             </plugin>
         </plugins>
     </build>
-</project>
+</project>

wrappercommon/src/main/java/com/genexus/diagnostics/core/provider/Log4J2Logger.java

@@ -1,6 +1,22 @@
 package com.genexus.diagnostics.core.provider;
 
+import com.genexus.diagnostics.LogLevel;
 import com.genexus.diagnostics.core.ILogger;
+import com.genexus.GxUserType;
+import com.google.gson.*;
+import com.google.gson.reflect.TypeToken;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.ThreadContext;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Configuration;
+import org.apache.logging.log4j.layout.template.json.JsonTemplateLayout;
+import org.apache.logging.log4j.message.ObjectMessage;
+
+import java.lang.reflect.Type;
+import java.util.*;
 
 public class Log4J2Logger implements ILogger {
 	private org.apache.logging.log4j.Logger log;
@@ -37,7 +53,7 @@ public void fatal(Throwable ex, String[] list) {
 	}
 
 	public void fatal(String[] list) {
-		fatal(null, list);
+		fatal((Throwable) null, list);
 	}
 
 	public void error(String msg, Throwable ex) {
@@ -59,7 +75,7 @@ public void error(Throwable ex, String[] list) {
 	}
 
 	public void error(String[] list) {
-		error(null, list);
+		error((Throwable) null, list);
 	}
 
 	public void error(String msg) {
@@ -80,7 +96,7 @@ public void warn(Throwable ex, String[] list) {
 	}
 
 	public void warn(String[] list) {
-		warn(null, list);
+		warn((Throwable) null, list);
 	}
 
 	public void warn(String msg, Throwable ex) {
@@ -106,7 +122,7 @@ public void debug(Throwable ex, String[] list) {
 	}
 
 	public void debug(String[] list) {
-		debug(null, list);
+		debug((Throwable) null, list);
 	}
 
 	// Lambda Functions not supported JAVA 7. Only Java 8.
@@ -162,7 +178,7 @@ public void trace(Throwable ex, String[] list) {
 	}
 
 	public void trace(String[] list) {
-		trace(null, list);
+		trace((Throwable) null, list);
 	}
 
 	// Lambda Functions not supported JAVA 7. Only Java 8.
@@ -190,4 +206,204 @@ public boolean isErrorEnabled() {
 		return log.isErrorEnabled();
 	}
 
+
+
+
+
+
+
+	/******** NEW methods to improve logging ********/
+
+	public void setContext(String key, Object value) {
+		// Add entry to the MDC (only works for JSON log format)
+		ThreadContext.put(key, fromObjectToString(value));
+	}
+
+	private ObjectMessage buildLogMessage(String messageKey, Object messageValue, boolean stackTrace) {
+		Map<String, Object> messageMap;
+		String stacktraceLabel = "stackTrace";
+		String msgLabel = "message";
+
+		if (isNullOrBlank(messageValue)) {
+			if (stackTrace) {
+				messageMap = new LinkedHashMap<>();
+				messageMap.put(msgLabel, messageKey);
+				messageMap.put(stacktraceLabel, getStackTraceAsList());
+				if(isJsonLogFormat())
+					return new ObjectMessage(messageMap);
+				else
+					return new ObjectMessage(new Gson().toJson(messageMap));
+			}
+			return new ObjectMessage(messageKey);
+		} else {
+			messageMap = objectToMap(messageKey, messageValue);
+			if (stackTrace) {
+				messageMap.put(stacktraceLabel, getStackTraceAsList());
+			}
+			if(isJsonLogFormat())
+				return new ObjectMessage(messageMap);
+			else
+				return new ObjectMessage(new Gson().toJson(messageMap));
+		}
+	}
+
+	public void write(String message, int logLevel, Object data, boolean stackTrace) {
+		printLog("data", data, stackTrace, Level.DEBUG);
+	}
+
+	private void printLog(final String messageKey, final Object messageValue, final boolean stackTrace,
+						  final Level logLevel) {
+
+		/* Generate the message JSON in this format:
+		 * { "message" :
+		 * 	{
+		 * 		"messageKey": "USER messageValue",
+		 * 	}
+		 * }
+		 * */
+		ObjectMessage om = buildLogMessage(messageKey, messageValue, stackTrace);
+
+		// Log the message received or the crafted msg
+		if (logLevel.equals(Level.FATAL))      log.fatal(om);
+		else if (logLevel.equals(Level.ERROR)) log.error(om);
+		else if (logLevel.equals(Level.WARN))  log.warn(om);
+		else if (logLevel.equals(Level.INFO))  log.info(om);
+		else if (logLevel.equals(Level.DEBUG)) log.debug(om);
+		else if (logLevel.equals(Level.TRACE)) log.trace(om);
+	}
+
+
+
+	private static String fromObjectToString(Object value) {
+		String res = "";
+		if (value == null) {
+			res = "null";
+		} else if (value instanceof String && isJson((String) value)) {
+			// Avoid double serialization
+			res = (String) value;
+		} else if (value instanceof String) {
+			res = (String) value;
+		} else if (value instanceof Number || value instanceof Boolean) {
+			res = value.toString();
+		} else if (value instanceof Map || value instanceof List) {
+			res = new Gson().toJson(value);
+		} else if (value instanceof GxUserType) {
+			res = ((GxUserType) value).toJSonString();
+		} else {
+			// Any other object → serialize as JSON
+			res = new Gson().toJson(value);
+		}
+		return res;
+	}
+
+	private static boolean isJson(String input) {
+		try {
+			JsonElement json = JsonParser.parseString(input);
+			return json.isJsonObject() || json.isJsonArray();
+		} catch (Exception e) {
+			return false;
+		}
+	}
+
+	private Map<String, Object> objectToMap(String key, Object value) {
+		Map<String, Object> result = new LinkedHashMap<>();
+		if (value == null) {
+			result.put(key, null);
+		} else if (value instanceof Number || value instanceof Boolean
+				   || value instanceof Map || value instanceof List) {
+			result.put(key, value);
+		} else if (value instanceof GxUserType) {
+			result.put(key, jsonStringToMap(((GxUserType) value).toJSonString()));
+		} else if (value instanceof String) {
+			String str = (String) value;
+
+			// Try to parse as JSON
+			try {
+				JsonElement parsed = JsonParser.parseString(str);
+				Gson gson = new Gson();
+				if (parsed.isJsonObject()) {
+					result.put(key, gson.fromJson(parsed, Map.class));
+				} else if (parsed.isJsonArray()) {
+					result.put(key, gson.fromJson(parsed, List.class));
+				} else if (parsed.isJsonPrimitive()) {
+					JsonPrimitive primitive = parsed.getAsJsonPrimitive();
+					if (primitive.isBoolean()) {
+						result.put(key, primitive.getAsBoolean());
+					} else if (primitive.isNumber()) {
+						result.put(key, primitive.getAsNumber());
+					} else if (primitive.isString()) {
+						result.put(key, primitive.getAsString());
+					}
+				}
+			} catch (JsonSyntaxException e) {
+				// Invalid JSON: it is left as string
+				result.put(key, str);
+			}
+		} else {
+			// Any other object: convert to string
+			result.put(key, value.toString());
+		}
+		return result;
+	}
+
+	private static String getStackTrace() {
+		StringBuilder stackTrace;
+		stackTrace = new StringBuilder();
+		for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
+			stackTrace.append(ste).append(System.lineSeparator());
+		}
+		return stackTrace.toString();
+	}
+
+	private static List<String> getStackTraceAsList() {
+		List<String> stackTraceLines = new ArrayList<>();
+		for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
+			stackTraceLines.add(ste.toString());
+		}
+		return stackTraceLines;
+	}
+
+	private static String stackTraceListToString(List<String> stackTraceLines) {
+		return String.join(System.lineSeparator(), stackTraceLines);
+	}
+
+	// Convert a JSON String to Map<String, Object>
+	private static Map<String, Object> jsonStringToMap(String jsonString) {
+		Gson gson = new Gson();
+		Type type = new TypeToken<Map<String, Object>>(){}.getType();
+		return gson.fromJson(jsonString, type);
+	}
+
+	private String toJson(String key, Object value) {
+		Map<String, Object> map = new HashMap<>();
+		map.put(key, value);
+		return new Gson().toJson(map);
+	}
+
+	private static boolean isJsonLogFormat() {
+		LoggerContext context = (LoggerContext) LogManager.getContext(false);
+		Configuration config = context.getConfiguration();
+
+		for (Appender appender : config.getAppenders().values()) {
+			if (appender instanceof AbstractAppender) {
+				Object layout = ((AbstractAppender) appender).getLayout();
+				if (layout instanceof JsonTemplateLayout) {
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	public static boolean isNullOrBlank(Object obj) {
+		if (obj == null) {
+			return true;
+		}
+		if (obj instanceof String) {
+			return ((String) obj).trim().isEmpty();
+		}
+		return false; // It is not null, and it isn't an empty string
+	}
+
 }