V0.31.0 rebased on master

opentracing-api/src/main/java/io/opentracing/propagation/Format.java

@@ -27,7 +27,7 @@
  * <pre><code>
  * Tracer tracer = ...
  * io.opentracing.propagation.HttpHeaders httpCarrier = new AnHttpHeaderCarrier(httpRequest);
- * SpanContext spanCtx = tracer.extract(Format.Builtin.HTTP_HEADERS, httpHeaderReader);
+ * SpanContext spanCtx = tracer.extract(Format.Builtin.HTTP_HEADERS, httpCarrier);
  * </code></pre>
  *
  * @see Tracer#inject(SpanContext, Format, Object)

opentracing-mock/src/main/java/io/opentracing/mock/MockSpan.java

@@ -13,11 +13,13 @@
  */
 package io.opentracing.mock;
 
+import io.opentracing.References;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.concurrent.atomic.AtomicLong;
 
 import io.opentracing.Span;
@@ -42,6 +44,7 @@ public final class MockSpan implements Span {
     private final Map<String, Object> tags;
     private final List<LogEntry> logEntries = new ArrayList<>();
     private String operationName;
+    private final List<Reference> references;
 
     private final List<RuntimeException> errors = new ArrayList<>();
 
@@ -57,11 +60,10 @@ public MockSpan setOperationName(String operationName) {
     }
 
     /**
-     * TODO: Support multiple parents in this API.
-     *
-     * @return the spanId of the Span's parent context, or 0 if no such parent exists.
+     * @return the spanId of the Span's first {@value References#CHILD_OF} reference, or the first reference of any type, or 0 if no reference exists.
      *
      * @see MockContext#spanId()
+     * @see MockSpan#references()
      */
     public long parentId() {
         return parentId;
@@ -97,6 +99,10 @@ public List<RuntimeException> generatedErrors() {
         return new ArrayList<>(errors);
     }
 
+    public List<Reference> references() {
+        return new ArrayList<>(references);
+    }
+
     @Override
     public synchronized MockContext context() {
         return this.context;
@@ -232,7 +238,39 @@ public long timestampMicros() {
         }
     }
 
-    MockSpan(MockTracer tracer, String operationName, long startMicros, Map<String, Object> initialTags, MockContext parent) {
+    public static final class Reference {
+        private final MockContext context;
+        private final String referenceType;
+
+        public Reference(MockContext context, String referenceType) {
+            this.context = context;
+            this.referenceType = referenceType;
+        }
+
+        public MockContext getContext() {
+            return context;
+        }
+
+        public String getReferenceType() {
+            return referenceType;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            Reference reference = (Reference) o;
+            return Objects.equals(context, reference.context) &&
+                Objects.equals(referenceType, reference.referenceType);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(context, referenceType);
+        }
+    }
+
+    MockSpan(MockTracer tracer, String operationName, long startMicros, Map<String, Object> initialTags, List<Reference> refs) {
         this.mockTracer = tracer;
         this.operationName = operationName;
         this.startMicros = startMicros;
@@ -241,17 +279,45 @@ public long timestampMicros() {
         } else {
             this.tags = new HashMap<>(initialTags);
         }
+        if(refs == null) {
+            this.references = Collections.emptyList();
+        } else {
+            this.references = new ArrayList<>(refs);
+        }
+        MockContext parent = findPreferredParentRef(this.references);
         if (parent == null) {
             // We're a root Span.
             this.context = new MockContext(nextId(), nextId(), new HashMap<String, String>());
             this.parentId = 0;
         } else {
             // We're a child Span.
-            this.context = new MockContext(parent.traceId, nextId(), parent.baggage);
+            this.context = new MockContext(parent.traceId, nextId(), mergeBaggages(this.references));
             this.parentId = parent.spanId;
         }
     }
 
+    private static MockContext findPreferredParentRef(List<Reference> references) {
+        if(references.isEmpty()) {
+            return null;
+        }
+        for (Reference reference : references) {
+            if (References.CHILD_OF.equals(reference.getReferenceType())) {
+                return reference.getContext();
+            }
+        }
+        return references.get(0).getContext();
+    }
+
+    private static Map<String, String> mergeBaggages(List<Reference> references) {
+        Map<String, String> baggage = new HashMap<>();
+        for(Reference ref : references) {
+            if(ref.getContext().baggage != null) {
+                baggage.putAll(ref.getContext().baggage);
+            }
+        }
+        return baggage;
+    }
+
     static long nextId() {
         return nextId.addAndGet(1);
     }

opentracing-mock/src/main/java/io/opentracing/mock/MockTracer.java

@@ -13,6 +13,17 @@
  */
 package io.opentracing.mock;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 import io.opentracing.Scope;
 import io.opentracing.ScopeManager;
 import io.opentracing.Span;
@@ -25,17 +36,6 @@
 import io.opentracing.propagation.TextMap;
 import io.opentracing.util.ThreadLocalScopeManager;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
 /**
  * MockTracer makes it easy to test the semantics of OpenTracing instrumentation.
  *
@@ -45,16 +45,16 @@
  * The MockTracerTest has simple usage examples.
  */
 public class MockTracer implements Tracer {
-    private List<MockSpan> finishedSpans = new ArrayList<>();
+    private final List<MockSpan> finishedSpans = new ArrayList<>();
     private final Propagator propagator;
-    private ScopeManager scopeManager;
+    private final ScopeManager scopeManager;
 
     public MockTracer() {
-        this(new ThreadLocalScopeManager(), Propagator.PRINTER);
+        this(new ThreadLocalScopeManager(), Propagator.TEXT_MAP);
     }
 
     public MockTracer(ScopeManager scopeManager) {
-        this(scopeManager, Propagator.PRINTER);
+        this(scopeManager, Propagator.TEXT_MAP);
     }
 
     public MockTracer(ScopeManager scopeManager, Propagator propagator) {
@@ -254,6 +254,15 @@ public SpanBuilder buildSpan(String operationName) {
         return new SpanBuilder(operationName);
     }
 
+    private SpanContext activeSpanContext() {
+        Scope handle = this.scopeManager.active();
+        if (handle == null) {
+            return null;
+        }
+
+        return handle.span().context();
+    }
+
     @Override
     public <C> void inject(SpanContext spanContext, Format<C> format, C carrier) {
         this.propagator.inject((MockSpan.MockContext)spanContext, format, carrier);
@@ -278,7 +287,7 @@ synchronized void appendFinishedSpan(MockSpan mockSpan) {
     public final class SpanBuilder implements Tracer.SpanBuilder {
         private final String operationName;
         private long startMicros;
-        private MockSpan.MockContext firstParent;
+        private List<MockSpan.Reference> references = new ArrayList<>();
         private boolean ignoringActiveSpan;
         private Map<String, Object> initialTags = new HashMap<>();
 
@@ -293,6 +302,9 @@ public SpanBuilder asChildOf(SpanContext parent) {
 
         @Override
         public SpanBuilder asChildOf(Span parent) {
+            if (parent == null) {
+                return this;
+            }
             return addReference(References.CHILD_OF, parent.context());
         }
 
@@ -304,9 +316,8 @@ public SpanBuilder ignoreActiveSpan() {
 
         @Override
         public SpanBuilder addReference(String referenceType, SpanContext referencedContext) {
-            if (firstParent == null && (
-                    referenceType.equals(References.CHILD_OF) || referenceType.equals(References.FOLLOWS_FROM))) {
-                this.firstParent = (MockSpan.MockContext)referencedContext;
+            if (referencedContext != null) {
+                this.references.add(new MockSpan.Reference((MockSpan.MockContext) referencedContext, referenceType));
             }
             return this;
         }
@@ -350,13 +361,11 @@ public MockSpan startManual() {
             if (this.startMicros == 0) {
                 this.startMicros = MockSpan.nowMicros();
             }
-            if (firstParent == null && !ignoringActiveSpan) {
-                Scope activeScope = scopeManager().active();
-                if (activeScope != null) {
-                    firstParent = (MockSpan.MockContext) activeScope.span().context();
-                }
+            SpanContext activeSpanContext = activeSpanContext();
+            if(references.isEmpty() && !ignoringActiveSpan && activeSpanContext != null) {
+                references.add(new MockSpan.Reference((MockSpan.MockContext) activeSpanContext, References.CHILD_OF));
             }
-            return new MockSpan(MockTracer.this, operationName, startMicros, initialTags, firstParent);
+            return new MockSpan(MockTracer.this, operationName, startMicros, initialTags, references);
         }
     }
 }

opentracing-mock/src/test/java/io/opentracing/mock/MockTracerTest.java

@@ -14,8 +14,19 @@
 package io.opentracing.mock;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import io.opentracing.References;
 import io.opentracing.Scope;
 import io.opentracing.Span;
 import io.opentracing.SpanContext;
@@ -24,13 +35,6 @@
 import io.opentracing.propagation.Format;
 import io.opentracing.propagation.TextMapExtractAdapter;
 import io.opentracing.propagation.TextMapInjectAdapter;
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import org.junit.Assert;
-import org.junit.Test;
 
 public class MockTracerTest {
     @Test
@@ -262,4 +266,93 @@ public void testReset() {
         mockTracer.reset();
         assertEquals(0, mockTracer.finishedSpans().size());
     }
+
+    @Test
+    public void testFollowFromReference() {
+        MockTracer tracer = new MockTracer(MockTracer.Propagator.TEXT_MAP);
+        final MockSpan precedent = tracer.buildSpan("precedent").startManual();
+
+        final MockSpan followingSpan = tracer.buildSpan("follows")
+            .addReference(References.FOLLOWS_FROM, precedent.context())
+            .startManual();
+
+        assertEquals(precedent.context().spanId(), followingSpan.parentId());
+        assertEquals(1, followingSpan.references().size());
+
+        final MockSpan.Reference followsFromRef = followingSpan.references().get(0);
+
+        assertEquals(new MockSpan.Reference(precedent.context(), References.FOLLOWS_FROM), followsFromRef);
+    }
+
+    @Test
+    public void testMultiReferences() {
+        MockTracer tracer = new MockTracer(MockTracer.Propagator.TEXT_MAP);
+        final MockSpan parent = tracer.buildSpan("parent").startManual();
+        final MockSpan precedent = tracer.buildSpan("precedent").startManual();
+
+        final MockSpan followingSpan = tracer.buildSpan("follows")
+            .addReference(References.FOLLOWS_FROM, precedent.context())
+            .asChildOf(parent.context())
+            .startManual();
+
+        assertEquals(parent.context().spanId(), followingSpan.parentId());
+        assertEquals(2, followingSpan.references().size());
+
+        final MockSpan.Reference followsFromRef = followingSpan.references().get(0);
+        final MockSpan.Reference parentRef = followingSpan.references().get(1);
+
+        assertEquals(new MockSpan.Reference(precedent.context(), References.FOLLOWS_FROM), followsFromRef);
+        assertEquals(new MockSpan.Reference(parent.context(), References.CHILD_OF), parentRef);
+    }
+
+    @Test
+    public void testMultiReferencesBaggage() {
+        MockTracer tracer = new MockTracer(MockTracer.Propagator.TEXT_MAP);
+        final MockSpan parent = tracer.buildSpan("parent").startManual();
+        parent.setBaggageItem("parent", "foo");
+        final MockSpan precedent = tracer.buildSpan("precedent").startManual();
+        precedent.setBaggageItem("precedent", "bar");
+
+        final MockSpan followingSpan = tracer.buildSpan("follows")
+            .addReference(References.FOLLOWS_FROM, precedent.context())
+            .asChildOf(parent.context())
+            .startManual();
+
+        assertEquals("foo", followingSpan.getBaggageItem("parent"));
+        assertEquals("bar", followingSpan.getBaggageItem("precedent"));
+    }
+
+    @Test
+    public void testNonStandardReference() {
+        MockTracer tracer = new MockTracer(MockTracer.Propagator.TEXT_MAP);
+        final MockSpan parent = tracer.buildSpan("parent").startManual();
+
+        final MockSpan nextSpan = tracer.buildSpan("follows")
+            .addReference("a_reference", parent.context())
+            .startManual();
+
+        assertEquals(parent.context().spanId(), nextSpan.parentId());
+        assertEquals(1, nextSpan.references().size());
+        assertEquals(nextSpan.references().get(0),
+            new MockSpan.Reference(parent.context(), "a_reference"));
+    }
+
+    @Test
+    public void testDefaultConstructor() {
+        MockTracer mockTracer = new MockTracer();
+        Scope activeSpan = mockTracer.buildSpan("foo").startActive(true);
+        assertEquals(activeSpan, mockTracer.scopeManager().active());
+
+        Map<String, String> propag = new HashMap<>();
+        mockTracer.inject(activeSpan.span().context(), Format.Builtin.TEXT_MAP, new TextMapInjectAdapter(propag));
+        assertFalse(propag.isEmpty());
+    }
+
+    @Test
+    public void testChildOfWithNullParentDoesNotThrowException() {
+        MockTracer tracer = new MockTracer();
+        final Span parent = null;
+        Span span = tracer.buildSpan("foo").asChildOf(parent).start();
+        span.finish();
+    }
 }