Updated Branches: refs/heads/master 62e7e1ac5 -> 292544445
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/29254444 Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/29254444 Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/29254444 Branch: refs/heads/master Commit: 292544445819f26ebbe90afa8140e12a66dea214 Parents: 62e7e1a Author: Claus Ibsen <[email protected]> Authored: Wed May 22 14:47:36 2013 +0200 Committer: Claus Ibsen <[email protected]> Committed: Wed May 22 17:43:56 2013 +0200 ---------------------------------------------------------------------- .../mbean/ManagedBacklogDebuggerMBean.java | 22 ++- .../org/apache/camel/impl/DefaultCamelContext.java | 2 +- .../org/apache/camel/impl/DefaultDebugger.java | 38 +++- .../management/mbean/ManagedBacklogDebugger.java | 29 +++- .../camel/processor/CamelInternalProcessor.java | 2 +- .../processor/interceptor/BacklogDebugger.java | 172 +++++++++++++-- .../camel/management/BacklogDebuggerTest.java | 6 +- 7 files changed, 237 insertions(+), 34 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/camel/blob/29254444/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 fd98029..0d938d1 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 @@ -23,6 +23,12 @@ import org.apache.camel.api.management.ManagedOperation; public interface ManagedBacklogDebuggerMBean { + @ManagedAttribute(description = "Logging Level") + String getLoggingLevel(); + + @ManagedAttribute(description = "Logging Level") + void setLoggingLevel(String level); + @ManagedAttribute(description = "Is debugger enabled") boolean isEnabled(); @@ -38,8 +44,20 @@ public interface ManagedBacklogDebuggerMBean { @ManagedOperation(description = "Remote the breakpoint from the given node id") void removeBreakpoint(String nodeId); - @ManagedOperation(description = "Continue debugging the suspended breakpoints at the given node id") - void continueBreakpoint(String nodeId); + @ManagedOperation(description = "Resume running from the suspended breakpoint at the given node id") + void resumeBreakpoint(String nodeId); + + @ManagedOperation(description = "Resume running any suspended breakpoints, and exits step mode") + void resumeAll(); + + @ManagedOperation(description = "Starts single step debugging from the suspended breakpoint at the given node id") + void stepBreakpoint(String nodeId); + + @ManagedAttribute(description = "Whether currently in step mode") + boolean isSingleStepMode(); + + @ManagedOperation(description = "Steps to next node in step mode") + void step(); @ManagedOperation(description = "Return the node ids which has breakpoints") Set<String> getBreakpoints(boolean includeInternal); http://git-wip-us.apache.org/repos/asf/camel/blob/29254444/camel-core/src/main/java/org/apache/camel/impl/DefaultCamelContext.java ---------------------------------------------------------------------- diff --git a/camel-core/src/main/java/org/apache/camel/impl/DefaultCamelContext.java b/camel-core/src/main/java/org/apache/camel/impl/DefaultCamelContext.java index 359249d..4067efb 100644 --- a/camel-core/src/main/java/org/apache/camel/impl/DefaultCamelContext.java +++ b/camel-core/src/main/java/org/apache/camel/impl/DefaultCamelContext.java @@ -2427,7 +2427,7 @@ public class DefaultCamelContext extends ServiceSupport implements ModelCamelCon public InterceptStrategy getDefaultBacklogDebugger() { if (defaultBacklogDebugger == null) { - defaultBacklogDebugger = new BacklogDebugger(); + defaultBacklogDebugger = new BacklogDebugger(this); } return defaultBacklogDebugger; } http://git-wip-us.apache.org/repos/asf/camel/blob/29254444/camel-core/src/main/java/org/apache/camel/impl/DefaultDebugger.java ---------------------------------------------------------------------- diff --git a/camel-core/src/main/java/org/apache/camel/impl/DefaultDebugger.java b/camel-core/src/main/java/org/apache/camel/impl/DefaultDebugger.java index d6f155e..59f1b26 100644 --- a/camel-core/src/main/java/org/apache/camel/impl/DefaultDebugger.java +++ b/camel-core/src/main/java/org/apache/camel/impl/DefaultDebugger.java @@ -39,8 +39,10 @@ import org.apache.camel.processor.interceptor.Tracer; import org.apache.camel.spi.Breakpoint; import org.apache.camel.spi.Condition; import org.apache.camel.spi.Debugger; +import org.apache.camel.spi.EventNotifier; import org.apache.camel.support.EventNotifierSupport; import org.apache.camel.util.ObjectHelper; +import org.apache.camel.util.ServiceHelper; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -52,10 +54,12 @@ import org.slf4j.LoggerFactory; public class DefaultDebugger implements Debugger, CamelContextAware { private static final Logger LOG = LoggerFactory.getLogger(DefaultDebugger.class); + private final EventNotifier debugEventNotifier = new DebugEventNotifier(); private final List<BreakpointConditions> breakpoints = new CopyOnWriteArrayList<BreakpointConditions>(); private final int maxConcurrentSingleSteps = 1; private final Map<String, Breakpoint> singleSteps = new HashMap<String, Breakpoint>(maxConcurrentSingleSteps); private CamelContext camelContext; + private boolean useTracer = true; /** * Holder class for breakpoint and the associated conditions @@ -97,6 +101,14 @@ public class DefaultDebugger implements Debugger, CamelContextAware { this.camelContext = camelContext; } + public boolean isUseTracer() { + return useTracer; + } + + public void setUseTracer(boolean useTracer) { + this.useTracer = useTracer; + } + public void addBreakpoint(Breakpoint breakpoint) { breakpoints.add(new BreakpointConditions(breakpoint)); } @@ -325,23 +337,29 @@ public class DefaultDebugger implements Debugger, CamelContextAware { public void start() throws Exception { ObjectHelper.notNull(camelContext, "CamelContext", this); + // register our event notifier - camelContext.getManagementStrategy().addEventNotifier(new DebugEventNotifier()); - Tracer tracer = Tracer.getTracer(camelContext); - if (tracer == null) { - // tracer is disabled so enable it silently so we can leverage it to trace the Exchanges for us - tracer = Tracer.createTracer(camelContext); - tracer.setLogLevel(LoggingLevel.OFF); - camelContext.addService(tracer); - camelContext.addInterceptStrategy(tracer); + ServiceHelper.startService(debugEventNotifier); + camelContext.getManagementStrategy().addEventNotifier(debugEventNotifier); + + if (isUseTracer()) { + Tracer tracer = Tracer.getTracer(camelContext); + if (tracer == null) { + // tracer is disabled so enable it silently so we can leverage it to trace the Exchanges for us + tracer = Tracer.createTracer(camelContext); + tracer.setLogLevel(LoggingLevel.OFF); + camelContext.addService(tracer); + camelContext.addInterceptStrategy(tracer); + } + // make sure tracer is enabled so the debugger can leverage the tracer for debugging purposes + tracer.setEnabled(true); } - // make sure tracer is enabled so the debugger can leverage the tracer for debugging purposes - tracer.setEnabled(true); } public void stop() throws Exception { breakpoints.clear(); singleSteps.clear(); + ServiceHelper.stopServices(debugEventNotifier); } @Override http://git-wip-us.apache.org/repos/asf/camel/blob/29254444/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 13387a9..3b6282d 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; @@ -48,6 +47,14 @@ public class ManagedBacklogDebugger implements ManagedBacklogDebuggerMBean { return backlogDebugger; } + public String getLoggingLevel() { + return backlogDebugger.getLoggingLevel(); + } + + public void setLoggingLevel(String level) { + backlogDebugger.setLoggingLevel(level); + } + public boolean isEnabled() { return backlogDebugger.isEnabled(); } @@ -72,8 +79,24 @@ public class ManagedBacklogDebugger implements ManagedBacklogDebuggerMBean { return backlogDebugger.getBreakpoints(includeInternal); } - public void continueBreakpoint(String nodeId) { - backlogDebugger.continueBreakpoint(nodeId); + public void resumeBreakpoint(String nodeId) { + backlogDebugger.resumeBreakpoint(nodeId); + } + + public void resumeAll() { + backlogDebugger.resumeAll(); + } + + public void stepBreakpoint(String nodeId) { + backlogDebugger.stepBreakpoint(nodeId); + } + + public boolean isSingleStepMode() { + return backlogDebugger.isSingleStepMode(); + } + + public void step() { + backlogDebugger.step(); } public Set<String> getSuspendedBreakpointNodeIds() { http://git-wip-us.apache.org/repos/asf/camel/blob/29254444/camel-core/src/main/java/org/apache/camel/processor/CamelInternalProcessor.java ---------------------------------------------------------------------- diff --git a/camel-core/src/main/java/org/apache/camel/processor/CamelInternalProcessor.java b/camel-core/src/main/java/org/apache/camel/processor/CamelInternalProcessor.java index 475dad0..a3052df 100644 --- a/camel-core/src/main/java/org/apache/camel/processor/CamelInternalProcessor.java +++ b/camel-core/src/main/java/org/apache/camel/processor/CamelInternalProcessor.java @@ -449,7 +449,7 @@ public final class CamelInternalProcessor extends DelegateAsyncProcessor { @Override public StopWatch before(Exchange exchange) throws Exception { - if (backlogDebugger.isEnabled() && backlogDebugger.hasBreakpoint(nodeId)) { + if (backlogDebugger.isEnabled() && (backlogDebugger.hasBreakpoint(nodeId) || backlogDebugger.isSingleStepMode())) { StopWatch watch = new StopWatch(); backlogDebugger.beforeProcess(exchange, target, definition); return watch; http://git-wip-us.apache.org/repos/asf/camel/blob/29254444/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 efac7b1..7966a63 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 @@ -29,16 +29,19 @@ import java.util.concurrent.atomic.AtomicLong; import org.apache.camel.CamelContext; import org.apache.camel.Exchange; +import org.apache.camel.LoggingLevel; import org.apache.camel.Processor; import org.apache.camel.api.management.mbean.BacklogTracerEventMessage; import org.apache.camel.impl.BreakpointSupport; import org.apache.camel.impl.DefaultDebugger; +import org.apache.camel.management.event.ExchangeCompletedEvent; import org.apache.camel.model.ProcessorDefinition; import org.apache.camel.model.ProcessorDefinitionHelper; import org.apache.camel.spi.Condition; import org.apache.camel.spi.Debugger; import org.apache.camel.spi.InterceptStrategy; import org.apache.camel.support.ServiceSupport; +import org.apache.camel.util.CamelLogger; import org.apache.camel.util.MessageHelper; import org.apache.camel.util.ObjectHelper; import org.apache.camel.util.ServiceHelper; @@ -53,15 +56,22 @@ public class BacklogDebugger extends ServiceSupport implements InterceptStrategy private static final Logger LOG = LoggerFactory.getLogger(BacklogDebugger.class); + private final CamelContext camelContext; + private LoggingLevel loggingLevel = LoggingLevel.INFO; + private final CamelLogger logger = new CamelLogger(LOG, loggingLevel); private final AtomicBoolean enabled = new AtomicBoolean(); private final AtomicLong debugCounter = new AtomicLong(0); private final Debugger debugger; private final Map<String, NodeBreakpoint> breakpoints = new HashMap<String, NodeBreakpoint>(); private final Map<String, CountDownLatch> suspendedBreakpoints = new HashMap<String, CountDownLatch>(); private final Map<String, BacklogTracerEventMessage> suspendedBreakpointMessages = new HashMap<String, BacklogTracerEventMessage>(); + private volatile String singleStepExchangeId; - public BacklogDebugger() { - this.debugger = new DefaultDebugger(); + public BacklogDebugger(CamelContext camelContext) { + this.camelContext = camelContext; + DefaultDebugger debugger = new DefaultDebugger(camelContext); + debugger.setUseTracer(false); + this.debugger = debugger; } @Override @@ -89,10 +99,19 @@ public class BacklogDebugger extends ServiceSupport implements InterceptStrategy return debugger; } + public String getLoggingLevel() { + return loggingLevel.name(); + } + + public void setLoggingLevel(String level) { + loggingLevel = LoggingLevel.valueOf(level); + logger.setLevel(loggingLevel); + } + public void enableDebugger() { + logger.log("Enabling debugger"); try { - // TODO: should not start debugger as its old-schoold tracer depedent - //debugger.start(); + ServiceHelper.startService(debugger); enabled.set(true); } catch (Exception e) { throw ObjectHelper.wrapRuntimeCamelException(e); @@ -100,11 +119,12 @@ public class BacklogDebugger extends ServiceSupport implements InterceptStrategy } public void disableDebugger() { + logger.log("Disabling debugger"); try { enabled.set(false); - debugger.stop(); + ServiceHelper.stopService(debugger); } catch (Exception e) { - throw ObjectHelper.wrapRuntimeCamelException(e); + // ignore } // make sure to clear state and latches is counted down so we wont have hanging threads @@ -124,7 +144,16 @@ public class BacklogDebugger extends ServiceSupport implements InterceptStrategy return breakpoints.containsKey(nodeId); } + public boolean isSingleStepMode() { + return singleStepExchangeId != null; + } + public void addBreakpoint(String nodeId, boolean internal) { + if (internal) { + logger.log("Adding internal breakpoint " + nodeId); + } else { + logger.log("Adding breakpoint " + nodeId); + } if (!breakpoints.containsKey(nodeId)) { NodeBreakpoint breakpoint = new NodeBreakpoint(nodeId, internal); breakpoints.put(nodeId, breakpoint); @@ -133,6 +162,7 @@ public class BacklogDebugger extends ServiceSupport implements InterceptStrategy } public void removeBreakpoint(String nodeId) { + logger.log("Removing breakpoint " + nodeId); // when removing a break point then ensure latches is cleared and counted down so we wont have hanging threads suspendedBreakpointMessages.remove(nodeId); CountDownLatch latch = suspendedBreakpoints.remove(nodeId); @@ -155,7 +185,20 @@ public class BacklogDebugger extends ServiceSupport implements InterceptStrategy return answer; } - public void continueBreakpoint(String nodeId) { + public void resumeBreakpoint(String nodeId) { + resumeBreakpoint(nodeId, false); + } + + private void resumeBreakpoint(String nodeId, boolean stepMode) { + logger.log("Resume breakpoint " + nodeId); + + if (!stepMode) { + if (singleStepExchangeId != null) { + debugger.stopSingleStepExchange(singleStepExchangeId); + singleStepExchangeId = null; + } + } + // remember to remove the dumped message as its no longer in need suspendedBreakpointMessages.remove(nodeId); CountDownLatch latch = suspendedBreakpoints.remove(nodeId); @@ -164,11 +207,52 @@ public class BacklogDebugger extends ServiceSupport implements InterceptStrategy } } + public void resumeAll() { + logger.log("Resume all"); + // stop single stepping + singleStepExchangeId = null; + + for (String node : getSuspendedBreakpointNodeIds()) { + // remember to remove the dumped message as its no longer in need + suspendedBreakpointMessages.remove(node); + CountDownLatch latch = suspendedBreakpoints.remove(node); + if (latch != null) { + latch.countDown(); + } + } + } + + public void stepBreakpoint(String nodeId) { + logger.log("Step breakpoint " + nodeId); + // we want to step current exchange to next + BacklogTracerEventMessage msg = suspendedBreakpointMessages.get(nodeId); + NodeBreakpoint breakpoint = breakpoints.get(nodeId); + if (msg != null && breakpoint != null) { + singleStepExchangeId = msg.getExchangeId(); + if (debugger.startSingleStepExchange(singleStepExchangeId, new StepBreakpoint())) { + // now resume + resumeBreakpoint(nodeId, true); + } + } + } + + public void step() { + for (String node : getSuspendedBreakpointNodeIds()) { + // remember to remove the dumped message as its no longer in need + suspendedBreakpointMessages.remove(node); + CountDownLatch latch = suspendedBreakpoints.remove(node); + if (latch != null) { + latch.countDown(); + } + } + } + public Set<String> getSuspendedBreakpointNodeIds() { return new LinkedHashSet<String>(suspendedBreakpoints.keySet()); } public void suspendBreakpoint(String nodeId) { + logger.log("Suspend breakpoint " + nodeId); NodeBreakpoint breakpoint = breakpoints.get(nodeId); if (breakpoint != null) { breakpoint.suspend(); @@ -176,6 +260,7 @@ public class BacklogDebugger extends ServiceSupport implements InterceptStrategy } public void activateBreakpoint(String nodeId) { + logger.log("Activate breakpoint " + nodeId); NodeBreakpoint breakpoint = breakpoints.get(nodeId); if (breakpoint != null) { breakpoint.activate(); @@ -183,6 +268,7 @@ public class BacklogDebugger extends ServiceSupport implements InterceptStrategy } public String dumpTracedMessagesAsXml(String nodeId) { + logger.log("Dump trace message from breakpoint " + nodeId); BacklogTracerEventMessage msg = suspendedBreakpointMessages.get(nodeId); if (msg != null) { return msg.toXml(4); @@ -196,6 +282,7 @@ public class BacklogDebugger extends ServiceSupport implements InterceptStrategy } public void resetDebugCounter() { + logger.log("Reset debug counter"); debugCounter.set(0); } @@ -208,12 +295,11 @@ public class BacklogDebugger extends ServiceSupport implements InterceptStrategy } protected void doStart() throws Exception { - ServiceHelper.startService(debugger); + // noop } protected void doStop() throws Exception { disableDebugger(); - ServiceHelper.stopServices(debugger); } /** @@ -241,7 +327,7 @@ public class BacklogDebugger extends ServiceSupport implements InterceptStrategy public void beforeProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition) { // store a copy of the message so we can see that from the debugger Date timestamp = new Date(); - String toNode = nodeId; + String toNode = definition.getId(); String routeId = ProcessorDefinitionHelper.getRouteId(definition); String exchangeId = exchange.getExchangeId(); String messageAsXml = MessageHelper.dumpAsXml(exchange.getIn(), true, 4, false, false, 1000); @@ -255,13 +341,11 @@ public class BacklogDebugger extends ServiceSupport implements InterceptStrategy suspendedBreakpoints.put(nodeId, latch); // now wait until we should continue - // TODO: have a fallback timeout so we wont wait forever - if (LOG.isInfoEnabled()) { - LOG.info("Breakpoint at node {} is waiting to continue for exchangeId: {}", nodeId, exchange.getExchangeId()); - } + 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(); - LOG.info("Breakpoint at node {} is continued for exchangeId: {}", nodeId, exchange.getExchangeId()); + logger.log("NodeBreakpoint at node " + toNode + " is continued exchangeId: " + exchange.getExchangeId()); } catch (InterruptedException e) { // ignore } @@ -278,4 +362,62 @@ public class BacklogDebugger extends ServiceSupport implements InterceptStrategy return false; } } + + /** + * Represents a {@link org.apache.camel.spi.Breakpoint} that is used during single step mode. + */ + private final class StepBreakpoint extends BreakpointSupport implements Condition { + + @Override + public void beforeProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition) { + // store a copy of the message so we can see that from the debugger + Date timestamp = new Date(); + String toNode = definition.getId(); + String routeId = ProcessorDefinitionHelper.getRouteId(definition); + String exchangeId = exchange.getExchangeId(); + String messageAsXml = MessageHelper.dumpAsXml(exchange.getIn(), true, 4, false, false, 1000); + long uid = debugCounter.incrementAndGet(); + + BacklogTracerEventMessage msg = new DefaultBacklogTracerEventMessage(uid, timestamp, routeId, toNode, exchangeId, messageAsXml); + suspendedBreakpointMessages.put(toNode, msg); + + // mark as suspend + final CountDownLatch latch = new CountDownLatch(1); + suspendedBreakpoints.put(toNode, latch); + + // 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()); + } catch (InterruptedException e) { + // ignore + } + super.beforeProcess(exchange, processor, definition); + } + + @Override + public boolean matchProcess(Exchange exchange, Processor processor, ProcessorDefinition<?> definition) { + return true; + } + + @Override + public boolean matchEvent(Exchange exchange, EventObject event) { + return event instanceof ExchangeCompletedEvent; + } + + @Override + public void onEvent(Exchange exchange, EventObject event, ProcessorDefinition<?> definition) { + // when the exchange is complete, we need to turn off single step mode if we were debug stepping the exchange + if (event instanceof ExchangeCompletedEvent) { + String completedId = ((ExchangeCompletedEvent) event).getExchange().getExchangeId(); + + if (singleStepExchangeId != null && singleStepExchangeId.equals(completedId)) { + logger.log("ExchangeId: " + completedId + " is completed, so exiting single step mode."); + singleStepExchangeId = null; + } + } + } + } } http://git-wip-us.apache.org/repos/asf/camel/blob/29254444/camel-core/src/test/java/org/apache/camel/management/BacklogDebuggerTest.java ---------------------------------------------------------------------- diff --git a/camel-core/src/test/java/org/apache/camel/management/BacklogDebuggerTest.java b/camel-core/src/test/java/org/apache/camel/management/BacklogDebuggerTest.java index 64969cd..f154572 100644 --- a/camel-core/src/test/java/org/apache/camel/management/BacklogDebuggerTest.java +++ b/camel-core/src/test/java/org/apache/camel/management/BacklogDebuggerTest.java @@ -43,11 +43,13 @@ public class BacklogDebuggerTest extends ManagementTestSupport { public void configure() throws Exception { context.setUseBreadcrumb(false); - from("timer:foo?period=10s").setBody().constant("Hello World").to("seda:start"); + // from("timer:foo?period=10s").setBody().constant("Hello World").to("seda:start"); from("seda:start") .to("log:foo").id("foo") - .to("log:bar").id("bar"); + .to("log:bar").id("bar") + .transform().constant("Bye World").id("transform") + .to("log:cheese").id("cheese"); } }; }
