PAYARA-2547 Implement MicroProfile OpenTracing 1.0

api/payara-api/pom.xml

@@ -175,5 +175,12 @@
             <scope>provided</scope>
             <optional>true</optional>
         </dependency>
+        <dependency>
+            <groupId>io.opentracing</groupId>
+            <artifactId>opentracing-api</artifactId>
+            <version>${opentracing.version}</version>
+            <optional>true</optional>
+            <scope>provided</scope>
+        </dependency>
     </dependencies>
 </project>

api/payara-api/src/main/java/fish/payara/notification/requesttracing/RequestTrace.java

@@ -86,43 +86,94 @@ public void addEvent(RequestTraceSpan span) {
         if (null != span.getEventType()) {
             switch (span.getEventType()) {
                 case TRACE_START:
-                    trace.clear();
-                    startTime = span.getStartInstant();
-                    trace.add(span);
-                    started = true;
-                    completed = false;
+                    handleTraceStart(span);
                     break;
                 case PROPAGATED_TRACE:
-                    trace.clear();
-                    startTime = span.getStartInstant();
-                    trace.add(span);
-                    started = true;
-                    completed = false;
+                    handlePropagatedTrace(span);
                     break;
                 case REQUEST_EVENT: {
-                    if (!started) {
-                        return;
-                    }
-                    RequestTraceSpan rootSpan = trace.getFirst();
-                    span.setTraceId(rootSpan.getTraceId());
-                    span.setSpanDuration(span.getStartInstant().until(Instant.now(), ChronoUnit.NANOS));
-                    span.setTraceEndTime(Instant.now());
-                    trace.add(span);
+                    handleRequestEvent(span);
                     break;
                 }
                 default:
                     break;
             }
         }
     }
-
-     public void endTrace() {
+
+    public void addEvent(RequestTraceSpan span, long timestampMillis) {
+        // Do not add trace events if completed
+        if (completed
+                && span.getEventType() != TRACE_START
+                && span.getEventType() != PROPAGATED_TRACE) {
+            return;
+        }
+
+        if (null != span.getEventType()) {
+            switch (span.getEventType()) {
+                case TRACE_START:
+                    handleTraceStart(span);
+                    break;
+                case PROPAGATED_TRACE:
+                    handlePropagatedTrace(span);
+                    break;
+                case REQUEST_EVENT: {
+                    handleRequestEvent(span, timestampMillis);
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+    }
+
+    private void handleTraceStart(RequestTraceSpan span) {
+        trace.clear();
+        startTime = span.getStartInstant();
+        trace.add(span);
+        started = true;
+        completed = false;
+    }
+
+    private void handlePropagatedTrace(RequestTraceSpan span) {
+        trace.clear();
+        startTime = span.getStartInstant();
+        trace.add(span);
+        started = true;
+        completed = false;
+    }
+
+    private void handleRequestEvent(RequestTraceSpan span) {
         if (!started) {
             return;
         }
 
-        Collections.sort(trace);
+        RequestTraceSpan rootSpan = trace.getFirst();
+        span.setTraceId(rootSpan.getTraceId());
+        span.setSpanDuration(span.getStartInstant().until(Instant.now(), ChronoUnit.NANOS));
+        span.setTraceEndTime(Instant.now());
+        trace.add(span);
+    }
+
+    private void handleRequestEvent(RequestTraceSpan span, long timestampMillis) {
+        if (!started) {
+            return;
+        }
 
+        RequestTraceSpan rootSpan = trace.getFirst();
+        span.setTraceId(rootSpan.getTraceId());
+        span.setSpanDuration(span.getStartInstant().until(Instant.ofEpochMilli(timestampMillis), ChronoUnit.NANOS));
+        span.setTraceEndTime(Instant.ofEpochMilli(timestampMillis));
+        trace.add(span);
+    }
+
+    public void endTrace() {
+        if (!started) {
+            return;
+        }
+
+        Collections.sort(trace);
+
         RequestTraceSpan startSpan = trace.getFirst();
         endTime = Instant.now();
         startSpan.setSpanDuration(startTime.until(endTime, ChronoUnit.NANOS));
@@ -171,16 +222,16 @@ public boolean isStarted() {
 
     /**
      * Returns a list of all the events that make up the trace.
-     * @return 
+     * @return
      */
     public LinkedList<RequestTraceSpan> getTraceSpans() {
         return trace;
     }
 
     /**
-     * Gets the Instant  when the span was started
+     * Gets the Instant when the span was started
      * See {@link java.time.Instant#now()} for how this time is generated.
-     * @return 
+     * @return
      */
     public Instant getStartTime() {
         return startTime;
@@ -250,8 +301,8 @@ private void assignReferences() {
             if (trace.indexOf(span) != 0) {
                 RequestTraceSpan bestMatchingParent = null;
                 for (RequestTraceSpan comparisonSpan : trace) {
-                    if (span.getTimeOccured() > comparisonSpan.getTimeOccured() &&
-                            span.getTraceEndTime().compareTo(comparisonSpan.getTraceEndTime()) < 0) {
+                    if (span.getTimeOccured() > comparisonSpan.getTimeOccured()
+                            && span.getTraceEndTime().compareTo(comparisonSpan.getTraceEndTime()) < 0) {
                         if (bestMatchingParent == null) {
                             bestMatchingParent = comparisonSpan;
                         } else {
@@ -291,8 +342,8 @@ public boolean equals(Object o) {
 
         RequestTrace that = (RequestTrace) o;
 
-        return elapsedTime == that.elapsedTime && (this.toString() != null ? 
-                this.toString().equals(that.toString()) : that.toString() == null);
+        return elapsedTime == that.elapsedTime && (this.toString() != null
+                ? this.toString().equals(that.toString()) : that.toString() == null);
     }
 
     @Override

api/payara-api/src/main/java/fish/payara/notification/requesttracing/RequestTraceSpan.java

@@ -42,7 +42,7 @@
 import java.io.Serializable;
 import java.time.Instant;
 import java.time.ZoneId;
-import java.util.ArrayList;;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -57,21 +57,28 @@
 public class RequestTraceSpan implements Serializable, Comparable<RequestTraceSpan> {
 
     private final SpanContext spanContext;
-    private final Instant startTime;
+    private Instant startTime;
     private Instant endTime;
     private long spanDuration;
-    private final EventType eventType;
-    private Map<String, String> spanTags;
-    private List<RequestTraceSpanLog> spanLogs;
+    private EventType eventType;
+    private final Map<String, String> spanTags;
+    private final List<RequestTraceSpanLog> spanLogs;
     private String eventName;
     private final List<SpanReference> spanReferences;
 
+    protected RequestTraceSpan() {
+        this.spanContext = new SpanContext();
+        this.spanTags = new HashMap<>();
+        this.spanLogs = new ArrayList<>();
+        this.spanReferences = new ArrayList<>();
+    }
+
     public RequestTraceSpan(String eventName) {
         this(EventType.REQUEST_EVENT, eventName);
     }
 
     public RequestTraceSpan(EventType eventType, String eventName) {
-        this.spanContext = new SpanContext();;
+        this.spanContext = new SpanContext();
         this.startTime = Instant.now();
         this.eventType = eventType;
         this.eventName = eventName;
@@ -109,17 +116,20 @@ public SpanContext getSpanContext() {
         return spanContext;
     }
 
-    public Instant getStartInstant(){
+    public Instant getStartInstant() {
         return startTime;
     }
-
+
+    public void setStartInstant(Instant startTime) {
+        this.startTime = startTime;
+    }
+
     /**
      * Gets the time in milliseconds since the epoch (midnight, January 1st 1970)
      * when the the request event occurred.
-     * 
      * @return the time the trace occurred
      */
-    public long getTimeOccured(){
+    public long getTimeOccured() {
         return startTime.toEpochMilli();
     }
 
@@ -146,17 +156,17 @@ public EventType getEventType() {
     public String getEventName() {
         return eventName;
     }
-
+
+    public void setEventName(String eventName) {
+        this.eventName = eventName;
+    }
+
     /**
      * Adds more information about a span
      * @param name
      * @param value 
      */
     public void addSpanTag(String name, String value) {
-        if (spanTags == null) {
-            spanTags = new HashMap<>();
-        }
-
         if (value != null) {
             // Escape any quotes
             spanTags.put(name, value.replaceAll("\"", "\\\\\""));
@@ -184,10 +194,13 @@ public Instant getTraceEndTime() {
     public void setTraceEndTime(Instant endTime) {
         this.endTime = endTime;
     }
-
+
+    public void setEventType(EventType spanType) {
+        this.eventType = spanType;
+    }
+
     @Override
     public String toString() {
-
         StringBuilder result = new StringBuilder("\n{");
         result.append("\"operationName\":\"").append(eventName).append("\",")
                 .append("\"spanContext\":{")
@@ -260,6 +273,7 @@ public int compareTo(RequestTraceSpan span) {
     }
 
     public class SpanContext implements Serializable {
+
         private final UUID spanId;
         private UUID traceId;
         private final Map<String, String> baggageItems;
@@ -297,18 +311,20 @@ public void setTraceId(UUID traceId) {
         public void addBaggageItem(String name, String value) {
             if (value != null) {
                 // Escape any quotes
-                spanTags.put(name, value.replaceAll("\"", "\\\""));
+                addSpanTag(name, value.replaceAll("\"", "\\\""));
             } else {
-                spanTags.put(name, value);
+                addSpanTag(name, value);
             }
         }
 
         public Map<String, String> getBaggageItems() {
             return baggageItems;
         }
+
     }
 
     public class SpanReference implements Serializable {
+
         private final SpanContext referenceSpanContext;
         private final SpanContextRelationshipType relationshipType;
 
@@ -324,10 +340,12 @@ public SpanContext getReferenceSpanContext() {
         public SpanContextRelationshipType getSpanContextRelationshipType() {
             return relationshipType;
         }
+
     }
 
     public enum SpanContextRelationshipType {
         ChildOf,
         FollowsFrom;
     }
+
 }

api/payara-api/src/main/java/fish/payara/notification/requesttracing/RequestTraceSpanLog.java

@@ -52,12 +52,28 @@ public class RequestTraceSpanLog implements Serializable {
     private final long timeMillis;
     private final Map<String, String> logEntries;
 
+    public RequestTraceSpanLog() {
+        timeMillis = System.currentTimeMillis();
+        logEntries = new LinkedHashMap<>();
+    }
+
+    public RequestTraceSpanLog(long timestampMillis) {
+        timeMillis = timestampMillis;
+        logEntries = new LinkedHashMap<>();
+    }
+
     public RequestTraceSpanLog(String logName) {
         timeMillis = System.currentTimeMillis();
         logEntries = new LinkedHashMap<>();
         logEntries.put("logEvent", logName);
     }
 
+    public RequestTraceSpanLog(long timestampMillis, String logName) {
+        timeMillis = timestampMillis;
+        logEntries = new LinkedHashMap<>();
+        logEntries.put("logEvent", logName);
+    }
+
     public long getTimeMillis() {
         return timeMillis;
     }