targetMap = metadata.computeIfAbsent(metadataNamespace, __ -> new ConcurrentHashMap<>());
298 | setTagAny(namespaceKeyParts, value, targetMap);
299 | }
300 | }
301 | }
302 |
303 | /**
304 | *
305 | * Store an arbitrary value in a nested {@link Map} structure, assuming
306 | * that at each level of nesting we either have a key-value pair, or else
307 | * a key pointing to a nested Map. This mimics the JSON structure used
308 | * by X-Ray to transmit tag and baggage data.
309 | *
310 | *
311 | * For example, given the following existing value for targetMap:
312 | *
313 | *
314 | * {
315 | * "http": {
316 | * "request": {
317 | * "method": "GET",
318 | * "url": "http://www.example.com"
319 | * }
320 | * }
321 | * }
322 | *
323 | *
324 | * and the inputs:
325 | *
326 | *
327 | * keyParts: ["http", "response", "code"],
328 | * value: 200
329 | *
330 | *
331 | * we return the value:
332 | *
333 | *
334 | * {
335 | * "http": {
336 | * "request": {
337 | * "method": "GET",
338 | * "url": "http://www.example.com"
339 | * },
340 | * "response": {
341 | * "code": 200
342 | * }
343 | * }
344 | * }
345 | *
346 | *
347 | * NB this method mutates the underlying value of targetMap so care should
348 | * be taken to only ever pass thread-safe instances (and this method in turn will
349 | * create thread-safe sub-Maps for nested values).
350 | *
351 | * @param remainingKeyParts the list of individual parts of the tag (name) for the value to be stored
352 | * @param value the value to be stored
353 | * @param targetMap the target Map instance
354 | */
355 | private void setTagAny(Iterator remainingKeyParts, Object value, Map targetMap) {
356 |
357 | // The iterator should never be empty here, but just for safety
358 | if (remainingKeyParts.hasNext()) {
359 | final String nextKeyPart = remainingKeyParts.next();
360 |
361 | // The key is further nested so recurse to the next level of the map
362 | if (remainingKeyParts.hasNext()) {
363 |
364 | @SuppressWarnings("unchecked")
365 | final Map targetSubMap = (Map) targetMap.computeIfAbsent(nextKeyPart, __ -> new ConcurrentHashMap<>());
366 | setTagAny(remainingKeyParts, value, targetSubMap);
367 |
368 | // This is the last key, so store at this level
369 | } else {
370 | targetMap.put(nextKeyPart, value);
371 | }
372 | }
373 | }
374 |
375 | @Override
376 | public void finish() {
377 | finish(Instant.now().toEpochMilli() / 1000.0);
378 | }
379 |
380 | @Override
381 | public void finish(long finishMicros) {
382 | finish(finishMicros / 1000.0 / 1000.0);
383 | }
384 |
385 | /**
386 | * Set the end time for this span and close it - this will usually trigger
387 | * sending the trace data back to AWS.
388 | *
389 | * @param finishSeconds timestamp of the end of this span as a number of
390 | * seconds since the UNIX
391 | */
392 | private void finish(double finishSeconds) {
393 | if (isFinished.compareAndSet(false, true)) {
394 | try {
395 | entity.setEndTime(finishSeconds);
396 | entity.close();
397 | } catch (Exception e) {
398 | log.error("Failed to close underlying AWS trace Entity: " + e.getMessage(), e);
399 | }
400 | }
401 | }
402 | }
403 |
--------------------------------------------------------------------------------
/src/main/java/io/opentracing/contrib/aws/xray/AWSXRaySpanContext.java:
--------------------------------------------------------------------------------
1 | package io.opentracing.contrib.aws.xray;
2 |
3 | import io.opentracing.SpanContext;
4 |
5 | import java.util.HashMap;
6 | import java.util.Map;
7 |
8 | /**
9 | * In AWS, the span context usually only needs to hold the trace header
10 | * information (current trace ID, parent segment ID, sampling decision) such
11 | * that this can be propagated to child processes.
12 | *
13 | * @author ashley.mercer@skylightipv.com
14 | * @see io.opentracing.SpanContext
15 | * @see com.amazonaws.xray.entities.TraceHeader
16 | */
17 | class AWSXRaySpanContext implements SpanContext {
18 |
19 | private final Map baggage;
20 |
21 | AWSXRaySpanContext(Map baggage) {
22 | this.baggage = new HashMap<>(baggage);
23 | }
24 |
25 | @Override
26 | public Iterable> baggageItems() {
27 | return baggage.entrySet();
28 | }
29 |
30 | Map getBaggage() {
31 | return baggage;
32 | }
33 |
34 | void setBaggageItem(String key, String value) {
35 | baggage.put(key, value);
36 | }
37 |
38 | String getBaggageItem(String key) {
39 | return baggage.get(key);
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/src/main/java/io/opentracing/contrib/aws/xray/AWSXRayTags.java:
--------------------------------------------------------------------------------
1 | package io.opentracing.contrib.aws.xray;
2 |
3 | import com.amazonaws.xray.entities.Entity;
4 | import com.amazonaws.xray.entities.Segment;
5 | import io.opentracing.tag.BooleanTag;
6 | import io.opentracing.tag.StringTag;
7 |
8 | /**
9 | * Additional known tags which are specific to AWS X-Ray. In general, users
10 | * should prefer the standard OpenTracing tag names and conventions, but it
11 | * can be useful to sometimes take advantage of X-Ray specific functionality.
12 | *
13 | * @author ashley.mercer@skylightipv.com
14 | */
15 | @SuppressWarnings("WeakerAccess")
16 | public final class AWSXRayTags {
17 |
18 | private AWSXRayTags(){}
19 |
20 | /**
21 | * FAULT indicates whether or not a Span ended in a fault
22 | * (non-recoverable exception) state.
23 | *
24 | * @see Entity#isFault()
25 | */
26 | public static final BooleanTag FAULT = new BooleanTag("fault");
27 |
28 | /**
29 | * THROTTLE indicates that the underlying request was throttled,
30 | * usually caused by resource constraints.
31 | *
32 | * @see Entity#isThrottle()
33 | */
34 | public static final BooleanTag THROTTLE = new BooleanTag("throttle");
35 |
36 | /**
37 | * IS_SAMPLED indicates that the current trace segment should be
38 | * subject to sampling by X-Ray.
39 | *
40 | * @see Segment#isSampled()
41 | */
42 | public static final BooleanTag IS_SAMPLED = new BooleanTag("isSampled");
43 |
44 | /**
45 | * USER is the identifier for the user who initiated this request,
46 | * typically a logged-in website user or IAM username. Should only be
47 | * set on top-level trace Spans.
48 | *
49 | * @see Segment#getUser()
50 | */
51 | public static final StringTag USER = new StringTag("user");
52 |
53 | /**
54 | * ORIGIN indicates the type of AWS resource running the application,
55 | * value is typically something like "AWS::EC2::Instance". Should only
56 | * be set on top-level trace Spans.
57 | *
58 | * @see Segment#getOrigin()
59 | */
60 | public static final StringTag ORIGIN = new StringTag("origin");
61 |
62 | /**
63 | * PARENT_ID is the unique identifier for the parent span (as
64 | * distinct from the ID of the whole trace).
65 | *
66 | * @see Entity#getParentId()
67 | */
68 | public static final StringTag PARENT_ID = new StringTag("parentId");
69 | }
70 |
--------------------------------------------------------------------------------
/src/main/java/io/opentracing/contrib/aws/xray/AWSXRayTracer.java:
--------------------------------------------------------------------------------
1 | package io.opentracing.contrib.aws.xray;
2 |
3 | import com.amazonaws.xray.AWSXRayRecorder;
4 | import com.amazonaws.xray.contexts.LambdaSegmentContext;
5 | import com.amazonaws.xray.entities.*;
6 | import io.opentracing.*;
7 | import io.opentracing.propagation.Format;
8 | import io.opentracing.propagation.TextMap;
9 | import org.slf4j.Logger;
10 | import org.slf4j.LoggerFactory;
11 |
12 | import java.time.Instant;
13 | import java.util.Collections;
14 | import java.util.HashMap;
15 | import java.util.Map;
16 | import java.util.concurrent.ConcurrentHashMap;
17 | import java.util.concurrent.atomic.AtomicReference;
18 |
19 | /**
20 | * Top-level OpenTracing {@link Tracer} implementation which is backed
21 | * by the AWS X-Ray client libraries.
22 | *
23 | * @see https://opentracing.io
24 | * @see https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html
25 | * @author ashley.mercer@skylightipv.com
26 | */
27 | @SuppressWarnings("WeakerAccess")
28 | public class AWSXRayTracer implements Tracer {
29 |
30 | private static final Logger log = LoggerFactory.getLogger(AWSXRayTracer.class);
31 |
32 | private final AWSXRayRecorder xRayRecorder;
33 | private final AWSXRayScopeManager scopeManager;
34 |
35 | public AWSXRayTracer(AWSXRayRecorder xRayRecorder) {
36 | this.xRayRecorder = xRayRecorder;
37 | this.scopeManager = new AWSXRayScopeManager(xRayRecorder);
38 | }
39 |
40 | @Override
41 | public ScopeManager scopeManager() {
42 | return scopeManager;
43 | }
44 |
45 | @Override
46 | public Span activeSpan() {
47 | return scopeManager.activeSpan();
48 | }
49 |
50 | @Override
51 | public SpanBuilder buildSpan(String operationName) {
52 | return new AWSXRaySpanBuilderImpl(operationName);
53 | }
54 |
55 | @Override
56 | public void inject(SpanContext spanContext, Format format, C carrier) {
57 | if (format == Format.Builtin.TEXT_MAP || format == Format.Builtin.HTTP_HEADERS) {
58 | final TextMap textMap = (TextMap) carrier;
59 | spanContext.baggageItems().forEach(e -> textMap.put(e.getKey(), e.getValue()));
60 | }
61 | else {
62 | throw new UnsupportedOperationException("Format " + format.toString() + " is not currently supported");
63 | }
64 | }
65 |
66 | @Override
67 | public SpanContext extract(Format format, C carrier) {
68 | if (format == Format.Builtin.TEXT_MAP || format == Format.Builtin.HTTP_HEADERS) {
69 | final TextMap textMap = (TextMap) carrier;
70 | final Map baggage = new HashMap<>();
71 | for (Map.Entry e : textMap) { baggage.put(e.getKey(), e.getValue()); }
72 | return new AWSXRaySpanContext(baggage);
73 | }
74 | else {
75 | throw new UnsupportedOperationException("Format " + format.toString() + " is not currently supported");
76 | }
77 | }
78 |
79 | /**
80 | * AWS-specific {@link io.opentracing.Tracer.SpanBuilder} implementation
81 | */
82 | private final class AWSXRaySpanBuilderImpl implements SpanBuilder {
83 |
84 | private final String operationName;
85 |
86 | private final Map stringTags;
87 | private final Map booleanTags;
88 | private final Map numberTags;
89 |
90 | /**
91 | * AWS X-Ray timestamps are stored a number of seconds since
92 | * the UNIX epoch, with the fractional part giving sub-second
93 | * precision. Defaults to creation time of this builder.
94 | *
95 | * @see #withStartTimestamp(long)
96 | * @see Entity#getStartTime()
97 | */
98 | private final AtomicReference startTimestampEpochSeconds;
99 |
100 | /**
101 | * @see SpanBuilder#ignoreActiveSpan()
102 | */
103 | private final AtomicReference ignoreActiveSpan;
104 |
105 | /**
106 | * Currently only support a single reference to the parent Span (if
107 | * it exists). Other references are not supported.
108 | *
109 | * @see References
110 | */
111 | private final Map references;
112 |
113 | private AWSXRaySpanBuilderImpl(String operationName) {
114 | this.operationName = operationName;
115 |
116 | this.stringTags = new HashMap<>();
117 | this.booleanTags = new HashMap<>();
118 | this.numberTags = new HashMap<>();
119 |
120 | this.startTimestampEpochSeconds = new AtomicReference<>();
121 | this.ignoreActiveSpan = new AtomicReference<>(false);
122 | this.references = new ConcurrentHashMap<>();
123 | }
124 |
125 | @Override
126 | public SpanBuilder asChildOf(SpanContext parent) {
127 | return addReference(References.CHILD_OF, parent);
128 | }
129 |
130 | @Override
131 | public SpanBuilder asChildOf(Span parent) {
132 | if (parent == null) {
133 | return this;
134 | }
135 | else if (parent instanceof AWSXRaySpan) {
136 | return addReference(References.CHILD_OF, new CapturingSpanContext((AWSXRaySpan) parent));
137 | }
138 | else {
139 | return addReference(References.CHILD_OF, parent.context());
140 | }
141 | }
142 |
143 | @Override
144 | public SpanBuilder addReference(String referenceType, SpanContext referencedContext) {
145 | if (references.containsKey(referenceType)) {
146 | log.warn("Replacing reference of type '" + referenceType + "': multiple references of the same type are not supported by X-Ray");
147 | }
148 | references.put(referenceType, referencedContext);
149 | return this;
150 | }
151 |
152 | @Override
153 | public SpanBuilder ignoreActiveSpan() {
154 | ignoreActiveSpan.set(true);
155 | return this;
156 | }
157 |
158 | @Override
159 | public SpanBuilder withTag(String key, String value) {
160 | stringTags.put(key, value);
161 | return this;
162 | }
163 |
164 | @Override
165 | public SpanBuilder withTag(String key, boolean value) {
166 | booleanTags.put(key, value);
167 | return this;
168 | }
169 |
170 | @Override
171 | public SpanBuilder withTag(String key, Number value) {
172 | numberTags.put(key, value);
173 | return this;
174 | }
175 |
176 | @Override
177 | public SpanBuilder withStartTimestamp(long microseconds) {
178 | startTimestampEpochSeconds.set(microseconds / 1000.0 / 1000.0);
179 | return this;
180 | }
181 |
182 | @Override
183 | @Deprecated
184 | public Span startManual() {
185 | return start();
186 | }
187 |
188 | @Override
189 | public Scope startActive(boolean finishSpanOnClose) {
190 | final Span span = start();
191 | return scopeManager.activate(span, finishSpanOnClose);
192 | }
193 |
194 | @Override
195 | public Span start() {
196 |
197 | // X-Ray only supports parent-child relationships between spans
198 | // (OpenTracing allows for other references e.g. FOLLOWS_FROM)
199 | references.forEach((key, value) -> {
200 | if (!References.CHILD_OF.equals(key)) {
201 | log.warn("Ignoring reference of type '" + key + "': references of this type are not supported by X-Ray");
202 | }
203 | });
204 |
205 | // If an explicit CHILD_OF reference is set, this should override
206 | // any (implicit) reference to the current trace entity
207 | final Entity originalTraceEntity = xRayRecorder.getTraceEntity();
208 | final SpanContext explicitParentContext = references.get(References.CHILD_OF);
209 |
210 | final Entity parentEntity;
211 | final Map parentBaggage;
212 |
213 | // Because X-Ray an OpenTracing maintain their references to the
214 | // "current" trace separately, we can be in one of four possible states:
215 | //
216 | // 1. an explicit parent is set, and it has captured a full AWSXRaySpan
217 | // i.e. this is an in-memory Span with a real X-Ray Entity
218 | //
219 | if (explicitParentContext instanceof CapturingSpanContext) {
220 | parentEntity = ((CapturingSpanContext) explicitParentContext).span.getEntity();
221 | parentBaggage = AWSXRayUtils.extract(explicitParentContext.baggageItems());
222 | }
223 |
224 | // 2. an explicit parent is set but it doesn't have an X-Ray Entity
225 | // attached: we can present a FacadeSegment to X-Ray
226 | //
227 | else if (explicitParentContext != null) {
228 |
229 | // If the parent context has a valid AWS trace ID in its baggage
230 | // (e.g. it came from some remote upstream server) then extract
231 | // the trace and parent segment IDs here
232 | TraceHeader traceHeader = null;
233 | for (Map.Entry e : explicitParentContext.baggageItems()) {
234 | if (TraceHeader.HEADER_KEY.equals(e.getKey())) {
235 | traceHeader = TraceHeader.fromString(e.getValue());
236 | }
237 | }
238 | final TraceID traceId = null == traceHeader ? null : traceHeader.getRootTraceId();
239 | final String parentId = null == traceHeader ? null : traceHeader.getParentId();
240 | final TraceHeader.SampleDecision sampleDecision = traceHeader == null ? null : traceHeader.getSampled();
241 |
242 | // NB the default FacadeSegment class throws exceptions but we want
243 | // to allow subsegments to be added and removed (even though both
244 | // of these are ultimately a no-op)
245 | parentEntity = new FacadeSegment(xRayRecorder, traceId, parentId, sampleDecision) {
246 | @Override public void addSubsegment(Subsegment subsegment) {}
247 | @Override public void removeSubsegment(Subsegment subsegment) {}
248 | };
249 | parentBaggage = AWSXRayUtils.extract(explicitParentContext.baggageItems());
250 | }
251 |
252 | // 3. no explicit parent is set, but ignoreActiveSpan has been set so
253 | // make sure the parent Entity is null (i.e. we'll create a new
254 | // Segment in X-Ray terms)
255 | //
256 | else if (ignoreActiveSpan.get()) {
257 | parentEntity = null;
258 | parentBaggage = Collections.emptyMap();
259 | }
260 |
261 | // 4. no explicit parent, and ignoreActiveSpan is not set so create an
262 | // implicit reference to the current trace entity (if it exists:
263 | // if it's null we'll instead end up creating a top-level Segment
264 | // instead)
265 | //
266 | else {
267 | parentEntity = originalTraceEntity;
268 | parentBaggage = Collections.emptyMap();
269 | }
270 |
271 | // X-Ray automatically maintains internal references between Segments and
272 | // Subsegments - rather than trying to replicate that logic here, we cheat
273 | // by (temporarily) overwriting the parent trace Entity, creating the new
274 | // Entity, then setting it back once we're done
275 | xRayRecorder.setTraceEntity(parentEntity);
276 |
277 | // Special case when running in AWS Lambda: the Lambda infrastructure
278 | // creates a top-level trace Segment to which we do not have access, so
279 | // creating another Segment here would be an error. Instead, we need to
280 | // forcibly create a Subsegment.
281 | final boolean isAwsLambda = xRayRecorder.getSegmentContextResolverChain().resolve() instanceof LambdaSegmentContext;
282 |
283 | final Entity childEntity = (xRayRecorder.getTraceEntity() == null && !isAwsLambda) ?
284 | xRayRecorder.beginSegment(operationName) :
285 | xRayRecorder.beginSubsegment(operationName);
286 |
287 | // Set the original trace entity back on AWSXRayRecorder as soon as possible
288 | xRayRecorder.setTraceEntity(originalTraceEntity);
289 |
290 | // AWS X-Ray doesn't support the notion of "not-yet-started" segments
291 | // so set the Entity to be "in progress"
292 | childEntity.setInProgress(true);
293 |
294 | // Default to "now" if an explicit start time wasn't set
295 | startTimestampEpochSeconds.compareAndSet(null, Instant.now().toEpochMilli() / 1000.0);
296 | childEntity.setStartTime(startTimestampEpochSeconds.get());
297 |
298 | // Baggage items should mostly be carried over from the parent Span's
299 | // context (if it exists) to the child Span; however, the TraceHeader
300 | // should be replaced with the new value for the child span
301 | final TraceHeader traceHeader = new TraceHeader(
302 | childEntity.getParentSegment().getTraceId(),
303 | null == parentEntity ? null : parentEntity.getId(),
304 | childEntity.getParentSegment().isSampled() ? TraceHeader.SampleDecision.SAMPLED : TraceHeader.SampleDecision.NOT_SAMPLED
305 | );
306 |
307 | final Map childBaggage = new HashMap<>(parentBaggage);
308 | childBaggage.put(TraceHeader.HEADER_KEY, traceHeader.toString());
309 |
310 | final AWSXRaySpanContext newSpanContext = new AWSXRaySpanContext(childBaggage);
311 |
312 | // Defer to AWSXRaySpan to set tag values since this will handle
313 | // converting to X-Ray's naming conventions and format
314 | final AWSXRaySpan newSpan = new AWSXRaySpan(childEntity, newSpanContext);
315 | stringTags.forEach(newSpan::setTag);
316 | booleanTags.forEach(newSpan::setTag);
317 | numberTags.forEach(newSpan::setTag);
318 |
319 | return newSpan;
320 | }
321 | }
322 |
323 | /**
324 | * Parent-child relationships between Spans are typically only defined in
325 | * terms of the SpanContext (i.e. we only need to know the parent span's
326 | * trace and span ID). However, X-Ray also holds directly object references
327 | * to the underlying Segment and Subsegment instances, so try to capture
328 | * the full AWSXRaySpan instance here if we can.
329 | */
330 | private static final class CapturingSpanContext implements SpanContext {
331 | private final AWSXRaySpan span;
332 |
333 | public CapturingSpanContext(AWSXRaySpan span) {
334 | this.span = span;
335 | }
336 |
337 | @Override
338 | public Iterable> baggageItems() {
339 | return span.context().baggageItems();
340 | }
341 | }
342 | }
343 |
--------------------------------------------------------------------------------
/src/main/java/io/opentracing/contrib/aws/xray/AWSXRayUtils.java:
--------------------------------------------------------------------------------
1 | package io.opentracing.contrib.aws.xray;
2 |
3 | import io.opentracing.SpanContext;
4 |
5 | import java.util.Collections;
6 | import java.util.HashMap;
7 | import java.util.Map;
8 |
9 | /**
10 | * @author ashley.mercer@skylightipv.com
11 | */
12 | @SuppressWarnings("WeakerAccess")
13 | public final class AWSXRayUtils {
14 |
15 | private AWSXRayUtils(){}
16 |
17 | /**
18 | * Utility method to copy baggage values from a {@link SpanContext}
19 | * back into a vanilla Map, which is much easier to work with.
20 | *
21 | * @param baggage the view of underlying baggage
22 | * @return a new, unmodifiable Map instance containing all
23 | * of the values copied from the underlying baggage
24 | */
25 | public static Map extract(Iterable> baggage) {
26 | final Map targetMap = new HashMap<>();
27 | baggage.forEach(e -> targetMap.put(e.getKey(), e.getValue()));
28 | return Collections.unmodifiableMap(targetMap);
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/src/main/java/io/opentracing/contrib/tag/ExtraTags.java:
--------------------------------------------------------------------------------
1 | package io.opentracing.contrib.tag;
2 |
3 | import io.opentracing.tag.IntTag;
4 | import io.opentracing.tag.StringTag;
5 |
6 | /**
7 | * Additional suggested standard tag names that conform to
8 | * the OpenTracing naming patterns.
9 | *
10 | * @author ashley.mercer@skylightipv.com
11 | */
12 | public final class ExtraTags {
13 |
14 | private ExtraTags(){}
15 |
16 | /**
17 | * VERSION records the software version of the current application
18 | */
19 | public static final StringTag VERSION = new StringTag("version");
20 |
21 | /**
22 | * DB_DRIVER records the name and / or version number of the client-side
23 | * database driver
24 | */
25 | public static final StringTag DB_DRIVER = new StringTag("db.driver");
26 |
27 | /**
28 | * DB_VERSION captures the database server-side version String
29 | */
30 | public static final StringTag DB_VERSION = new StringTag("db.version");
31 |
32 | /**
33 | * HTTP_CLIENT_IP records the IP address of the requester, could be captured
34 | * e.g. from the IP packet's 'Source Address' or the X-Forwarded-For header
35 | */
36 | public static final StringTag HTTP_CLIENT_IP = new StringTag("http.client_ip");
37 |
38 | /**
39 | * HTTP_USER_AGENT records the HTTP client's User-Agent header
40 | */
41 | public static final StringTag HTTP_USER_AGENT = new StringTag("http.user_agent");
42 |
43 | /**
44 | * HTTP_CONTENT_LENGTH records the number of bytes returned to the client
45 | * by the server over the course of the request
46 | */
47 | public static final IntTag HTTP_CONTENT_LENGTH = new IntTag("http.content_length");
48 | }
49 |
--------------------------------------------------------------------------------
/src/test/java/io/opentracing/contrib/aws/xray/AWSXRaySpanBuilderTests.java:
--------------------------------------------------------------------------------
1 | package io.opentracing.contrib.aws.xray;
2 |
3 | import com.amazonaws.xray.AWSXRayRecorder;
4 | import com.amazonaws.xray.AWSXRayRecorderBuilder;
5 | import com.amazonaws.xray.entities.Entity;
6 | import com.amazonaws.xray.entities.Segment;
7 | import com.amazonaws.xray.entities.TraceHeader;
8 | import io.opentracing.Scope;
9 | import io.opentracing.Span;
10 | import io.opentracing.SpanContext;
11 | import org.junit.jupiter.api.DisplayName;
12 | import org.junit.jupiter.api.Test;
13 |
14 | import java.util.Collections;
15 | import java.util.Map;
16 |
17 | import static org.junit.jupiter.api.Assertions.*;
18 |
19 | /**
20 | * @author ashley.mercer@skylightipv.com
21 | */
22 | class AWSXRaySpanBuilderTests extends AWSXRayTestParent {
23 |
24 | private final AWSXRayRecorder recorder = AWSXRayRecorderBuilder.defaultRecorder();
25 | private final AWSXRayTracer tracer = new AWSXRayTracer(recorder);
26 |
27 | @Test
28 | @DisplayName("set span name")
29 | void setSpanName() {
30 | final Span span = tracer
31 | .buildSpan("test-span-name")
32 | .start();
33 |
34 | assertEquals("test-span-name", ((AWSXRaySpan) span).getEntity().getName());
35 | }
36 |
37 | @Test
38 | @DisplayName("set active span")
39 | void setActiveSpan() {
40 | final Scope activeScope = tracer
41 | .buildSpan("test-active-span")
42 | .startActive(true);
43 |
44 | assertEquals(activeScope.span(), tracer.activeSpan());
45 |
46 | activeScope.close();
47 | }
48 |
49 | @Test
50 | @DisplayName("set trace header in baggage")
51 | void setTraceHeaderInBaggage() {
52 | final Scope activeScope = tracer
53 | .buildSpan("test-trace-header")
54 | .startActive(true);
55 |
56 | final String activeTraceHeader = activeScope.span().getBaggageItem(TraceHeader.HEADER_KEY);
57 | assertNotNull(activeTraceHeader);
58 | assertTrue(activeTraceHeader.contains(((AWSXRaySpan) activeScope.span()).getEntity().getTraceId().toString()));
59 |
60 | activeScope.close();
61 | }
62 |
63 | @Test
64 | @DisplayName("set implicit active span as parent")
65 | void setImplicitParentSpan() {
66 | final Scope parentScope = tracer
67 | .buildSpan("parent-span")
68 | .startActive(true);
69 |
70 | final Scope childScope = tracer
71 | .buildSpan("child-span")
72 | .startActive(true);
73 |
74 | final Entity parentEntity = ((AWSXRayScope) parentScope).span().getEntity();
75 | final Entity childEntity = ((AWSXRayScope) childScope).span().getEntity();
76 |
77 | assertFalse(parentEntity.getSubsegments().isEmpty());
78 | assertEquals(parentEntity, childEntity.getParent());
79 | assertEquals(parentEntity.getTraceId(), childEntity.getParent().getTraceId());
80 |
81 | // Check that trace header is correctly set in the child
82 | final String childTraceHeader = childScope.span().getBaggageItem(TraceHeader.HEADER_KEY);
83 | assertNotNull(childTraceHeader);
84 | assertTrue(childTraceHeader.contains(parentEntity.getTraceId().toString()));
85 | assertTrue(childTraceHeader.contains(parentEntity.getId()));
86 |
87 | childScope.close();
88 | parentScope.close();
89 | }
90 |
91 | @Test
92 | @DisplayName("set explicit span as parent")
93 | void setExplicitParentSpan() {
94 |
95 | // NB we *don't* startActive here - assume this Span
96 | // object came from somewhere else in the code
97 | final AWSXRaySpan explicitParentSpan = mockSpan("explicit-parent-span");
98 |
99 | // This implicit parent should be ignored by SpanBuilder
100 | // when we set the explicit parent
101 | final Scope implicitParentScope = tracer
102 | .buildSpan("implicit-parent-span")
103 | .startActive(true);
104 |
105 | final Scope childScope = tracer
106 | .buildSpan("child-span")
107 | .asChildOf(explicitParentSpan)
108 | .startActive(true);
109 |
110 | final Entity explicitParentEntity = explicitParentSpan.getEntity();
111 | final Entity implicitParentEntity = ((AWSXRayScope) implicitParentScope).span().getEntity();
112 | final Entity childEntity = ((AWSXRayScope) childScope).span().getEntity();
113 |
114 | assertFalse(explicitParentEntity.getSubsegments().isEmpty());
115 | assertTrue(implicitParentEntity.getSubsegments().isEmpty());
116 |
117 | assertEquals(explicitParentEntity, childEntity.getParent());
118 | assertNotEquals(explicitParentEntity.getId(), childEntity.getId());
119 |
120 | // Check that trace header is correctly set in the child
121 | final String childTraceHeader = childScope.span().getBaggageItem(TraceHeader.HEADER_KEY);
122 | assertNotNull(childTraceHeader);
123 | assertTrue(childTraceHeader.contains(explicitParentEntity.getTraceId().toString()));
124 | assertTrue(childTraceHeader.contains(explicitParentEntity.getId()));
125 |
126 | childScope.close();
127 | implicitParentScope.close();
128 | }
129 |
130 | @Test
131 | @DisplayName("set explicit span as parent from remote server")
132 | void setExplicitParentSpanFromRemote() {
133 |
134 | // SpanContext can be passed to remote servers using inject() and
135 | // extract(), so assume we read this in from e.g. HTTP headers
136 | final SpanContext remoteContext = new AWSXRaySpanContext(Collections.singletonMap(
137 | TraceHeader.HEADER_KEY,
138 | traceHeader.toString()
139 | ));
140 |
141 | final Scope childScope = tracer
142 | .buildSpan("child-span")
143 | .asChildOf(remoteContext)
144 | .startActive(true);
145 |
146 | final Entity childEntity = ((AWSXRayScope) childScope).span().getEntity();
147 |
148 | assertEquals(childEntity.getParentSegment().getTraceId(), traceHeader.getRootTraceId());
149 | assertEquals(childEntity.getParentSegment().getId(), traceHeader.getParentId());
150 |
151 | // Check that trace header is correctly set in the child
152 | final String childTraceHeader = childScope.span().getBaggageItem(TraceHeader.HEADER_KEY);
153 | assertNotNull(childTraceHeader);
154 |
155 | childScope.close();
156 | }
157 |
158 | @Test
159 | @DisplayName("ignore implicit active span on ignoreActiveSpan")
160 | void ignoreImplicitParentSpan() {
161 | final Scope parentScope = tracer
162 | .buildSpan("parent-span")
163 | .startActive(true);
164 |
165 | final Scope childScope = tracer
166 | .buildSpan("child-span")
167 | .ignoreActiveSpan()
168 | .startActive(true);
169 |
170 | final Entity parentEntity = ((AWSXRayScope) parentScope).span().getEntity();
171 | final Entity childEntity = ((AWSXRayScope) childScope).span().getEntity();
172 |
173 | assertTrue(parentEntity.getSubsegments().isEmpty());
174 | assertNull(childEntity.getParent());
175 | assertNotEquals(parentEntity.getParentSegment().getTraceId(), childEntity.getParentSegment().getTraceId());
176 |
177 | // Check that trace header is correctly set in the child
178 | final String childTraceHeader = childScope.span().getBaggageItem(TraceHeader.HEADER_KEY);
179 | assertNotNull(childTraceHeader);
180 | assertTrue(childTraceHeader.contains(childEntity.getParentSegment().getTraceId().toString()));
181 | assertFalse(childTraceHeader.contains(parentEntity.getParentSegment().getTraceId().toString()));
182 | assertFalse(childTraceHeader.contains(parentEntity.getId()));
183 |
184 | childScope.close();
185 | parentScope.close();
186 | }
187 |
188 | /**
189 | * In systems where the surrounding code is using X-Ray directly, but
190 | * not the OpenTracing API, we should detect if a trace is already in
191 | * progress. For example, in AWS Lambda functions, the lambda server
192 | * creates a top-level trace segment for the whole function call
193 | *
194 | * @see https://docs.aws.amazon.com/xray/latest/devguide/xray-services-lambda.html
195 | */
196 | @Test
197 | @DisplayName("detect a pre-existing X-Ray trace")
198 | void detectPreExisting() {
199 | final Segment parentEntity = awsxRayRecorder.beginSegment("pre-existing-trace");
200 |
201 | final Scope childScope = tracer
202 | .buildSpan("child-of-pre-existing-trace")
203 | .startActive(true);
204 |
205 | final Entity childEntity = ((AWSXRayScope) childScope).span().getEntity();
206 |
207 | assertFalse(parentEntity.getSubsegments().isEmpty());
208 | assertEquals(parentEntity, childEntity.getParent());
209 |
210 | // Check that trace header is correctly set in the child
211 | final String childTraceHeader = childScope.span().getBaggageItem(TraceHeader.HEADER_KEY);
212 | assertNotNull(childTraceHeader);
213 | assertTrue(childTraceHeader.contains(parentEntity.getTraceId().toString()));
214 | assertTrue(childTraceHeader.contains(parentEntity.getId()));
215 |
216 | childScope.close();
217 | }
218 |
219 | @Test
220 | @DisplayName("set tags correctly")
221 | @SuppressWarnings("unchecked")
222 | void setTags() {
223 | final Scope scope = tracer
224 | .buildSpan("test-set-tags")
225 | .withTag("http.request.method", "POST")
226 | .withTag("http.response.status_code", 503)
227 | .withTag("fault", true)
228 | .startActive(true);
229 |
230 | final Entity entity = ((AWSXRayScope) scope).span().getEntity();
231 | assertEquals("POST", ((Map) entity.getHttp().get("request")).get("method"));
232 | assertEquals(503, ((Map) entity.getHttp().get("response")).get("status_code"));
233 | assertTrue(entity.isFault());
234 |
235 | scope.close();
236 | }
237 |
238 | @Test
239 | @DisplayName("set start timestamp correctly")
240 | void setStartTimestamp() {
241 | final Scope scope = tracer
242 | .buildSpan("test-set-start-timestamp")
243 | .withStartTimestamp(1551016321000000L)
244 | .startActive(true);
245 |
246 | final Entity entity = ((AWSXRayScope) scope).span().getEntity();
247 | assertEquals(1551016321.0, entity.getStartTime());
248 |
249 | scope.close();
250 | }
251 | }
252 |
--------------------------------------------------------------------------------
/src/test/java/io/opentracing/contrib/aws/xray/AWSXRaySpanTests.java:
--------------------------------------------------------------------------------
1 | package io.opentracing.contrib.aws.xray;
2 |
3 | import com.amazonaws.xray.entities.Segment;
4 | import io.opentracing.log.Fields;
5 | import io.opentracing.tag.Tags;
6 | import org.junit.jupiter.api.DisplayName;
7 | import org.junit.jupiter.api.Test;
8 |
9 | import java.time.Instant;
10 | import java.util.HashMap;
11 | import java.util.Map;
12 | import java.util.function.Function;
13 |
14 | import static org.junit.jupiter.api.Assertions.*;
15 |
16 | /**
17 | * @author ashley.mercer@skylightipv.com
18 | */
19 | class AWSXRaySpanTests extends AWSXRayTestParent {
20 |
21 | @Test
22 | @DisplayName("set ERROR tag on underlying Entity")
23 | void tagError() {
24 | final AWSXRaySpan span = mockSpan("test-tag-is-error");
25 | span.setTag(Tags.ERROR.getKey(), true);
26 |
27 | assertTrue(span.getEntity().isError());
28 | assertFalse(span.getEntity().isFault());
29 | }
30 |
31 | @Test
32 | @DisplayName("set FAULT tag on underlying Entity")
33 | void tagFault() {
34 | final AWSXRaySpan span = mockSpan("test-tag-is-fault");
35 | span.setTag(AWSXRayTags.FAULT.getKey(), true);
36 |
37 | assertFalse(span.getEntity().isError());
38 | assertTrue(span.getEntity().isFault());
39 | }
40 |
41 | @Test
42 | @DisplayName("set THROTTLE tag on underlying Entity")
43 | void tagThrottle() {
44 | final AWSXRaySpan span = mockSpan("test-tag-is-throttle");
45 | span.setTag(AWSXRayTags.THROTTLE.getKey(), true);
46 |
47 | assertFalse(span.getEntity().isFault());
48 | assertTrue(span.getEntity().isThrottle());
49 | }
50 |
51 | @Test
52 | @DisplayName("set IS_SAMPLED tag on underlying Entity")
53 | void tagSampled() {
54 | final AWSXRaySpan span = mockSpan("test-tag-is-sampled");
55 | assertTrue(span.getEntity() instanceof Segment);
56 |
57 | span.setTag(AWSXRayTags.IS_SAMPLED.getKey(), false);
58 | assertFalse(((Segment) span.getEntity()).isSampled());
59 |
60 | span.setTag(AWSXRayTags.IS_SAMPLED.getKey(), true);
61 | assertTrue(((Segment) span.getEntity()).isSampled());
62 | }
63 |
64 | @Test
65 | @DisplayName("set USER tag on underlying Entity")
66 | void tagUser() {
67 | final String expectedUser = "test.user@example.com";
68 |
69 | final AWSXRaySpan span = mockSpan("test-tag-user");
70 | span.setTag(AWSXRayTags.USER.getKey(), expectedUser);
71 |
72 | assertTrue(span.getEntity() instanceof Segment);
73 | assertEquals(expectedUser, ((Segment) span.getEntity()).getUser());
74 | }
75 |
76 | @Test
77 | @DisplayName("set ORIGIN tag on underlying Entity")
78 | void tagOrigin() {
79 | final String expectedOrigin = "AWS::EC2::Instance";
80 |
81 | final AWSXRaySpan span = mockSpan("test-tag-origin");
82 | span.setTag(AWSXRayTags.ORIGIN.getKey(), expectedOrigin);
83 |
84 | assertTrue(span.getEntity() instanceof Segment);
85 | assertEquals(expectedOrigin, ((Segment) span.getEntity()).getOrigin());
86 | }
87 |
88 | @Test
89 | @DisplayName("set PARENT_ID tag on underlying Entity")
90 | void tagParentId() {
91 | final String expectedParentId = "";
92 |
93 | final AWSXRaySpan span = mockSpan("test-tag-parent-id");
94 | span.setTag(AWSXRayTags.PARENT_ID.getKey(), expectedParentId);
95 |
96 | assertEquals(expectedParentId, span.getEntity().getParentId());
97 | }
98 |
99 | @Test
100 | @DisplayName("tag annotations values")
101 | void tagAnnotations() {
102 | testSpecialTags("annotations", s -> s.getEntity().getAnnotations());
103 | }
104 |
105 | @Test
106 | @DisplayName("tag AWS values")
107 | void tagAws() {
108 | testSpecialTags("aws", s -> s.getEntity().getAws());
109 | }
110 |
111 | @Test
112 | @DisplayName("tag HTTP values")
113 | void tagHTTP() {
114 | testSpecialTags("http", s -> s.getEntity().getHttp());
115 | }
116 |
117 | @Test
118 | @DisplayName("tag service values")
119 | void tagService() {
120 | testSpecialTags("service", s -> ((Segment) s.getEntity()).getService());
121 | }
122 |
123 | @Test
124 | @DisplayName("tag SQL values")
125 | void tagSQL() {
126 | testSpecialTags("sql", s -> s.getEntity().getSql());
127 | }
128 |
129 | @Test
130 | @DisplayName("tag metadata with empty key")
131 | void tagMetadataEmptyKey() {
132 | testMetadataTags("", AWSXRayMetadataNamespaces.DEFAULT, "");
133 | }
134 |
135 | @Test
136 | @DisplayName("tag metadata with no prefix, no namespace")
137 | void tagMetadataNoPrefixNoNamespace() {
138 | testMetadataTags("foo", AWSXRayMetadataNamespaces.DEFAULT, "foo");
139 | }
140 | @Test
141 | @DisplayName("tag metadata with no prefix, no namespace, key=metadata")
142 | void tagMetadataNoPrefixNoNamespaceAsNamespace() {
143 | testMetadataTags("metadata", AWSXRayMetadataNamespaces.DEFAULT, "metadata");
144 | }
145 |
146 | @Test
147 | @DisplayName("tag metadata with no namespace")
148 | void tagMetadataNoNamespace() {
149 | testMetadataTags("metadata.foo", AWSXRayMetadataNamespaces.DEFAULT, "foo");
150 | }
151 |
152 | @Test
153 | @DisplayName("tag metadata with no prefix")
154 | void tagMetadataNoPrefix() {
155 | testMetadataTags("bar.foo", "bar", "foo");
156 | }
157 |
158 | @Test
159 | @DisplayName("tag metadata with full name")
160 | void tagMetadataFullName() {
161 | testMetadataTags("metadata.bar.foo", "bar", "foo");
162 | }
163 |
164 | @Test
165 | @DisplayName("tag metadata with nested key")
166 | void tagMetadataNestedKey() {
167 | final AWSXRaySpan span = mockSpan("test-tag-metadata-nested-key");
168 | span.setTag("metadata.default.nested.is_test", true);
169 | span.setTag("metadata.default.nested.counter", 42);
170 | span.setTag("metadata.default.nested.service", "backend");
171 |
172 | @SuppressWarnings("unchecked")
173 | final Map targetMap = (Map) span.getEntity().getMetadata().get(AWSXRayMetadataNamespaces.DEFAULT).get("nested");
174 | assertEquals(true, targetMap.get("is_test"));
175 | assertEquals(42, targetMap.get("counter"));
176 | assertEquals("backend", targetMap.get("service"));
177 | }
178 |
179 | private void testSpecialTags(String keyPrefix, Function> getTargetMap) {
180 | final AWSXRaySpan span = mockSpan("test-tag-" + keyPrefix);
181 | span.setTag(keyPrefix + ".is_test", true);
182 | span.setTag(keyPrefix + ".counter", 42);
183 | span.setTag(keyPrefix + ".service", "backend");
184 |
185 | final Map targetMap = getTargetMap.apply(span);
186 | assertEquals(true, targetMap.get("is_test"));
187 | assertEquals(42, targetMap.get("counter"));
188 | assertEquals("backend", targetMap.get("service"));
189 | }
190 |
191 | private void testMetadataTags(String fullKey, String expectedNamespace, String expectedKey) {
192 | final AWSXRaySpan span = mockSpan("test-tag-metadata-" + fullKey.replaceAll("\\.", "-"));
193 | span.setTag(fullKey + "_boolean", true);
194 | span.setTag(fullKey + "_number", 42);
195 | span.setTag(fullKey + "_string", "backend");
196 |
197 | final Map targetMap = span.getEntity().getMetadata().get(expectedNamespace);
198 | assertEquals(true, targetMap.get(expectedKey + "_boolean"));
199 | assertEquals(42, targetMap.get(expectedKey + "_number"));
200 | assertEquals("backend", targetMap.get(expectedKey + "_string"));
201 | }
202 |
203 | private final String LOG_MESSAGE = "This is a log message";
204 | private final Map LOG_OBJECT = new HashMap<>();
205 | {
206 | LOG_OBJECT.put(Fields.MESSAGE, LOG_MESSAGE);
207 | LOG_OBJECT.put(Fields.EVENT, "timeout");
208 | }
209 |
210 | @Test
211 | @DisplayName("log raw event")
212 | void logRawEvent() {
213 | final AWSXRaySpan span = mockSpan("test-log-raw-event");
214 | span.log(LOG_MESSAGE);
215 |
216 | assertNotNull(span.getEntity().getMetadata().get(AWSXRayMetadataNamespaces.LOG));
217 | assertEquals(1, span.getEntity().getMetadata().get(AWSXRayMetadataNamespaces.LOG).size());
218 | }
219 |
220 | @Test
221 | @DisplayName("log raw event with timestamp")
222 | void logRawEventWithTimestamp() {
223 | final AWSXRaySpan span = mockSpan("test-log-raw-event-with-timestamp");
224 | span.log(Instant.now().toEpochMilli() * 1000, LOG_MESSAGE);
225 |
226 | assertNotNull(span.getEntity().getMetadata().get(AWSXRayMetadataNamespaces.LOG));
227 | assertEquals(1, span.getEntity().getMetadata().get(AWSXRayMetadataNamespaces.LOG).size());
228 | }
229 |
230 | @Test
231 | @DisplayName("log structured event")
232 | void logStructuredEvent() {
233 | final AWSXRaySpan span = mockSpan("test-log-structured-event");
234 | span.log(LOG_OBJECT);
235 |
236 | assertNotNull(span.getEntity().getMetadata().get(AWSXRayMetadataNamespaces.LOG));
237 | assertEquals(1, span.getEntity().getMetadata().get(AWSXRayMetadataNamespaces.LOG).size());
238 | }
239 |
240 | @Test
241 | @DisplayName("log structured event with timestamp")
242 | void logStructuredEventWithTimestamp() {
243 | final AWSXRaySpan span = mockSpan("test-log-structured-event");
244 | span.log(Instant.now().toEpochMilli() * 1000, LOG_OBJECT);
245 |
246 | assertNotNull(span.getEntity().getMetadata().get(AWSXRayMetadataNamespaces.LOG));
247 | assertEquals(1, span.getEntity().getMetadata().get(AWSXRayMetadataNamespaces.LOG).size());
248 | }
249 |
250 | @Test
251 | @DisplayName("log multiple events")
252 | void logMultipleEvents() throws InterruptedException {
253 | final AWSXRaySpan span = mockSpan("test-log-multiple-events");
254 |
255 | // Currently only support millisecond precision for logs, so
256 | // multiple logs can have the same timestamp which fails the test
257 | span.log(LOG_MESSAGE);
258 | Thread.sleep(5);
259 | span.log(LOG_MESSAGE);
260 | Thread.sleep(5);
261 | span.log(LOG_MESSAGE);
262 |
263 | assertEquals(3, span.getEntity().getMetadata().get(AWSXRayMetadataNamespaces.LOG).size());
264 | }
265 |
266 | @Test
267 | @DisplayName("set baggage")
268 | void setBaggage() {
269 | final AWSXRaySpan span = mockSpan("test-set-baggage");
270 | span.setBaggageItem("baggage_key", "value");
271 |
272 | assertNotNull(span.context().getBaggage());
273 | assertFalse(span.context().getBaggage().isEmpty());
274 | assertTrue(span.context().baggageItems().iterator().hasNext());
275 | assertEquals("value", span.getBaggageItem("baggage_key"));
276 | assertEquals("value", span.context().getBaggageItem("baggage_key"));
277 | }
278 |
279 | @Test
280 | @DisplayName("refuse to set operation name after construction")
281 | void setOperationName() {
282 | final AWSXRaySpan span = mockSpan("test-set-operation-name");
283 | assertThrows(Exception.class, () -> span.setOperationName("some-other-name"));
284 | }
285 |
286 | @Test
287 | @DisplayName("close the underlying X-Ray Entity on finish")
288 | void finish() {
289 |
290 | // Fake scope management here by setting the current trace Entity
291 | final AWSXRaySpan span = mockSpan("test-finish");
292 | awsxRayRecorder.setTraceEntity(span.getEntity());
293 | assertTrue(span.getEntity().isInProgress());
294 |
295 | span.finish();
296 |
297 | // X-Ray automatically unsets the current trace Entity on completion
298 | assertFalse(span.getEntity().isInProgress());
299 | assertNull(awsxRayRecorder.getTraceEntity());
300 | }
301 |
302 | @Test
303 | @DisplayName("ignore repeated calls to finish")
304 | void finishMultiple() {
305 |
306 | // Fake scope management here by setting the current trace entity
307 | final AWSXRaySpan span = mockSpan("test-finish");
308 | awsxRayRecorder.setTraceEntity(span.getEntity());
309 | assertTrue(span.getEntity().isInProgress());
310 |
311 | // If the second call to finish() proceeded, X-Ray would throw
312 | // an exception because the underlying Entity has already completed
313 | span.finish();
314 | span.finish();
315 |
316 | // X-Ray automatically unsets the current trace Entity on completion
317 | assertFalse(span.getEntity().isInProgress());
318 | assertNull(awsxRayRecorder.getTraceEntity());
319 | }
320 | }
321 |
--------------------------------------------------------------------------------
/src/test/java/io/opentracing/contrib/aws/xray/AWSXRayTestParent.java:
--------------------------------------------------------------------------------
1 | package io.opentracing.contrib.aws.xray;
2 |
3 | import com.amazonaws.xray.AWSXRayRecorder;
4 | import com.amazonaws.xray.AWSXRayRecorderBuilder;
5 | import com.amazonaws.xray.entities.SegmentImpl;
6 | import com.amazonaws.xray.entities.TraceHeader;
7 | import com.amazonaws.xray.entities.TraceID;
8 | import io.opentracing.Tracer;
9 |
10 | import java.util.Collections;
11 |
12 | /**
13 | * @author ashley.mercer@skylightipv.com
14 | */
15 | abstract class AWSXRayTestParent {
16 |
17 | final AWSXRayRecorder awsxRayRecorder = AWSXRayRecorderBuilder.defaultRecorder();
18 |
19 | /**
20 | * Make sure this reference stays as pure {@link Tracer} since we don't
21 | * want to rely on implementation-specific details or return types.
22 | */
23 | final Tracer tracer = new AWSXRayTracer(awsxRayRecorder);
24 |
25 | /**
26 | * A sample {@link com.amazonaws.xray.entities.TraceHeader} value to use
27 | * for testing. NB we use all parts (root, parent, sampling decision) to
28 | * ensure that they all get propagated correctly.
29 | */
30 | final TraceHeader traceHeader = new TraceHeader(
31 | new TraceID(),
32 | "0f15eadda7879f1d",
33 | TraceHeader.SampleDecision.SAMPLED
34 | );
35 |
36 | /**
37 | * @param operationName the operation name
38 | */
39 | AWSXRaySpan mockSpan(String operationName) {
40 | return new AWSXRaySpan(
41 | new SegmentImpl(awsxRayRecorder, operationName),
42 | new AWSXRaySpanContext(Collections.emptyMap()));
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/src/test/java/io/opentracing/contrib/aws/xray/AWSXRayTracerTests.java:
--------------------------------------------------------------------------------
1 | package io.opentracing.contrib.aws.xray;
2 |
3 | import com.amazonaws.xray.entities.TraceHeader;
4 | import io.opentracing.Scope;
5 | import io.opentracing.SpanContext;
6 | import io.opentracing.propagation.*;
7 | import org.junit.jupiter.api.DisplayName;
8 | import org.junit.jupiter.api.Test;
9 |
10 | import java.util.Collections;
11 | import java.util.HashMap;
12 |
13 | import static org.junit.jupiter.api.Assertions.*;
14 |
15 | /**
16 | * @author ashley.mercer@skylightipv.com
17 | */
18 | class AWSXRayTracerTests extends AWSXRayTestParent {
19 |
20 | @Test
21 | @DisplayName("store a reference to the current span")
22 | void storeReference() {
23 | final Scope scope = tracer
24 | .buildSpan("simple-span")
25 | .startActive(true);
26 |
27 | assertNotNull(tracer.activeSpan());
28 | assertNotNull(tracer.scopeManager().active().span());
29 |
30 | assertEquals(tracer.activeSpan(), scope.span());
31 | assertEquals(tracer.scopeManager().active().span(), scope.span());
32 |
33 | scope.close();
34 | }
35 |
36 | @Test
37 | @DisplayName("succeed on SpanContext injection (empty)")
38 | void contextInjectEmpty() {
39 | final TextMap textMap = new TextMapAdapter(new HashMap<>());
40 | final SpanContext context = new AWSXRaySpanContext(new HashMap<>());
41 |
42 | tracer.inject(context, Format.Builtin.TEXT_MAP, textMap);
43 | assertFalse(textMap.iterator().hasNext());
44 | }
45 |
46 | @Test
47 | @DisplayName("succeed on SpanContext injection (TraceID)")
48 | void contextInjectTraceId() {
49 | final TextMap textMap = new TextMapAdapter(new HashMap<>());
50 | final SpanContext context = new AWSXRaySpanContext(Collections.singletonMap(
51 | TraceHeader.HEADER_KEY,
52 | traceHeader.toString()
53 | ));
54 |
55 | tracer.inject(context, Format.Builtin.TEXT_MAP, textMap);
56 | assertTrue(textMap.iterator().hasNext());
57 |
58 | final TraceHeader extractedTraceHeader = TraceHeader.fromString(textMap.iterator().next().getValue());
59 | assertEquals(traceHeader.getRootTraceId(), extractedTraceHeader.getRootTraceId());
60 | assertEquals(traceHeader.getParentId(), extractedTraceHeader.getParentId());
61 | assertEquals(traceHeader.getSampled(), extractedTraceHeader.getSampled());
62 | }
63 |
64 | @Test
65 | @DisplayName("succeed on SpanContext extraction (empty)")
66 | void contextExtractEmpty() {
67 | final TextMap textMap = new TextMapAdapter(new HashMap<>());
68 | final SpanContext context = tracer.extract(Format.Builtin.TEXT_MAP, textMap);
69 | assertFalse(context.baggageItems().iterator().hasNext());
70 | }
71 |
72 | @Test
73 | @DisplayName("succeed on SpanContext extraction (TraceID)")
74 | void contextExtractTraceId() {
75 | final TextMap textMap = new TextMapAdapter(Collections.singletonMap(
76 | TraceHeader.HEADER_KEY,
77 | traceHeader.toString()
78 | ));
79 |
80 | final SpanContext context = tracer.extract(Format.Builtin.TEXT_MAP, textMap);
81 | assertTrue(context.baggageItems().iterator().hasNext());
82 |
83 | final TraceHeader extractedTraceHeader = TraceHeader.fromString(context.baggageItems().iterator().next().getValue());
84 | assertEquals(traceHeader.getRootTraceId(), extractedTraceHeader.getRootTraceId());
85 | assertEquals(traceHeader.getParentId(), extractedTraceHeader.getParentId());
86 | assertEquals(traceHeader.getSampled(), extractedTraceHeader.getSampled());
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/src/test/java/io/opentracing/propagation/TextMapAdapter.java:
--------------------------------------------------------------------------------
1 | package io.opentracing.propagation;
2 |
3 | import java.util.Iterator;
4 | import java.util.Map;
5 |
6 | /**
7 | * @author ashley.mercer@skylightipv.com
8 | */
9 | public class TextMapAdapter implements TextMap {
10 |
11 | private final Map map;
12 |
13 | public TextMapAdapter(Map map) {
14 | this.map = map;
15 | }
16 |
17 | @Override
18 | public Iterator> iterator() {
19 | return map.entrySet().iterator();
20 | }
21 |
22 | @Override
23 | public void put(String key, String value) {
24 | map.put(key, value);
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/src/test/resources/logback.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 | [%level] %m%n
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
--------------------------------------------------------------------------------
/travis/publish.sh:
--------------------------------------------------------------------------------
1 | #
2 | # Copyright 2016-2017 The OpenTracing Authors
3 | #
4 | # Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
5 | # in compliance with the License. You may obtain a copy of the License at
6 | #
7 | # http://www.apache.org/licenses/LICENSE-2.0
8 | #
9 | # Unless required by applicable law or agreed to in writing, software distributed under the License
10 | # is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
11 | # or implied. See the License for the specific language governing permissions and limitations under
12 | # the License.
13 | #
14 |
15 | set -euo pipefail
16 | set -x
17 |
18 | build_started_by_tag() {
19 | if [ "${TRAVIS_TAG}" == "" ]; then
20 | echo "[Publishing] This build was not started by a tag, publishing snapshot"
21 | return 1
22 | else
23 | echo "[Publishing] This build was started by the tag ${TRAVIS_TAG}, publishing release"
24 | return 0
25 | fi
26 | }
27 |
28 | is_pull_request() {
29 | if [ "${TRAVIS_PULL_REQUEST}" != "false" ]; then
30 | echo "[Not Publishing] This is a Pull Request"
31 | return 0
32 | else
33 | echo "[Publishing] This is not a Pull Request"
34 | return 1
35 | fi
36 | }
37 |
38 | is_travis_branch_master_or_release() {
39 | # release to bintray si done from master or release-X.Y maintenance branches
40 | if [[ "${TRAVIS_BRANCH}" = master || "${TRAVIS_BRANCH}" =~ ^release-[0-9]+\.[0-9]+$ ]]; then
41 | echo "[Publishing] Travis branch is master"
42 | return 0
43 | else
44 | echo "[Not Publishing] Travis branch is not master"
45 | return 1
46 | fi
47 | }
48 |
49 | check_travis_branch_equals_travis_tag() {
50 | #Weird comparison comparing branch to tag because when you 'git push --tags'
51 | #the branch somehow becomes the tag value
52 | #github issue: https://github.com/travis-ci/travis-ci/issues/1675
53 | if [ "${TRAVIS_BRANCH}" != "${TRAVIS_TAG}" ]; then
54 | echo "Travis branch does not equal Travis tag, which it should, bailing out."
55 | echo " github issue: https://github.com/travis-ci/travis-ci/issues/1675"
56 | exit 1
57 | else
58 | echo "[Publishing] Branch (${TRAVIS_BRANCH}) same as Tag (${TRAVIS_TAG})"
59 | fi
60 | }
61 |
62 | check_release_tag() {
63 | tag="${TRAVIS_TAG}"
64 | if [[ "$tag" =~ ^[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+(\.RC[[:digit:]]+)?$ ]]; then
65 | echo "Build started by version tag $tag. During the release process tags like this"
66 | echo "are created by the 'release' Maven plugin. Nothing to do here."
67 | exit 0
68 | elif [[ ! "$tag" =~ ^release-[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+(\.RC[[:digit:]]+)?$ ]]; then
69 | echo "You must specify a tag of the format 'release-0.0.0' or 'release-0.0.0.RC0' to release this project."
70 | echo "The provided tag ${tag} doesn't match that. Aborting."
71 | exit 1
72 | fi
73 | }
74 |
75 | is_release_commit() {
76 | project_version=$(./mvnw help:evaluate -N -Dexpression=project.version|grep -v '\[')
77 | if [[ "$project_version" =~ ^[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+(\.RC[[:digit:]]+)?$ ]]; then
78 | echo "Build started by release commit $project_version. Will synchronize to maven central."
79 | return 0
80 | else
81 | return 1
82 | fi
83 | }
84 |
85 | release_version() {
86 | echo "${TRAVIS_TAG}" | sed 's/^release-//'
87 | }
88 |
89 | safe_checkout_master() {
90 | # We need to be on a branch for release:perform to be able to create commits,
91 | # and we want that branch to be master or release-X.Y, which has been checked before.
92 | # But we also want to make sure that we build and release exactly the tagged version, so we verify that the remote
93 | # branch is where our tag is.
94 | checkoutBranch=release-`release_version | sed 's/.[[:digit:]]\+$//'`
95 | if ! git ls-remote --exit-code --heads origin "$checkoutBranch" ; then
96 | checkoutBranch=master
97 | fi
98 | git checkout -B "${checkoutBranch}"
99 | git fetch origin "${checkoutBranch}":origin/"${checkoutBranch}"
100 | commit_local_master="$(git show --pretty='format:%H' ${checkoutBranch})"
101 | commit_remote_master="$(git show --pretty='format:%H' origin/${checkoutBranch})"
102 | if [ "$commit_local_master" != "$commit_remote_master" ]; then
103 | echo "${checkoutBranch} on remote 'origin' has commits since the version under release, aborting"
104 | exit 1
105 | fi
106 | }
107 |
108 | #----------------------
109 | # MAIN
110 | #----------------------
111 |
112 | if ! is_pull_request && build_started_by_tag; then
113 | check_travis_branch_equals_travis_tag
114 | check_release_tag
115 | fi
116 |
117 | ./mvnw clean install -nsu
118 |
119 | # If we are on a pull request, our only job is to run tests, which happened above via ./mvnw install
120 | if is_pull_request; then
121 | true
122 | # If we are on master, we will deploy the latest snapshot or release version
123 | # - If a release commit fails to deploy for a transient reason, delete the broken version from bintray and click rebuild
124 | elif is_travis_branch_master_or_release; then
125 | ./mvnw --batch-mode -s ./.settings.xml -Prelease -nsu -DskipTests deploy
126 |
127 | # If the deployment succeeded, sync it to Maven Central. Note: this needs to be done once per project, not module, hence -N
128 | if is_release_commit; then
129 | ./mvnw --batch-mode -s ./.settings.xml -nsu -N io.zipkin.centralsync-maven-plugin:centralsync-maven-plugin:sync
130 | fi
131 |
132 | # If we are on a release tag, the following will update any version references and push a version tag for deployment.
133 | elif build_started_by_tag; then
134 | safe_checkout_master
135 | ./mvnw --batch-mode -s ./.settings.xml -Prelease -nsu -DreleaseVersion="$(release_version)" -Darguments="-DskipTests" release:prepare
136 | fi
137 |
138 |
--------------------------------------------------------------------------------