Implemented base zPages classes and TraceZ zPage

sdk_extensions/zpages/README.md

@@ -0,0 +1,9 @@
+# OpenTelemetry SDK Contrib - zPages
+
+[![Javadocs][javadoc-image]][javadoc-url]
+
+This module contains code for OpenTelemetry's Java zPages.
+
+<!--- TODO: Update javadoc -->
+[javadoc-image]: https://www.javadoc.io/badge/io.opentelemetry/opentelemetry-sdk-contrib-auto-config.svg
+[javadoc-url]: https://www.javadoc.io/doc/io.opentelemetry/opentelemetry-sdk-contrib-auto-config

sdk_extensions/zpages/build.gradle

@@ -0,0 +1,19 @@
+plugins {
+    id "java"
+    id "maven-publish"
+
+    id "ru.vyarus.animalsniffer"
+}
+
+description = 'OpenTelemetry - zPages'
+ext.moduleName = "io.opentelemetry.sdk.extension.zpages"
+
+dependencies {
+    api project(':opentelemetry-api'),
+            project(':opentelemetry-sdk')
+
+    implementation libraries.guava
+    compileOnly 'com.sun.net.httpserver:http:20070405'
+
+    signature "org.codehaus.mojo.signature:java17:1.0@signature"
+}

sdk_extensions/zpages/src/main/java/io/opentelemetry/sdk/extensions/zpages/LatencyBoundary.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2020, OpenTelemetry Authors
+ *
+ * Licensed 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 io.opentelemetry.sdk.extensions.zpages;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A class of boundaries for the latency buckets. The completed spans with a status of {@link
+ * io.opentelemetry.trace.Status#OK} are categorized into one of these buckets om the traceZ zPage.
+ */
+enum LatencyBoundary {
+  /** Stores finished successful requests of duration within the interval [0, 10us). */
+  ZERO_MICROSx10(0, TimeUnit.MICROSECONDS.toNanos(10)),
+
+  /** Stores finished successful requests of duration within the interval [10us, 100us). */
+  MICROSx10_MICROSx100(TimeUnit.MICROSECONDS.toNanos(10), TimeUnit.MICROSECONDS.toNanos(100)),
+
+  /** Stores finished successful requests of duration within the interval [100us, 1ms). */
+  MICROSx100_MILLIx1(TimeUnit.MICROSECONDS.toNanos(100), TimeUnit.MILLISECONDS.toNanos(1)),
+
+  /** Stores finished successful requests of duration within the interval [1ms, 10ms). */
+  MILLIx1_MILLIx10(TimeUnit.MILLISECONDS.toNanos(1), TimeUnit.MILLISECONDS.toNanos(10)),
+
+  /** Stores finished successful requests of duration within the interval [10ms, 100ms). */
+  MILLIx10_MILLIx100(TimeUnit.MILLISECONDS.toNanos(10), TimeUnit.MILLISECONDS.toNanos(100)),
+
+  /** Stores finished successful requests of duration within the interval [100ms, 1sec). */
+  MILLIx100_SECONDx1(TimeUnit.MILLISECONDS.toNanos(100), TimeUnit.SECONDS.toNanos(1)),
+
+  /** Stores finished successful requests of duration within the interval [1sec, 10sec). */
+  SECONDx1_SECONDx10(TimeUnit.SECONDS.toNanos(1), TimeUnit.SECONDS.toNanos(10)),
+
+  /** Stores finished successful requests of duration within the interval [10sec, 100sec). */
+  SECONDx10_SECONDx100(TimeUnit.SECONDS.toNanos(10), TimeUnit.SECONDS.toNanos(100)),
+
+  /** Stores finished successful requests of duration greater than or equal to 100sec. */
+  SECONDx100_MAX(TimeUnit.SECONDS.toNanos(100), Long.MAX_VALUE);
+
+  private final long latencyLowerBound;
+  private final long latencyUpperBound;
+
+  /**
+   * Constructs a {@code LatencyBoundaries} with the given boundaries and label.
+   *
+   * @param latencyLowerBound the latency lower bound of the bucket.
+   * @param latencyUpperBound the latency upper bound of the bucket.
+   */
+  LatencyBoundary(long latencyLowerBound, long latencyUpperBound) {
+    this.latencyLowerBound = latencyLowerBound;
+    this.latencyUpperBound = latencyUpperBound;
+  }
+
+  /**
+   * Returns the latency lower bound of the bucket.
+   *
+   * @return the latency lower bound of the bucket.
+   */
+  long getLatencyLowerBound() {
+    return latencyLowerBound;
+  }
+
+  /**
+   * Returns the latency upper bound of the bucket.
+   *
+   * @return the latency upper bound of the bucket.
+   */
+  long getLatencyUpperBound() {
+    return latencyUpperBound;
+  }
+
+  /**
+   * Returns the LatencyBoundary that the argument falls into.
+   *
+   * @param latencyNanos latency in nanoseconds.
+   * @return the LatencyBoundary that latencyNanos falls into.
+   */
+  static LatencyBoundary getBoundary(long latencyNanos) {
+    for (LatencyBoundary bucket : LatencyBoundary.values()) {
+      if (latencyNanos >= bucket.getLatencyLowerBound()
+          && latencyNanos < bucket.getLatencyUpperBound()) {
+        return bucket;
+      }
+    }
+    return ZERO_MICROSx10;
+  }
+}

sdk_extensions/zpages/src/main/java/io/opentelemetry/sdk/extensions/zpages/SpanBucket.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2020, OpenTelemetry Authors
+ *
+ * Licensed 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 io.opentelemetry.sdk.extensions.zpages;
+
+import com.google.common.primitives.UnsignedInts;
+import io.opentelemetry.sdk.trace.ReadableSpan;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+final class SpanBucket {
+  // A power of 2 means Integer.MAX_VALUE % bucketSize = bucketSize - 1, so the index will always
+  // loop back to 0.
+  private static final int LATENCY_BUCKET_SIZE = 16;
+  private static final int ERROR_BUCKET_SIZE = 8;
+
+  private final ReadableSpan[] spans;
+  private final AtomicInteger index;
+  private final int bucketSize;
+
+  SpanBucket(boolean isLatencyBucket) {
+    bucketSize = isLatencyBucket ? LATENCY_BUCKET_SIZE : ERROR_BUCKET_SIZE;
+    spans = new ReadableSpan[bucketSize];
+    index = new AtomicInteger();
+  }
+
+  void add(ReadableSpan span) {
+    spans[UnsignedInts.remainder(index.getAndIncrement(), bucketSize)] = span;
+  }
+
+  int size() {
+    for (int i = bucketSize - 1; i >= 0; i--) {
+      if (spans[i] != null) {
+        return i + 1;
+      }
+    }
+    return 0;
+  }
+
+  void addTo(List<ReadableSpan> result) {
+    for (int i = 0; i < bucketSize; i++) {
+      ReadableSpan span = spans[i];
+      if (span != null) {
+        result.add(span);
+      } else {
+        break;
+      }
+    }
+  }
+}

sdk_extensions/zpages/src/main/java/io/opentelemetry/sdk/extensions/zpages/TracezDataAggregator.java

@@ -0,0 +1,173 @@
+/*
+ * Copyright 2020, OpenTelemetry Authors
+ *
+ * Licensed 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 io.opentelemetry.sdk.extensions.zpages;
+
+import io.opentelemetry.sdk.trace.ReadableSpan;
+import io.opentelemetry.sdk.trace.data.SpanData;
+import io.opentelemetry.trace.Status;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.TreeSet;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * A data aggregator for the traceZ zPage.
+ *
+ * <p>The traceZ data aggregator compiles information about the running spans, span latencies, and
+ * error spans for the frontend of the zPage.
+ */
+@ThreadSafe
+final class TracezDataAggregator {
+  private final TracezSpanProcessor spanProcessor;
+
+  /**
+   * Constructor for {@link TracezDataAggregator}.
+   *
+   * @param spanProcessor collects span data.
+   */
+  TracezDataAggregator(TracezSpanProcessor spanProcessor) {
+    this.spanProcessor = spanProcessor;
+  }
+
+  /**
+   * Returns a Set of running and completed span names for {@link TracezDataAggregator}.
+   *
+   * @return a Set of {@link String}.
+   */
+  Set<String> getSpanNames() {
+    Set<String> spanNames = new TreeSet<>();
+    Collection<ReadableSpan> allRunningSpans = spanProcessor.getRunningSpans();
+    for (ReadableSpan span : allRunningSpans) {
+      spanNames.add(span.getName());
+    }
+    spanNames.addAll(spanProcessor.getCompletedSpanCache().keySet());
+    return spanNames;
+  }
+
+  /**
+   * Returns a Map of the running span counts for {@link TracezDataAggregator}.
+   *
+   * @return a Map of span counts for each span name.
+   */
+  Map<String, Integer> getRunningSpanCounts() {
+    Collection<ReadableSpan> allRunningSpans = spanProcessor.getRunningSpans();
+    Map<String, Integer> numSpansPerName = new HashMap<>();
+    for (ReadableSpan span : allRunningSpans) {
+      Integer prevValue = numSpansPerName.get(span.getName());
+      numSpansPerName.put(span.getName(), prevValue != null ? prevValue + 1 : 1);
+    }
+    return numSpansPerName;
+  }
+
+  /**
+   * Returns a List of all running spans with a given span name for {@link TracezDataAggregator}.
+   *
+   * @param spanName name to filter returned spans.
+   * @return a List of {@link SpanData}.
+   */
+  List<SpanData> getRunningSpans(String spanName) {
+    Collection<ReadableSpan> allRunningSpans = spanProcessor.getRunningSpans();
+    List<SpanData> filteredSpans = new ArrayList<>();
+    for (ReadableSpan span : allRunningSpans) {
+      if (span.getName().equals(spanName)) {
+        filteredSpans.add(span.toSpanData());
+      }
+    }
+    return filteredSpans;
+  }
+
+  /**
+   * Returns a Map of span names to counts for all {@link Status#OK} spans in {@link
+   * TracezDataAggregator}.
+   *
+   * @return a Map of span names to counts, where the counts are further indexed by the latency
+   *     boundaries.
+   */
+  Map<String, Map<LatencyBoundary, Integer>> getSpanLatencyCounts() {
+    Map<String, TracezSpanBuckets> completedSpanCache = spanProcessor.getCompletedSpanCache();
+    Map<String, Map<LatencyBoundary, Integer>> numSpansPerName = new HashMap<>();
+    for (Entry<String, TracezSpanBuckets> cacheEntry : completedSpanCache.entrySet()) {
+      numSpansPerName.put(
+          cacheEntry.getKey(), cacheEntry.getValue().getLatencyBoundaryToCountMap());
+    }
+    return numSpansPerName;
+  }
+
+  /**
+   * Returns a List of all {@link Status#OK} spans with a given span name between [lowerBound,
+   * upperBound) for {@link TracezDataAggregator}.
+   *
+   * @param spanName name to filter returned spans.
+   * @param lowerBound latency lower bound (inclusive)
+   * @param upperBound latency upper bound (exclusive)
+   * @return a List of {@link SpanData}.
+   */
+  List<SpanData> getOkSpans(String spanName, long lowerBound, long upperBound) {
+    Map<String, TracezSpanBuckets> completedSpanCache = spanProcessor.getCompletedSpanCache();
+    TracezSpanBuckets buckets = completedSpanCache.get(spanName);
+    if (buckets == null) {
+      return new ArrayList<>();
+    }
+    Collection<ReadableSpan> allOkSpans = buckets.getOkSpans();
+    List<SpanData> filteredSpans = new ArrayList<>();
+    for (ReadableSpan span : allOkSpans) {
+      if (span.getLatencyNanos() >= lowerBound && span.getLatencyNanos() < upperBound) {
+        filteredSpans.add(span.toSpanData());
+      }
+    }
+    return filteredSpans;
+  }
+
+  /**
+   * Returns a Map of error span counts for {@link TracezDataAggregator}.
+   *
+   * @return a Map of error span counts for each span name.
+   */
+  Map<String, Integer> getErrorSpanCounts() {
+    Map<String, TracezSpanBuckets> completedSpanCache = spanProcessor.getCompletedSpanCache();
+    Map<String, Integer> numErrorsPerName = new HashMap<>();
+    for (Entry<String, TracezSpanBuckets> cacheEntry : completedSpanCache.entrySet()) {
+      numErrorsPerName.put(cacheEntry.getKey(), cacheEntry.getValue().getErrorSpans().size());
+    }
+    return numErrorsPerName;
+  }
+
+  /**
+   * Returns a List of error spans with a given span name for {@link TracezDataAggregator}.
+   *
+   * @param spanName name to filter returned spans.
+   * @return a List of {@link SpanData}.
+   */
+  List<SpanData> getErrorSpans(String spanName) {
+    Map<String, TracezSpanBuckets> completedSpanCache = spanProcessor.getCompletedSpanCache();
+    TracezSpanBuckets buckets = completedSpanCache.get(spanName);
+    if (buckets == null) {
+      return new ArrayList<>();
+    }
+    Collection<ReadableSpan> allErrorSpans = buckets.getErrorSpans();
+    List<SpanData> errorSpans = new ArrayList<>();
+    for (ReadableSpan span : allErrorSpans) {
+      errorSpans.add(span.toSpanData());
+    }
+    return errorSpans;
+  }
+}