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 2021/04/05 08:57:03 UTC

[camel] branch master updated (25ec795 -> 0649f57)

This is an automated email from the ASF dual-hosted git repository.

davsclaus pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git.


    from 25ec795  upgrade to frontend-maven-plugin 1.11.3
     new 8db83a9  CAMEL-16450: camel-core - Optimize WireTap only use dynamic send processor when being dynamic.
     new 13798aa  CAMEL-16450: camel-core - Optimize WireTap to support pooled tasks for reduced object allocations.
     new 8d8db66  CAMEL-16450: camel-core - Optimize WireTap to support pooled tasks for reduced object allocations.
     new 0649f57  Reduce logging noise

The 4 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:
 .../org/apache/camel/processor/SendProcessor.java  |   2 +-
 .../apache/camel/processor/WireTapProcessor.java   | 108 +++++++++++++++------
 .../java/org/apache/camel/reifier/SendReifier.java |   2 +-
 .../org/apache/camel/reifier/WireTapReifier.java   |  35 +++++--
 .../apache/camel/main/EagerClassloadedHelper.java  |   2 +-
 5 files changed, 112 insertions(+), 37 deletions(-)

[camel] 03/04: CAMEL-16450: camel-core - Optimize WireTap to support pooled tasks for reduced object allocations.

Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git

commit 8d8db66ed5fe662a6428e8f1af91363c71f73be2
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Mon Apr 5 10:55:15 2021 +0200

    CAMEL-16450: camel-core - Optimize WireTap to support pooled tasks for reduced object allocations.
---
 .../src/main/java/org/apache/camel/processor/WireTapProcessor.java | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/core/camel-core-processor/src/main/java/org/apache/camel/processor/WireTapProcessor.java b/core/camel-core-processor/src/main/java/org/apache/camel/processor/WireTapProcessor.java
index 98017f6..b6c7822 100644
--- a/core/camel-core-processor/src/main/java/org/apache/camel/processor/WireTapProcessor.java
+++ b/core/camel-core-processor/src/main/java/org/apache/camel/processor/WireTapProcessor.java
@@ -47,7 +47,6 @@ import org.apache.camel.support.DefaultExchange;
 import org.apache.camel.support.ExchangeHelper;
 import org.apache.camel.support.service.ServiceHelper;
 import org.apache.camel.util.ObjectHelper;
-import org.apache.camel.util.URISupport;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -100,12 +99,6 @@ public class WireTapProcessor extends AsyncProcessorSupport
         private final AsyncCallback callback = new AsyncCallback() {
             @Override
             public void done(boolean doneSync) {
-                if (exchange.getException() != null) {
-                    String u = URISupport.sanitizeUri(uri);
-                    LOG.warn("Error occurred during processing " + exchange + " wiretap to " + u
-                             + ". This exception will be ignored.",
-                            exchange.getException());
-                }
                 taskCount.decrement();
                 taskFactory.release(WireTapTask.this);
             }

[camel] 04/04: Reduce logging noise

Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git

commit 0649f573041a5be92d48ac145077ea168e45cc0a
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Mon Apr 5 10:56:03 2021 +0200

    Reduce logging noise
---
 .../src/main/java/org/apache/camel/main/EagerClassloadedHelper.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/camel-main/src/main/java/org/apache/camel/main/EagerClassloadedHelper.java b/core/camel-main/src/main/java/org/apache/camel/main/EagerClassloadedHelper.java
index db65aec..a67e340 100644
--- a/core/camel-main/src/main/java/org/apache/camel/main/EagerClassloadedHelper.java
+++ b/core/camel-main/src/main/java/org/apache/camel/main/EagerClassloadedHelper.java
@@ -52,6 +52,6 @@ public final class EagerClassloadedHelper {
         // EAGER-CLASSLOADED: END
 
         String time = TimeUtils.printDuration(watch.taken());
-        LOG.info("Eager loaded {} classes in {}", count, time);
+        LOG.debug("Eager loaded {} classes in {}", count, time);
     }
 }

[camel] 02/04: CAMEL-16450: camel-core - Optimize WireTap to support pooled tasks for reduced object allocations.

Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git

commit 13798aa92b575a2b968ea776974bef1d4bdd76a6
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Mon Apr 5 10:15:58 2021 +0200

    CAMEL-16450: camel-core - Optimize WireTap to support pooled tasks for reduced object allocations.
---
 .../apache/camel/processor/WireTapProcessor.java   | 86 +++++++++++++++++-----
 1 file changed, 66 insertions(+), 20 deletions(-)

diff --git a/core/camel-core-processor/src/main/java/org/apache/camel/processor/WireTapProcessor.java b/core/camel-core-processor/src/main/java/org/apache/camel/processor/WireTapProcessor.java
index e72526d..98017f6 100644
--- a/core/camel-core-processor/src/main/java/org/apache/camel/processor/WireTapProcessor.java
+++ b/core/camel-core-processor/src/main/java/org/apache/camel/processor/WireTapProcessor.java
@@ -30,6 +30,7 @@ import org.apache.camel.Exchange;
 import org.apache.camel.ExchangePattern;
 import org.apache.camel.ExchangePropertyKey;
 import org.apache.camel.Expression;
+import org.apache.camel.ExtendedCamelContext;
 import org.apache.camel.Message;
 import org.apache.camel.Processor;
 import org.apache.camel.RuntimeCamelException;
@@ -70,6 +71,7 @@ public class WireTapProcessor extends AsyncProcessorSupport
     private final ExecutorService executorService;
     private volatile boolean shutdownExecutorService;
     private final LongAdder taskCount = new LongAdder();
+    private PooledExchangeTaskFactory taskFactory;
 
     // expression or processor used for populating a new exchange to send
     // as opposed to traditional wiretap that sends a copy of the original exchange
@@ -92,6 +94,42 @@ public class WireTapProcessor extends AsyncProcessorSupport
         this.dynamicUri = dynamicUri;
     }
 
+    private final class WireTapTask implements PooledExchangeTask, Runnable {
+
+        private Exchange exchange;
+        private final AsyncCallback callback = new AsyncCallback() {
+            @Override
+            public void done(boolean doneSync) {
+                if (exchange.getException() != null) {
+                    String u = URISupport.sanitizeUri(uri);
+                    LOG.warn("Error occurred during processing " + exchange + " wiretap to " + u
+                             + ". This exception will be ignored.",
+                            exchange.getException());
+                }
+                taskCount.decrement();
+                taskFactory.release(WireTapTask.this);
+            }
+        };
+
+        @Override
+        public void prepare(Exchange exchange, AsyncCallback callback) {
+            this.exchange = exchange;
+            // we use our own callback
+        }
+
+        @Override
+        public void reset() {
+            this.exchange = null;
+        }
+
+        @Override
+        public void run() {
+            taskCount.increment();
+            LOG.debug(">>>> (wiretap) {} {}", uri, exchange);
+            asyncProcessor.process(exchange, callback);
+        }
+    }
+
     @Override
     public String toString() {
         return id;
@@ -172,23 +210,11 @@ public class WireTapProcessor extends AsyncProcessorSupport
             return true;
         }
 
-        final Exchange wireTapExchange = target;
-
         // send the exchange to the destination using an executor service
         try {
-            executorService.submit(() -> {
-                taskCount.increment();
-                LOG.debug(">>>> (wiretap) {} {}", uri, wireTapExchange);
-                asyncProcessor.process(wireTapExchange, doneSync -> {
-                    if (wireTapExchange.getException() != null) {
-                        String u = URISupport.sanitizeUri(uri);
-                        LOG.warn("Error occurred during processing " + wireTapExchange + " wiretap to " + u
-                                 + ". This exception will be ignored.",
-                                wireTapExchange.getException());
-                    }
-                    taskCount.decrement();
-                });
-            });
+            // create task which has state used during routing
+            PooledExchangeTask task = taskFactory.acquire(target, null);
+            executorService.submit(task);
         } catch (Throwable e) {
             // in case the thread pool rejects or cannot submit the task then we need to catch
             // so camel error handler can react
@@ -331,27 +357,47 @@ public class WireTapProcessor extends AsyncProcessorSupport
 
     @Override
     protected void doBuild() throws Exception {
-        ServiceHelper.buildService(processor);
+        boolean pooled = camelContext.adapt(ExtendedCamelContext.class).getExchangeFactory().isPooled();
+        if (pooled) {
+            taskFactory = new PooledTaskFactory(getId()) {
+                @Override
+                public PooledExchangeTask create(Exchange exchange, AsyncCallback callback) {
+                    return new WireTapTask();
+                }
+            };
+            int capacity = camelContext.adapt(ExtendedCamelContext.class).getExchangeFactory().getCapacity();
+            taskFactory.setCapacity(capacity);
+        } else {
+            taskFactory = new PrototypeTaskFactory() {
+                @Override
+                public PooledExchangeTask create(Exchange exchange, AsyncCallback callback) {
+                    return new WireTapTask();
+                }
+            };
+        }
+        LOG.trace("Using TaskFactory: {}", taskFactory);
+
+        ServiceHelper.buildService(taskFactory, processor);
     }
 
     @Override
     protected void doInit() throws Exception {
-        ServiceHelper.initService(processor);
+        ServiceHelper.initService(taskFactory, processor);
     }
 
     @Override
     protected void doStart() throws Exception {
-        ServiceHelper.startService(processor);
+        ServiceHelper.startService(taskFactory, processor);
     }
 
     @Override
     protected void doStop() throws Exception {
-        ServiceHelper.stopService(processor);
+        ServiceHelper.stopService(taskFactory, processor);
     }
 
     @Override
     protected void doShutdown() throws Exception {
-        ServiceHelper.stopAndShutdownService(processor);
+        ServiceHelper.stopAndShutdownServices(taskFactory, processor);
         if (shutdownExecutorService) {
             getCamelContext().getExecutorServiceManager().shutdownNow(executorService);
         }

[camel] 01/04: CAMEL-16450: camel-core - Optimize WireTap only use dynamic send processor when being dynamic.

Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git

commit 8db83a9b2250a817df69fb7c43adf19f4c2cea77
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Mon Apr 5 09:38:46 2021 +0200

    CAMEL-16450: camel-core - Optimize WireTap only use dynamic send processor when being dynamic.
---
 .../org/apache/camel/processor/SendProcessor.java  |  2 +-
 .../apache/camel/processor/WireTapProcessor.java   | 27 ++++++++++++-----
 .../java/org/apache/camel/reifier/SendReifier.java |  2 +-
 .../org/apache/camel/reifier/WireTapReifier.java   | 35 ++++++++++++++++++----
 4 files changed, 51 insertions(+), 15 deletions(-)

diff --git a/core/camel-core-processor/src/main/java/org/apache/camel/processor/SendProcessor.java b/core/camel-core-processor/src/main/java/org/apache/camel/processor/SendProcessor.java
index e76b002..f156ddd 100644
--- a/core/camel-core-processor/src/main/java/org/apache/camel/processor/SendProcessor.java
+++ b/core/camel-core-processor/src/main/java/org/apache/camel/processor/SendProcessor.java
@@ -70,10 +70,10 @@ public class SendProcessor extends AsyncProcessorSupport implements Traceable, E
         ObjectHelper.notNull(destination, "destination");
         this.destination = destination;
         this.camelContext = (ExtendedCamelContext) destination.getCamelContext();
+        ObjectHelper.notNull(this.camelContext, "camelContext");
         this.pattern = pattern;
         this.destinationExchangePattern = null;
         this.destinationExchangePattern = EndpointHelper.resolveExchangePatternFromUrl(destination.getEndpointUri());
-        ObjectHelper.notNull(this.camelContext, "camelContext");
     }
 
     @Override
diff --git a/core/camel-core-processor/src/main/java/org/apache/camel/processor/WireTapProcessor.java b/core/camel-core-processor/src/main/java/org/apache/camel/processor/WireTapProcessor.java
index 00111ba..e72526d 100644
--- a/core/camel-core-processor/src/main/java/org/apache/camel/processor/WireTapProcessor.java
+++ b/core/camel-core-processor/src/main/java/org/apache/camel/processor/WireTapProcessor.java
@@ -61,7 +61,7 @@ public class WireTapProcessor extends AsyncProcessorSupport
     private String id;
     private String routeId;
     private CamelContext camelContext;
-    private final SendDynamicProcessor dynamicProcessor;
+    private final SendDynamicProcessor dynamicSendProcessor; // is only used for reporting statistics
     private final String uri;
     private final boolean dynamicUri;
     private final Processor processor;
@@ -78,10 +78,11 @@ public class WireTapProcessor extends AsyncProcessorSupport
     private boolean copy;
     private Processor onPrepare;
 
-    public WireTapProcessor(SendDynamicProcessor dynamicProcessor, Processor processor, ExchangePattern exchangePattern,
+    public WireTapProcessor(SendDynamicProcessor dynamicSendProcessor, Processor processor, String uri,
+                            ExchangePattern exchangePattern,
                             ExecutorService executorService, boolean shutdownExecutorService, boolean dynamicUri) {
-        this.dynamicProcessor = dynamicProcessor;
-        this.uri = dynamicProcessor.getUri();
+        this.dynamicSendProcessor = dynamicSendProcessor;
+        this.uri = uri;
         this.processor = processor;
         this.asyncProcessor = AsyncProcessorConverterHelper.convert(processor);
         this.exchangePattern = exchangePattern;
@@ -148,7 +149,11 @@ public class WireTapProcessor extends AsyncProcessorSupport
     }
 
     public EndpointUtilizationStatistics getEndpointUtilizationStatistics() {
-        return dynamicProcessor.getEndpointUtilizationStatistics();
+        if (dynamicSendProcessor != null) {
+            return dynamicSendProcessor.getEndpointUtilizationStatistics();
+        } else {
+            return null;
+        }
     }
 
     @Override
@@ -305,11 +310,19 @@ public class WireTapProcessor extends AsyncProcessorSupport
     }
 
     public int getCacheSize() {
-        return dynamicProcessor.getCacheSize();
+        if (dynamicSendProcessor != null) {
+            return dynamicSendProcessor.getCacheSize();
+        } else {
+            return 0;
+        }
     }
 
     public boolean isIgnoreInvalidEndpoint() {
-        return dynamicProcessor.isIgnoreInvalidEndpoint();
+        if (dynamicSendProcessor != null) {
+            return dynamicSendProcessor.isIgnoreInvalidEndpoint();
+        } else {
+            return false;
+        }
     }
 
     public boolean isDynamicUri() {
diff --git a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/SendReifier.java b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/SendReifier.java
index c8cd1e0..f5a3051 100644
--- a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/SendReifier.java
+++ b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/SendReifier.java
@@ -40,7 +40,7 @@ public class SendReifier extends ProcessorReifier<SendDefinition<?>> {
     public Endpoint resolveEndpoint() {
         if (definition.getEndpoint() == null) {
             if (definition.getEndpointProducerBuilder() == null) {
-                return CamelContextHelper.resolveEndpoint(camelContext, definition.getEndpointUri(), (String) null);
+                return CamelContextHelper.resolveEndpoint(camelContext, definition.getEndpointUri(), null);
             } else {
                 return definition.getEndpointProducerBuilder().resolve(camelContext);
             }
diff --git a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/WireTapReifier.java b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/WireTapReifier.java
index 79c1d55..3d0c214 100644
--- a/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/WireTapReifier.java
+++ b/core/camel-core-reifier/src/main/java/org/apache/camel/reifier/WireTapReifier.java
@@ -19,6 +19,7 @@ package org.apache.camel.reifier;
 import java.util.concurrent.ExecutorService;
 
 import org.apache.camel.AsyncProcessor;
+import org.apache.camel.Endpoint;
 import org.apache.camel.ExchangePattern;
 import org.apache.camel.Expression;
 import org.apache.camel.ExtendedCamelContext;
@@ -28,7 +29,11 @@ import org.apache.camel.model.ProcessorDefinition;
 import org.apache.camel.model.SetHeaderDefinition;
 import org.apache.camel.model.WireTapDefinition;
 import org.apache.camel.processor.SendDynamicProcessor;
+import org.apache.camel.processor.SendProcessor;
 import org.apache.camel.processor.WireTapProcessor;
+import org.apache.camel.support.CamelContextHelper;
+import org.apache.camel.support.LanguageSupport;
+import org.apache.camel.util.StringHelper;
 
 public class WireTapReifier extends ToDynamicReifier<WireTapDefinition<?>> {
 
@@ -45,11 +50,30 @@ public class WireTapReifier extends ToDynamicReifier<WireTapDefinition<?>> {
         // must use InOnly for WireTap
         definition.setPattern(ExchangePattern.InOnly.name());
 
-        // create the send dynamic producer to send to the wire tapped endpoint
-        SendDynamicProcessor dynamicTo = (SendDynamicProcessor) super.createProcessor();
+        // optimize to only use dynamic processor if really needed
+        String uri;
+        if (definition.getEndpointProducerBuilder() != null) {
+            uri = definition.getEndpointProducerBuilder().getUri();
+        } else {
+            uri = StringHelper.notEmpty(definition.getUri(), "uri", this);
+        }
+
+        SendDynamicProcessor dynamicSendProcessor = null;
+        SendProcessor sendProcessor = null;
+        boolean simple = LanguageSupport.hasSimpleFunction(definition.getUri());
+        boolean dynamic = parseBoolean(definition.getDynamicUri(), true);
+        if (dynamic && simple) {
+            // dynamic so we need the dynamic send processor
+            dynamicSendProcessor = (SendDynamicProcessor) super.createProcessor();
+        } else {
+            // static so we can use a plain send processor
+            Endpoint endpoint = CamelContextHelper.resolveEndpoint(camelContext, uri, null);
+            sendProcessor = new SendProcessor(endpoint);
+        }
 
         // create error handler we need to use for processing the wire tapped
-        Processor childProcessor = wrapInErrorHandler(dynamicTo);
+        Processor producer = dynamicSendProcessor != null ? dynamicSendProcessor : sendProcessor;
+        Processor childProcessor = wrapInErrorHandler(producer);
 
         // and wrap in unit of work
         AsyncProcessor target = camelContext.adapt(ExtendedCamelContext.class).getInternalProcessorFactory()
@@ -59,10 +83,9 @@ public class WireTapReifier extends ToDynamicReifier<WireTapDefinition<?>> {
         boolean isCopy = parseBoolean(definition.getCopy(), true);
 
         WireTapProcessor answer = new WireTapProcessor(
-                dynamicTo, target,
+                dynamicSendProcessor, target, uri,
                 parse(ExchangePattern.class, definition.getPattern()),
-                threadPool, shutdownThreadPool,
-                parseBoolean(definition.getDynamicUri(), true));
+                threadPool, shutdownThreadPool, dynamic);
         answer.setCopy(isCopy);
         Processor newExchangeProcessor = definition.getNewExchangeProcessor();
         String ref = parseString(definition.getNewExchangeProcessorRef());