ID-claus-acer/4412-1222625653890/2-0 -> to(mock:a)                , Pattern:InOnly , Headers:{to=James} , BodyType:String , Body:Hello London

>>> direct:start --> process(MyProcessor)
>>> process(MyProcessor) --> to(mock:a)
>>> to(mock:a) --> to(mock:b)

java org.apache.camel.spring.Main -t

java org.apache.camel.spring.Main -trace

context.setTracing(true);

INFO  TraceInterceptor     - ID-davsclaus-local-54403-1246038742624-0-0 >>> from(direct:start) --> MyProcessor     , Pattern:InOnly, Headers:{to=James}, BodyType:String, Body:Hello London
INFO  TraceInterceptor     - ID-davsclaus-local-54403-1246038742624-0-0 >>> MyProcessor --> mock:a                 , Pattern:InOnly, Headers:{to=James}, BodyType:String, Body:Hello London
INFO  TraceInterceptor     - ID-davsclaus-local-54403-1246038742624-0-0 >>> mock:a --> mock:b                      , Pattern:InOnly, Headers:{to=James}, BodyType:String, Body:Hello London
...
INFO  TraceInterceptor     - ID-davsclaus-local-54403-1246038742624-0-1 >>> from(direct:start) --> MyProcessor     , Pattern:InOnly, Headers:{from=Claus}, BodyType:String, Body:This is Copenhagen calling
INFO  TraceInterceptor     - ID-davsclaus-local-54403-1246038742624-0-1 >>> MyProcessor --> mock:a                 , Pattern:InOnly, Headers:{from=Claus}, BodyType:String, Body:This is Copenhagen calling
INFO  TraceInterceptor     - ID-davsclaus-local-54403-1246038742624-0-1 >>> mock:a --> mock:b                      , Pattern:InOnly, Headers:{from=Claus}, BodyType:String, Body:This is Copenhagen calling

    public void configure() throws Exception {
        // add tracer as an interceptor so it will log the exchange executions at runtime
        // this can aid us to understand/see how the exchanges is routed etc.
        Tracer tracer = new Tracer();
        formatter.getDefaultTraceFormatter().setShowBreadCrumb(false);
        formatter.getDefaultTraceFormatter().setShowNode(false);
        ...
        getContext().addInterceptStrategy(tracer);

    Tracer tracer = new Tracer();
    // set the level to FATAL so we can easily spot it
    tracer.setLogLevel(LoggingLevel.FATAL);
    // and only trace if the body contains London as text
    tracer.setTraceFilter(body().contains(constant("London")));

  <camelContext trace="true" xmlns="http://activemq.apache.org/camel/schema/spring">
    ...
  </camelContext>

<!-- we can configure the tracer by defining the tracer bean and set the properties as we like -->
<!-- the id name can be anything its the class that must be org.apache.camel.processor.interceptor.Tracer -->
<bean id="camelTracer" class="org.apache.camel.processor.interceptor.Tracer">
    <property name="traceExceptions" value="false"/>
    <property name="traceInterceptors" value="true"/>
    <property name="logLevel" value="ERROR"/>
    <property name="logName" value="com.mycompany.messages"/>
</bean>

<camelContext trace="true" xmlns="http://camel.apache.org/schema/spring">
    <route>
        <from uri="direct:start"/>
        <to uri="mock:result"/>
    </route>
</camelContext>

<bean id="traceFormatter" class="org.apache.camel.processor.interceptor.DefaultTraceFormatter">
    <property name="showBody" value="true"/>
    <property name="showBodyType" value="false"/>
    <property name="showBreadCrumb" value="false"/>
    <property name="maxChars" value="100"/>
</bean>

<camelContext trace="true" xmlns="http://camel.apache.org/schema/spring">
    <route>
        <from uri="direct:start"/>
        <to uri="mock:result"/>
    </route>
</camelContext>

Tracer tracer = new Tracer();
tracer.setTraceOutExchanges(true);

// we configure the default trace formatter where we can
// specify which fields we want in the output
DefaultTraceFormatter formatter = new DefaultTraceFormatter();
formatter.setShowOutBody(true);
formatter.setShowOutBodyType(true);

// set to use our formatter
tracer.setFormatter(formatter);

getContext().addInterceptStrategy(tracer);

<bean id="camelTracer" class="org.apache.camel.processor.interceptor.Tracer">
  <property name="traceOutExchanges" value="true" />
</bean>

<bean id="traceFormatter" class="org.apache.camel.processor.interceptor.DefaultTraceFormatter">
  <property name="showOutBody" value="true" />
  <property name="showOutBodyType" value="true" />
</bean>

INFO  TraceInterceptor - ID-mojo/59899-1225474989226/2-0 -> transform(body) , Pattern:InOnly , Headers:{to=James} , BodyType:String , Body:Hello London
INFO  TraceInterceptor - transform(body) -> ID-mojo/59899-1225474989226/2-0 , Pattern:InOnly , Headers:{to=James} , BodyType:String , Body:Hello London , OutBodyType:String , OutBody:Hello London

// we create a tracer where we want to use our own formatter instead of the default one
Tracer tracer = new Tracer();

// use our own formatter instead of the default one
MyTraceFormatter formatter = new MyTraceFormatter();
tracer.setFormatter(formatter);

// and we must remeber to add the tracer to Camel
getContext().addInterceptStrategy(tracer);

// here we have out own formatter where we can create the output we want for trace logs
// as this is a test we just create a simple string with * around the body
class MyTraceFormatter implements TraceFormatter {

    public Object format(TraceInterceptor interceptor, ProcessorDefinition<?> node, Exchange exchange) {
        return "***" + exchange.getIn().getBody(String.class) + "***";
    }
}

// we create a tracer where we want to send TraveEvents to an endpoint
// "direct:traced" where we can do some custom processing such as storing
// it in a file or a database
Tracer tracer = new Tracer();
tracer.setDestinationUri("direct:traced");
// we disable regular trace logging in the log file. You can omit this and
// have both.
tracer.setLogLevel(LoggingLevel.OFF);
// and we must remember to add the tracer to Camel
getContext().addInterceptStrategy(tracer);

   from("direct:traced").process(new MyTraceMessageProcessor()).to("file://myapp/logs/trace);

class MyTraceMessageProcessor implements Processor {

    public void process(Exchange exchange) throws Exception {
        // here we can transform the message how we like want it
        TraceEventMessage msg = exchange.getIn().getBody(DefaultTraceEventMessage.class);

        // we want to store it as a CSV with from;to;exchangeId;body
        String s = msg.getFromEndpointUri() + ";" + msg.getToNode() + ";" + msg.getExchangeId() + ";" + msg.getBody();

        // so we replace the IN body with our CSV string
        exchange.getIn().setBody(s);
    }
}

protected RouteBuilder createRouteBuilder() throws Exception {
    return new RouteBuilder() {
        public void configure() throws Exception {
            errorHandler(deadLetterChannel("mock:error").redeliveryDelay(0).maximumRedeliveries(3));

            // must enable tracer to trace the route path taken during runtime
            context.setTracing(true);

            // let our my error processor handle all exceptions
            onException(Exception.class).handled(true).process(new MyErrorProcessor());

            // our route where an exception can be thrown from either foo or bar bean
            // so we have enable tracing so we can check it at runtime to get the actual
            // node path taken
            from("direct:start").to("bean:foo").to("bean:bar");
        }
    };
}

private static class MyErrorProcessor implements Processor {
    public void process(Exchange exchange) throws Exception {
        TracedRouteNodes traced = exchange.getUnitOfWork().getTracedRouteNodes();

        // get the list of intercepted nodes
        List<RouteNode> list = traced.getNodes();
        // get the 3rd last as its the bean
        Processor last = list.get(list.size() - 3).getProcessor();

        // wrapped by JMX
        if (last instanceof InstrumentationProcessor) {
            InstrumentationProcessor ip = (InstrumentationProcessor) last;
            last = ip.getProcessor();
        }

        // set error message
        exchange.getOut().setFault(true);
        exchange.getOut().setBody("Failed at: " + last.toString());
    }

    public String toString() {
        return "MyErrorProcessor";
    }
}