Timing breakdown

apm-agent-core/src/main/java/co/elastic/apm/agent/metrics/Labels.java

@@ -0,0 +1,259 @@
+/*-
+ * #%L
+ * Elastic APM Java agent
+ * %%
+ * Copyright (C) 2018 - 2019 Elastic and contributors
+ * %%
+ * 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.
+ * #L%
+ */
+package co.elastic.apm.agent.metrics;
+
+import co.elastic.apm.agent.objectpool.Recyclable;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+public class Labels implements Recyclable {
+
+    private static final Labels EMPTY = Labels.of().immutableCopy();
+    private final List<String> keys = new ArrayList<>();
+    private final List<CharSequence> values = new ArrayList<>();
+    private final boolean immutable;
+    @Nullable
+    private CharSequence transactionName;
+    @Nullable
+    private String transactionType;
+    @Nullable
+    private String spanType;
+    private int cachedHash;
+
+    public Labels() {
+        this(Collections.<String>emptyList(), Collections.<CharSequence>emptyList(), false);
+    }
+
+    private Labels(List<String> keys, List<? extends CharSequence> values, boolean immutable) {
+        this.keys.addAll(keys);
+        this.values.addAll(values);
+        this.immutable = immutable;
+    }
+
+    public static Labels of() {
+        return new Labels();
+    }
+
+    public static Labels of(String key, CharSequence value) {
+        final Labels labels = new Labels();
+        labels.add(key, value);
+        return labels;
+    }
+
+    public static Labels of(Map<String, ? extends CharSequence> labelMap) {
+        Labels labels = new Labels();
+        for (Map.Entry<String, ? extends CharSequence> entry : labelMap.entrySet()) {
+            labels.add(entry.getKey(), entry.getValue());
+        }
+        return labels;
+    }
+
+    public static Labels empty() {
+        return EMPTY;
+    }
+
+    public Labels add(String key, CharSequence value) {
+        assertMutable();
+        keys.add(key);
+        values.add(value);
+        return this;
+    }
+
+    public Labels transactionName(CharSequence transactionName) {
+        assertMutable();
+        this.transactionName = transactionName;
+        return this;
+    }
+
+    public Labels transactionType(String transactionType) {
+        assertMutable();
+        this.transactionType = transactionType;
+        return this;
+    }
+
+    public Labels spanType(String spanType) {
+        assertMutable();
+        this.spanType = spanType;
+        return this;
+    }
+
+    private void assertMutable() {
+        if (immutable) {
+            throw new UnsupportedOperationException("This Labels instance is immutable");
+        }
+    }
+
+    @Nullable
+    public CharSequence getTransactionName() {
+        return transactionName;
+    }
+
+    @Nullable
+    public String getTransactionType() {
+        return transactionType;
+    }
+
+    @Nullable
+    public String getSpanType() {
+        return spanType;
+    }
+
+    public Labels immutableCopy() {
+        List<String> immutableValues = new ArrayList<>(values.size());
+        for (int i = 0; i < keys.size(); i++) {
+            immutableValues.add(values.get(i).toString());
+        }
+        final Labels labels = new Labels(keys, immutableValues, true);
+        labels.transactionName = this.transactionName != null ? this.transactionName.toString() : null;
+        labels.transactionType = this.transactionType;
+        labels.spanType = this.spanType;
+        labels.cachedHash = labels.hashCode();
+        return labels;
+    }
+
+    public List<String> getKeys() {
+        return keys;
+    }
+
+    public List<CharSequence> getValues() {
+        return values;
+    }
+
+    public boolean isEmpty() {
+        return keys.isEmpty();
+    }
+
+    public int size() {
+        return keys.size();
+    }
+
+    public String getKey(int i) {
+        return keys.get(i);
+    }
+
+    public CharSequence getValue(int i) {
+        return values.get(i);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Labels labels = (Labels) o;
+        return keys.equals(labels.keys) &&
+            isEqual(values, labels.values) &&
+            contentEquals(transactionName, labels.transactionName) &&
+            Objects.equals(transactionType, labels.transactionType) &&
+            Objects.equals(spanType, labels.spanType);
+    }
+
+    @Override
+    public int hashCode() {
+        if (cachedHash != 0) {
+            return cachedHash;
+        }
+        int h = 0;
+        for (int i = 0; i < values.size(); i++) {
+            h = 31 * h + hash(i);
+        }
+        h = 31 * h + hash(transactionName);
+        h = 31 * h + Objects.hashCode(transactionType);
+        h = 31 * h + Objects.hashCode(spanType);
+        return h;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < keys.size(); i++) {
+            if (i > 0) {
+                sb.append(", ");
+            }
+            sb.append(keys.get(i)).append("=").append(values.get(i));
+
+        }
+        return sb.toString();
+    }
+
+    private int hash(int i) {
+        return keys.get(i).hashCode() * 31 + hash(values.get(i));
+    }
+
+    private static boolean isEqual(List<CharSequence> values, List<CharSequence> otherValues) {
+        if (values.size() != otherValues.size()) {
+            return false;
+        }
+        for (int i = 0; i < values.size(); i++) {
+            if (!contentEquals(values.get(i), otherValues.get(i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static boolean contentEquals(@Nullable CharSequence cs1, @Nullable CharSequence cs2) {
+        if (cs1 == null || cs2 == null) {
+            return cs1 == cs2;
+        }
+        if (cs1 instanceof String) {
+            return ((String) cs1).contentEquals(cs2);
+        } else if (cs2 instanceof String) {
+            return ((String) cs2).contentEquals(cs1);
+        } else {
+            if (cs1.length() == cs2.length()) {
+                for (int i = 0; i < cs1.length(); i++) {
+                    if (cs1.charAt(i) != cs2.charAt(i)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static int hash(@Nullable CharSequence cs) {
+        if (cs == null) {
+            return 0;
+        }
+        // this is safe as the hash code calculation is well defined
+        // (see javadoc for String.hashCode())
+        if (cs instanceof String) return cs.hashCode();
+        int h = 0;
+        for (int i = 0; i < cs.length(); i++) {
+            h = 31 * h + cs.charAt(i);
+        }
+        return h;
+    }
+
+    @Override
+    public void resetState() {
+        keys.clear();
+        values.clear();
+        transactionName = null;
+        transactionType = null;
+        spanType = null;
+    }
+}

apm-agent-core/src/main/java/co/elastic/apm/agent/metrics/MetricRegistry.java

@@ -36,92 +36,98 @@
 public class MetricRegistry {
 
     /**
-     * Groups {@link MetricSet}s by their unique tags.
+     * Groups {@link MetricSet}s by their unique labels.
      */
-    private final ConcurrentMap<Map<String, String>, MetricSet> metricSets = new ConcurrentHashMap<>();
+    private final ConcurrentMap<Labels, MetricSet> metricSets = new ConcurrentHashMap<>();
     private final ReporterConfiguration config;
 
     public MetricRegistry(ReporterConfiguration config) {
         this.config = config;
     }
 
     /**
-     * Same as {@link #add(String, Map, DoubleSupplier)} but only adds the metric
+     * Same as {@link #add(String, Labels, DoubleSupplier)} but only adds the metric
      * if the {@link DoubleSupplier} does not return {@link Double#NaN}
      *
      * @param name   the name of the metric
-     * @param tags   tags for the metric.
+     * @param labels labels for the metric.
      *               Tags can be used to create different graphs based for each value of a specific tag name, using a terms aggregation.
-     *               Note that there will be a {@link MetricSet} created for each distinct set of tags.
+     *               Note that there will be a {@link MetricSet} created for each distinct set of labels.
      * @param metric this supplier will be called for every reporting cycle
      *               ({@link co.elastic.apm.agent.report.ReporterConfiguration#metricsInterval metrics_interval)})
-     * @see #add(String, Map, DoubleSupplier)
+     * @see #add(String, Labels, DoubleSupplier)
      */
-    public void addUnlessNan(String name, Map<String, String> tags, DoubleSupplier metric) {
+    public void addUnlessNan(String name, Labels labels, DoubleSupplier metric) {
         if (isDisabled(name)) {
             return;
         }
         if (!Double.isNaN(metric.get())) {
-            add(name, tags, metric);
+            add(name, labels, metric);
         }
     }
 
     /**
-     * Same as {@link #add(String, Map, DoubleSupplier)} but only adds the metric
+     * Same as {@link #add(String, Labels, DoubleSupplier)} but only adds the metric
      * if the {@link DoubleSupplier} returns a positive number or zero.
      *
      * @param name   the name of the metric
-     * @param tags   tags for the metric.
+     * @param labels labels for the metric.
      *               Tags can be used to create different graphs based for each value of a specific tag name, using a terms aggregation.
-     *               Note that there will be a {@link MetricSet} created for each distinct set of tags.
+     *               Note that there will be a {@link MetricSet} created for each distinct set of labels.
      * @param metric this supplier will be called for every reporting cycle
      *               ({@link co.elastic.apm.agent.report.ReporterConfiguration#metricsInterval metrics_interval)})
-     * @see #add(String, Map, DoubleSupplier)
+     * @see #add(String, Labels, DoubleSupplier)
      */
-    public void addUnlessNegative(String name, Map<String, String> tags, DoubleSupplier metric) {
+    public void addUnlessNegative(String name, Labels labels, DoubleSupplier metric) {
         if (isDisabled(name)) {
             return;
         }
         if (metric.get() >= 0) {
-            add(name, tags, metric);
+            add(name, labels, metric);
         }
     }
 
     /**
      * Adds a gauge to the metric registry.
      *
      * @param name   the name of the metric
-     * @param tags   tags for the metric.
+     * @param labels labels for the metric.
      *               Tags can be used to create different graphs based for each value of a specific tag name, using a terms aggregation.
-     *               Note that there will be a {@link MetricSet} created for each distinct set of tags.
+     *               Note that there will be a {@link MetricSet} created for each distinct set of labels.
      * @param metric this supplier will be called for every reporting cycle
      *               ({@link co.elastic.apm.agent.report.ReporterConfiguration#metricsInterval metrics_interval)})
      */
-    public void add(String name, Map<String, String> tags, DoubleSupplier metric) {
+    public void add(String name, Labels labels, DoubleSupplier metric) {
         if (isDisabled(name)) {
             return;
         }
-        MetricSet metricSet = metricSets.get(tags);
-        if (metricSet == null) {
-            metricSets.putIfAbsent(tags, new MetricSet(tags));
-            metricSet = metricSets.get(tags);
-        }
+        MetricSet metricSet = getOrCreateMetricSet(labels);
         metricSet.add(name, metric);
     }
 
     private boolean isDisabled(String name) {
         return WildcardMatcher.anyMatch(config.getDisableMetrics(), name) != null;
     }
 
-    public double get(String name, Map<String, String> tags) {
-        final MetricSet metricSet = metricSets.get(tags);
+    public double get(String name, Labels labels) {
+        final MetricSet metricSet = metricSets.get(labels);
         if (metricSet != null) {
             return metricSet.get(name).get();
         }
         return Double.NaN;
     }
 
-    public Map<Map<String, String>, MetricSet> getMetricSets() {
+    public Map<Labels, MetricSet> getMetricSets() {
         return metricSets;
     }
+
+    private MetricSet getOrCreateMetricSet(Labels labels) {
+        MetricSet metricSet = metricSets.get(labels);
+        if (metricSet == null) {
+            final Labels copy = labels.immutableCopy();
+            metricSets.putIfAbsent(copy, new MetricSet(copy));
+            metricSet = metricSets.get(copy);
+        }
+        return metricSet;
+    }
 }