io.opencensus.implcore.metrics.DerivedLongCumulativeImpl Maven / Gradle / Ivy
The newest version!
/*
* Copyright 2019, OpenCensus 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.opencensus.implcore.metrics;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import io.opencensus.common.Clock;
import io.opencensus.common.Timestamp;
import io.opencensus.common.ToLongFunction;
import io.opencensus.implcore.internal.Utils;
import io.opencensus.metrics.DerivedLongCumulative;
import io.opencensus.metrics.LabelKey;
import io.opencensus.metrics.LabelValue;
import io.opencensus.metrics.export.Metric;
import io.opencensus.metrics.export.MetricDescriptor;
import io.opencensus.metrics.export.MetricDescriptor.Type;
import io.opencensus.metrics.export.Point;
import io.opencensus.metrics.export.TimeSeries;
import io.opencensus.metrics.export.Value;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.annotation.concurrent.GuardedBy;
/*>>>
import org.checkerframework.checker.nullness.qual.Nullable;
*/
/** Implementation of {@link DerivedLongCumulative}. */
public final class DerivedLongCumulativeImpl extends DerivedLongCumulative implements Meter {
private final MetricDescriptor metricDescriptor;
private final int labelKeysSize;
private final List constantLabelValues;
private final Timestamp startTime;
private volatile Map, PointWithFunction> registeredPoints =
Collections., PointWithFunction>emptyMap();
DerivedLongCumulativeImpl(
String name,
String description,
String unit,
List labelKeys,
Map constantLabels,
Timestamp startTime) {
List constantLabelValues = new ArrayList();
List allKeys = new ArrayList<>(labelKeys);
for (Entry label : constantLabels.entrySet()) {
// Ensure constant label keys and values are in the same order.
allKeys.add(label.getKey());
constantLabelValues.add(label.getValue());
}
labelKeysSize = allKeys.size();
this.metricDescriptor =
MetricDescriptor.create(name, description, unit, Type.CUMULATIVE_INT64, allKeys);
this.constantLabelValues = Collections.unmodifiableList(constantLabelValues);
this.startTime = startTime;
}
@Override
public synchronized void createTimeSeries(
List labelValues,
@javax.annotation.Nullable T obj,
ToLongFunction function) {
checkNotNull(function, "function");
Utils.checkListElementNotNull(checkNotNull(labelValues, "labelValues"), "labelValue");
List labelValuesCopy = new ArrayList(labelValues);
labelValuesCopy.addAll(constantLabelValues);
checkArgument(
labelKeysSize == labelValuesCopy.size(),
"Label Keys and Label Values don't have same size.");
PointWithFunction existingPoint =
registeredPoints.get(Collections.unmodifiableList(labelValuesCopy));
if (existingPoint != null) {
throw new IllegalArgumentException(
"A different time series with the same labels already exists.");
}
PointWithFunction newPoint =
new PointWithFunction(labelValuesCopy, obj, function, startTime);
// Updating the map of time series happens under a lock to avoid multiple add operations
// to happen in the same time.
Map, PointWithFunction> registeredPointsCopy =
new LinkedHashMap, PointWithFunction>(registeredPoints);
registeredPointsCopy.put(labelValuesCopy, newPoint);
registeredPoints = Collections.unmodifiableMap(registeredPointsCopy);
}
@Override
public synchronized void removeTimeSeries(List labelValues) {
List labelValuesCopy =
new ArrayList(checkNotNull(labelValues, "labelValues"));
labelValuesCopy.addAll(constantLabelValues);
Map, PointWithFunction> registeredPointsCopy =
new LinkedHashMap, PointWithFunction>(registeredPoints);
if (registeredPointsCopy.remove(labelValuesCopy) == null) {
// The element not present, no need to update the current map of time series.
return;
}
registeredPoints = Collections.unmodifiableMap(registeredPointsCopy);
}
@Override
public synchronized void clear() {
registeredPoints = Collections., PointWithFunction>emptyMap();
}
@Override
public MetricDescriptor getMetricDescriptor() {
return metricDescriptor;
}
@javax.annotation.Nullable
@Override
public Metric getMetric(Clock clock) {
Map, PointWithFunction> currentRegisteredPoints = registeredPoints;
if (currentRegisteredPoints.isEmpty()) {
return null;
}
if (currentRegisteredPoints.size() == 1) {
PointWithFunction point = currentRegisteredPoints.values().iterator().next();
return Metric.createWithOneTimeSeries(metricDescriptor, point.getTimeSeries(clock));
}
List timeSeriesList = new ArrayList(currentRegisteredPoints.size());
for (Map.Entry, PointWithFunction> entry :
currentRegisteredPoints.entrySet()) {
timeSeriesList.add(entry.getValue().getTimeSeries(clock));
}
return Metric.create(metricDescriptor, timeSeriesList);
}
/** Implementation of {@link PointWithFunction} with an object and a callback function. */
public static final class PointWithFunction {
private final List labelValues;
private final Timestamp startTime;
@javax.annotation.Nullable private final WeakReference ref;
private final ToLongFunction function;
@GuardedBy("this")
private long value = 0;
PointWithFunction(
List labelValues,
@javax.annotation.Nullable T obj,
ToLongFunction function,
Timestamp startTime) {
this.labelValues = labelValues;
this.startTime = startTime;
ref = obj != null ? new WeakReference(obj) : null;
this.function = function;
}
private TimeSeries getTimeSeries(Clock clock) {
final T obj = ref != null ? ref.get() : null;
long newValue = function.applyAsLong(obj);
Point point;
synchronized (this) {
value = newValue > value ? newValue : value;
point = Point.create(Value.longValue(value), clock.now());
}
return TimeSeries.createWithOnePoint(labelValues, point, startTime);
}
}
}