You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by da...@apache.org on 2023/05/17 16:43:43 UTC
[camel] branch main updated (7597d063c5d -> 6829f1f3ac9)
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a change to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
from 7597d063c5d CAMEL-19228: separate tests that run only with Couchbase 7 than those that run with 6
new 3907d999101 CAMEL-19362: camel-core - Allow tracing without inner details of Kamelets
new 6829f1f3ac9 CAMEL-19362: camel-core - Allow tracing without inner details of Kamelets
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../main/java/org/apache/camel/CamelContext.java | 25 +++++++
.../src/main/java/org/apache/camel/NamedRoute.java | 10 +++
.../java/org/apache/camel/spi/BacklogTracer.java | 20 ++++++
.../camel/spi/BacklogTracerEventMessage.java | 10 +++
.../src/main/java/org/apache/camel/spi/Tracer.java | 26 +++++++-
.../camel/impl/debugger/BacklogDebugger.java | 7 +-
.../apache/camel/impl/debugger/BacklogTracer.java | 18 +++++
.../debugger/DefaultBacklogTracerEventMessage.java | 19 ++++++
.../camel/impl/engine/AbstractCamelContext.java | 22 ++++++
.../camel/impl/engine/CamelInternalProcessor.java | 78 ++++++++++++++++------
.../apache/camel/impl/engine/DefaultChannel.java | 4 ++
.../apache/camel/impl/engine/DefaultTracer.java | 22 ++++++
.../camel/impl/engine/SimpleCamelContext.java | 4 ++
.../apache/camel/impl/CamelContextConfigurer.java | 12 ++++
.../org/apache/camel/model/RouteDefinition.java | 13 ++++
.../MainConfigurationPropertiesConfigurer.java | 12 ++++
.../camel-main-configuration-metadata.json | 2 +
core/camel-main/src/main/docs/main.adoc | 4 +-
.../camel/main/DefaultConfigurationConfigurer.java | 2 +
.../camel/main/DefaultConfigurationProperties.java | 52 +++++++++++++++
.../mbean/ManagedBacklogTracerMBean.java | 6 ++
.../api/management/mbean/ManagedTracerMBean.java | 6 ++
.../management/mbean/ManagedBacklogTracer.java | 10 +++
.../camel/management/mbean/ManagedTracer.java | 10 +++
.../modules/ROOT/pages/backlog-tracer.adoc | 6 ++
.../ROOT/pages/camel-3x-upgrade-guide-3_21.adoc | 6 ++
.../ROOT/pages/camel-4-migration-guide.adoc | 6 ++
27 files changed, 385 insertions(+), 27 deletions(-)
[camel] 02/02: CAMEL-19362: camel-core - Allow tracing without inner details of Kamelets
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 6829f1f3ac9da6295b687e5adfaf2b3df19a7a3e
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Wed May 17 18:40:45 2023 +0200
CAMEL-19362: camel-core - Allow tracing without inner details of Kamelets
---
docs/user-manual/modules/ROOT/pages/backlog-tracer.adoc | 6 ++++++
.../user-manual/modules/ROOT/pages/camel-3x-upgrade-guide-3_21.adoc | 6 ++++++
docs/user-manual/modules/ROOT/pages/camel-4-migration-guide.adoc | 6 ++++++
3 files changed, 18 insertions(+)
diff --git a/docs/user-manual/modules/ROOT/pages/backlog-tracer.adoc b/docs/user-manual/modules/ROOT/pages/backlog-tracer.adoc
index 7175c7a9def..0b02dfd5a67 100644
--- a/docs/user-manual/modules/ROOT/pages/backlog-tracer.adoc
+++ b/docs/user-manual/modules/ROOT/pages/backlog-tracer.adoc
@@ -47,6 +47,12 @@ messages with a given header, use `${header.foo} != null`. To use
xref:components:languages:groovy-language.adoc[Groovy] then prefix the value with "groovy:". And
similar for the other languages.
+|traceRests |`false` | Whether tracing should trace inner details from Rest DSL.
+Turning this on increases the verbosity of tracing by including events from internal routes by Rest DSL.
+
+|traceTemplates |`false` | Whether tracing should trace inner details from route templates (or kamelets).
+Turning this on increases the verbosity of tracing by including events from internal routes in the templates or kamelets.
+
|removeOnDump |`true` |Whether to remove the traced messages that was returned when invoking
the dump methods.
diff --git a/docs/user-manual/modules/ROOT/pages/camel-3x-upgrade-guide-3_21.adoc b/docs/user-manual/modules/ROOT/pages/camel-3x-upgrade-guide-3_21.adoc
index c9b0c06b1e9..041a94bddcc 100644
--- a/docs/user-manual/modules/ROOT/pages/camel-3x-upgrade-guide-3_21.adoc
+++ b/docs/user-manual/modules/ROOT/pages/camel-3x-upgrade-guide-3_21.adoc
@@ -10,6 +10,12 @@ from both 3.0 to 3.1 and 3.1 to 3.2.
XML parsers & XML transformers has been made more secure by disabling DOCTYPE and/or access to external DTD/Schema.
+==== Tracing
+
+The xref:tracer.adoc[Tracer] and xref:backlog-tracer.adoc[Backlog Tracer] no longer includes internal tracing events
+from routes that was created by Rest DSL or route templates or Kamelets. You can turn this on, by setting
+`traceTemplates=true` in the tracer.
+
==== UseOriginalMessage / UseOriginalBody
When `useOriginalMessage` or `useOriginalBody` is enabled in `OnException`, `OnCompletion` or error handlers,
diff --git a/docs/user-manual/modules/ROOT/pages/camel-4-migration-guide.adoc b/docs/user-manual/modules/ROOT/pages/camel-4-migration-guide.adoc
index 515192c87fb..c78fdb08a79 100644
--- a/docs/user-manual/modules/ROOT/pages/camel-4-migration-guide.adoc
+++ b/docs/user-manual/modules/ROOT/pages/camel-4-migration-guide.adoc
@@ -94,6 +94,12 @@ Removed `lang` attribute for the `<description>` on every EIPs.
The `InOnly` and `InOut` EIPs has been removed.
Instead, use `SetExchangePattern` or `To` where you can specify exchange pattern to use.
+=== Tracing
+
+The xref:tracer.adoc[Tracer] and xref:backlog-tracer.adoc[Backlog Tracer] no longer includes internal tracing events
+from routes that was created by Rest DSL or route templates or Kamelets. You can turn this on, by setting
+`traceTemplates=true` in the tracer.
+
=== UseOriginalMessage / UseOriginalBody
When `useOriginalMessage` or `useOriginalBody` is enabled in `OnException`, `OnCompletion` or error handlers,
[camel] 01/02: CAMEL-19362: camel-core - Allow tracing without inner details of Kamelets
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 3907d9991010aa7cbda1a8bb1f647911458a6cac
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Wed May 17 18:34:35 2023 +0200
CAMEL-19362: camel-core - Allow tracing without inner details of Kamelets
---
.../main/java/org/apache/camel/CamelContext.java | 25 +++++++
.../src/main/java/org/apache/camel/NamedRoute.java | 10 +++
.../java/org/apache/camel/spi/BacklogTracer.java | 20 ++++++
.../camel/spi/BacklogTracerEventMessage.java | 10 +++
.../src/main/java/org/apache/camel/spi/Tracer.java | 26 +++++++-
.../camel/impl/debugger/BacklogDebugger.java | 7 +-
.../apache/camel/impl/debugger/BacklogTracer.java | 18 +++++
.../debugger/DefaultBacklogTracerEventMessage.java | 19 ++++++
.../camel/impl/engine/AbstractCamelContext.java | 22 ++++++
.../camel/impl/engine/CamelInternalProcessor.java | 78 ++++++++++++++++------
.../apache/camel/impl/engine/DefaultChannel.java | 4 ++
.../apache/camel/impl/engine/DefaultTracer.java | 22 ++++++
.../camel/impl/engine/SimpleCamelContext.java | 4 ++
.../apache/camel/impl/CamelContextConfigurer.java | 12 ++++
.../org/apache/camel/model/RouteDefinition.java | 13 ++++
.../MainConfigurationPropertiesConfigurer.java | 12 ++++
.../camel-main-configuration-metadata.json | 2 +
core/camel-main/src/main/docs/main.adoc | 4 +-
.../camel/main/DefaultConfigurationConfigurer.java | 2 +
.../camel/main/DefaultConfigurationProperties.java | 52 +++++++++++++++
.../mbean/ManagedBacklogTracerMBean.java | 6 ++
.../api/management/mbean/ManagedTracerMBean.java | 6 ++
.../management/mbean/ManagedBacklogTracer.java | 10 +++
.../camel/management/mbean/ManagedTracer.java | 10 +++
24 files changed, 367 insertions(+), 27 deletions(-)
diff --git a/core/camel-api/src/main/java/org/apache/camel/CamelContext.java b/core/camel-api/src/main/java/org/apache/camel/CamelContext.java
index 565930039f3..22fe97e2853 100644
--- a/core/camel-api/src/main/java/org/apache/camel/CamelContext.java
+++ b/core/camel-api/src/main/java/org/apache/camel/CamelContext.java
@@ -1180,6 +1180,19 @@ public interface CamelContext extends CamelContextLifecycle, RuntimeConfiguratio
*/
boolean isBacklogTracingStandby();
+ /**
+ * Whether backlog tracing should trace inner details from route templates (or kamelets). Turning this off can
+ * reduce the verbosity of tracing when using many route templates, and allow to focus on tracing your own Camel
+ * routes only.
+ */
+ void setBacklogTracingTemplates(boolean backlogTracingTemplates);
+
+ /**
+ * Whether backlog tracing should trace inner details from route templates (or kamelets). Turning this on increases
+ * the verbosity of tracing by including events from internal routes in the templates or kamelets.
+ */
+ boolean isBacklogTracingTemplates();
+
/**
* Gets the current {@link UuidGenerator}
*
@@ -1354,6 +1367,18 @@ public interface CamelContext extends CamelContextLifecycle, RuntimeConfiguratio
*/
void setTracingLoggingFormat(String format);
+ /**
+ * Whether tracing should trace inner details from route templates (or kamelets). Turning this on increases the
+ * verbosity of tracing by including events from internal routes in the templates or kamelets.
+ */
+ void setTracingTemplates(boolean tracingTemplates);
+
+ /**
+ * Whether tracing should trace inner details from route templates (or kamelets). Turning this off can reduce the
+ * verbosity of tracing when using many route templates, and allow to focus on tracing your own Camel routes only.
+ */
+ boolean isTracingTemplates();
+
/**
* If dumping is enabled then Camel will during startup dump all loaded routes (incl rests and route templates)
* represented as XML DSL into the log. This is intended for trouble shooting or to assist during development.
diff --git a/core/camel-api/src/main/java/org/apache/camel/NamedRoute.java b/core/camel-api/src/main/java/org/apache/camel/NamedRoute.java
index 4d592941f4a..37ff8e86561 100644
--- a/core/camel-api/src/main/java/org/apache/camel/NamedRoute.java
+++ b/core/camel-api/src/main/java/org/apache/camel/NamedRoute.java
@@ -31,6 +31,16 @@ public interface NamedRoute {
*/
String getEndpointUrl();
+ /**
+ * Is the route created from template;
+ */
+ boolean isCreatedFromTemplate();
+
+ /**
+ * Is the route created from Rest DSL
+ */
+ boolean isCreatedFromRest();
+
/**
* Gets the route input
*/
diff --git a/core/camel-api/src/main/java/org/apache/camel/spi/BacklogTracer.java b/core/camel-api/src/main/java/org/apache/camel/spi/BacklogTracer.java
index 9ff19a3aa21..3c894a95294 100644
--- a/core/camel-api/src/main/java/org/apache/camel/spi/BacklogTracer.java
+++ b/core/camel-api/src/main/java/org/apache/camel/spi/BacklogTracer.java
@@ -119,6 +119,26 @@ public interface BacklogTracer {
*/
void setIncludeException(boolean includeException);
+ /**
+ * Whether to trace routes that is created from Rest DSL.
+ */
+ boolean isTraceRests();
+
+ /**
+ * Whether to trace routes that is created from route templates or kamelets.
+ */
+ void setTraceRests(boolean traceRests);
+
+ /**
+ * Whether to trace routes that is created from route templates or kamelets.
+ */
+ boolean isTraceTemplates();
+
+ /**
+ * Whether to trace routes that is created from route templates or kamelets.
+ */
+ void setTraceTemplates(boolean traceTemplates);
+
/**
* Filter for tracing by route or node id
*/
diff --git a/core/camel-api/src/main/java/org/apache/camel/spi/BacklogTracerEventMessage.java b/core/camel-api/src/main/java/org/apache/camel/spi/BacklogTracerEventMessage.java
index 873b0cc54b4..1529d3d4151 100644
--- a/core/camel-api/src/main/java/org/apache/camel/spi/BacklogTracerEventMessage.java
+++ b/core/camel-api/src/main/java/org/apache/camel/spi/BacklogTracerEventMessage.java
@@ -56,6 +56,16 @@ public interface BacklogTracerEventMessage {
*/
String getRouteId();
+ /**
+ * Whether this event was from a route that is created from Rest DSL.
+ */
+ boolean isRest();
+
+ /**
+ * Whether this event was from a route that is created from route template or kamelet.
+ */
+ boolean isTemplate();
+
/**
* Node id where the message is being routed to
*/
diff --git a/core/camel-api/src/main/java/org/apache/camel/spi/Tracer.java b/core/camel-api/src/main/java/org/apache/camel/spi/Tracer.java
index b904734a69e..fa168a65389 100644
--- a/core/camel-api/src/main/java/org/apache/camel/spi/Tracer.java
+++ b/core/camel-api/src/main/java/org/apache/camel/spi/Tracer.java
@@ -88,7 +88,7 @@ public interface Tracer extends StaticService {
/**
* Whether the tracer is standby.
- *
+ * <p>
* If a tracer is in standby then the tracer is activated during startup and are ready to be enabled manually via
* JMX or calling the enabled method.
*/
@@ -96,12 +96,34 @@ public interface Tracer extends StaticService {
/**
* Whether the tracer is standby.
- *
+ * <p>
* If a tracer is in standby then the tracer is activated during startup and are ready to be enabled manually via
* JMX or calling the enabled method.
*/
void setStandby(boolean standby);
+ /**
+ * Whether to trace routes that is created from Rest DSL.
+ */
+ boolean isTraceRests();
+
+ /**
+ * Whether to trace routes that is created from route templates or kamelets.
+ */
+ void setTraceRests(boolean traceRests);
+
+ /**
+ * Whether tracing should trace inner details from route templates (or kamelets). Turning this off can reduce the
+ * verbosity of tracing when using many route templates, and allow to focus on tracing your own Camel routes only.
+ */
+ boolean isTraceTemplates();
+
+ /**
+ * Whether tracing should trace inner details from route templates (or kamelets). Turning this off can reduce the
+ * verbosity of tracing when using many route templates, and allow to focus on tracing your own Camel routes only.
+ */
+ void setTraceTemplates(boolean traceTemplates);
+
/**
* Tracing pattern to match which node EIPs to trace. For example to match all To EIP nodes, use to*. The pattern
* matches by node and route id's Multiple patterns can be separated by comma.
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/BacklogDebugger.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/BacklogDebugger.java
index b67edf2ee6c..f08a8f2ab10 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/BacklogDebugger.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/BacklogDebugger.java
@@ -612,6 +612,7 @@ public final class BacklogDebugger extends ServiceSupport {
false, false, message.getUid(), message.getTimestamp(), message.getLocation(), message.getRouteId(),
message.getToNode(),
message.getExchangeId(),
+ false, false,
dumpAsXml(suspendedExchange.getExchange()),
dumpAsJSon(suspendedExchange.getExchange())));
}
@@ -673,7 +674,8 @@ public final class BacklogDebugger extends ServiceSupport {
BacklogTracerEventMessage msg
= new DefaultBacklogTracerEventMessage(
- false, false, uid, timestamp, source, routeId, toNode, exchangeId, messageAsXml, messageAsJSon);
+ false, false, uid, timestamp, source, routeId, toNode, exchangeId, false, false, messageAsXml,
+ messageAsJSon);
suspendedBreakpointMessages.put(nodeId, msg);
// suspend at this breakpoint
@@ -742,7 +744,8 @@ public final class BacklogDebugger extends ServiceSupport {
BacklogTracerEventMessage msg
= new DefaultBacklogTracerEventMessage(
- false, false, uid, timestamp, source, routeId, toNode, exchangeId, messageAsXml, messageAsJSon);
+ false, false, uid, timestamp, source, routeId, toNode, exchangeId, false, false, messageAsXml,
+ messageAsJSon);
suspendedBreakpointMessages.put(toNode, msg);
// suspend at this breakpoint
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/BacklogTracer.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/BacklogTracer.java
index 48ccfb667f0..2c6f13181de 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/BacklogTracer.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/BacklogTracer.java
@@ -62,6 +62,8 @@ public final class BacklogTracer extends ServiceSupport implements org.apache.ca
private boolean bodyIncludeFiles = true;
private boolean includeExchangeProperties = true;
private boolean includeException = true;
+ private boolean traceRests;
+ private boolean traceTemplates;
// a pattern to filter tracing nodes
private String tracePattern;
private String[] patterns;
@@ -244,6 +246,22 @@ public final class BacklogTracer extends ServiceSupport implements org.apache.ca
this.includeException = includeException;
}
+ public boolean isTraceRests() {
+ return traceRests;
+ }
+
+ public void setTraceRests(boolean traceRests) {
+ this.traceRests = traceRests;
+ }
+
+ public boolean isTraceTemplates() {
+ return traceTemplates;
+ }
+
+ public void setTraceTemplates(boolean traceTemplates) {
+ this.traceTemplates = traceTemplates;
+ }
+
@Override
public String getTracePattern() {
return tracePattern;
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/DefaultBacklogTracerEventMessage.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/DefaultBacklogTracerEventMessage.java
index 98bf1595c5b..bcdeb3a24b5 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/DefaultBacklogTracerEventMessage.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/DefaultBacklogTracerEventMessage.java
@@ -40,6 +40,8 @@ public final class DefaultBacklogTracerEventMessage implements BacklogTracerEven
private final String toNode;
private final String exchangeId;
private final String threadName;
+ private final boolean rest;
+ private final boolean template;
private final String messageAsXml;
private final String messageAsJSon;
private String exceptionAsXml;
@@ -49,6 +51,7 @@ public final class DefaultBacklogTracerEventMessage implements BacklogTracerEven
public DefaultBacklogTracerEventMessage(boolean first, boolean last, long uid, long timestamp,
String location, String routeId, String toNode, String exchangeId,
+ boolean rest, boolean template,
String messageAsXml, String messageAsJSon) {
this.watch = new StopWatch();
this.first = first;
@@ -59,6 +62,8 @@ public final class DefaultBacklogTracerEventMessage implements BacklogTracerEven
this.routeId = routeId;
this.toNode = toNode;
this.exchangeId = exchangeId;
+ this.rest = rest;
+ this.template = template;
this.messageAsXml = messageAsXml;
this.messageAsJSon = messageAsJSon;
this.threadName = Thread.currentThread().getName();
@@ -102,6 +107,16 @@ public final class DefaultBacklogTracerEventMessage implements BacklogTracerEven
return routeId;
}
+ @Override
+ public boolean isRest() {
+ return rest;
+ }
+
+ @Override
+ public boolean isTemplate() {
+ return template;
+ }
+
@Override
public String getToNode() {
return toNode;
@@ -190,6 +205,8 @@ public final class DefaultBacklogTracerEventMessage implements BacklogTracerEven
sb.append(prefix).append(" <uid>").append(uid).append("</uid>\n");
sb.append(prefix).append(" <first>").append(first).append("</first>\n");
sb.append(prefix).append(" <last>").append(last).append("</last>\n");
+ sb.append(prefix).append(" <rest>").append(rest).append("</rest>\n");
+ sb.append(prefix).append(" <template>").append(template).append("</template>\n");
String ts = new SimpleDateFormat(TIMESTAMP_FORMAT).format(timestamp);
sb.append(prefix).append(" <timestamp>").append(ts).append("</timestamp>\n");
sb.append(prefix).append(" <elapsed>").append(getElapsed()).append("</elapsed>\n");
@@ -232,6 +249,8 @@ public final class DefaultBacklogTracerEventMessage implements BacklogTracerEven
jo.put("uid", uid);
jo.put("first", first);
jo.put("last", last);
+ jo.put("rest", rest);
+ jo.put("template", template);
if (location != null) {
jo.put("location", location);
}
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
index c7174b3fe77..6781a3ed56c 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
@@ -233,8 +233,10 @@ public abstract class AbstractCamelContext extends BaseService
private Boolean autoStartup = Boolean.TRUE;
private Boolean backlogTrace = Boolean.FALSE;
private Boolean backlogTraceStandby = Boolean.FALSE;
+ private Boolean backlogTraceTemplates = Boolean.FALSE;
private Boolean trace = Boolean.FALSE;
private Boolean traceStandby = Boolean.FALSE;
+ private Boolean traceTemplates = Boolean.FALSE;
private String tracePattern;
private String tracingLoggingFormat;
private Boolean modeline = Boolean.FALSE;
@@ -3737,6 +3739,26 @@ public abstract class AbstractCamelContext extends BaseService
return traceStandby != null && traceStandby;
}
+ @Override
+ public void setTracingTemplates(boolean tracingTemplates) {
+ this.traceTemplates = tracingTemplates;
+ }
+
+ @Override
+ public boolean isTracingTemplates() {
+ return traceTemplates != null && traceTemplates;
+ }
+
+ @Override
+ public void setBacklogTracingTemplates(boolean backlogTracingTemplates) {
+ this.backlogTraceTemplates = backlogTracingTemplates;
+ }
+
+ @Override
+ public boolean isBacklogTracingTemplates() {
+ return backlogTraceTemplates != null && backlogTraceTemplates;
+ }
+
@Override
public void setBacklogTracingStandby(boolean backlogTracingStandby) {
this.backlogTraceStandby = backlogTracingStandby;
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/CamelInternalProcessor.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/CamelInternalProcessor.java
index e64f1bc7ca3..e70454c88c4 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/CamelInternalProcessor.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/CamelInternalProcessor.java
@@ -557,6 +557,9 @@ public class CamelInternalProcessor extends DelegateAsyncProcessor implements In
private final NamedNode processorDefinition;
private final NamedRoute routeDefinition;
private final boolean first;
+ private final boolean rest;
+ private final boolean template;
+ private final boolean skip;
public BacklogTracerAdvice(BacklogTracer backlogTracer, NamedNode processorDefinition,
NamedRoute routeDefinition, boolean first) {
@@ -564,11 +567,27 @@ public class CamelInternalProcessor extends DelegateAsyncProcessor implements In
this.processorDefinition = processorDefinition;
this.routeDefinition = routeDefinition;
this.first = first;
+
+ if (routeDefinition != null) {
+ this.rest = routeDefinition.isCreatedFromRest();
+ this.template = routeDefinition.isCreatedFromTemplate();
+ } else {
+ this.rest = false;
+ this.template = false;
+ }
+ // optimize whether to skip this route or not
+ if (this.rest && !backlogTracer.isTraceRests()) {
+ this.skip = true;
+ } else if (this.template && !backlogTracer.isTraceTemplates()) {
+ this.skip = true;
+ } else {
+ this.skip = false;
+ }
}
@Override
public DefaultBacklogTracerEventMessage before(Exchange exchange) throws Exception {
- if (backlogTracer.shouldTrace(processorDefinition, exchange)) {
+ if (!skip && backlogTracer.shouldTrace(processorDefinition, exchange)) {
long timestamp = System.currentTimeMillis();
String toNode = processorDefinition.getId();
String exchangeId = exchange.getExchangeId();
@@ -588,8 +607,7 @@ public class CamelInternalProcessor extends DelegateAsyncProcessor implements In
long created = exchange.getCreated();
DefaultBacklogTracerEventMessage pseudoFirst = new DefaultBacklogTracerEventMessage(
true, false, backlogTracer.incrementTraceCounter(), created, source, routeId, null, exchangeId,
- messageAsXml,
- messageAsJSon);
+ rest, template, messageAsXml, messageAsJSon);
backlogTracer.traceEvent(pseudoFirst);
exchange.getExchangeExtension().addOnCompletion(new SynchronizationAdapter() {
@Override
@@ -608,9 +626,7 @@ public class CamelInternalProcessor extends DelegateAsyncProcessor implements In
backlogTracer.getBodyMaxChars(), true);
DefaultBacklogTracerEventMessage pseudoLast = new DefaultBacklogTracerEventMessage(
false, true, backlogTracer.incrementTraceCounter(), created, source, routeId, null,
- exchangeId,
- messageAsXml,
- messageAsJSon);
+ exchangeId, rest, template, messageAsXml, messageAsJSon);
backlogTracer.traceEvent(pseudoLast);
doneProcessing(exchange, pseudoLast);
doneProcessing(exchange, pseudoFirst);
@@ -623,8 +639,7 @@ public class CamelInternalProcessor extends DelegateAsyncProcessor implements In
String source = LoggerHelper.getLineNumberLoggerName(processorDefinition);
DefaultBacklogTracerEventMessage event = new DefaultBacklogTracerEventMessage(
false, false, backlogTracer.incrementTraceCounter(), timestamp, source, routeId, toNode, exchangeId,
- messageAsXml,
- messageAsJSon);
+ rest, template, messageAsXml, messageAsJSon);
backlogTracer.traceEvent(event);
return event;
@@ -635,21 +650,21 @@ public class CamelInternalProcessor extends DelegateAsyncProcessor implements In
@Override
public void after(Exchange exchange, DefaultBacklogTracerEventMessage data) throws Exception {
- doneProcessing(exchange, data);
+ if (data != null) {
+ doneProcessing(exchange, data);
+ }
}
private void doneProcessing(Exchange exchange, DefaultBacklogTracerEventMessage data) {
- if (data != null) {
- data.doneProcessing();
- if (!data.isFirst()) {
- // we want to capture if there was an exception
- Throwable e = exchange.getException();
- if (e != null) {
- String xml = MessageHelper.dumpExceptionAsXML(e, 4);
- data.setExceptionAsXml(xml);
- String json = MessageHelper.dumpExceptionAsJSon(e, 4, true);
- data.setExceptionAsJSon(json);
- }
+ data.doneProcessing();
+ if (!data.isFirst()) {
+ // we want to capture if there was an exception
+ Throwable e = exchange.getException();
+ if (e != null) {
+ String xml = MessageHelper.dumpExceptionAsXML(e, 4);
+ data.setExceptionAsXml(xml);
+ String json = MessageHelper.dumpExceptionAsJSon(e, 4, true);
+ data.setExceptionAsJSon(json);
}
}
}
@@ -1049,6 +1064,9 @@ public class CamelInternalProcessor extends DelegateAsyncProcessor implements In
private final NamedNode processorDefinition;
private final NamedRoute routeDefinition;
private final Synchronization tracingAfterRoute;
+ private final boolean rest;
+ private final boolean template;
+ private final boolean skip;
public TracingAdvice(Tracer tracer, NamedNode processorDefinition, NamedRoute routeDefinition, boolean first) {
this.tracer = tracer;
@@ -1057,11 +1075,27 @@ public class CamelInternalProcessor extends DelegateAsyncProcessor implements In
this.tracingAfterRoute
= routeDefinition != null
? new TracingAfterRoute(tracer, routeDefinition.getRouteId(), routeDefinition) : null;
+
+ if (routeDefinition != null) {
+ this.rest = routeDefinition.isCreatedFromRest();
+ this.template = routeDefinition.isCreatedFromTemplate();
+ } else {
+ this.rest = false;
+ this.template = false;
+ }
+ // optimize whether to skip this route or not
+ if (this.rest && !tracer.isTraceRests()) {
+ this.skip = true;
+ } else if (this.template && !tracer.isTraceTemplates()) {
+ this.skip = true;
+ } else {
+ this.skip = false;
+ }
}
@Override
public Object before(Exchange exchange) throws Exception {
- if (tracer.isEnabled()) {
+ if (!skip && tracer.isEnabled()) {
if (tracingAfterRoute != null) {
// add before route and after route tracing but only once per route, so check if there is already an existing
boolean contains = exchange.getUnitOfWork().containsSynchronization(tracingAfterRoute);
@@ -1077,7 +1111,7 @@ public class CamelInternalProcessor extends DelegateAsyncProcessor implements In
@Override
public void after(Exchange exchange, Object data) throws Exception {
- if (tracer.isEnabled()) {
+ if (!skip && tracer.isEnabled()) {
tracer.traceAfterNode(processorDefinition, exchange);
}
}
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultChannel.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultChannel.java
index 50cc9201a28..a3ec2d77988 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultChannel.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultChannel.java
@@ -282,6 +282,10 @@ public class DefaultChannel extends CamelInternalProcessor implements Channel {
tracer = BacklogTracer.createTracer(camelContext);
tracer.setEnabled(camelContext.isBacklogTracing() != null && camelContext.isBacklogTracing());
tracer.setStandby(camelContext.isBacklogTracingStandby());
+ // enable both rest/templates if templates is enabled (we only want 1 public option)
+ boolean restOrTemplates = camelContext.isBacklogTracingTemplates();
+ tracer.setTraceTemplates(restOrTemplates);
+ tracer.setTraceRests(restOrTemplates);
camelContext.getCamelContextExtension().addContextPlugin(BacklogTracer.class, tracer);
}
return tracer;
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultTracer.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultTracer.java
index 51f42e5358e..e34e2abd826 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultTracer.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultTracer.java
@@ -52,6 +52,8 @@ public class DefaultTracer extends ServiceSupport implements CamelContextAware,
private CamelContext camelContext;
private boolean enabled = true;
private boolean standby;
+ private boolean traceRests;
+ private boolean traceTemplates;
private long traceCounter;
private ExchangeFormatter exchangeFormatter;
@@ -206,6 +208,26 @@ public class DefaultTracer extends ServiceSupport implements CamelContextAware,
this.standby = standby;
}
+ @Override
+ public boolean isTraceRests() {
+ return traceRests;
+ }
+
+ @Override
+ public void setTraceRests(boolean traceRests) {
+ this.traceRests = traceRests;
+ }
+
+ @Override
+ public boolean isTraceTemplates() {
+ return traceTemplates;
+ }
+
+ @Override
+ public void setTraceTemplates(boolean traceTemplates) {
+ this.traceTemplates = traceTemplates;
+ }
+
@Override
public String getTracePattern() {
return tracePattern;
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/SimpleCamelContext.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/SimpleCamelContext.java
index d7d35a4b113..d9a6e3a2e72 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/SimpleCamelContext.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/SimpleCamelContext.java
@@ -583,6 +583,10 @@ public class SimpleCamelContext extends AbstractCamelContext {
tracer = new DefaultTracer();
tracer.setEnabled(isTracing());
tracer.setStandby(isTracingStandby());
+ // enable both rest/templates if templates is enabled (we only want 1 public option)
+ boolean restOrTemplates = isTracingTemplates();
+ tracer.setTraceTemplates(restOrTemplates);
+ tracer.setTraceRests(restOrTemplates);
getCamelContextExtension().addContextPlugin(Tracer.class, tracer);
}
return tracer;
diff --git a/core/camel-core-engine/src/generated/java/org/apache/camel/impl/CamelContextConfigurer.java b/core/camel-core-engine/src/generated/java/org/apache/camel/impl/CamelContextConfigurer.java
index ac9d605f8b8..903b657713f 100644
--- a/core/camel-core-engine/src/generated/java/org/apache/camel/impl/CamelContextConfigurer.java
+++ b/core/camel-core-engine/src/generated/java/org/apache/camel/impl/CamelContextConfigurer.java
@@ -33,6 +33,8 @@ public class CamelContextConfigurer extends org.apache.camel.support.component.P
case "BacklogTracing": target.setBacklogTracing(property(camelContext, java.lang.Boolean.class, value)); return true;
case "backlogtracingstandby":
case "BacklogTracingStandby": target.setBacklogTracingStandby(property(camelContext, boolean.class, value)); return true;
+ case "backlogtracingtemplates":
+ case "BacklogTracingTemplates": target.setBacklogTracingTemplates(property(camelContext, boolean.class, value)); return true;
case "caseinsensitiveheaders":
case "CaseInsensitiveHeaders": target.setCaseInsensitiveHeaders(property(camelContext, java.lang.Boolean.class, value)); return true;
case "classresolver":
@@ -115,6 +117,8 @@ public class CamelContextConfigurer extends org.apache.camel.support.component.P
case "TracingPattern": target.setTracingPattern(property(camelContext, java.lang.String.class, value)); return true;
case "tracingstandby":
case "TracingStandby": target.setTracingStandby(property(camelContext, boolean.class, value)); return true;
+ case "tracingtemplates":
+ case "TracingTemplates": target.setTracingTemplates(property(camelContext, boolean.class, value)); return true;
case "typeconverterregistry":
case "TypeConverterRegistry": target.setTypeConverterRegistry(property(camelContext, org.apache.camel.spi.TypeConverterRegistry.class, value)); return true;
case "typeconverterstatisticsenabled":
@@ -148,6 +152,8 @@ public class CamelContextConfigurer extends org.apache.camel.support.component.P
case "BacklogTracing": return java.lang.Boolean.class;
case "backlogtracingstandby":
case "BacklogTracingStandby": return boolean.class;
+ case "backlogtracingtemplates":
+ case "BacklogTracingTemplates": return boolean.class;
case "caseinsensitiveheaders":
case "CaseInsensitiveHeaders": return java.lang.Boolean.class;
case "classresolver":
@@ -230,6 +236,8 @@ public class CamelContextConfigurer extends org.apache.camel.support.component.P
case "TracingPattern": return java.lang.String.class;
case "tracingstandby":
case "TracingStandby": return boolean.class;
+ case "tracingtemplates":
+ case "TracingTemplates": return boolean.class;
case "typeconverterregistry":
case "TypeConverterRegistry": return org.apache.camel.spi.TypeConverterRegistry.class;
case "typeconverterstatisticsenabled":
@@ -264,6 +272,8 @@ public class CamelContextConfigurer extends org.apache.camel.support.component.P
case "BacklogTracing": return target.isBacklogTracing();
case "backlogtracingstandby":
case "BacklogTracingStandby": return target.isBacklogTracingStandby();
+ case "backlogtracingtemplates":
+ case "BacklogTracingTemplates": return target.isBacklogTracingTemplates();
case "caseinsensitiveheaders":
case "CaseInsensitiveHeaders": return target.isCaseInsensitiveHeaders();
case "classresolver":
@@ -346,6 +356,8 @@ public class CamelContextConfigurer extends org.apache.camel.support.component.P
case "TracingPattern": return target.getTracingPattern();
case "tracingstandby":
case "TracingStandby": return target.isTracingStandby();
+ case "tracingtemplates":
+ case "TracingTemplates": return target.isTracingTemplates();
case "typeconverterregistry":
case "TypeConverterRegistry": return target.getTypeConverterRegistry();
case "typeconverterstatisticsenabled":
diff --git a/core/camel-core-model/src/main/java/org/apache/camel/model/RouteDefinition.java b/core/camel-core-model/src/main/java/org/apache/camel/model/RouteDefinition.java
index d64b02a06f6..b204c02019d 100644
--- a/core/camel-core-model/src/main/java/org/apache/camel/model/RouteDefinition.java
+++ b/core/camel-core-model/src/main/java/org/apache/camel/model/RouteDefinition.java
@@ -1128,6 +1128,9 @@ public class RouteDefinition extends OutputDefinition<RouteDefinition>
this.errorHandlerFactory = errorHandlerFactory;
}
+ /**
+ * This route is created from REST DSL
+ */
public void setRest(Boolean rest) {
this.rest = rest;
}
@@ -1206,6 +1209,16 @@ public class RouteDefinition extends OutputDefinition<RouteDefinition>
this.routeProperties = routeProperties;
}
+ @Override
+ public boolean isCreatedFromTemplate() {
+ return template != null && template;
+ }
+
+ @Override
+ public boolean isCreatedFromRest() {
+ return rest != null && rest;
+ }
+
// ****************************
// Static helpers
// ****************************
diff --git a/core/camel-main/src/generated/java/org/apache/camel/main/MainConfigurationPropertiesConfigurer.java b/core/camel-main/src/generated/java/org/apache/camel/main/MainConfigurationPropertiesConfigurer.java
index b18dd20177e..24f2bb7a78f 100644
--- a/core/camel-main/src/generated/java/org/apache/camel/main/MainConfigurationPropertiesConfigurer.java
+++ b/core/camel-main/src/generated/java/org/apache/camel/main/MainConfigurationPropertiesConfigurer.java
@@ -41,6 +41,8 @@ public class MainConfigurationPropertiesConfigurer extends org.apache.camel.supp
case "BacklogTracing": target.setBacklogTracing(property(camelContext, boolean.class, value)); return true;
case "backlogtracingstandby":
case "BacklogTracingStandby": target.setBacklogTracingStandby(property(camelContext, boolean.class, value)); return true;
+ case "backlogtracingtemplates":
+ case "BacklogTracingTemplates": target.setBacklogTracingTemplates(property(camelContext, boolean.class, value)); return true;
case "basepackagescan":
case "BasePackageScan": target.setBasePackageScan(property(camelContext, java.lang.String.class, value)); return true;
case "basepackagescanenabled":
@@ -243,6 +245,8 @@ public class MainConfigurationPropertiesConfigurer extends org.apache.camel.supp
case "TracingPattern": target.setTracingPattern(property(camelContext, java.lang.String.class, value)); return true;
case "tracingstandby":
case "TracingStandby": target.setTracingStandby(property(camelContext, boolean.class, value)); return true;
+ case "tracingtemplates":
+ case "TracingTemplates": target.setTracingTemplates(property(camelContext, boolean.class, value)); return true;
case "typeconverterstatisticsenabled":
case "TypeConverterStatisticsEnabled": target.setTypeConverterStatisticsEnabled(property(camelContext, boolean.class, value)); return true;
case "usebreadcrumb":
@@ -280,6 +284,8 @@ public class MainConfigurationPropertiesConfigurer extends org.apache.camel.supp
case "BacklogTracing": return boolean.class;
case "backlogtracingstandby":
case "BacklogTracingStandby": return boolean.class;
+ case "backlogtracingtemplates":
+ case "BacklogTracingTemplates": return boolean.class;
case "basepackagescan":
case "BasePackageScan": return java.lang.String.class;
case "basepackagescanenabled":
@@ -482,6 +488,8 @@ public class MainConfigurationPropertiesConfigurer extends org.apache.camel.supp
case "TracingPattern": return java.lang.String.class;
case "tracingstandby":
case "TracingStandby": return boolean.class;
+ case "tracingtemplates":
+ case "TracingTemplates": return boolean.class;
case "typeconverterstatisticsenabled":
case "TypeConverterStatisticsEnabled": return boolean.class;
case "usebreadcrumb":
@@ -520,6 +528,8 @@ public class MainConfigurationPropertiesConfigurer extends org.apache.camel.supp
case "BacklogTracing": return target.isBacklogTracing();
case "backlogtracingstandby":
case "BacklogTracingStandby": return target.isBacklogTracingStandby();
+ case "backlogtracingtemplates":
+ case "BacklogTracingTemplates": return target.isBacklogTracingTemplates();
case "basepackagescan":
case "BasePackageScan": return target.getBasePackageScan();
case "basepackagescanenabled":
@@ -722,6 +732,8 @@ public class MainConfigurationPropertiesConfigurer extends org.apache.camel.supp
case "TracingPattern": return target.getTracingPattern();
case "tracingstandby":
case "TracingStandby": return target.isTracingStandby();
+ case "tracingtemplates":
+ case "TracingTemplates": return target.isTracingTemplates();
case "typeconverterstatisticsenabled":
case "TypeConverterStatisticsEnabled": return target.isTypeConverterStatisticsEnabled();
case "usebreadcrumb":
diff --git a/core/camel-main/src/generated/resources/META-INF/camel-main-configuration-metadata.json b/core/camel-main/src/generated/resources/META-INF/camel-main-configuration-metadata.json
index 84dd30a3935..d608e6d195d 100644
--- a/core/camel-main/src/generated/resources/META-INF/camel-main-configuration-metadata.json
+++ b/core/camel-main/src/generated/resources/META-INF/camel-main-configuration-metadata.json
@@ -22,6 +22,7 @@
{ "name": "camel.main.autowiredEnabled", "description": "Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. Default is true.", "sourceType": "org.apache.camel.main.DefaultConfiguration [...]
{ "name": "camel.main.backlogTracing", "description": "Sets whether backlog tracing is enabled or not. Default is false.", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "boolean", "javaType": "boolean", "defaultValue": "false" },
{ "name": "camel.main.backlogTracingStandby", "description": "Whether to set backlog tracing on standby. If on standby then the backlog tracer is installed and made available. Then the backlog tracer can be enabled later at runtime via JMX or via Java API. Default is false.", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "boolean", "javaType": "boolean", "defaultValue": "false" },
+ { "name": "camel.main.backlogTracingTemplates", "description": "Whether backlog tracing should trace inner details from route templates (or kamelets). Turning this on increases the verbosity of tracing by including events from internal routes in the templates or kamelets. Default is false.", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "boolean", "javaType": "boolean", "defaultValue": "false" },
{ "name": "camel.main.basePackageScan", "description": "Package name to use as base (offset) for classpath scanning of RouteBuilder , and org.apache.camel.TypeConverter classes. If you are using Spring Boot then it is instead recommended to use Spring Boots component scanning and annotate your route builder classes with Component. In other words only use this for Camel Main in standalone mode.", "sourceType": "org.apache.camel.main.MainConfigurationProperties", "type": "string", "jav [...]
{ "name": "camel.main.basePackageScanEnabled", "description": "Whether base package scan is enabled.", "sourceType": "org.apache.camel.main.MainConfigurationProperties", "type": "boolean", "javaType": "boolean", "defaultValue": true },
{ "name": "camel.main.beanIntrospectionExtendedStatistics", "description": "Sets whether bean introspection uses extended statistics. The default is false.", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "boolean", "javaType": "boolean", "defaultValue": "false" },
@@ -123,6 +124,7 @@
{ "name": "camel.main.tracingLoggingFormat", "description": "To use a custom tracing logging format. The default format (arrow, routeId, label) is: %-4.4s %-12.12s %-33.33s", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "string", "javaType": "java.lang.String", "defaultValue": "%-4.4s [%-12.12s] [%-33.33s]" },
{ "name": "camel.main.tracingPattern", "description": "Tracing pattern to match which node EIPs to trace. For example to match all To EIP nodes, use to. The pattern matches by node and route id's Multiple patterns can be separated by comma.", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "string", "javaType": "java.lang.String" },
{ "name": "camel.main.tracingStandby", "description": "Whether to set tracing on standby. If on standby then the tracer is installed and made available. Then the tracer can be enabled later at runtime via JMX or via Tracer#setEnabled(boolean) .", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "boolean", "javaType": "boolean", "defaultValue": "false" },
+ { "name": "camel.main.tracingTemplates", "description": "Whether tracing should trace inner details from route templates (or kamelets). Turning this on increases the verbosity of tracing by including events from internal routes in the templates or kamelets. Default is false.", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "boolean", "javaType": "boolean", "defaultValue": "false" },
{ "name": "camel.main.typeConverterStatisticsEnabled", "description": "Sets whether type converter statistics is enabled. By default the type converter utilization statistics is disabled. Notice: If enabled then there is a slight performance impact under very heavy load.", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "boolean", "javaType": "boolean", "defaultValue": "false" },
{ "name": "camel.main.useBreadcrumb", "description": "Set whether breadcrumb is enabled. The default value is false.", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "boolean", "javaType": "boolean", "defaultValue": "false" },
{ "name": "camel.main.useDataType", "description": "Whether to enable using data type on Camel messages. Data type are automatic turned on if one ore more routes has been explicit configured with input and output types. Otherwise data type is default off.", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "boolean", "javaType": "boolean", "defaultValue": "false" },
diff --git a/core/camel-main/src/main/docs/main.adoc b/core/camel-main/src/main/docs/main.adoc
index 76b5a0fba41..5481c32a19e 100644
--- a/core/camel-main/src/main/docs/main.adoc
+++ b/core/camel-main/src/main/docs/main.adoc
@@ -19,7 +19,7 @@ The following tables lists all the options:
// main options: START
=== Camel Main configurations
-The camel.main supports 116 options, which are listed below.
+The camel.main supports 118 options, which are listed below.
[width="100%",cols="2,5,^1,2",options="header"]
|===
@@ -34,6 +34,7 @@ The camel.main supports 116 options, which are listed below.
| *camel.main.autowiredEnabled* | Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. Default is true. | true | boolean
| *camel.main.backlogTracing* | Sets whether backlog tracing is enabled or not. Default is false. | false | boolean
| *camel.main.backlogTracing{zwsp}Standby* | Whether to set backlog tracing on standby. If on standby then the backlog tracer is installed and made available. Then the backlog tracer can be enabled later at runtime via JMX or via Java API. Default is false. | false | boolean
+| *camel.main.backlogTracing{zwsp}Templates* | Whether backlog tracing should trace inner details from route templates (or kamelets). Turning this on increases the verbosity of tracing by including events from internal routes in the templates or kamelets. Default is false. | false | boolean
| *camel.main.basePackageScan* | Package name to use as base (offset) for classpath scanning of RouteBuilder , and org.apache.camel.TypeConverter classes. If you are using Spring Boot then it is instead recommended to use Spring Boots component scanning and annotate your route builder classes with Component. In other words only use this for Camel Main in standalone mode. | | String
| *camel.main.basePackageScan{zwsp}Enabled* | Whether base package scan is enabled. | true | boolean
| *camel.main.beanIntrospection{zwsp}ExtendedStatistics* | Sets whether bean introspection uses extended statistics. The default is false. | false | boolean
@@ -135,6 +136,7 @@ The camel.main supports 116 options, which are listed below.
| *camel.main.tracingLogging{zwsp}Format* | To use a custom tracing logging format. The default format (arrow, routeId, label) is: %-4.4s %-12.12s %-33.33s | %-4.4s [%-12.12s] [%-33.33s] | String
| *camel.main.tracingPattern* | Tracing pattern to match which node EIPs to trace. For example to match all To EIP nodes, use to. The pattern matches by node and route id's Multiple patterns can be separated by comma. | | String
| *camel.main.tracingStandby* | Whether to set tracing on standby. If on standby then the tracer is installed and made available. Then the tracer can be enabled later at runtime via JMX or via Tracer#setEnabled(boolean) . | false | boolean
+| *camel.main.tracingTemplates* | Whether tracing should trace inner details from route templates (or kamelets). Turning this on increases the verbosity of tracing by including events from internal routes in the templates or kamelets. Default is false. | false | boolean
| *camel.main.typeConverter{zwsp}StatisticsEnabled* | Sets whether type converter statistics is enabled. By default the type converter utilization statistics is disabled. Notice: If enabled then there is a slight performance impact under very heavy load. | false | boolean
| *camel.main.useBreadcrumb* | Set whether breadcrumb is enabled. The default value is false. | false | boolean
| *camel.main.useDataType* | Whether to enable using data type on Camel messages. Data type are automatic turned on if one ore more routes has been explicit configured with input and output types. Otherwise data type is default off. | false | boolean
diff --git a/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationConfigurer.java b/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationConfigurer.java
index 710d7f030d8..468ce783941 100644
--- a/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationConfigurer.java
+++ b/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationConfigurer.java
@@ -303,10 +303,12 @@ public final class DefaultConfigurationConfigurer {
camelContext.setBacklogTracing(config.isBacklogTracing());
camelContext.setBacklogTracingStandby(config.isBacklogTracingStandby());
+ camelContext.setBacklogTracingTemplates(config.isBacklogTracingTemplates());
camelContext.setTracing(config.isTracing());
camelContext.setTracingStandby(config.isTracingStandby());
camelContext.setTracingPattern(config.getTracingPattern());
camelContext.setTracingLoggingFormat(config.getTracingLoggingFormat());
+ camelContext.setTracingTemplates(config.isTracingTemplates());
if (config.getThreadNamePattern() != null) {
camelContext.getExecutorServiceManager().setThreadNamePattern(config.getThreadNamePattern());
diff --git a/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationProperties.java b/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationProperties.java
index a6fc8a4b63e..593e983995f 100644
--- a/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationProperties.java
+++ b/core/camel-main/src/main/java/org/apache/camel/main/DefaultConfigurationProperties.java
@@ -72,9 +72,11 @@ public abstract class DefaultConfigurationProperties<T> {
private boolean debugging;
private boolean backlogTracing;
private boolean backlogTracingStandby;
+ private boolean backlogTracingTemplates;
private boolean typeConverterStatisticsEnabled;
private boolean tracing;
private boolean tracingStandby;
+ private boolean tracingTemplates;
private String tracingPattern;
@Metadata(defaultValue = "%-4.4s [%-12.12s] [%-33.33s]")
private String tracingLoggingFormat;
@@ -622,6 +624,20 @@ public abstract class DefaultConfigurationProperties<T> {
this.tracingStandby = tracingStandby;
}
+ public boolean isTracingTemplates() {
+ return tracingTemplates;
+ }
+
+ /**
+ * Whether tracing should trace inner details from route templates (or kamelets). Turning this on increases the
+ * verbosity of tracing by including events from internal routes in the templates or kamelets.
+ *
+ * Default is false.
+ */
+ public void setTracingTemplates(boolean tracingTemplates) {
+ this.tracingTemplates = tracingTemplates;
+ }
+
public String getTracingPattern() {
return tracingPattern;
}
@@ -687,6 +703,20 @@ public abstract class DefaultConfigurationProperties<T> {
this.backlogTracingStandby = backlogTracingStandby;
}
+ public boolean isBacklogTracingTemplates() {
+ return backlogTracingTemplates;
+ }
+
+ /**
+ * Whether backlog tracing should trace inner details from route templates (or kamelets). Turning this on increases
+ * the verbosity of tracing by including events from internal routes in the templates or kamelets.
+ *
+ * Default is false.
+ */
+ public void setBacklogTracingTemplates(boolean backlogTracingTemplates) {
+ this.backlogTracingTemplates = backlogTracingTemplates;
+ }
+
public boolean isMessageHistory() {
return messageHistory;
}
@@ -1934,6 +1964,17 @@ public abstract class DefaultConfigurationProperties<T> {
return (T) this;
}
+ /**
+ * Whether tracing should trace inner details from route templates (or kamelets). Turning this on increases the
+ * verbosity of tracing by including events from internal routes in the templates or kamelets.
+ *
+ * Default is false.
+ */
+ public T withTracingTemplates(boolean tracingTemplates) {
+ this.tracingTemplates = tracingTemplates;
+ return (T) this;
+ }
+
/**
* Sets whether backlog tracing is enabled or not.
*
@@ -1955,6 +1996,17 @@ public abstract class DefaultConfigurationProperties<T> {
return (T) this;
}
+ /**
+ * Whether backlog tracing should trace inner details from route templates (or kamelets). Turning this on increases
+ * the verbosity of tracing by including events from internal routes in the templates or kamelets.
+ *
+ * Default is false.
+ */
+ public T withBacklogTracingTemplates(boolean backlogTracingTemplates) {
+ this.backlogTracingTemplates = backlogTracingTemplates;
+ return (T) this;
+ }
+
/**
* Sets whether message history is enabled or not.
*
diff --git a/core/camel-management-api/src/main/java/org/apache/camel/api/management/mbean/ManagedBacklogTracerMBean.java b/core/camel-management-api/src/main/java/org/apache/camel/api/management/mbean/ManagedBacklogTracerMBean.java
index cad1bdbbe9a..d89f8b63b68 100644
--- a/core/camel-management-api/src/main/java/org/apache/camel/api/management/mbean/ManagedBacklogTracerMBean.java
+++ b/core/camel-management-api/src/main/java/org/apache/camel/api/management/mbean/ManagedBacklogTracerMBean.java
@@ -93,6 +93,12 @@ public interface ManagedBacklogTracerMBean {
@ManagedAttribute(description = "Whether to include exchange properties in the trace message.")
boolean isIncludeExchangeProperties();
+ @ManagedAttribute(description = "Whether tracing routes created from Rest DSL.")
+ boolean isTraceRests();
+
+ @ManagedAttribute(description = "Whether tracing routes created from route templates or kamelets.")
+ boolean isTraceTemplates();
+
@ManagedAttribute(description = "Whether to include exchange properties in the trace message.")
void setIncludeExchangeProperties(boolean includeExchangeProperties);
diff --git a/core/camel-management-api/src/main/java/org/apache/camel/api/management/mbean/ManagedTracerMBean.java b/core/camel-management-api/src/main/java/org/apache/camel/api/management/mbean/ManagedTracerMBean.java
index b5465a6d253..0b977ceca0e 100644
--- a/core/camel-management-api/src/main/java/org/apache/camel/api/management/mbean/ManagedTracerMBean.java
+++ b/core/camel-management-api/src/main/java/org/apache/camel/api/management/mbean/ManagedTracerMBean.java
@@ -42,6 +42,12 @@ public interface ManagedTracerMBean {
@ManagedAttribute(description = "To filter tracing by nodes (pattern)")
String getTracePattern();
+ @ManagedAttribute(description = "Whether tracing routes created from Rest DSL.")
+ boolean isTraceRests();
+
+ @ManagedAttribute(description = "Whether tracing routes created from route templates or kamelets.")
+ boolean isTraceTemplates();
+
@ManagedAttribute(description = "Number of total traced messages")
long getTraceCounter();
diff --git a/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedBacklogTracer.java b/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedBacklogTracer.java
index 19de3926c2d..d697e8d79af 100644
--- a/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedBacklogTracer.java
+++ b/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedBacklogTracer.java
@@ -171,6 +171,16 @@ public class ManagedBacklogTracer implements ManagedBacklogTracerMBean {
backlogTracer.setIncludeExchangeProperties(includeExchangeProperties);
}
+ @Override
+ public boolean isTraceRests() {
+ return backlogTracer.isTraceRests();
+ }
+
+ @Override
+ public boolean isTraceTemplates() {
+ return backlogTracer.isTraceTemplates();
+ }
+
@Override
public List<BacklogTracerEventMessage> dumpTracedMessages(String nodeOrRouteId) {
return backlogTracer.dumpTracedMessages(nodeOrRouteId);
diff --git a/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedTracer.java b/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedTracer.java
index 42f2fe5604b..b5fb9020193 100644
--- a/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedTracer.java
+++ b/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedTracer.java
@@ -83,6 +83,16 @@ public class ManagedTracer implements ManagedTracerMBean {
return tracer.getTracePattern();
}
+ @Override
+ public boolean isTraceRests() {
+ return tracer.isTraceRests();
+ }
+
+ @Override
+ public boolean isTraceTemplates() {
+ return tracer.isTraceTemplates();
+ }
+
@Override
public long getTraceCounter() {
return tracer.getTraceCounter();