diff --git a/json-logger/README.md b/json-logger/README.md
index 37abe8f..7d41542 100644
--- a/json-logger/README.md
+++ b/json-logger/README.md
@@ -1,31 +1,38 @@
-# Json-logger Extension
-
-## 2.0.1 version - Release notes
-
-Bug fixes:
-* Added support for large payloads
-
-## 2.0.0 version - Release notes
-
-New features:
-* External Destinations
-* Data masking
-
-Improvements:
-* Field ordering
-
-More details in the coming blog post (stay tuned!)
-
-## 1.1.0 version - Release notes
-
-New features:
-* Scoped loggers to capture "scope bound elapsed time". Great for performance tracking of specific components (e.g. outbound calls)
-* Added "Parse content fields in json output" flag so that content fields can become part of final JSON output rather than a "stringified version" of the content
-
-Improvements:
-* Removed Guava and caching in general with a more efficient handling of timers (for elapsed time)
-* Optimized generation of JSON output
-* Code optimizations
-* Minimized dependency footprint (down from ~23MB to ~13MB)
-* Optimized parsing of TypedValue content fields
-
+# Json-logger Extension for Mule 4 runtime
+
+Json logger makes uses of [Mule Java SDK](https://docs.mulesoft.com/mule-sdk/1.1/getting-started)
+and contains a custom deserializer for masking fields in the JSON.
+
+> Data masking is not possible in any other formats at this time e.g. xml, csv, etc.
+
+## Serialization/Deserialization performance penalty
+When the payload is passed into the json logger component as `application/json`, it is first deserialized
+and masking if specified is applied in place. The serialization takes place when the log is being written out.
+Therefore, at the very minimum, it is a two-step process. The transformation done before or after the json logger
+to convert payload to `application/java` from `application/json` and vice versa will degrade performance.
+
+## Operations:
+There are two operations available:
+1. logger: Use this for regular logging
+2. loggerScope: Use this to measure response times for external calls
+
+## Logging structure:
+```json
+ {
+ "correlationId" : "cbfb9c1f-f904-40f2-bad9-2eac6bc05e84",
+ "message" : "",
+ "content": {
+ "dateOfBirth": "**-**-****"
+ },
+ "priority" : "INFO",
+ "tracePoint" : "START",
+ "locationInfo" : {
+ "fileName" : "api-main-router.xml",
+ "rootContainer" : "api-main",
+ "lineNumber" : "25"
+ },
+ "applicationName" : "proc-checkin-api-v1",
+ "applicationVersion" : "1.2.7",
+ "environment" : "local"
+}
+```
\ No newline at end of file
diff --git a/json-logger/pom.xml b/json-logger/pom.xml
index f76e48d..2cf05f3 100644
--- a/json-logger/pom.xml
+++ b/json-logger/pom.xml
@@ -3,141 +3,64 @@
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- 4.0.0
- ORG_ID_TOKEN
- json-logger
- 2.0.1
- mule-extension
- JSON Logger - Mule 4
+ 4.0.0
+ 7abbfaeb-3816-4907-865e-76d7cb24120f
+ json-logger
+ 3.0.0
+ mule-extension
+ JSON Logger - Mule 4
-
- org.mule.extensions
- mule-modules-parent
- 1.1.1
-
+
+ org.mule.extensions
+ mule-modules-parent
+ 1.1.1
+
-
-
-
- org.apache.maven.plugins
- maven-install-plugin
- 2.5.2
-
-
- org.apache.maven.plugins
- maven-deploy-plugin
- 2.8.2
-
-
- org.jsonschema2pojo
- jsonschema2pojo-maven-plugin
- 0.4.35
-
-
- io.github.mulesoft-consulting
- jsonschema2pojo-mule-annotations
- 1.2.0
- compile
-
-
-
- org.mule.custom.annotation.utils.CustomMuleAnnotator
- ${basedir}/src/main/resources/schema
- ${project.build.directory}/generated-sources
- org.mule.extension.jsonlogger.api.pojos
-
-
-
-
- generate
-
-
-
-
-
-
+
+
+
+ org.apache.maven.plugins
+ maven-install-plugin
+ 2.5.2
+
+
+ org.apache.maven.plugins
+ maven-deploy-plugin
+ 2.8.2
+
-
-
-
- Exchange2
- Exchange2 Repository
- https://maven.anypoint.mulesoft.com/api/v1/organizations/${project.groupId}/maven
- default
-
-
+
+
-
-
- com.fasterxml.jackson.core
- jackson-databind
- 2.10.3
-
-
- commons-lang
- commons-lang
- 2.6
-
-
- commons-beanutils
- commons-beanutils
- 1.9.4
-
-
- joda-time
- joda-time
- 2.10.5
-
-
- org.mule.connectors
- mule-jms-connector
- 1.6.3
- mule-plugin
- provided
-
-
- com.mulesoft.connectors
- mule-amqp-connector
- 1.6.0
- mule-plugin
- provided
-
-
- com.mulesoft.muleesb.modules
- anypoint-mq-rest-client
- 3.1.0
-
-
- async-http-client
- com.ning
-
-
- compile
-
-
- com.jayway.jsonpath
- json-path
- 2.4.0
-
-
- org.slf4j
- slf4j-api
-
-
-
-
- com.lmax
- disruptor
- 3.4.2
-
-
-
-
-
- Exchange2
- Exchange2 Repository
- https://maven.anypoint.mulesoft.com/api/v1/organizations/${project.groupId}/maven
- default
-
-
+
+
+ Exchange2
+ Exchange2 Repository
+ https://maven.anypoint.mulesoft.com/api/v1/organizations/${project.groupId}/maven
+ default
+
+
+
+
+
+ com.fasterxml.jackson.core
+ jackson-databind
+ 2.10.3
+
+
+ org.apache.logging.log4j
+ log4j-slf4j-impl
+ 2.14.1
+ test
+
+
+
+
+
+ Exchange2
+ Exchange2 Repository
+ https://maven.anypoint.mulesoft.com/api/v1/organizations/${project.groupId}/maven
+ default
+
+
diff --git a/json-logger/pom.xml.original b/json-logger/pom.xml.original
deleted file mode 100644
index 519c6eb..0000000
--- a/json-logger/pom.xml.original
+++ /dev/null
@@ -1,94 +0,0 @@
-
-
-
- 4.0.0
- ORG_ID_TOKEN
- json-logger
- 1.1.0
- mule-extension
- JSON Logger - Mule 4
-
-
- org.mule.extensions
- mule-modules-parent
- 1.1.1
-
-
-
-
-
- org.jsonschema2pojo
- jsonschema2pojo-maven-plugin
- 0.4.35
-
-
- cc568b69-a181-4d4c-b044-90054c52897b
- jsonschema2pojo-mule-annotations
- 1.0.0
-
-
-
- org.mule.custom.annotation.utils.CustomMuleAnnotator
- ${basedir}/src/main/resources/schema
- ${project.build.directory}/generated-sources
- org.mule.extension.jsonlogger.api.pojos
-
-
-
-
- generate
-
-
-
-
-
-
-
-
-
-
- Exchange2
- Exchange2 Repository
- https://maven.anypoint.mulesoft.com/api/v1/organizations/${project.groupId}/maven
- default
-
-
-
-
-
- org.jsonschema2pojo
- jsonschema2pojo-maven-plugin
- 0.4.35
-
-
- cc568b69-a181-4d4c-b044-90054c52897b
- jsonschema2pojo-mule-annotations
- 1.0.0
-
-
- com.google.guava
- guava
- 28.0-jre
-
-
-
-
-
- Exchange2-MulesoftServices
- Exchange2 Repository
- https://maven.anypoint.mulesoft.com/api/v1/organizations/cc568b69-a181-4d4c-b044-90054c52897b/maven
- default
-
-
-
-
-
- Exchange2-MulesoftServices
- Exchange2 Repository
- https://maven.anypoint.mulesoft.com/api/v1/organizations/cc568b69-a181-4d4c-b044-90054c52897b/maven
- default
-
-
-
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/Constants.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/Constants.java
new file mode 100644
index 0000000..591885f
--- /dev/null
+++ b/json-logger/src/main/java/org/mule/extension/jsonlogger/Constants.java
@@ -0,0 +1,20 @@
+package org.mule.extension.jsonlogger;
+
+class Constants {
+ static final String APPLICATION_NAME = "applicationName";
+ static final String APPLICATION_VERSION = "applicationVersion";
+ static final String CONTENT = "content";
+ static final String CORRELATION_ID = "correlationId";
+ static final String ENVIRONMENT = "environment";
+ static final String LOCATION_INFO = "locationInfo";
+ static final String ROOT_CONTAINER = "rootContainer";
+ static final String FILE_NAME = "fileName";
+ static final String LINE_NUMBER = "lineNumber";
+ static final String TIMSTAMP = "timestamp";
+ static final String MESSAGE = "message";
+ static final String PRIORITY = "priority";
+ static final String TRACE_POINT = "tracePoint";
+ static final String ELAPSED = "elapsed";
+ static final String START_TIME = "startTime";
+ static final String END_TIME = "endTime";
+}
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/JsonLoggerExtension.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/JsonLoggerExtension.java
new file mode 100644
index 0000000..d075ff5
--- /dev/null
+++ b/json-logger/src/main/java/org/mule/extension/jsonlogger/JsonLoggerExtension.java
@@ -0,0 +1,13 @@
+package org.mule.extension.jsonlogger;
+
+import org.mule.extension.jsonlogger.config.JsonLoggerConfig;
+import org.mule.runtime.extension.api.annotation.Configurations;
+import org.mule.runtime.extension.api.annotation.Extension;
+import org.mule.runtime.extension.api.annotation.dsl.xml.Xml;
+
+@Xml(prefix = "json-logger")
+@Extension(name = "JSON Logger")
+@Configurations(JsonLoggerConfig.class)
+public class JsonLoggerExtension {
+
+}
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/JsonLoggerOperations.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/JsonLoggerOperations.java
new file mode 100644
index 0000000..90d73b9
--- /dev/null
+++ b/json-logger/src/main/java/org/mule/extension/jsonlogger/JsonLoggerOperations.java
@@ -0,0 +1,237 @@
+package org.mule.extension.jsonlogger;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.ObjectWriter;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.mule.extension.jsonlogger.config.JsonLoggerConfig;
+import org.mule.extension.jsonlogger.config.LogProcessor;
+import org.mule.extension.jsonlogger.config.ScopeProcessor;
+import org.mule.runtime.api.component.location.ComponentLocation;
+import org.mule.runtime.api.metadata.DataType;
+import org.mule.runtime.api.metadata.MediaType;
+import org.mule.runtime.api.metadata.TypedValue;
+import org.mule.runtime.api.transformation.TransformationService;
+import org.mule.runtime.extension.api.annotation.Expression;
+import org.mule.runtime.extension.api.annotation.param.Config;
+import org.mule.runtime.extension.api.annotation.param.ParameterGroup;
+import org.mule.runtime.extension.api.runtime.operation.Result;
+import org.mule.runtime.extension.api.runtime.parameter.ParameterResolver;
+import org.mule.runtime.extension.api.runtime.process.CompletionCallback;
+import org.mule.runtime.extension.api.runtime.route.Chain;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.inject.Inject;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.Map;
+
+import static java.time.Duration.between;
+import static org.mule.runtime.api.meta.ExpressionSupport.NOT_SUPPORTED;
+import static org.mule.runtime.api.metadata.DataType.TEXT_STRING;
+
+public class JsonLoggerOperations {
+
+ private final static Logger log = LoggerFactory.getLogger("org.mule.extension.jsonlogger.JsonLogger");
+ private final Result VOID_RESULT = Result.builder().build();
+
+ @Inject
+ private TransformationService transformationService;
+
+ public void logger(@ParameterGroup(name = "Logger")
+ @Expression(value = NOT_SUPPORTED)
+ LogProcessor logProcessor,
+ @Config
+ JsonLoggerConfig config,
+ ComponentLocation location,
+ CompletionCallback callback) {
+
+ String priority = logProcessor.getPriority().toString();
+ if (!isLogEnabled(priority)) {
+ callback.success(VOID_RESULT);
+ return;
+ }
+ ObjectNode logEvent = Mapper.getInstance().createObjectNode();
+
+ logEvent.put(Constants.CORRELATION_ID, logProcessor.getCorrelationId())
+ .put(Constants.MESSAGE, logProcessor.getMessage())
+ .put(Constants.PRIORITY, priority)
+ .put(Constants.TRACE_POINT, logProcessor.getTracePoint().toString());
+
+ addLocationInfo(logEvent, location);
+
+ addAppInfo(logEvent, config);
+
+ addContent(logEvent, logProcessor.getContent(), config);
+
+ log(logEvent, priority, config.isPrettyPrint());
+
+ callback.success(VOID_RESULT);
+ }
+
+ // scope operations cannot receive config at this time
+ public void loggerScope(@ParameterGroup(name = "LoggerScope")
+ @Expression(value = NOT_SUPPORTED)
+ ScopeProcessor scopeProcessor,
+ ComponentLocation location,
+ Chain operations,
+ CompletionCallback callback) {
+
+ String priority = scopeProcessor.getPriority().toString();
+ if (!isLogEnabled(priority)) {
+ operations.process(
+ callback::success,
+ (error, previous) -> {
+ callback.error(error);
+ });
+ return;
+ }
+
+ ObjectNode logEvent = Mapper.getInstance().createObjectNode();
+
+ Instant startTime = Instant.now();
+
+ logEvent.put(Constants.CORRELATION_ID, scopeProcessor.getCorrelationId())
+ .put(Constants.TRACE_POINT, scopeProcessor.getScopeTracePoint().toString() + "_BEFORE")
+ .put(Constants.PRIORITY, priority)
+ .put(Constants.START_TIME, startTime.toString());
+
+ addLocationInfo(logEvent, location);
+
+ operations.process(
+ result -> {
+ Instant endTime = Instant.now();
+ logEvent.put(Constants.TRACE_POINT, scopeProcessor.getScopeTracePoint().toString() + "_AFTER")
+ .put(Constants.PRIORITY, priority)
+ .put(Constants.ELAPSED, between(startTime, endTime).toMillis())
+ .put(Constants.END_TIME, endTime.toString());
+
+ log(logEvent, priority, true);
+ callback.success(result);
+ },
+ (error, previous) -> {
+ Instant endTime = Instant.now();
+ logEvent.put(Constants.MESSAGE, error.getMessage())
+ .put(Constants.TRACE_POINT, "EXCEPTION_SCOPE")
+ .put(Constants.PRIORITY, "ERROR")
+ .put(Constants.ELAPSED, between(startTime, endTime).toMillis())
+ .put(Constants.END_TIME, endTime.toString());
+ log(logEvent, "ERROR", true);
+ callback.error(error);
+ });
+ }
+
+ void addContent(ObjectNode logEvent, ParameterResolver> v, JsonLoggerConfig config) {
+ TypedValue typedVal = null;
+ InputStream inputStream = null;
+ try {
+ typedVal = v.resolve();
+ if (typedVal == null) {
+ return;
+ }
+ inputStream = typedVal.getValue();
+ if (inputStream == null ) {
+ return;
+ }
+
+ DataType dataType = typedVal.getDataType();
+
+ //if payload is java, then use toString()
+ if (MediaType.APPLICATION_JAVA.matches(dataType.getMediaType())) {
+ ObjectInputStream ois = new ObjectInputStream(inputStream);
+ logEvent.put(Constants.CONTENT, ois.readObject().toString());
+ return;
+ }
+
+ //if payload is anything other java and json, then use transformationService
+ if (!MediaType.APPLICATION_JSON.matches(dataType.getMediaType())) {
+ logEvent.put(Constants.CONTENT, (String) transformationService.transform(inputStream,
+ dataType,
+ TEXT_STRING));
+ return;
+ }
+
+ ObjectMapper mapper = Mapper.getInstance(config.getContentFieldsDataMasking());
+ log.error(config.getContentFieldsDataMasking());
+ logEvent.put(Constants.CONTENT, mapper.readTree(inputStream));
+
+ } catch (Exception e) {
+ logEvent.put(Constants.CONTENT, e.getMessage());
+ } finally {
+ if (typedVal != null && inputStream != null) {
+ try {
+ inputStream.close();
+ } catch (Exception e) {
+ log.debug("Can't close stream", e);
+ }
+ }
+ }
+ }
+
+ void addAppInfo(ObjectNode logEvent, JsonLoggerConfig config) {
+ logEvent.put(Constants.APPLICATION_NAME, config.getApplicationName());
+ logEvent.put(Constants.APPLICATION_VERSION, config.getApplicationVersion());
+ logEvent.put(Constants.ENVIRONMENT, config.getEnvironment());
+ }
+
+ void addLocationInfo(ObjectNode logEvent, ComponentLocation location) {
+ Map locationInfo = new HashMap<>();
+ locationInfo.put(Constants.ROOT_CONTAINER, location.getRootContainerName());
+ locationInfo.put(Constants.FILE_NAME, location.getFileName().orElse(""));
+ locationInfo.put(Constants.LINE_NUMBER, String.valueOf(location.getLineInFile().orElse(null)));
+ logEvent.putPOJO(Constants.LOCATION_INFO, locationInfo);
+ }
+
+ private void log(ObjectNode logEvent, String priority, boolean isPrettyPrint) {
+ ObjectWriter ow = isPrettyPrint ?
+ Mapper.getInstance().writer().withDefaultPrettyPrinter() :
+ Mapper.getInstance().writer();
+ try {
+ doLog(priority, ow.writeValueAsString(logEvent));
+ } catch (Exception e) {
+ String s = String.format("{\"%s\": \"%s\", \"message\": \"Error parsing content as a string: %s\"}",
+ Constants.CORRELATION_ID,
+ logEvent.get(Constants.CORRELATION_ID),
+ e.getMessage());
+ log.error(s);
+ }
+ }
+
+ private void doLog(String priority, String logLine) {
+ switch (priority) {
+ case "TRACE":
+ log.trace(logLine);
+ break;
+ case "DEBUG":
+ log.debug(logLine);
+ break;
+ case "INFO":
+ log.info(logLine);
+ break;
+ case "WARN":
+ log.warn(logLine);
+ break;
+ case "ERROR":
+ log.error(logLine);
+ }
+ }
+
+ private Boolean isLogEnabled(String priority) {
+ switch (priority) {
+ case "TRACE":
+ return log.isTraceEnabled();
+ case "DEBUG":
+ return log.isDebugEnabled();
+ case "INFO":
+ return log.isInfoEnabled();
+ case "WARN":
+ return log.isWarnEnabled();
+ case "ERROR":
+ return log.isErrorEnabled();
+ }
+ return false;
+ }
+}
+
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/Mapper.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/Mapper.java
new file mode 100644
index 0000000..30a46db
--- /dev/null
+++ b/json-logger/src/main/java/org/mule/extension/jsonlogger/Mapper.java
@@ -0,0 +1,68 @@
+package org.mule.extension.jsonlogger;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class Mapper {
+ volatile static boolean isInitalized;
+
+ private final ObjectMapper om = new ObjectMapper()
+ .setSerializationInclusion(JsonInclude.Include.NON_NULL)
+ .setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
+
+ private final ObjectMapper maskingMapper = new ObjectMapper()
+ .setSerializationInclusion(JsonInclude.Include.NON_NULL)
+ .setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
+
+ private Mapper() {
+ }
+
+ private static class MapHolder {
+ static final ObjectMapper INSTANCE = new Mapper().om;
+ static final ObjectMapper MASKING_INSTANCE = new Mapper().maskingMapper;
+ }
+
+ public static ObjectMapper getInstance(String contentFieldsDataMasking) {
+ if (contentFieldsDataMasking == null || contentFieldsDataMasking.isEmpty()) {
+ return MapHolder.INSTANCE;
+ }
+ buildMaskedFields(contentFieldsDataMasking);
+ return MapHolder.MASKING_INSTANCE;
+ }
+
+ public static ObjectMapper getInstance() {
+ return MapHolder.INSTANCE;
+ }
+
+ private static void buildMaskedFields(String contentFieldsDataMasking) {
+ while (!isInitalized) {
+ Set maskedFields = new HashSet<>();
+ AtomicBoolean lock = new AtomicBoolean(false);
+ if (lock.compareAndSet(false, true)) {
+ try {
+ if (contentFieldsDataMasking != null && !contentFieldsDataMasking.isEmpty()) {
+ String[] split = contentFieldsDataMasking
+ .trim()
+ .split(",");
+
+ for (String s : split) {
+ maskedFields.add(s.trim());
+ }
+ SimpleModule module = new SimpleModule()
+ .addDeserializer(JsonNode.class, new MaskingDeserializer(maskedFields));
+ MapHolder.MASKING_INSTANCE.registerModule(module);
+ }
+ } finally {
+ isInitalized = true;
+ lock.set(false);
+ }
+ }
+ }
+ }
+}
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/MaskingDeserializer.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/MaskingDeserializer.java
new file mode 100644
index 0000000..4cc1232
--- /dev/null
+++ b/json-logger/src/main/java/org/mule/extension/jsonlogger/MaskingDeserializer.java
@@ -0,0 +1,184 @@
+package org.mule.extension.jsonlogger;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.deser.std.JsonNodeDeserializer;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+import java.io.IOException;
+import java.util.Set;
+
+class MaskingDeserializer extends JsonNodeDeserializer {
+ Set maskedFields;
+
+ public MaskingDeserializer(Set maskedFields) {
+ this.maskedFields = maskedFields;
+ }
+
+ @Override
+ public JsonNode deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
+ switch (p.currentTokenId()) {
+ case 1:
+ return deserializeObject(p, ctxt, ctxt.getNodeFactory(), false);
+ case 3:
+ return deserializeArray(p, ctxt, ctxt.getNodeFactory(), false);
+ default:
+ return deserializeAny(p, ctxt, ctxt.getNodeFactory(), false);
+ }
+ }
+
+ protected final ObjectNode deserializeObject(JsonParser p, DeserializationContext ctxt, JsonNodeFactory nodeFactory, boolean shouldMask) throws IOException {
+ ObjectNode node = nodeFactory.objectNode();
+
+ for (String key = p.nextFieldName(); key != null; key = p.nextFieldName()) {
+ if (maskedFields.contains(key)) {
+ shouldMask = true;
+ }
+ JsonToken t = p.nextToken();
+ if (t == null) {
+ t = JsonToken.NOT_AVAILABLE;
+ }
+
+ JsonNode value;
+ switch (t.id()) {
+ case 1:
+ value = deserializeObject(p, ctxt, nodeFactory, shouldMask);
+ shouldMask = false;
+ break;
+ case 2:
+ case 4:
+ case 5:
+ case 8:
+ default:
+ value = deserializeAny(p, ctxt, nodeFactory, shouldMask);
+ shouldMask = false;
+ break;
+ case 3:
+ value = deserializeArray(p, ctxt, nodeFactory, shouldMask);
+ shouldMask = false;
+ break;
+ case 6:
+ if (shouldMask) {
+ value = nodeFactory.textNode(replace(p.getText()));
+ shouldMask = false;
+ } else {
+ value = nodeFactory.textNode(p.getText());
+ }
+ break;
+ case 7:
+ value = this._fromInt(p, ctxt, nodeFactory);
+ break;
+ case 9:
+ value = nodeFactory.booleanNode(true);
+ break;
+ case 10:
+ value = nodeFactory.booleanNode(false);
+ break;
+ case 11:
+ value = nodeFactory.nullNode();
+ break;
+ case 12:
+ value = this._fromEmbedded(p, ctxt, nodeFactory);
+ }
+
+ JsonNode old = node.replace(key, value);
+ if (old != null) {
+ this._handleDuplicateField(p, ctxt, nodeFactory, key, node, old, value);
+ }
+ }
+
+ return node;
+ }
+
+ protected final ArrayNode deserializeArray(JsonParser p, DeserializationContext ctxt, JsonNodeFactory nodeFactory, boolean shouldMask) throws IOException {
+ ArrayNode node = nodeFactory.arrayNode();
+
+ while (true) {
+ JsonToken t = p.nextToken();
+ switch (t.id()) {
+ case 1:
+ node.add(deserializeObject(p, ctxt, nodeFactory, shouldMask));
+ break;
+ case 2:
+ case 5:
+ case 8:
+ default:
+ node.add(deserializeAny(p, ctxt, nodeFactory, shouldMask));
+ break;
+ case 3:
+ node.add(deserializeArray(p, ctxt, nodeFactory, shouldMask));
+ break;
+ case 4:
+ return node;
+ case 6:
+ if (shouldMask) {
+ node.add(nodeFactory.textNode(replace(p.getText())));
+ } else {
+ node.add(nodeFactory.textNode(p.getText()));
+ }
+ break;
+ case 7:
+ node.add(this._fromInt(p, ctxt, nodeFactory));
+ break;
+ case 9:
+ node.add(nodeFactory.booleanNode(true));
+ break;
+ case 10:
+ node.add(nodeFactory.booleanNode(false));
+ break;
+ case 11:
+ node.add(nodeFactory.nullNode());
+ break;
+ case 12:
+ node.add(this._fromEmbedded(p, ctxt, nodeFactory));
+ }
+ }
+ }
+
+ protected final JsonNode deserializeAny(JsonParser p, DeserializationContext ctxt, JsonNodeFactory nodeFactory, boolean shouldMask) throws IOException {
+ switch (p.currentTokenId()) {
+ case 2:
+ return nodeFactory.objectNode();
+ case 3:
+ case 4:
+ default:
+ return (JsonNode) ctxt.handleUnexpectedToken(this.handledType(), p);
+ case 5:
+ return deserializeObjectAtName(p, ctxt, nodeFactory);
+ case 6:
+ if (shouldMask) {
+ return nodeFactory.textNode(replace(p.getText()));
+ }
+ return nodeFactory.textNode(p.getText());
+ case 7:
+ return this._fromInt(p, ctxt, nodeFactory);
+ case 8:
+ return this._fromFloat(p, ctxt, nodeFactory);
+ case 9:
+ return nodeFactory.booleanNode(true);
+ case 10:
+ return nodeFactory.booleanNode(false);
+ case 11:
+ return nodeFactory.nullNode();
+ case 12:
+ return this._fromEmbedded(p, ctxt, nodeFactory);
+ }
+ }
+
+ private String replace(String input) {
+ int len = input.length();
+ StringBuilder sb = new StringBuilder(len);
+ for (int i = 0; i < len; i++) {
+ if (Character.isLetterOrDigit(input.charAt(i))) {
+ sb.append('*');
+ } else {
+ sb.append(input.charAt(i));
+ }
+ }
+ return sb.toString();
+ }
+}
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/config/JsonLoggerConfig.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/config/JsonLoggerConfig.java
new file mode 100644
index 0000000..298059f
--- /dev/null
+++ b/json-logger/src/main/java/org/mule/extension/jsonlogger/config/JsonLoggerConfig.java
@@ -0,0 +1,86 @@
+package org.mule.extension.jsonlogger.config;
+
+import org.mule.extension.jsonlogger.JsonLoggerOperations;
+import org.mule.runtime.extension.api.annotation.Configuration;
+import org.mule.runtime.extension.api.annotation.Expression;
+import org.mule.runtime.extension.api.annotation.Operations;
+import org.mule.runtime.extension.api.annotation.param.Optional;
+import org.mule.runtime.extension.api.annotation.param.Parameter;
+import org.mule.runtime.extension.api.annotation.param.display.Summary;
+
+import static org.mule.runtime.api.meta.ExpressionSupport.NOT_SUPPORTED;
+
+@Configuration(name = "config")
+@Operations({JsonLoggerOperations.class})
+public class JsonLoggerConfig {
+
+ @Parameter
+ @Optional
+ @Expression(NOT_SUPPORTED)
+ String contentFieldsDataMasking;
+
+ @Parameter
+ @Optional(defaultValue = "true")
+ @Expression(NOT_SUPPORTED)
+ boolean prettyPrint;
+
+
+ @Parameter
+ @Optional(defaultValue = "applicationName")
+ @Summary("Name of the application")
+ private String applicationName;
+
+ @Parameter
+ @Optional(defaultValue = "applicationVersion")
+ @Summary("Version of the application")
+ private String applicationVersion;
+
+ @Parameter
+ @Optional(defaultValue = "environment")
+ private String environment;
+
+ public String getApplicationName() {
+ return applicationName;
+ }
+
+ public JsonLoggerConfig setApplicationName(String applicationName) {
+ this.applicationName = applicationName;
+ return this;
+ }
+
+ public String getApplicationVersion() {
+ return applicationVersion;
+ }
+
+ public JsonLoggerConfig setApplicationVersion(String applicationVersion) {
+ this.applicationVersion = applicationVersion;
+ return this;
+ }
+
+ public String getEnvironment() {
+ return environment;
+ }
+
+ public JsonLoggerConfig setEnvironment(String environment) {
+ this.environment = environment;
+ return this;
+ }
+
+ public boolean isPrettyPrint() {
+ return prettyPrint;
+ }
+
+ public JsonLoggerConfig setPrettyPrint(boolean prettyPrint) {
+ this.prettyPrint = prettyPrint;
+ return this;
+ }
+
+ public String getContentFieldsDataMasking() {
+ return contentFieldsDataMasking;
+ }
+
+ public JsonLoggerConfig setContentFieldsDataMasking(String contentFieldsDataMasking) {
+ this.contentFieldsDataMasking = contentFieldsDataMasking;
+ return this;
+ }
+}
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/config/LogProcessor.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/config/LogProcessor.java
new file mode 100644
index 0000000..88f73ee
--- /dev/null
+++ b/json-logger/src/main/java/org/mule/extension/jsonlogger/config/LogProcessor.java
@@ -0,0 +1,88 @@
+package org.mule.extension.jsonlogger.config;
+
+import org.mule.runtime.api.metadata.TypedValue;
+import org.mule.runtime.extension.api.annotation.param.Content;
+import org.mule.runtime.extension.api.annotation.param.Optional;
+import org.mule.runtime.extension.api.annotation.param.Parameter;
+import org.mule.runtime.extension.api.annotation.param.display.Example;
+import org.mule.runtime.extension.api.annotation.param.display.Placement;
+import org.mule.runtime.extension.api.annotation.param.display.Summary;
+import org.mule.runtime.extension.api.runtime.parameter.ParameterResolver;
+
+import java.io.InputStream;
+
+public class LogProcessor {
+
+ @Parameter
+ @Optional(defaultValue = "#[correlationId]")
+ @Placement(tab = "Advanced")
+ private String correlationId;
+
+ @Parameter
+ @Optional(defaultValue = "")
+ @Summary("Message to be logged")
+ @Example("Add a log message")
+ private String message;
+
+ @Parameter
+ @Optional(defaultValue = "{}")
+ @Summary("NOTE: Writing the entire payload every time across your application can cause serious performance issues")
+ @Content
+ private ParameterResolver> content;
+
+ @Parameter
+ @Optional(defaultValue = "START")
+ @Summary("Current processing stage")
+ private TracePoint tracePoint;
+
+ @Parameter
+ @Optional(defaultValue = "INFO")
+ @Summary("Logger priority")
+ private Priority priority;
+
+ public String getCorrelationId() {
+ return correlationId;
+ }
+
+ public LogProcessor setCorrelationId(String correlationId) {
+ this.correlationId = correlationId;
+ return this;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+
+ public LogProcessor setMessage(String message) {
+ this.message = message;
+ return this;
+ }
+
+ public ParameterResolver> getContent() {
+ return content;
+ }
+
+ public LogProcessor setContent(ParameterResolver> content) {
+ this.content = content;
+ return this;
+ }
+
+ public TracePoint getTracePoint() {
+ return tracePoint;
+ }
+
+ public LogProcessor setTracePoint(TracePoint tracePoint) {
+ this.tracePoint = tracePoint;
+ return this;
+ }
+
+ public Priority getPriority() {
+ return priority;
+ }
+
+ public LogProcessor setPriority(Priority priority) {
+ this.priority = priority;
+ return this;
+ }
+
+}
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/config/Priority.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/config/Priority.java
new file mode 100644
index 0000000..29f2d6e
--- /dev/null
+++ b/json-logger/src/main/java/org/mule/extension/jsonlogger/config/Priority.java
@@ -0,0 +1,20 @@
+package org.mule.extension.jsonlogger.config;
+
+public enum Priority {
+ DEBUG("DEBUG"),
+ TRACE("TRACE"),
+ INFO("INFO"),
+ WARN("WARN"),
+ ERROR("ERROR");
+
+ private final String value;
+
+ Priority(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public String toString() {
+ return this.value;
+ }
+}
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/config/ScopeProcessor.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/config/ScopeProcessor.java
new file mode 100644
index 0000000..9180882
--- /dev/null
+++ b/json-logger/src/main/java/org/mule/extension/jsonlogger/config/ScopeProcessor.java
@@ -0,0 +1,48 @@
+package org.mule.extension.jsonlogger.config;
+
+import org.mule.runtime.extension.api.annotation.param.Optional;
+import org.mule.runtime.extension.api.annotation.param.Parameter;
+import org.mule.runtime.extension.api.annotation.param.display.Placement;
+import org.mule.runtime.extension.api.annotation.param.display.Summary;
+
+public class ScopeProcessor {
+
+ @Parameter
+ @Optional(defaultValue = "OUTBOUND_REQUEST_SCOPE")
+ @Summary("Current processing stage")
+ private ScopeTracePoint scopeTracePoint;
+
+ @Parameter
+ @Optional(defaultValue = "#[correlationId]")
+ @Placement(tab = "Advanced")
+ private String correlationId;
+
+ @Parameter
+ @Optional(defaultValue = "INFO")
+ @Summary("Logger priority")
+ private Priority priority;
+
+ public ScopeTracePoint getScopeTracePoint() {
+ return scopeTracePoint;
+ }
+
+ public void setScopeTracePoint(ScopeTracePoint scopeTracePoint) {
+ this.scopeTracePoint = scopeTracePoint;
+ }
+
+ public String getCorrelationId() {
+ return correlationId;
+ }
+
+ public void setCorrelationId(String correlationId) {
+ this.correlationId = correlationId;
+ }
+
+ public Priority getPriority() {
+ return priority;
+ }
+
+ public void setPriority(Priority priority) {
+ this.priority = priority;
+ }
+}
\ No newline at end of file
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/config/ScopeTracePoint.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/config/ScopeTracePoint.java
new file mode 100644
index 0000000..3792827
--- /dev/null
+++ b/json-logger/src/main/java/org/mule/extension/jsonlogger/config/ScopeTracePoint.java
@@ -0,0 +1,18 @@
+package org.mule.extension.jsonlogger.config;
+
+public enum ScopeTracePoint {
+
+ DATA_TRANSFORM_SCOPE("DATA_TRANSFORM_SCOPE"),
+ OUTBOUND_REQUEST_SCOPE("OUTBOUND_REQUEST_SCOPE"),
+ FLOW_LOGIC_SCOPE("FLOW_LOGIC_SCOPE");
+ private final String value;
+
+ ScopeTracePoint(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public String toString() {
+ return this.value;
+ }
+}
\ No newline at end of file
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/config/TracePoint.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/config/TracePoint.java
new file mode 100644
index 0000000..b020d18
--- /dev/null
+++ b/json-logger/src/main/java/org/mule/extension/jsonlogger/config/TracePoint.java
@@ -0,0 +1,23 @@
+package org.mule.extension.jsonlogger.config;
+
+public enum TracePoint {
+
+ START("START"),
+ BEFORE_TRANSFORM("BEFORE_TRANSFORM"),
+ AFTER_TRANSFORM("AFTER_TRANSFORM"),
+ BEFORE_REQUEST("BEFORE_REQUEST"),
+ AFTER_REQUEST("AFTER_REQUEST"),
+ FLOW("FLOW"),
+ END("END"),
+ EXCEPTION("EXCEPTION");
+ private final String value;
+
+ TracePoint(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public String toString() {
+ return this.value;
+ }
+}
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/JsonloggerConfiguration.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/JsonloggerConfiguration.java
deleted file mode 100644
index 86ba69a..0000000
--- a/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/JsonloggerConfiguration.java
+++ /dev/null
@@ -1,84 +0,0 @@
-package org.mule.extension.jsonlogger.internal;
-
-import org.mule.extension.jsonlogger.api.pojos.LoggerConfig;
-import org.mule.extension.jsonlogger.internal.destinations.Destination;
-import org.mule.extension.jsonlogger.internal.singleton.ConfigsSingleton;
-import org.mule.runtime.api.lifecycle.Disposable;
-import org.mule.runtime.api.lifecycle.Initialisable;
-import org.mule.runtime.api.lifecycle.InitialisationException;
-import org.mule.runtime.extension.api.annotation.Operations;
-import org.mule.runtime.extension.api.annotation.param.Optional;
-import org.mule.runtime.extension.api.annotation.param.Parameter;
-import org.mule.runtime.extension.api.annotation.param.RefName;
-import org.mule.runtime.extension.api.annotation.param.display.Placement;
-
-import javax.inject.Inject;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * This class represents an extension configuration, values set in this class are commonly used across multiple
- * operations since they represent something core from the extension.
- */
-@Operations(JsonloggerOperations.class)
-public class JsonloggerConfiguration extends LoggerConfig implements Initialisable, Disposable {
-
- @Inject
- ConfigsSingleton configsSingleton;
-
- @RefName
- private String configName;
-
- @Parameter
- @Optional
- @Placement(tab = "Destinations")
- private Destination externalDestination;
-
- public String getConfigName() {
- return configName;
- }
-
- /** Timer methods for Elapsed Time **/
-
- public ConcurrentHashMap timers = new ConcurrentHashMap();
-
- public ConcurrentHashMap getTimers() { return timers; }
-
- public void setTimers(ConcurrentHashMap timers) { this.timers = timers; }
-
- public void printTimersKeys () {
- System.out.println("Current timers: " + timers);
- }
-
- public Long getCachedTimerTimestamp(String key, Long initialTimeStamp) throws Exception {
- Long startTimestamp = timers.putIfAbsent(key, initialTimeStamp);
- return (startTimestamp == null) ? timers.get(key) : startTimestamp;
- }
-
- public void removeCachedTimerTimestamp(String key) {
- timers.remove(key);
- }
-
- /** Init configs singleton **/
- public void setExternalDestination(Destination externalDestination) {
- this.externalDestination = externalDestination;
- }
-
- public Destination getExternalDestination() {
- return externalDestination;
- }
-
- @Override
- public void initialise() throws InitialisationException {
- if (this.externalDestination != null) {
- this.externalDestination.initialise();
- }
- configsSingleton.addConfig(configName, this); // Should be refactored once SDK supports passing configs to Scopes
- }
-
- @Override
- public void dispose() {
- if (this.externalDestination != null) {
- this.externalDestination.dispose();
- }
- }
-}
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/JsonloggerConnection.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/JsonloggerConnection.java
deleted file mode 100644
index 85e23bd..0000000
--- a/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/JsonloggerConnection.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package org.mule.extension.jsonlogger.internal;
-
-
-/**
- * This class represents an extension connection just as example (there is no real connection with anything here c:).
- */
-public final class JsonloggerConnection {
-
- private final String id;
-
- public JsonloggerConnection(String id) {
- this.id = id;
- }
-
- public String getId() {
- return id;
- }
-
- public void invalidate() {
- // do something to invalidate this connection!
- }
-}
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/JsonloggerExtension.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/JsonloggerExtension.java
deleted file mode 100644
index d2bc9c6..0000000
--- a/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/JsonloggerExtension.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package org.mule.extension.jsonlogger.internal;
-
-import org.mule.extension.jsonlogger.internal.destinations.AMQDestination;
-import org.mule.extension.jsonlogger.internal.destinations.AMQPDestination;
-import org.mule.extension.jsonlogger.internal.destinations.Destination;
-import org.mule.extension.jsonlogger.internal.destinations.JMSDestination;
-import org.mule.runtime.extension.api.annotation.Export;
-import org.mule.runtime.extension.api.annotation.Extension;
-import org.mule.runtime.extension.api.annotation.Configurations;
-import org.mule.runtime.extension.api.annotation.SubTypeMapping;
-import org.mule.runtime.extension.api.annotation.dsl.xml.Xml;
-
-/**
- * This is the main class of an extension, is the entry point from which configurations, connection providers, operations
- * and sources are going to be declared.
- */
-@Xml(prefix = "json-logger")
-@Extension(name = "JSON Logger")
-@Export(resources = {"modules/JSONLoggerModule.dwl"})
-@Configurations(JsonloggerConfiguration.class)
-@SubTypeMapping(baseType = Destination.class,
- subTypes = {JMSDestination.class, AMQDestination.class, AMQPDestination.class})
-public class JsonloggerExtension {
-
-}
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/JsonloggerOperations.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/JsonloggerOperations.java
deleted file mode 100644
index a1a2d7f..0000000
--- a/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/JsonloggerOperations.java
+++ /dev/null
@@ -1,496 +0,0 @@
-package org.mule.extension.jsonlogger.internal;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectWriter;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-import org.apache.commons.beanutils.BeanUtils;
-import org.apache.commons.beanutils.PropertyUtils;
-import org.joda.time.DateTime;
-import org.mule.extension.jsonlogger.api.pojos.LoggerProcessor;
-import org.mule.extension.jsonlogger.api.pojos.Priority;
-import org.mule.extension.jsonlogger.api.pojos.ScopeTracePoint;
-import org.mule.extension.jsonlogger.internal.datamask.JsonMasker;
-import org.mule.extension.jsonlogger.internal.singleton.ConfigsSingleton;
-import org.mule.extension.jsonlogger.internal.singleton.LogEventSingleton;
-import org.mule.extension.jsonlogger.internal.singleton.ObjectMapperSingleton;
-import org.mule.runtime.api.component.location.ComponentLocation;
-import org.mule.runtime.api.meta.model.operation.ExecutionType;
-import org.mule.runtime.api.metadata.TypedValue;
-import org.mule.runtime.api.transformation.TransformationService;
-import org.mule.runtime.extension.api.annotation.Expression;
-import org.mule.runtime.extension.api.annotation.execution.Execution;
-import org.mule.runtime.extension.api.annotation.param.Config;
-import org.mule.runtime.extension.api.annotation.param.Optional;
-import org.mule.runtime.extension.api.annotation.param.ParameterGroup;
-import org.mule.runtime.extension.api.annotation.param.display.DisplayName;
-import org.mule.runtime.extension.api.annotation.param.display.Example;
-import org.mule.runtime.extension.api.annotation.param.display.Placement;
-import org.mule.runtime.extension.api.annotation.param.display.Summary;
-import org.mule.runtime.extension.api.runtime.operation.FlowListener;
-import org.mule.runtime.extension.api.runtime.operation.Result;
-import org.mule.runtime.extension.api.runtime.parameter.CorrelationInfo;
-import org.mule.runtime.extension.api.runtime.parameter.ParameterResolver;
-import org.mule.runtime.extension.api.runtime.process.CompletionCallback;
-import org.mule.runtime.extension.api.runtime.route.Chain;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.inject.Inject;
-import java.io.InputStream;
-import java.util.*;
-
-import static org.mule.runtime.api.meta.ExpressionSupport.NOT_SUPPORTED;
-import static org.mule.runtime.api.metadata.DataType.TEXT_STRING;
-
-/**
- * This class is a container for operations, every public method in this class will be taken as an extension operation.
- */
-public class JsonloggerOperations {
-
- /**
- * jsonLogger: JSON Logger output log
- * log: Connector internal log
- */
- protected transient Logger jsonLogger;
- private static final Logger LOGGER = LoggerFactory.getLogger(JsonloggerOperations.class);
-
- // Void Result for NIO
- private final Result VOID_RESULT = Result.builder().build();
-
- // JSON Object Mapper
- @Inject
- ObjectMapperSingleton om;
-
- // Log Event for External Destination
- @Inject
- LogEventSingleton logEvent;
-
- // Global definition of logger configs so that it's available for scope processor (SDK scope doesn't support passing configurations)
- @Inject
- ConfigsSingleton configs;
-
- // Transformation Service
- @Inject
- private TransformationService transformationService;
-
- /**
- * Log a new entry
- */
- @Execution(ExecutionType.BLOCKING)
- public void logger(@ParameterGroup(name = "Logger") @Expression(value = NOT_SUPPORTED) LoggerProcessor loggerProcessor,
- CorrelationInfo correlationInfo,
- ComponentLocation location,
- @Config JsonloggerConfiguration config,
- FlowListener flowListener,
- CompletionCallback callback) {
-
- Long initialTimestamp, loggerTimestamp;
- initialTimestamp = loggerTimestamp = System.currentTimeMillis();
-
- initLoggerCategory(loggerProcessor.getCategory());
-
- LOGGER.debug("correlationInfo.getEventId(): " + correlationInfo.getEventId());
- LOGGER.debug("correlationInfo.getCorrelationId(): " + correlationInfo.getCorrelationId());
-
- try {
- // Add cache entry for initial timestamp based on unique EventId
- initialTimestamp = config.getCachedTimerTimestamp(correlationInfo.getCorrelationId(), initialTimestamp);
- } catch (Exception e) {
- LOGGER.error("initialTimestamp could not be retrieved from the cache config. Defaulting to current System.currentTimeMillis()", e);
- }
-
- // Calculate elapsed time based on cached initialTimestamp
- Long elapsed = loggerTimestamp - initialTimestamp;
-
- //config.printTimersKeys();
- if (elapsed == 0) {
- LOGGER.debug("configuring flowListener....");
- flowListener.onComplete(new TimerRemoverRunnable(correlationInfo.getCorrelationId(), config));
- } else {
- LOGGER.debug("flowListener already configured");
- }
-
- /**
- * Avoid Logger logic execution based on log priority
- */
- if (isLogEnabled(loggerProcessor.getPriority().toString())) {
- // Load disabledFields
- List disabledFields = (config.getJsonOutput().getDisabledFields() != null) ? Arrays.asList(config.getJsonOutput().getDisabledFields().split(",")) : new ArrayList<>();
- LOGGER.debug("The following fields will be disabled for logging: " + disabledFields);
-
- // Logic to disable fields and/or parse TypedValues as String for JSON log printing
- //Map typedValuesAsString = new HashMap<>();
- Map typedValuesAsString = new HashMap<>();
- Map typedValuesAsJsonNode = new HashMap<>();
- try {
- PropertyUtils.describe(loggerProcessor).forEach((k, v) -> {
- if (disabledFields.stream().anyMatch(k::equals)) {
- try {
- BeanUtils.setProperty(loggerProcessor, k, null);
- } catch (Exception e) {
- LOGGER.error("Failed disabling field: " + k, e);
- }
- } else {
- if (v != null) {
- try {
- if (v instanceof ParameterResolver) {
- v = ((ParameterResolver) v).resolve();
- }
- if (v.getClass().getCanonicalName().equals("org.mule.runtime.api.metadata.TypedValue")) {
- LOGGER.debug("org.mule.runtime.api.metadata.TypedValue type was found for field: " + k);
- TypedValue typedVal = (TypedValue) v;
- LOGGER.debug("Parsing TypedValue for field " + k);
-
- LOGGER.debug("TypedValue MediaType: " + typedVal.getDataType().getMediaType());
- LOGGER.debug("TypedValue Type: " + typedVal.getDataType().getType().getCanonicalName());
- LOGGER.debug("TypedValue Class: " + typedVal.getValue().getClass().getCanonicalName());
-
- // Remove unparsed field
- BeanUtils.setProperty(loggerProcessor, k, null);
-
- // Evaluate if typedValue is null
- if (typedVal.getValue() != null) {
- // Should content type field be parsed as part of JSON log?
- if (config.getJsonOutput().isParseContentFieldsInJsonOutput()) {
- // Is content type application/json?
- if (typedVal.getDataType().getMediaType().getPrimaryType().equals("application") && typedVal.getDataType().getMediaType().getSubType().equals("json")) {
- // Apply masking if needed
- List dataMaskingFields = (config.getJsonOutput().getContentFieldsDataMasking() != null) ? Arrays.asList(config.getJsonOutput().getContentFieldsDataMasking().split(",")) : new ArrayList<>();
- LOGGER.debug("The following JSON keys/paths will be masked for logging: " + dataMaskingFields);
- if (!dataMaskingFields.isEmpty()) {
- JsonNode tempContentNode = om.getObjectMapper().readTree((InputStream)typedVal.getValue());
- JsonMasker masker = new JsonMasker(dataMaskingFields, true);
- JsonNode masked = masker.mask(tempContentNode);
- typedValuesAsJsonNode.put(k, masked);
- } else {
- typedValuesAsJsonNode.put(k, om.getObjectMapper().readTree((InputStream)typedVal.getValue()));
- }
- } else {
- typedValuesAsString.put(k, (String) transformationService.transform(typedVal.getValue(), typedVal.getDataType(), TEXT_STRING));
- }
- } else {
- typedValuesAsString.put(k, (String) transformationService.transform(typedVal.getValue(), typedVal.getDataType(), TEXT_STRING));
- }
- }
- }
- } catch (Exception e) {
- LOGGER.error("Failed parsing field: " + k, e);
- typedValuesAsString.put(k, "Error parsing expression. See logs for details.");
- }
- }
- }
- });
- } catch (Exception e) {
- LOGGER.error("Unknown error while processing the logger object", e);
- }
-
- // Aggregate Logger data into mergedLogger
- ObjectNode mergedLogger = om.getObjectMapper().createObjectNode();
- mergedLogger.setAll((ObjectNode) om.getObjectMapper().valueToTree(loggerProcessor));
-
- /**
- * Custom field ordering for Logger Operation
- * ==========================================
- * This will take place after LoggerProcessor ordering which is defined by the field sequence in loggerProcessor.json
- **/
- // 1. Elapsed Time
- mergedLogger.put("elapsed", elapsed);
- // 2. Location Info: Logger location within Mule application
- if (config.getJsonOutput().isLogLocationInfo()) {
- Map locationInfo = locationInfoToMap(location);
- mergedLogger.putPOJO("locationInfo", locationInfo);
- }
- // 3. Timestamp: Add formatted timestamp entry to the logger
- mergedLogger.put("timestamp", getFormattedTimestamp(loggerTimestamp));
- // 4. Content fields: String based fields
- if (!typedValuesAsString.isEmpty()) {
- JsonNode typedValuesNode = om.getObjectMapper().valueToTree(typedValuesAsString);
- mergedLogger.setAll((ObjectNode) typedValuesNode);
- }
- // 5. Content fields: JSONNode based fields
- if (!typedValuesAsJsonNode.isEmpty()) {
- mergedLogger.setAll(typedValuesAsJsonNode);
- }
- // 6. Global info from config
- mergedLogger.setAll((ObjectNode) om.getObjectMapper().valueToTree(config.getGlobalSettings()));
- // 7. Thread Name
- mergedLogger.put("threadName", Thread.currentThread().getName());
- /** End field ordering **/
-
- /** Print Logger **/
- String finalLog = printObjectToLog(mergedLogger, loggerProcessor.getPriority().toString(), config.getJsonOutput().isPrettyPrint());
-
- /** Forward Log to External Destination **/
- if (config.getExternalDestination() != null) {
- LOGGER.debug("config.getExternalDestination().getSupportedCategories().isEmpty(): " + config.getExternalDestination().getSupportedCategories().isEmpty());
- LOGGER.debug("config.getExternalDestination().getSupportedCategories().contains(jsonLogger.getName()): " + config.getExternalDestination().getSupportedCategories().contains(jsonLogger.getName()));
- if (configs.getConfig(config.getConfigName()).getExternalDestination().getSupportedCategories().isEmpty() || config.getExternalDestination().getSupportedCategories().contains(jsonLogger.getName())) {
- LOGGER.debug(jsonLogger.getName() + " is a supported category for external destination");
- logEvent.publishToExternalDestination(correlationInfo.getEventId(), finalLog, config.getConfigName());
- }
- }
- } else {
- LOGGER.debug("Avoiding logger operation logic execution due to log priority not being enabled");
- }
- callback.success(VOID_RESULT);
- }
-
- /**
- * Log scope
- */
- @Execution(ExecutionType.BLOCKING)
- public void loggerScope(@DisplayName("Module configuration") @Example("JSON_Logger_Config") @Summary("Indicate which Global config should be associated with this Scope.") String configurationRef,
- @Optional(defaultValue="INFO") Priority priority,
- @Optional(defaultValue="OUTBOUND_REQUEST_SCOPE") ScopeTracePoint scopeTracePoint,
- @Optional @Summary("If not set, by default will log to the org.mule.extension.jsonlogger.JsonLogger category") String category,
- @Optional(defaultValue="#[correlationId]") @Placement(tab = "Advanced") String correlationId,
- ComponentLocation location,
- CorrelationInfo correlationInfo,
- FlowListener flowListener,
- Chain operations,
- CompletionCallback callback) {
-
- /**
- * BEFORE scope logger
- * ===================
- **/
-
- Long initialTimestamp,loggerTimestamp;
- initialTimestamp = loggerTimestamp = System.currentTimeMillis();
-
- initLoggerCategory(category);
-
- LOGGER.debug("correlationInfo.getEventId(): " + correlationInfo.getEventId());
- LOGGER.debug("correlationInfo.getCorrelationId(): " + correlationInfo.getCorrelationId());
-
- try {
- // Add cache entry for initial timestamp based on unique EventId
- initialTimestamp = configs.getConfig(configurationRef).getCachedTimerTimestamp(correlationInfo.getCorrelationId(), initialTimestamp);
- } catch (Exception e) {
- LOGGER.error("initialTimestamp could not be retrieved from the cache config. Defaulting to current System.currentTimeMillis()", e);
- }
-
- // Calculate elapsed time based on cached initialTimestamp
- Long elapsed = loggerTimestamp - initialTimestamp;
-
- //config.printTimersKeys();
- if (elapsed == 0) {
- LOGGER.debug("configuring flowListener....");
- flowListener.onComplete(new TimerRemoverRunnable(correlationInfo.getCorrelationId(), configs.getConfig(configurationRef)));
- } else {
- LOGGER.debug("flowListener already configured");
- }
-
- /**
- * Avoid Logger Scope logic execution based on log priority
- */
- if (isLogEnabled(priority.toString())) {
- // Execute Scope Logger
- ObjectNode loggerProcessor = om.getObjectMapper().createObjectNode();
-
- /**
- * Custom field ordering for Logger Scope
- * ===============================
- **/
- loggerProcessor.put("correlationId", correlationId);
- loggerProcessor.put("tracePoint", scopeTracePoint.toString() + "_BEFORE");
- loggerProcessor.put("priority", priority.toString());
- loggerProcessor.put("elapsed", elapsed);
- loggerProcessor.put("scopeElapsed", 0);
- if (configs.getConfig(configurationRef).getJsonOutput().isLogLocationInfo()) {
- Map locationInfoMap = locationInfoToMap(location);
- loggerProcessor.putPOJO("locationInfo", locationInfoMap);
- }
- loggerProcessor.put("timestamp", getFormattedTimestamp(loggerTimestamp));
- loggerProcessor.put("applicationName", configs.getConfig(configurationRef).getGlobalSettings().getApplicationName());
- loggerProcessor.put("applicationVersion", configs.getConfig(configurationRef).getGlobalSettings().getApplicationVersion());
- loggerProcessor.put("environment", configs.getConfig(configurationRef).getGlobalSettings().getEnvironment());
- loggerProcessor.put("threadName", Thread.currentThread().getName());
-
- // Define JSON output formatting
- // Print Logger
- String finalLogBefore = printObjectToLog(loggerProcessor, priority.toString(), configs.getConfig(configurationRef).getJsonOutput().isPrettyPrint());
-
- // Added temp variable to comply with lambda
- Long finalInitialTimestamp = initialTimestamp;
- operations.process(
- result -> {
-
- /**
- * AFTER scope logger
- * ===================
- **/
-
- Long endScopeTimestamp = System.currentTimeMillis();
-
- // Calculate elapsed time
- Long scopeElapsed = endScopeTimestamp - loggerTimestamp;
- Long mainElapsed = endScopeTimestamp - finalInitialTimestamp;
-
- loggerProcessor.put("tracePoint", scopeTracePoint.toString() + "_AFTER");
- loggerProcessor.put("priority", priority.toString());
- loggerProcessor.put("elapsed", mainElapsed);
- loggerProcessor.put("scopeElapsed", scopeElapsed);
- loggerProcessor.put("timestamp", getFormattedTimestamp(endScopeTimestamp));
-
- // Print Logger
- String finalLogAfter = printObjectToLog(loggerProcessor, priority.toString(), configs.getConfig(configurationRef).getJsonOutput().isPrettyPrint());
-
- /** Forward Log to External Destination **/
- if (configs.getConfig(configurationRef).getExternalDestination() != null) {
- publishScopeLogEvents(configurationRef, correlationId, finalLogBefore, finalLogAfter);
- }
-
- callback.success(result);
- },
- (error, previous) -> {
-
- /** ERROR scope logger **/
-
- Long errorScopeTimestamp = System.currentTimeMillis();
- Long mainElapsed = errorScopeTimestamp - finalInitialTimestamp;
-
- // Calculate elapsed time
- Long scopeElapsed = errorScopeTimestamp - loggerTimestamp;
-
- loggerProcessor.put("message", "Error found: " + error.getMessage());
- loggerProcessor.put("tracePoint", "EXCEPTION_SCOPE");
- loggerProcessor.put("priority", "ERROR");
- loggerProcessor.put("elapsed", mainElapsed);
- loggerProcessor.put("scopeElapsed", scopeElapsed);
- loggerProcessor.put("timestamp", getFormattedTimestamp(errorScopeTimestamp));
-
- // Print Logger
- String finalLogError = printObjectToLog(loggerProcessor, "ERROR", configs.getConfig(configurationRef).getJsonOutput().isPrettyPrint());
-
- /** Forward Log to External Destination **/
- if (configs.getConfig(configurationRef).getExternalDestination() != null) {
- publishScopeLogEvents(configurationRef, correlationId, finalLogBefore, finalLogError);
- }
-
- callback.error(error);
- });
- } else {
- // Execute operations without Logger
- LOGGER.debug("Avoiding logger scope logic execution due to log priority not being enabled");
- operations.process(
- result -> {
- callback.success(result);
- },
- (error, previous) -> {
- callback.error(error);
- });
- }
- }
-
- private void publishScopeLogEvents(String configurationRef, String correlationId, String finalLogBefore, String finalLogAfter) {
- LOGGER.debug("externalDestination.getDestination().getSupportedCategories().isEmpty(): " + configs.getConfig(configurationRef).getExternalDestination().getSupportedCategories().isEmpty());
- LOGGER.debug("externalDestination.getDestination().getSupportedCategories().contains(jsonLogger.getName()): " + configs.getConfig(configurationRef).getExternalDestination().getSupportedCategories().contains(jsonLogger.getName()));
- if (configs.getConfig(configurationRef).getExternalDestination().getSupportedCategories().isEmpty() || configs.getConfig(configurationRef).getExternalDestination().getSupportedCategories().contains(jsonLogger.getName())) {
- LOGGER.debug(jsonLogger.getName() + " is a supported category for external destination");
- // Publishing before and after logEvents for better efficiency
- logEvent.publishToExternalDestination(correlationId, finalLogBefore, configurationRef);
- logEvent.publishToExternalDestination(correlationId, finalLogAfter, configurationRef);
- }
- }
-
- private Map locationInfoToMap(ComponentLocation location) {
- Map locationInfo = new HashMap();
- //locationInfo.put("location", location.getLocation());
- locationInfo.put("rootContainer", location.getRootContainerName());
- locationInfo.put("component", location.getComponentIdentifier().getIdentifier().toString());
- locationInfo.put("fileName", location.getFileName().orElse(""));
- locationInfo.put("lineInFile", String.valueOf(location.getLineInFile().orElse(null)));
- return locationInfo;
- }
-
- private String getFormattedTimestamp(Long loggerTimestamp) {
- /*
- Define timestamp:
- - DateTime: Defaults to ISO format
- - TimeZone: Defaults to UTC. Refer to https://en.wikipedia.org/wiki/List_of_tz_database_time_zones for valid timezones
- */
- DateTime dateTime = new DateTime(loggerTimestamp).withZone(org.joda.time.DateTimeZone.forID(System.getProperty("json.logger.timezone", "UTC")));
- String timestamp = dateTime.toString();
- if (System.getProperty("json.logger.dateformat") != null && !System.getProperty("json.logger.dateformat").equals("")) {
- timestamp = dateTime.toString(System.getProperty("json.logger.dateformat"));
- }
- return timestamp;
- }
-
- private String printObjectToLog(ObjectNode loggerObj, String priority, boolean isPrettyPrint) {
- ObjectWriter ow = (isPrettyPrint) ? om.getObjectMapper().writer().withDefaultPrettyPrinter() : om.getObjectMapper().writer();
- String logLine = "";
- try {
- logLine = ow.writeValueAsString(loggerObj);
- } catch (Exception e) {
- LOGGER.error("Error parsing log data as a string", e);
- }
- doLog(priority.toString(), logLine);
-
- return logLine;
- }
-
- private void doLog(String priority, String logLine) {
- switch (priority) {
- case "TRACE":
- jsonLogger.trace(logLine);
- break;
- case "DEBUG":
- jsonLogger.debug(logLine);
- break;
- case "INFO":
- jsonLogger.info(logLine);
- break;
- case "WARN":
- jsonLogger.warn(logLine);
- break;
- case "ERROR":
- jsonLogger.error(logLine);
- break;
- }
- }
-
- private Boolean isLogEnabled(String priority) {
- switch (priority) {
- case "TRACE":
- return jsonLogger.isTraceEnabled();
- case "DEBUG":
- return jsonLogger.isDebugEnabled();
- case "INFO":
- return jsonLogger.isInfoEnabled();
- case "WARN":
- return jsonLogger.isWarnEnabled();
- case "ERROR":
- return jsonLogger.isErrorEnabled();
- }
- return false;
- }
-
- protected void initLoggerCategory(String category) {
- if (category != null) {
- jsonLogger = LoggerFactory.getLogger(category);
- } else {
- jsonLogger = LoggerFactory.getLogger("org.mule.extension.jsonlogger.JsonLogger");
- }
- LOGGER.debug("category set: " + jsonLogger.getName());
- }
-
- // Allows executing timer cleanup on flowListener onComplete events
- private static class TimerRemoverRunnable implements Runnable {
-
- private final String key;
- private final JsonloggerConfiguration config;
-
- public TimerRemoverRunnable(String key, JsonloggerConfiguration config) {
- this.key = key;
- this.config = config;
- }
-
- @Override
- public void run() {
- LOGGER.debug("Removing key: " + key);
- config.removeCachedTimerTimestamp(key);
- }
- }
-}
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/datamask/JsonMasker.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/datamask/JsonMasker.java
deleted file mode 100644
index 38f6a77..0000000
--- a/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/datamask/JsonMasker.java
+++ /dev/null
@@ -1,133 +0,0 @@
-package org.mule.extension.jsonlogger.internal.datamask;
-
-import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.MapperFeature;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
-import com.fasterxml.jackson.databind.node.ArrayNode;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-import com.fasterxml.jackson.databind.node.TextNode;
-import com.jayway.jsonpath.Configuration;
-import com.jayway.jsonpath.JsonPath;
-import com.jayway.jsonpath.Option;
-import com.jayway.jsonpath.spi.json.JacksonJsonNodeJsonProvider;
-
-import java.util.*;
-import java.util.regex.Pattern;
-
-public class JsonMasker {
-
- private static final Pattern digits = Pattern.compile("\\d");
- private static final Pattern capitalLetters = Pattern.compile("[A-Z]");
- private static final Pattern nonSpecialCharacters = Pattern.compile("[^X\\s!-/:-@\\[-`{-~]");
-
- private static final Configuration jsonPathConfig = Configuration.builder()
- .jsonProvider(new JacksonJsonNodeJsonProvider())
- .options(Option.AS_PATH_LIST, Option.SUPPRESS_EXCEPTIONS).build();
-
- private final Set blacklistedKeys;
- private final Set blacklistedJsonPaths;
- private final boolean enabled;
-
- public JsonMasker(Collection blacklist, boolean enabled) {
- this.enabled = enabled;
-
- blacklistedKeys = new HashSet<>();
- blacklistedJsonPaths = new HashSet<>();
-
- blacklist.forEach(item -> {
- if (item.startsWith("$")) {
- blacklistedJsonPaths.add(JsonPath.compile(item));
- } else {
- blacklistedKeys.add(item.toUpperCase());
- }
- });
- }
-
- public JsonMasker() {
- this(Collections.emptySet(), true);
- }
-
- public JsonMasker(boolean enabled) {
- this(Collections.emptySet(), enabled);
- }
-
- public JsonMasker(Collection blacklist) {
- this(blacklist, true);
- }
-
- public JsonNode mask(JsonNode target) {
- if (!enabled)
- return target;
- if (target == null)
- return null;
-
- Set expandedBlacklistedPaths = new HashSet<>();
- for (JsonPath jsonPath : blacklistedJsonPaths) {
- if (jsonPath.isDefinite()) {
- expandedBlacklistedPaths.add(jsonPath.getPath());
- } else {
- for (JsonNode node : jsonPath.read(target, jsonPathConfig)) {
- expandedBlacklistedPaths.add(node.asText());
- }
- }
- }
-
- return traverseAndMask(target.deepCopy(), expandedBlacklistedPaths, "$", false);
- }
-
- @SuppressWarnings("ConstantConditions")
- private JsonNode traverseAndMask(JsonNode target, Set expandedBlacklistedPaths, String path, Boolean isBlackListed) {
- if (target.isTextual() && isBlackListed) {
- return new TextNode(maskString(target.asText()));
- }
- if (target.isNumber() && isBlackListed) {
- return new TextNode(maskNumber(target.asText()));
- }
-
- if (target.isObject()) {
- Iterator> fields = target.fields();
- while (fields.hasNext()) {
- Map.Entry field = fields.next();
- String childPath = appendPath(path, field.getKey());
- if (blacklistedKeys.contains(field.getKey().toUpperCase()) || expandedBlacklistedPaths.contains(childPath) || isBlackListed == true) {
- ((ObjectNode) target).replace(field.getKey(), traverseAndMask(field.getValue(), expandedBlacklistedPaths, childPath, true));
- } else {
- ((ObjectNode) target).replace(field.getKey(), traverseAndMask(field.getValue(), expandedBlacklistedPaths, childPath, false));
- }
- }
- }
- if (target.isArray()) {
- for (int i = 0; i < target.size(); i++) {
- String childPath = appendPath(path, i);
- if (expandedBlacklistedPaths.contains(childPath) || isBlackListed == true) {
- ((ArrayNode) target).set(i, traverseAndMask(target.get(i), expandedBlacklistedPaths, childPath, true));
- } else {
- ((ArrayNode) target).set(i, traverseAndMask(target.get(i), expandedBlacklistedPaths, childPath, false));
- }
- }
- }
- return target;
- }
-
- private static String appendPath(String path, String key) {
- return path + "['" + key + "']";
- }
-
- private static String appendPath(String path, int ind) {
- return path + "[" + ind + "]";
- }
-
- private static String maskString(String value) {
- String tmpMasked = digits.matcher(value).replaceAll("*");
- tmpMasked = capitalLetters.matcher(tmpMasked).replaceAll("X");
- return nonSpecialCharacters.matcher(tmpMasked).replaceAll("x");
- }
-
- private static String maskNumber(String value) {
- return value.replaceAll("[0-9]", "*");
- }
-
-}
\ No newline at end of file
diff --git a/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/destinations/AMQDestination.java b/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/destinations/AMQDestination.java
deleted file mode 100644
index 0c3e831..0000000
--- a/json-logger/src/main/java/org/mule/extension/jsonlogger/internal/destinations/AMQDestination.java
+++ /dev/null
@@ -1,189 +0,0 @@
-package org.mule.extension.jsonlogger.internal.destinations;
-
-import com.mulesoft.mq.restclient.api.*;
-import com.mulesoft.mq.restclient.impl.OAuthCredentials;
-import org.mule.extension.jsonlogger.internal.destinations.amq.client.MuleBasedAnypointMQClientFactory;
-import org.mule.runtime.api.metadata.MediaType;
-import org.mule.runtime.api.scheduler.SchedulerService;
-import org.mule.runtime.extension.api.annotation.param.NullSafe;
-import org.mule.runtime.extension.api.annotation.param.Optional;
-import org.mule.runtime.extension.api.annotation.param.Parameter;
-import org.mule.runtime.extension.api.annotation.param.display.DisplayName;
-import org.mule.runtime.extension.api.annotation.param.display.Example;
-import org.mule.runtime.extension.api.annotation.param.display.Password;
-import org.mule.runtime.extension.api.annotation.param.display.Summary;
-import org.mule.runtime.http.api.HttpService;
-import org.mule.runtime.http.api.client.HttpClient;
-import org.mule.runtime.http.api.client.HttpClientConfiguration;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.inject.Inject;
-import java.io.ByteArrayInputStream;
-import java.nio.charset.Charset;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
-
-public class AMQDestination implements Destination {
-
- private static final Logger LOGGER = LoggerFactory.getLogger(AMQDestination.class);
-
- @Parameter
- @Optional
- @Summary("Name of the target queue or exchange destination (e.g. logger-queue, logger-exchange)")
- @DisplayName("Queue or Exchange Destination")
- private String queueOrExchangeDestination;
-
- /**
- * The region URL where the Queue resides. This URL can be obtained and configured from the Anypoint Platform > MQ console.
- * Copy/paste the region URL into this field."
- */
- @Parameter
- @DisplayName("URL")
- @Example("https://mq-us-east-1.anypoint.mulesoft.com/api/v1")
- @Optional(defaultValue = "https://mq-us-east-1.anypoint.mulesoft.com/api/v1")
- @Summary("The region URL where the Queue resides. Obtain this URL from the Anypoint Platform > MQ")
- private String url;
-
- /**
- * In Anypoint Platform > MQ > Client Apps, click an app name (or create a new app) and
- * click Copy for the Client App ID field. Paste this value in the Studio Client App ID field
- */
- @Parameter
- @DisplayName("Client App ID")
- @Summary("The Client App ID to be used. Obtain this ID from Anypoint Platform > MQ > Client Apps")
- private String clientId;
-
- /**
- * In Anypoint Platform > MQ > Client Apps, click an app name (or create a new app) and
- * click Copy for the Client Secret field. Paste this value in the Studio Client Secret field.
- */
- @Parameter
- @DisplayName("Client Secret")
- @Password
- @Summary("The Client App Secret for the given Client App ID")
- private String clientSecret;
-
- @Parameter
- @Optional
- @NullSafe
- @Summary("Indicate which log categories should be send (e.g. [\"my.category\",\"another.category\"]). If empty, all will be send.")
- @DisplayName("Log Categories")
- private ArrayList logCategories;
-
- @Parameter
- @Optional(defaultValue = "25")
- @Summary("Indicate max quantity of logs entries to be send to the external destination")
- @DisplayName("Max Batch Size")
- private int maxBatchSize;
-
- @Override
- public int getMaxBatchSize() {
- return this.maxBatchSize;
- }
-
- @Inject
- protected HttpService httpService;
-
- @Inject
- protected SchedulerService schedulerService;
-
- private final String AMQ_HTTP_CLIENT = "amqHttpClient";
- private final String USER_AGENT_VERSION = "3.1.0"; // Version of the AMQ Connector code this logic is based of
-
- private HttpClientConfiguration httpClientConfiguration;
- private HttpClient httpClient;
- private AnypointMqClient amqClient;
- private DestinationLocator destinationLocator;
- private DestinationLocation location;
-
- @Override
- public String getSelectedDestinationType() {
- return "AMQ";
- }
-
- @Override
- public ArrayList getSupportedCategories() {
- return logCategories;
- }
-
- @Override
- public void sendToExternalDestination(String finalLog) {
-
- try {
- // Send message
- MediaType mediaType = MediaType.parse("application/json; charset=UTF-8");
- AnypointMQMessage message = createMessage(finalLog, true, mediaType.toString(),
- mediaType.getCharset(), null, new HashMap<>(), null, null);
-
- this.destinationLocator.getDestination(this.location)
- .send(message)
- .subscribe(new CourierObserver() {
- @Override
- public void onSuccess(MessageIdResult result) {
- LOGGER.debug("AMQ Message Id: " + result.getMessageId());
- }
-
- @Override
- public void onError(Throwable e) {
- String msg = String.format("Failed to publish message to destination '%s': %s", location, e.getMessage());
- LOGGER.error(msg, e);
- }
- });
- } catch (Exception e) {
- LOGGER.error("Error sending message to AMQ: " + e.getMessage());
- e.printStackTrace();
- }
- }
-
- private static AnypointMQMessage createMessage(String messageBody, boolean sendContentType, String mediaType,
- java.util.Optional charset, String messageId, Map properties,
- java.util.Optional deliveryDelay, java.util.Optional messageGroupId) {
- AnypointMQMessageBuilder messageBuilder = new AnypointMQMessageBuilder();
- messageBuilder.withBody(new ByteArrayInputStream(messageBody.getBytes()));
-
- String id = java.util.Optional.