Updated Branches:
  refs/heads/master 3e53d971b -> e120e891a

CAMEL-6384: Added BacklogDebugger MBean for live debugging of Camel routes. 
Work in progress.


Project: http://git-wip-us.apache.org/repos/asf/camel/repo
Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/e120e891
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/e120e891
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/e120e891

Branch: refs/heads/master
Commit: e120e891a3164b4c7def773bd08238a30299eaf3
Parents: 3e53d97
Author: Claus Ibsen <[email protected]>
Authored: Thu May 23 10:29:39 2013 +0200
Committer: Claus Ibsen <[email protected]>
Committed: Thu May 23 11:17:28 2013 +0200

----------------------------------------------------------------------
 .../mbean/ManagedBacklogDebuggerMBean.java         |   26 +++++-
 .../management/mbean/ManagedBacklogDebugger.java   |   33 ++++++-
 .../processor/interceptor/BacklogDebugger.java     |   74 +++++++++++---
 3 files changed, 108 insertions(+), 25 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/camel/blob/e120e891/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedBacklogDebuggerMBean.java
----------------------------------------------------------------------
diff --git 
a/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedBacklogDebuggerMBean.java
 
b/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedBacklogDebuggerMBean.java
index 700b048..bd1c813 100644
--- 
a/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedBacklogDebuggerMBean.java
+++ 
b/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedBacklogDebuggerMBean.java
@@ -68,11 +68,29 @@ public interface ManagedBacklogDebuggerMBean {
     @ManagedOperation(description = "Return the node ids which is currently 
suspended")
     Set<String> getSuspendedBreakpointNodeIds();
 
-    @ManagedOperation(description = "Suspend a breakpoint")
-    public void suspendBreakpoint(String nodeId);
+    @ManagedOperation(description = "Disables a breakpoint")
+    public void disableBreakpoint(String nodeId);
 
-    @ManagedOperation(description = "Activate a breakpoint")
-    public void activateBreakpoint(String nodeId);
+    @ManagedOperation(description = "Enables a breakpoint which has been 
disabled")
+    public void enableBreakpoint(String nodeId);
+
+    @ManagedAttribute(description = "Number of maximum chars in the message 
body in the trace message. Use zero or negative value to have unlimited size.")
+    int getBodyMaxChars();
+
+    @ManagedAttribute(description = "Number of maximum chars in the message 
body in the trace message. Use zero or negative value to have unlimited size.")
+    void setBodyMaxChars(int bodyMaxChars);
+
+    @ManagedAttribute(description = "Whether to include stream based message 
body in the trace message.")
+    boolean isBodyIncludeStreams();
+
+    @ManagedAttribute(description = "Whether to include stream based message 
body in the trace message.")
+    void setBodyIncludeStreams(boolean bodyIncludeStreams);
+
+    @ManagedAttribute(description = "Whether to include file based message 
body in the trace message.")
+    boolean isBodyIncludeFiles();
+
+    @ManagedAttribute(description = "Whether to include file based message 
body in the trace message.")
+    void setBodyIncludeFiles(boolean bodyIncludeFiles);
 
     @ManagedOperation(description = "Dumps the messages in xml format from the 
suspended breakpoint at the given node")
     String dumpTracedMessagesAsXml(String nodeId);

http://git-wip-us.apache.org/repos/asf/camel/blob/e120e891/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedBacklogDebugger.java
----------------------------------------------------------------------
diff --git 
a/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedBacklogDebugger.java
 
b/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedBacklogDebugger.java
index 442f6bf..03a8081 100644
--- 
a/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedBacklogDebugger.java
+++ 
b/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedBacklogDebugger.java
@@ -19,7 +19,6 @@ package org.apache.camel.management.mbean;
 import java.util.Set;
 
 import org.apache.camel.CamelContext;
-import org.apache.camel.api.management.ManagedOperation;
 import org.apache.camel.api.management.ManagedResource;
 import org.apache.camel.api.management.mbean.ManagedBacklogDebuggerMBean;
 import org.apache.camel.processor.interceptor.BacklogDebugger;
@@ -108,12 +107,36 @@ public class ManagedBacklogDebugger implements 
ManagedBacklogDebuggerMBean {
         return backlogDebugger.getSuspendedBreakpointNodeIds();
     }
 
-    public void suspendBreakpoint(String nodeId) {
-        backlogDebugger.suspendBreakpoint(nodeId);
+    public void disableBreakpoint(String nodeId) {
+        backlogDebugger.disableBreakpoint(nodeId);
     }
 
-    public void activateBreakpoint(String nodeId) {
-        backlogDebugger.activateBreakpoint(nodeId);
+    public void enableBreakpoint(String nodeId) {
+        backlogDebugger.enableBreakpoint(nodeId);
+    }
+
+    public int getBodyMaxChars() {
+        return backlogDebugger.getBodyMaxChars();
+    }
+
+    public void setBodyMaxChars(int bodyMaxChars) {
+        backlogDebugger.setBodyMaxChars(bodyMaxChars);
+    }
+
+    public boolean isBodyIncludeStreams() {
+        return backlogDebugger.isBodyIncludeStreams();
+    }
+
+    public void setBodyIncludeStreams(boolean bodyIncludeStreams) {
+        backlogDebugger.setBodyIncludeStreams(bodyIncludeStreams);
+    }
+
+    public boolean isBodyIncludeFiles() {
+        return backlogDebugger.isBodyIncludeFiles();
+    }
+
+    public void setBodyIncludeFiles(boolean bodyIncludeFiles) {
+        backlogDebugger.setBodyIncludeFiles(bodyIncludeFiles);
     }
 
     public String dumpTracedMessagesAsXml(String nodeId) {

http://git-wip-us.apache.org/repos/asf/camel/blob/e120e891/camel-core/src/main/java/org/apache/camel/processor/interceptor/BacklogDebugger.java
----------------------------------------------------------------------
diff --git 
a/camel-core/src/main/java/org/apache/camel/processor/interceptor/BacklogDebugger.java
 
b/camel-core/src/main/java/org/apache/camel/processor/interceptor/BacklogDebugger.java
index 56337af..dedc63c 100644
--- 
a/camel-core/src/main/java/org/apache/camel/processor/interceptor/BacklogDebugger.java
+++ 
b/camel-core/src/main/java/org/apache/camel/processor/interceptor/BacklogDebugger.java
@@ -18,14 +18,13 @@ package org.apache.camel.processor.interceptor;
 
 import java.util.Date;
 import java.util.EventObject;
-import java.util.HashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 
@@ -52,13 +51,23 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
- * A {@link org.apache.camel.spi.Debugger} that should be used together with 
the {@link BacklogTracer} to
- * offer debugging and tracing functionality.
+ * A {@link org.apache.camel.spi.Debugger} that has easy debugging 
functionality which
+ * can be used from JMX with {@link 
org.apache.camel.api.management.mbean.ManagedBacklogDebuggerMBean}.
+ * <p/>
+ * This implementation allows to set breakpoints (with or without a condition) 
and inspect the {@link Exchange}
+ * dumped in XML in {@link BacklogTracerEventMessage} format. There is 
operations to resume suspended breakpoints
+ * to continue routing the {@link Exchange}. There is also step functionality 
so you can single step a given
+ * {@link Exchange}.
+ * <p/>
+ * This implementation will only break the first {@link Exchange} that arrives 
to a breakpoint. If Camel routes using
+ * concurrency then sub-sequent {@link Exchange} will continue to be routed, 
if there breakpoint already holds a
+ * suspended {@link Exchange}.
  */
 public class BacklogDebugger extends ServiceSupport implements 
InterceptStrategy {
 
     private static final Logger LOG = 
LoggerFactory.getLogger(BacklogDebugger.class);
 
+    private long fallbackTimeout = 300;
     private final CamelContext camelContext;
     private LoggingLevel loggingLevel = LoggingLevel.INFO;
     private final CamelLogger logger = new CamelLogger(LOG, loggingLevel);
@@ -69,6 +78,9 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
     private final ConcurrentMap<String, CountDownLatch> suspendedBreakpoints = 
new ConcurrentHashMap<String, CountDownLatch>();
     private final ConcurrentMap<String, BacklogTracerEventMessage> 
suspendedBreakpointMessages = new ConcurrentHashMap<String, 
BacklogTracerEventMessage>();
     private volatile String singleStepExchangeId;
+    private int bodyMaxChars = 128 * 1024;
+    private boolean bodyIncludeStreams;
+    private boolean bodyIncludeFiles = true;
 
     public BacklogDebugger(CamelContext camelContext) {
         this.camelContext = camelContext;
@@ -266,22 +278,46 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
         return new LinkedHashSet<String>(suspendedBreakpoints.keySet());
     }
 
-    public void suspendBreakpoint(String nodeId) {
-        logger.log("Suspend breakpoint " + nodeId);
+    public void disableBreakpoint(String nodeId) {
+        logger.log("Disable breakpoint " + nodeId);
         NodeBreakpoint breakpoint = breakpoints.get(nodeId);
         if (breakpoint != null) {
             breakpoint.suspend();
         }
     }
 
-    public void activateBreakpoint(String nodeId) {
-        logger.log("Activate breakpoint " + nodeId);
+    public void enableBreakpoint(String nodeId) {
+        logger.log("Enable breakpoint " + nodeId);
         NodeBreakpoint breakpoint = breakpoints.get(nodeId);
         if (breakpoint != null) {
             breakpoint.activate();
         }
     }
 
+    public int getBodyMaxChars() {
+        return bodyMaxChars;
+    }
+
+    public void setBodyMaxChars(int bodyMaxChars) {
+        this.bodyMaxChars = bodyMaxChars;
+    }
+
+    public boolean isBodyIncludeStreams() {
+        return bodyIncludeStreams;
+    }
+
+    public void setBodyIncludeStreams(boolean bodyIncludeStreams) {
+        this.bodyIncludeStreams = bodyIncludeStreams;
+    }
+
+    public boolean isBodyIncludeFiles() {
+        return bodyIncludeFiles;
+    }
+
+    public void setBodyIncludeFiles(boolean bodyIncludeFiles) {
+        this.bodyIncludeFiles = bodyIncludeFiles;
+    }
+
     public String dumpTracedMessagesAsXml(String nodeId) {
         logger.log("Dump trace message from breakpoint " + nodeId);
         BacklogTracerEventMessage msg = 
suspendedBreakpointMessages.get(nodeId);
@@ -350,7 +386,7 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
             String toNode = definition.getId();
             String routeId = ProcessorDefinitionHelper.getRouteId(definition);
             String exchangeId = exchange.getExchangeId();
-            String messageAsXml = MessageHelper.dumpAsXml(exchange.getIn(), 
true, 2, false, false, 1000);
+            String messageAsXml = MessageHelper.dumpAsXml(exchange.getIn(), 
true, 2, isBodyIncludeStreams(), isBodyIncludeFiles(), getBodyMaxChars());
             long uid = debugCounter.incrementAndGet();
 
             BacklogTracerEventMessage msg = new 
DefaultBacklogTracerEventMessage(uid, timestamp, routeId, toNode, exchangeId, 
messageAsXml);
@@ -362,9 +398,12 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
             // now wait until we should continue
             logger.log("NodeBreakpoint at node " + toNode + " is waiting to 
continue for exchangeId: " + exchange.getExchangeId());
             try {
-                // TODO: have a fallback timeout so we wont wait forever
-                latch.await();
-                logger.log("NodeBreakpoint at node " + toNode + " is continued 
exchangeId: " + exchange.getExchangeId());
+                boolean hit = latch.await(fallbackTimeout, TimeUnit.SECONDS);
+                if (!hit) {
+                    logger.log("NodeBreakpoint at node " + toNode + " timed 
out and is continued exchangeId: " + exchange.getExchangeId(), 
LoggingLevel.WARN);
+                } else {
+                    logger.log("NodeBreakpoint at node " + toNode + " is 
continued exchangeId: " + exchange.getExchangeId());
+                }
             } catch (InterruptedException e) {
                 // ignore
             }
@@ -405,7 +444,7 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
             String toNode = definition.getId();
             String routeId = ProcessorDefinitionHelper.getRouteId(definition);
             String exchangeId = exchange.getExchangeId();
-            String messageAsXml = MessageHelper.dumpAsXml(exchange.getIn(), 
true, 2, false, false, 1000);
+            String messageAsXml = MessageHelper.dumpAsXml(exchange.getIn(), 
true, 2, isBodyIncludeStreams(), isBodyIncludeFiles(), getBodyMaxChars());
             long uid = debugCounter.incrementAndGet();
 
             BacklogTracerEventMessage msg = new 
DefaultBacklogTracerEventMessage(uid, timestamp, routeId, toNode, exchangeId, 
messageAsXml);
@@ -418,9 +457,12 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
             // now wait until we should continue
             logger.log("StepBreakpoint at node " + toNode + " is waiting to 
continue for exchangeId: " + exchange.getExchangeId());
             try {
-                // TODO: have a fallback timeout so we wont wait forever
-                latch.await();
-                logger.log("StepBreakpoint at node " + toNode + " is continued 
exchangeId: " + exchange.getExchangeId());
+                boolean hit = latch.await(fallbackTimeout, TimeUnit.SECONDS);
+                if (!hit) {
+                    logger.log("StepBreakpoint at node " + toNode + " timed 
out and is continued exchangeId: " + exchange.getExchangeId(), 
LoggingLevel.WARN);
+                } else {
+                    logger.log("StepBreakpoint at node " + toNode + " is 
continued exchangeId: " + exchange.getExchangeId());
+                }
             } catch (InterruptedException e) {
                 // ignore
             }

Reply via email to