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 2017/04/27 13:12:37 UTC
camel git commit: CAMEL-11211 Remove the deprecated SpanManager,
which uses threadlocal, and instead just manage the spans within the exchanges
Repository: camel
Updated Branches:
refs/heads/master 71229bcbf -> 63b3caf04
CAMEL-11211 Remove the deprecated SpanManager, which uses threadlocal, and instead just manage the spans within the exchanges
Project: http://git-wip-us.apache.org/repos/asf/camel/repo
Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/63b3caf0
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/63b3caf0
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/63b3caf0
Branch: refs/heads/master
Commit: 63b3caf04f291da2df558caf4981bfd4b02ee83e
Parents: 71229bc
Author: Gary Brown <ga...@brownuk.com>
Authored: Thu Apr 27 11:42:22 2017 +0100
Committer: Claus Ibsen <da...@apache.org>
Committed: Thu Apr 27 15:12:29 2017 +0200
----------------------------------------------------------------------
components/camel-opentracing/pom.xml | 6 +-
.../camel/opentracing/ActiveSpanManager.java | 102 +++++++++
.../camel/opentracing/OpenTracingTracer.java | 73 ++-----
.../concurrent/CamelSpanManager.java | 207 -------------------
.../OpenTracingExecutorServiceManager.java | 200 ------------------
.../opentracing/ActiveSpanManagerTest.java | 86 ++++++++
parent/pom.xml | 1 -
7 files changed, 213 insertions(+), 462 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/camel/blob/63b3caf0/components/camel-opentracing/pom.xml
----------------------------------------------------------------------
diff --git a/components/camel-opentracing/pom.xml b/components/camel-opentracing/pom.xml
index e1b8090..2bc4dbe 100644
--- a/components/camel-opentracing/pom.xml
+++ b/components/camel-opentracing/pom.xml
@@ -56,9 +56,9 @@
<version>${opentracing-version}</version>
</dependency>
<dependency>
- <groupId>io.opentracing.contrib</groupId>
- <artifactId>opentracing-spanmanager</artifactId>
- <version>${opentracing-java-spanmanager-version}</version>
+ <groupId>io.opentracing</groupId>
+ <artifactId>opentracing-noop</artifactId>
+ <version>${opentracing-version}</version>
</dependency>
<!-- test dependencies -->
http://git-wip-us.apache.org/repos/asf/camel/blob/63b3caf0/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/ActiveSpanManager.java
----------------------------------------------------------------------
diff --git a/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/ActiveSpanManager.java b/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/ActiveSpanManager.java
new file mode 100644
index 0000000..8689e8d
--- /dev/null
+++ b/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/ActiveSpanManager.java
@@ -0,0 +1,102 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.opentracing;
+
+import io.opentracing.Span;
+
+import org.apache.camel.Exchange;
+
+/**
+ * Utility class for managing active spans as a stack associated with
+ * an exchange.
+ *
+ */
+public final class ActiveSpanManager {
+
+ private static final String ACTIVE_SPAN_PROPERTY = "OpenTracing.activeSpan";
+
+ private ActiveSpanManager() {
+ }
+
+ /**
+ * This method returns the current active span associated with the
+ * exchange.
+ *
+ * @param exchange The exchange
+ * @return The current active span, or null if none exists
+ */
+ public static Span getSpan(Exchange exchange) {
+ Holder holder = (Holder) exchange.getProperty(ACTIVE_SPAN_PROPERTY);
+ if (holder != null) {
+ return holder.getSpan();
+ }
+ return null;
+ }
+
+ /**
+ * This method activates the supplied span for the supplied exchange.
+ * If an existing span is found for the exchange, this will be pushed
+ * onto a stack.
+ *
+ * @param exchange The exchange
+ * @param span The span
+ */
+ public static void activate(Exchange exchange, Span span) {
+ exchange.setProperty(ACTIVE_SPAN_PROPERTY,
+ new Holder((Holder) exchange.getProperty(ACTIVE_SPAN_PROPERTY), span));
+ }
+
+ /**
+ * This method deactivates an existing active span associated with the
+ * supplied exchange. Once deactivated, if a parent span is found
+ * associated with the stack for the exchange, it will be restored
+ * as the current span for that exchange.
+ *
+ * @param exchange The exchange
+ */
+ public static void deactivate(Exchange exchange) {
+ Holder holder = (Holder) exchange.getProperty(ACTIVE_SPAN_PROPERTY);
+ if (holder != null) {
+ exchange.setProperty(ACTIVE_SPAN_PROPERTY, holder.getParent());
+ }
+ }
+
+ /**
+ * Simple holder for the currently active span and an optional reference to
+ * the parent holder. This will be used to maintain a stack for spans, built
+ * up during the execution of a series of chained camel exchanges, and then
+ * unwound when the responses are processed.
+ *
+ */
+ public static class Holder {
+ private Holder parent;
+ private Span span;
+
+ public Holder(Holder parent, Span span) {
+ this.parent = parent;
+ this.span = span;
+ }
+
+ public Holder getParent() {
+ return parent;
+ }
+
+ public Span getSpan() {
+ return span;
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/camel/blob/63b3caf0/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/OpenTracingTracer.java
----------------------------------------------------------------------
diff --git a/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/OpenTracingTracer.java b/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/OpenTracingTracer.java
index a3876af..0a03044 100644
--- a/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/OpenTracingTracer.java
+++ b/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/OpenTracingTracer.java
@@ -28,7 +28,6 @@ import io.opentracing.NoopTracerFactory;
import io.opentracing.Span;
import io.opentracing.Tracer;
import io.opentracing.Tracer.SpanBuilder;
-import io.opentracing.contrib.spanmanager.SpanManager;
import io.opentracing.propagation.Format;
import io.opentracing.tag.Tags;
import org.apache.camel.CamelContext;
@@ -41,8 +40,6 @@ import org.apache.camel.api.management.ManagedResource;
import org.apache.camel.management.event.ExchangeSendingEvent;
import org.apache.camel.management.event.ExchangeSentEvent;
import org.apache.camel.model.RouteDefinition;
-import org.apache.camel.opentracing.concurrent.CamelSpanManager;
-import org.apache.camel.opentracing.concurrent.OpenTracingExecutorServiceManager;
import org.apache.camel.opentracing.propagation.CamelHeadersExtractAdapter;
import org.apache.camel.opentracing.propagation.CamelHeadersInjectAdapter;
import org.apache.camel.spi.LogListener;
@@ -69,13 +66,10 @@ public class OpenTracingTracer extends ServiceSupport implements RoutePolicyFact
private static final Logger LOG = LoggerFactory.getLogger(OpenTracingTracer.class);
- private static final String MANAGED_SPAN_PROPERTY = "ManagedSpan";
-
private static Map<String, SpanDecorator> decorators = new HashMap<>();
private final OpenTracingEventNotifier eventNotifier = new OpenTracingEventNotifier();
private final OpenTracingLogListener logListener = new OpenTracingLogListener();
- private final CamelSpanManager spanManager = CamelSpanManager.getInstance();
private Tracer tracer;
private CamelContext camelContext;
@@ -111,10 +105,6 @@ public class OpenTracingTracer extends ServiceSupport implements RoutePolicyFact
// start this service eager so we init before Camel is starting up
camelContext.addService(this, true, true);
- // Wrap the ExecutorServiceManager with a SpanManager aware version
- camelContext.setExecutorServiceManager(
- new OpenTracingExecutorServiceManager(camelContext.getExecutorServiceManager(), spanManager));
-
} catch (Exception e) {
throw ObjectHelper.wrapRuntimeCamelException(e);
}
@@ -200,27 +190,23 @@ public class OpenTracingTracer extends ServiceSupport implements RoutePolicyFact
try {
if (event instanceof ExchangeSendingEvent) {
ExchangeSendingEvent ese = (ExchangeSendingEvent) event;
- SpanManager.ManagedSpan parent = spanManager.current();
- if (ese.getExchange().getProperties().containsKey(MANAGED_SPAN_PROPERTY)) {
- parent = (SpanManager.ManagedSpan)
- ese.getExchange().getProperty(MANAGED_SPAN_PROPERTY);
- }
SpanDecorator sd = getSpanDecorator(ese.getEndpoint());
if (!sd.newSpan()) {
return;
}
+ Span parent = ActiveSpanManager.getSpan(ese.getExchange());
SpanBuilder spanBuilder = tracer.buildSpan(sd.getOperationName(ese.getExchange(), ese.getEndpoint()))
.withTag(Tags.SPAN_KIND.getKey(), sd.getInitiatorSpanKind());
// Temporary workaround to avoid adding 'null' span as a parent
- if (parent != null && parent.getSpan() != null) {
- spanBuilder.asChildOf(parent.getSpan());
+ if (parent != null) {
+ spanBuilder.asChildOf(parent);
}
Span span = spanBuilder.start();
sd.pre(span, ese.getExchange(), ese.getEndpoint());
tracer.inject(span.context(), Format.Builtin.TEXT_MAP,
new CamelHeadersInjectAdapter(ese.getExchange().getIn().getHeaders()));
- ese.getExchange().setProperty(MANAGED_SPAN_PROPERTY, spanManager.activate(span));
- spanManager.clear();
+ ActiveSpanManager.activate(ese.getExchange(), span);
+
if (LOG.isTraceEnabled()) {
LOG.trace("OpenTracing: start client span=" + span);
}
@@ -230,20 +216,17 @@ public class OpenTracingTracer extends ServiceSupport implements RoutePolicyFact
if (!sd.newSpan()) {
return;
}
- SpanManager.ManagedSpan managedSpan = (SpanManager.ManagedSpan)
- ese.getExchange().getProperty(MANAGED_SPAN_PROPERTY);
- if (managedSpan != null) {
- spanManager.activate(managedSpan);
- ese.getExchange().setProperty(MANAGED_SPAN_PROPERTY, null);
+ Span span = ActiveSpanManager.getSpan(ese.getExchange());
+ if (span != null) {
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("OpenTracing: start client span=" + span);
+ }
+ sd.post(span, ese.getExchange(), ese.getEndpoint());
+ span.finish();
+ ActiveSpanManager.deactivate(ese.getExchange());
} else {
- managedSpan = spanManager.current();
- }
- if (LOG.isTraceEnabled()) {
- LOG.trace("OpenTracing: start client span=" + managedSpan.getSpan());
+ LOG.warn("OpenTracing: could not find managed span for exchange=" + ese.getExchange());
}
- sd.post(managedSpan.getSpan(), ese.getExchange(), ese.getEndpoint());
- managedSpan.getSpan().finish();
- managedSpan.deactivate();
}
} catch (Throwable t) {
// This exception is ignored
@@ -271,10 +254,6 @@ public class OpenTracingTracer extends ServiceSupport implements RoutePolicyFact
@Override
public void onExchangeBegin(Route route, Exchange exchange) {
try {
- // Check if continuing exchange on same thread
- if (exchange.getProperties().containsKey(MANAGED_SPAN_PROPERTY)) {
- spanManager.activate((SpanManager.ManagedSpan)exchange.getProperty(MANAGED_SPAN_PROPERTY));
- }
SpanDecorator sd = getSpanDecorator(route.getEndpoint());
Span span = tracer.buildSpan(sd.getOperationName(exchange, route.getEndpoint()))
.asChildOf(tracer.extract(Format.Builtin.TEXT_MAP,
@@ -282,7 +261,7 @@ public class OpenTracingTracer extends ServiceSupport implements RoutePolicyFact
.withTag(Tags.SPAN_KIND.getKey(), sd.getReceiverSpanKind())
.start();
sd.pre(span, exchange, route.getEndpoint());
- exchange.setProperty(MANAGED_SPAN_PROPERTY, spanManager.activate(span));
+ ActiveSpanManager.activate(exchange, span);
if (LOG.isTraceEnabled()) {
LOG.trace("OpenTracing: start server span=" + span);
}
@@ -295,16 +274,15 @@ public class OpenTracingTracer extends ServiceSupport implements RoutePolicyFact
@Override
public void onExchangeDone(Route route, Exchange exchange) {
try {
- SpanManager.ManagedSpan managedSpan = spanManager.current();
- if (managedSpan.getSpan() != null) {
+ Span span = ActiveSpanManager.getSpan(exchange);
+ if (span != null) {
if (LOG.isTraceEnabled()) {
- LOG.trace("OpenTracing: finish server span=" + managedSpan.getSpan());
+ LOG.trace("OpenTracing: finish server span=" + span);
}
SpanDecorator sd = getSpanDecorator(route.getEndpoint());
- sd.post(managedSpan.getSpan(), exchange, route.getEndpoint());
- managedSpan.getSpan().finish();
- managedSpan.deactivate();
- exchange.setProperty(MANAGED_SPAN_PROPERTY, null);
+ sd.post(span, exchange, route.getEndpoint());
+ span.finish();
+ ActiveSpanManager.deactivate(exchange);
} else {
LOG.warn("OpenTracing: could not find managed span for exchange=" + exchange);
}
@@ -320,14 +298,7 @@ public class OpenTracingTracer extends ServiceSupport implements RoutePolicyFact
@Override
public String onLog(Exchange exchange, CamelLogger camelLogger, String message) {
try {
- SpanManager.ManagedSpan managedSpan = (SpanManager.ManagedSpan)
- exchange.getProperty(MANAGED_SPAN_PROPERTY);
- Span span = null;
- if (managedSpan != null) {
- span = managedSpan.getSpan();
- } else {
- span = spanManager.current().getSpan();
- }
+ Span span = ActiveSpanManager.getSpan(exchange);
if (span != null) {
Map<String, Object> fields = new HashMap<>();
fields.put("message", message);
http://git-wip-us.apache.org/repos/asf/camel/blob/63b3caf0/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/concurrent/CamelSpanManager.java
----------------------------------------------------------------------
diff --git a/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/concurrent/CamelSpanManager.java b/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/concurrent/CamelSpanManager.java
deleted file mode 100644
index c5c34af..0000000
--- a/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/concurrent/CamelSpanManager.java
+++ /dev/null
@@ -1,207 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.opentracing.concurrent;
-
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import io.opentracing.NoopSpan;
-import io.opentracing.Span;
-import io.opentracing.contrib.spanmanager.SpanManager;
-
-/**
- * Camel {@link SpanManager} implementation using {@link ThreadLocal} storage
- * maintaining a stack-like structure of linked managed spans.
- * <p>
- * The linked managed spans provide the following stack unwinding algorithm:
- * <ol>
- * <li>If the deactivated span is not the <em>managed</em> span, the <em>current managed</em> span is left alone.</li>
- * <li>Otherwise, the first parent that is <em>not yet deactivated</em> is set as the new managed span.</li>
- * <li>If no managed parents remain, the <em>managed span</em> is cleared.</li>
- * <li>Consecutive <code>deactivate()</code> calls for already-deactivated spans will be ignored.</li>
- * </ol>
- * <p>
- * NOTE: This implementation has been copied and extended from opentracing-contrib/java-spanmanager
- * project, to provide the additional functionality for transferring the managed spans from one thread
- * to another. This functionality will soon be provided by the core opentracing-java project, at which
- * time this implementation will be removed.
- */
-public final class CamelSpanManager implements SpanManager {
-
- private static final Logger LOGGER = Logger.getLogger(CamelSpanManager.class.getName());
- private static final CamelSpanManager INSTANCE = new CamelSpanManager();
- private static final ManagedSpan NO_MANAGED_SPAN = new NoManagedSpan();
-
- private final ThreadLocal<LinkedManagedSpan> managed = new ThreadLocal<LinkedManagedSpan>();
-
- private CamelSpanManager() {
- }
-
- /**
- * @return The singleton instance of the camel span manager.
- */
- public static CamelSpanManager getInstance() {
- return INSTANCE;
- }
-
- /**
- * Stack unwinding algorithm that refreshes the currently managed span.
- * <p>
- * See {@link CamelSpanManager class javadoc} for a full description.
- *
- * @return The current non-deactivated LinkedManagedSpan or <code>null</code> if none remained.
- */
- private LinkedManagedSpan refreshCurrent() {
- LinkedManagedSpan managedSpan = managed.get();
- LinkedManagedSpan current = managedSpan;
- while (current != null && current.deactivated.get()) { // Unwind stack if necessary.
- current = current.parent;
- }
- if (current != managedSpan) { // refresh current if necessary.
- if (current == null) {
- managed.remove();
- } else {
- managed.set(current);
- }
- }
- return current;
- }
-
- @Override
- public ManagedSpan activate(Span span) {
- LinkedManagedSpan managedSpan = new LinkedManagedSpan(span, refreshCurrent());
- managed.set(managedSpan);
- return managedSpan;
- }
-
- /**
- * This method associates the supplied managed span with the current
- * execution context (thread).
- *
- * @param managedSpan The managed span
- */
- public void activate(ManagedSpan managedSpan) {
- if (managedSpan instanceof LinkedManagedSpan) {
- managed.set((LinkedManagedSpan)managedSpan);
- }
- }
-
- @Override
- public ManagedSpan current() {
- LinkedManagedSpan current = refreshCurrent();
- return current != null ? current : NO_MANAGED_SPAN;
- }
-
- @Override
- public void clear() {
- managed.remove();
- }
-
- @Override
- @Deprecated
- public Span currentSpan() {
- ManagedSpan current = current();
- return current.getSpan() != null ? current.getSpan() : NoopSpan.INSTANCE;
- }
-
- /**
- * @see #activate(Span)
- * @deprecated renamed to activate()
- */
- @Deprecated
- public ManagedSpan manage(Span span) {
- return activate(span);
- }
-
- @Override
- public String toString() {
- return getClass().getSimpleName();
- }
-
- private final class LinkedManagedSpan implements ManagedSpan {
- private final LinkedManagedSpan parent;
- private final Span span;
- private final AtomicBoolean deactivated = new AtomicBoolean(false);
-
- private LinkedManagedSpan(Span span, LinkedManagedSpan parent) {
- this.parent = parent;
- this.span = span;
- }
-
- @Override
- public Span getSpan() {
- return span;
- }
-
- public void deactivate() {
- if (deactivated.compareAndSet(false, true)) {
- LinkedManagedSpan current = refreshCurrent(); // Trigger stack-unwinding algorithm.
- LOGGER.log(Level.FINER, "Released {0}, current span is {1}.", new Object[]{this, current});
- } else {
- LOGGER.log(Level.FINEST, "No action needed, {0} was already deactivated.", this);
- }
- }
-
- @Override
- public void close() {
- deactivate();
- }
-
- /**
- * @see #deactivate()
- * @deprecated renamed to deactivate()
- */
- @Deprecated
- public void release() {
- deactivate();
- }
-
- @Override
- public String toString() {
- return getClass().getSimpleName() + '{' + span + '}';
- }
- }
-
- /**
- * Empty implementation signifying there is no managed span.
- */
- private static final class NoManagedSpan implements ManagedSpan {
- private NoManagedSpan() {
- }
-
- @Override
- public Span getSpan() {
- return null;
- }
-
- @Override
- public void deactivate() {
- // no-op
- }
-
- @Override
- public void close() {
- // no-op
- }
-
- @Override
- public String toString() {
- return getClass().getSimpleName();
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/camel/blob/63b3caf0/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/concurrent/OpenTracingExecutorServiceManager.java
----------------------------------------------------------------------
diff --git a/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/concurrent/OpenTracingExecutorServiceManager.java b/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/concurrent/OpenTracingExecutorServiceManager.java
deleted file mode 100644
index 2b19a88..0000000
--- a/components/camel-opentracing/src/main/java/org/apache/camel/opentracing/concurrent/OpenTracingExecutorServiceManager.java
+++ /dev/null
@@ -1,200 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.opentracing.concurrent;
-
-import java.util.List;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.ScheduledExecutorService;
-
-import io.opentracing.contrib.spanmanager.SpanManager;
-import io.opentracing.contrib.spanmanager.concurrent.SpanPropagatingExecutorService;
-
-import org.apache.camel.spi.ExecutorServiceManager;
-import org.apache.camel.spi.ThreadPoolFactory;
-import org.apache.camel.spi.ThreadPoolProfile;
-
-public class OpenTracingExecutorServiceManager implements ExecutorServiceManager {
-
- private final ExecutorServiceManager delegate;
- private final SpanManager spanManager;
-
- public OpenTracingExecutorServiceManager(ExecutorServiceManager delegate, SpanManager spanManager) {
- this.delegate = delegate;
- this.spanManager = spanManager;
- }
-
- @Override
- public void shutdown() throws Exception {
- delegate.shutdown();
- }
-
- @Override
- public void start() throws Exception {
- delegate.start();
- }
-
- @Override
- public void stop() throws Exception {
- delegate.stop();
- }
-
- @Override
- public boolean awaitTermination(ExecutorService arg0, long arg1) throws InterruptedException {
- return delegate.awaitTermination(arg0, arg1);
- }
-
- @Override
- public ThreadPoolProfile getDefaultThreadPoolProfile() {
- return delegate.getDefaultThreadPoolProfile();
- }
-
- @Override
- public long getShutdownAwaitTermination() {
- return delegate.getShutdownAwaitTermination();
- }
-
- @Override
- public String getThreadNamePattern() {
- return delegate.getThreadNamePattern();
- }
-
- @Override
- public ThreadPoolFactory getThreadPoolFactory() {
- return delegate.getThreadPoolFactory();
- }
-
- @Override
- public ThreadPoolProfile getThreadPoolProfile(String arg0) {
- return delegate.getThreadPoolProfile(arg0);
- }
-
- @Override
- public ExecutorService newCachedThreadPool(Object arg0, String arg1) {
- return new SpanPropagatingExecutorService(delegate.newCachedThreadPool(arg0, arg1), spanManager);
- }
-
- @Override
- public ScheduledExecutorService newDefaultScheduledThreadPool(Object arg0, String arg1) {
- return delegate.newDefaultScheduledThreadPool(arg0, arg1);
- }
-
- @Override
- public ExecutorService newDefaultThreadPool(Object arg0, String arg1) {
- return new SpanPropagatingExecutorService(delegate.newDefaultThreadPool(arg0, arg1), spanManager);
- }
-
- @Override
- public ExecutorService newFixedThreadPool(Object arg0, String arg1, int arg2) {
- return new SpanPropagatingExecutorService(delegate.newFixedThreadPool(arg0, arg1, arg2), spanManager);
- }
-
- @Override
- public ScheduledExecutorService newScheduledThreadPool(Object arg0, String arg1, int arg2) {
- return delegate.newScheduledThreadPool(arg0, arg1, arg2);
- }
-
- @Override
- public ScheduledExecutorService newScheduledThreadPool(Object arg0, String arg1, ThreadPoolProfile arg2) {
- return delegate.newScheduledThreadPool(arg0, arg1, arg2);
- }
-
- @Override
- public ScheduledExecutorService newScheduledThreadPool(Object arg0, String arg1, String arg2) {
- return delegate.newScheduledThreadPool(arg0, arg1, arg2);
- }
-
- @Override
- public ExecutorService newSingleThreadExecutor(Object arg0, String arg1) {
- return new SpanPropagatingExecutorService(delegate.newSingleThreadExecutor(arg0, arg1), spanManager);
- }
-
- @Override
- public ScheduledExecutorService newSingleThreadScheduledExecutor(Object arg0, String arg1) {
- return delegate.newSingleThreadScheduledExecutor(arg0, arg1);
- }
-
- @Override
- public Thread newThread(String arg0, Runnable arg1) {
- return delegate.newThread(arg0, arg1);
- }
-
- @Override
- public ExecutorService newThreadPool(Object arg0, String arg1, ThreadPoolProfile arg2) {
- return new SpanPropagatingExecutorService(delegate.newThreadPool(arg0, arg1, arg2), spanManager);
- }
-
- @Override
- public ExecutorService newThreadPool(Object arg0, String arg1, String arg2) {
- return new SpanPropagatingExecutorService(delegate.newThreadPool(arg0, arg1, arg2), spanManager);
- }
-
- @Override
- public ExecutorService newThreadPool(Object arg0, String arg1, int arg2, int arg3) {
- return new SpanPropagatingExecutorService(delegate.newThreadPool(arg0, arg1, arg2, arg3), spanManager);
- }
-
- @Override
- public void registerThreadPoolProfile(ThreadPoolProfile arg0) {
- delegate.registerThreadPoolProfile(arg0);
- }
-
- @Override
- public String resolveThreadName(String arg0) {
- return delegate.resolveThreadName(arg0);
- }
-
- @Override
- public void setDefaultThreadPoolProfile(ThreadPoolProfile arg0) {
- delegate.setDefaultThreadPoolProfile(arg0);
- }
-
- @Override
- public void setShutdownAwaitTermination(long arg0) {
- delegate.setShutdownAwaitTermination(arg0);
- }
-
- @Override
- public void setThreadNamePattern(String arg0) throws IllegalArgumentException {
- delegate.setThreadNamePattern(arg0);
- }
-
- @Override
- public void setThreadPoolFactory(ThreadPoolFactory arg0) {
- delegate.setThreadPoolFactory(arg0);
- }
-
- @Override
- public void shutdown(ExecutorService arg0) {
- delegate.shutdown(arg0);
- }
-
- @Override
- public void shutdownGraceful(ExecutorService arg0) {
- delegate.shutdownGraceful(arg0);
- }
-
- @Override
- public void shutdownGraceful(ExecutorService arg0, long arg1) {
- delegate.shutdownGraceful(arg0, arg1);
- }
-
- @Override
- public List<Runnable> shutdownNow(ExecutorService arg0) {
- return delegate.shutdownNow(arg0);
- }
-
-}
http://git-wip-us.apache.org/repos/asf/camel/blob/63b3caf0/components/camel-opentracing/src/test/java/org/apache/camel/opentracing/ActiveSpanManagerTest.java
----------------------------------------------------------------------
diff --git a/components/camel-opentracing/src/test/java/org/apache/camel/opentracing/ActiveSpanManagerTest.java b/components/camel-opentracing/src/test/java/org/apache/camel/opentracing/ActiveSpanManagerTest.java
new file mode 100644
index 0000000..7b347a5
--- /dev/null
+++ b/components/camel-opentracing/src/test/java/org/apache/camel/opentracing/ActiveSpanManagerTest.java
@@ -0,0 +1,86 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.opentracing;
+
+import io.opentracing.Span;
+import io.opentracing.mock.MockTracer;
+
+import org.apache.camel.Exchange;
+import org.apache.camel.test.junit4.ExchangeTestSupport;
+import org.junit.Test;
+
+public class ActiveSpanManagerTest extends ExchangeTestSupport {
+
+ private MockTracer tracer = new MockTracer();
+
+ @Test
+ public void testNoSpan() {
+ Exchange exchange = createExchange();
+ assertNull(ActiveSpanManager.getSpan(exchange));
+ }
+
+ @Test
+ public void testCurrentSpan() {
+ Exchange exchange = createExchange();
+ Span span = tracer.buildSpan("test").start();
+ ActiveSpanManager.activate(exchange, span);
+ assertEquals(span, ActiveSpanManager.getSpan(exchange));
+
+ ActiveSpanManager.deactivate(exchange);
+ assertNull(ActiveSpanManager.getSpan(exchange));
+ }
+
+ @Test
+ public void testCreateChild() {
+ Exchange exchange = createExchange();
+ Span parent = tracer.buildSpan("parent").start();
+ ActiveSpanManager.activate(exchange, parent);
+ Span child = tracer.buildSpan("child").start();
+ ActiveSpanManager.activate(exchange, child);
+
+ assertEquals(child, ActiveSpanManager.getSpan(exchange));
+
+ ActiveSpanManager.deactivate(exchange);
+ assertEquals(parent, ActiveSpanManager.getSpan(exchange));
+ }
+
+ @Test
+ public void testIsolatedConcurrentExchanges() {
+ Exchange exchange = createExchange();
+ Span parent = tracer.buildSpan("parent").start();
+ ActiveSpanManager.activate(exchange, parent);
+
+ Exchange path1 = exchange.copy(true);
+ Exchange path2 = exchange.copy(true);
+
+ // Check the parent span is available in the new exchanges
+ assertEquals(parent, ActiveSpanManager.getSpan(path1));
+ assertEquals(parent, ActiveSpanManager.getSpan(path2));
+
+ Span child1 = tracer.buildSpan("child1").start();
+ ActiveSpanManager.activate(path1, child1);
+
+ Span child2 = tracer.buildSpan("child2").start();
+ ActiveSpanManager.activate(path2, child2);
+
+ ActiveSpanManager.deactivate(path2);
+
+ // Check that the current span in path2 is back to parent
+ // and hasn't been affected by path1 creating its own child
+ ActiveSpanManager.activate(path2, parent);
+ }
+}
http://git-wip-us.apache.org/repos/asf/camel/blob/63b3caf0/parent/pom.xml
----------------------------------------------------------------------
diff --git a/parent/pom.xml b/parent/pom.xml
index 123b2f4..7c45b24 100644
--- a/parent/pom.xml
+++ b/parent/pom.xml
@@ -500,7 +500,6 @@
<openstack4j-version>3.0.2</openstack4j-version>
<openstack4j-guava-version>17.0</openstack4j-guava-version>
<opentracing-java-agent-version>0.0.11</opentracing-java-agent-version>
- <opentracing-java-spanmanager-version>0.0.3</opentracing-java-spanmanager-version>
<opentracing-version>0.21.0</opentracing-version>
<ops4j-base-version>1.5.0</ops4j-base-version>
<optaplanner-version>6.5.0.Final</optaplanner-version>