fish.payara.microprofile.metrics.impl.MetricRegistryImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of payara-embedded-web Show documentation
Show all versions of payara-embedded-web Show documentation
Embedded-Web Distribution of the Payara Project
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) [2018-2023] Payara Foundation and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://github.com/payara/Payara/blob/master/LICENSE.txt
* See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at glassfish/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* The Payara Foundation designates this particular file as subject to the "Classpath"
* exception as provided by the Payara Foundation in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package fish.payara.microprofile.metrics.impl;
import fish.payara.microprofile.metrics.cdi.MetricUtils;
import jakarta.enterprise.inject.Vetoed;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import org.eclipse.microprofile.metrics.Counter;
import org.eclipse.microprofile.metrics.Gauge;
import org.eclipse.microprofile.metrics.Histogram;
import org.eclipse.microprofile.metrics.Metadata;
import org.eclipse.microprofile.metrics.Metric;
import org.eclipse.microprofile.metrics.MetricFilter;
import org.eclipse.microprofile.metrics.MetricID;
import org.eclipse.microprofile.metrics.MetricRegistry;
import org.eclipse.microprofile.metrics.MetricUnits;
import org.eclipse.microprofile.metrics.Tag;
import org.eclipse.microprofile.metrics.Timer;
import static java.util.Collections.emptyMap;
import static java.util.Collections.emptySet;
import static java.util.Collections.unmodifiableMap;
import static java.util.Collections.unmodifiableSet;
import static java.util.stream.Collectors.toMap;
import static org.eclipse.microprofile.metrics.MetricFilter.ALL;
/**
* The MetricRegistry stores the metrics and metadata information
*/
@Vetoed
public class MetricRegistryImpl implements MetricRegistry {
private static final Logger LOGGER = Logger.getLogger(MetricRegistryImpl.class.getName());
static final class MetricFamily {
final Metadata metadata;
final ConcurrentMap metrics = new ConcurrentHashMap<>();
MetricFamily(Metadata metadata) {
this.metadata = metadata;
}
boolean remove(MetricID metricID) {
return metrics.remove(metricID) != null;
}
T get(MetricID metricID) {
return metrics.get(metricID);
}
}
private final String scope;
private final ConcurrentMap> metricsFamiliesByName = new ConcurrentHashMap<>();
private final Clock clock;
private final List listeners = new ArrayList<>();
public static final String METRIC_PERCENTILES_PROPERTY = "mp.metrics.distribution.percentiles";
public static final String METRIC_HISTOGRAM_BUCKETS_PROPERTY = "mp.metrics.distribution.histogram.buckets";
public static final String METRIC_TIMER_BUCKETS_PROPERTY = "mp.metrics.distribution.timer.buckets";
private Map> percentilesConfigMap =
new HashMap>();
private Map> histogramBucketsConfigMap =
new HashMap<>();
private Map> timerBucketsConfigMap =
new HashMap<>();
public MetricRegistryImpl() {
this.scope = null;
this.clock = Clock.defaultClock();
}
public MetricRegistryImpl(String registryScope) {
this(registryScope, Clock.defaultClock());
}
public MetricRegistryImpl(String type, Clock clock) {
this.scope = type;
this.clock = clock;
}
public MetricRegistryImpl addListener(MetricRegistrationListener listener) {
listeners.add(listener);
return this;
}
@Override
public Counter counter(String name) {
return findMetricOrCreate(name, Counter.class.getTypeName(), new CounterImpl(),
new Tag[0]);
}
@Override
public Counter counter(Metadata metadata) {
return findMetricOrCreate(metadata, Counter.class.getTypeName());
}
@Override
public Counter counter(String name, Tag... tags) {
return findMetricOrCreate(name, Counter.class.getTypeName(), new CounterImpl(), tags);
}
@Override
public Counter counter(Metadata metadata, Tag... tags) {
return findMetricOrCreate(metadata, Counter.class.getTypeName(), tags);
}
@Override
public Counter counter(MetricID metricID) {
return findMetricOrCreate(metricID.getName(), Counter.class.getTypeName(), new CounterImpl(), metricID.getTagsAsArray());
}
@Override
public Gauge gauge(Metadata metadata, T object, Function func, Tag... tags) {
return gauge(metadata, () -> func.apply(object), tags);
}
@Override
public Gauge gauge(MetricID metricID, Supplier supplier) {
return gauge(metricID.getName(), supplier, metricID.getTagsAsArray());
}
@Override
public Gauge gauge(MetricID metricID, T object, Function func) {
return gauge(metricID, () -> func.apply(object));
}
@Override
public Gauge gauge(Metadata metadata, Supplier supplier, Tag... tags) {
return findMetricOrCreate(metadata, Gauge.class.getTypeName(), createGauge(supplier), tags);
}
@Override
public Gauge gauge(String name, Supplier supplier, Tag... tags) {
return findMetricOrCreate(name, Gauge.class.getTypeName(), createGauge(supplier), tags);
}
/**
* This is a non-standard feature that the {@link Supplier} passed to a {@code gauge}-method can implement
* {@link Gauge} as well in which case the passed instance is not wrapped in another lambda to get to {@link Gauge}
* interface.
*/
@SuppressWarnings("unchecked")
private static Gauge createGauge(Supplier supplier) {
return supplier instanceof Gauge ? (Gauge) supplier : () -> supplier.get();
}
@Override
public Gauge gauge(String name, T object, Function func, Tag... tags) {
return gauge(name, () -> func.apply(object), tags);
}
@Override
public Histogram histogram(String name, Tag... tags) {
return findMetricOrCreate(name, Histogram.class.getTypeName(), new HistogramImpl(name, percentilesConfigMap, histogramBucketsConfigMap), tags);
}
@Override
public Histogram histogram(Metadata metadata, Tag... tags) {
return findMetricOrCreate(metadata, Histogram.class.getTypeName(),new HistogramImpl(metadata.getName(),
percentilesConfigMap, histogramBucketsConfigMap), tags);
}
@Override
public Histogram histogram(String name) {
return findMetricOrCreate(name, Histogram.class.getTypeName(),
new HistogramImpl(name, percentilesConfigMap, histogramBucketsConfigMap),
new Tag[0]);
}
@Override
public Histogram histogram(Metadata metadata) {
return findMetricOrCreate(metadata, Histogram.class.getTypeName());
}
@Override
public Histogram histogram(MetricID metricID) {
return findMetricOrCreate(metricID.getName(), Histogram.class.getTypeName(), new HistogramImpl(metricID.getName(),
percentilesConfigMap, histogramBucketsConfigMap),
metricID.getTagsAsArray());
}
@Override
public Timer timer(String name, Tag... tags) {
return findMetricOrCreate(name, Timer.class.getTypeName(), null, tags);
}
@Override
public Timer timer(Metadata metadata, Tag... tags) {
return findMetricOrCreate(metadata, Timer.class.getTypeName(), null, tags);
}
@Override
public Timer timer(String name) {
return findMetricOrCreate(name, Timer.class.getTypeName(), null, new Tag[0]);
}
@Override
public Timer timer(Metadata metadata) {
return findMetricOrCreate(metadata, Timer.class.getTypeName());
}
@Override
public Timer timer(MetricID metricID) {
return findMetricOrCreate(metricID.getName(), Timer.class.getTypeName(), null, metricID.getTagsAsArray());
}
@Override
public Counter getCounter(MetricID metricID) {
return getMetric(metricID, Counter.class);
}
@Override
public Gauge getGauge(MetricID metricID) {
return getMetric(metricID, Gauge.class);
}
@Override
public Histogram getHistogram(MetricID metricID) {
return getMetric(metricID, Histogram.class);
}
@Override
public Timer getTimer(MetricID metricID) {
return getMetric(metricID, Timer.class);
}
@Override
public Metric getMetric(MetricID metricID) {
MetricFamily family = metricsFamiliesByName.get(metricID.getName());
return family == null ? null : family.get(metricID);
}
@Override
public SortedSet getMetricIDs() {
TreeSet ids = new TreeSet<>();
for (MetricFamily e : metricsFamiliesByName.values()) {
ids.addAll(e.metrics.keySet());
}
return ids;
}
@Override
public SortedSet getNames() {
return new TreeSet<>(metricsFamiliesByName.keySet());
}
@Override
public SortedMap getGauges() {
return getGauges(ALL);
}
@Override
public SortedMap getGauges(MetricFilter filter) {
return findMetrics(Gauge.class, filter);
}
@Override
public SortedMap getCounters() {
return getCounters(ALL);
}
@Override
public SortedMap getCounters(MetricFilter filter) {
return findMetrics(Counter.class, filter);
}
@Override
public SortedMap getHistograms() {
return getHistograms(ALL);
}
@Override
public SortedMap getHistograms(MetricFilter filter) {
return findMetrics(Histogram.class, filter);
}
@Override
public SortedMap getTimers() {
return getTimers(ALL);
}
@Override
public SortedMap getTimers(MetricFilter filter) {
return findMetrics(Timer.class, filter);
}
@Override
public Map getMetrics() {
return findMetrics((id, metric) -> true);
}
@Override
public Map getMetadata() {
return metricsFamiliesByName.entrySet().stream().collect(toMap(Entry::getKey,
e -> e.getValue().metadata));
}
@Override
public String getScope() {
return scope;
}
@Override
public boolean remove(String name) {
return metricsFamiliesByName.remove(name) != null;
}
@Override
public boolean remove(MetricID metricID) {
AtomicBoolean removed = new AtomicBoolean();
metricsFamiliesByName.computeIfPresent(metricID.getName(), (name, family) -> {
if (family.remove(metricID)) {
removed.set(true);
}
return family.metrics.isEmpty() ? null : family;
});
return removed.get();
}
@Override
public void removeMatching(MetricFilter filter) {
if (filter == MetricFilter.ALL) {
metricsFamiliesByName.clear();
}
Iterator> familyIter = metricsFamiliesByName.values().iterator();
while (familyIter.hasNext()) {
MetricFamily family = familyIter.next();
Iterator> metricIter = family.metrics.entrySet().iterator();
while (metricIter.hasNext()) {
Entry entry = metricIter.next();
if (filter.matches(entry.getKey(), entry.getValue())) {
remove(entry.getKey()); // OBS! it is important to not use the iterator.remove() so that the family is removed "atomically" when empty
}
}
}
}
private SortedMap findMetrics(Class metricClass, MetricFilter filter) {
return findMetrics((id, metric) -> metricClass.isInstance(metric) && filter.matches(id, metric));
}
@SuppressWarnings("unchecked")
private SortedMap findMetrics(MetricFilter filter) {
SortedMap matches = new TreeMap<>();
for (MetricFamily family : metricsFamiliesByName.values()) {
for (Entry entry : family.metrics.entrySet()) {
if (filter.matches(entry.getKey(), entry.getValue())) {
matches.put(entry.getKey(), (T) entry.getValue());
}
}
}
return matches;
}
private T findMetricOrCreate(String name, String typeName, T metric, Tag... tags) {
checkNameIsNotNullOrEmpty(name);
Metadata metadata = null;
if(Timer.class.getTypeName().equals(typeName)) {
metadata = Metadata.builder()
.withName(name)
.withUnit(MetricUnits.SECONDS)
.build();
} else {
metadata = Metadata.builder()
.withName(name)
.build();
}
return findMetricOrCreate(metadata, true, typeName, metric, tags);
}
private T findMetricOrCreate(Metadata metadata, String typeName, Tag... tags) {
return findMetricOrCreate(metadata, typeName, null, tags);
}
private T findMetricOrCreate(Metadata metadata, String typeName, T metric, Tag... tags) {
return findMetricOrCreate(withType(metadata), false, typeName, metric, tags);
}
@SuppressWarnings("unchecked")
private T findMetricOrCreate(Metadata metadata, boolean useExistingMetadata, String metricType, T metric, Tag... tags) {
validateTags(tags);
MetricID metricID = new MetricID(metadata.getName(), tags);
MetricFamily family = metricsFamiliesByName.get(metricID.getName());
if (family == null) {
return register(metadata, useExistingMetadata, metricType, metric, tags);
}
Metric existing = family.get(metricID);
if(existing == null) {
checkSameType(metricID, metricType, family.metrics);
if((useExistingMetadata && hasSameTagNames(metricID)) || hasSameTagNames(metricID)) {
return register(metadata, useExistingMetadata, metricType, metric, tags);
} else {
throw new IllegalArgumentException(
String.format("Tried to lookup a metric id with conflicting tags, %s", metricID.toString()));
}
}
return (T) existing;
}
/**
* This method will check if there is an available metric with the same tag names
* @param metricID used to search an available metric
* @return boolean indicating if there is an available Metric with same or different tag names
*/
private boolean hasSameTagNames(MetricID metricID) {
Optional optSameNameDifferentTags = getMetrics(metricID.getName()).keySet().stream()
.filter(m -> m.getTags().size() != metricID.getTags().size()).findAny();
if(optSameNameDifferentTags.isPresent()) {
return false;
}
Optional optSameNameSameTagsDifferentContent = getMetrics(metricID.getName()).keySet().stream()
.filter(m -> m.getTags().size() == metricID.getTags().size())
.filter(m -> !m.getTagsAsString().equals(metricID.getTagsAsString())).findAny();
if(optSameNameSameTagsDifferentContent.isPresent()) {
List metrics = getMetrics(metricID.getName()).keySet().stream()
.filter(m -> m.getTags().size() == metricID.getTags().size()).collect(Collectors.toList());
for(Tag t : metricID.getTagsAsArray()) {
Optional result = metrics.stream().filter(m -> m.getTags().containsKey(t.getTagName())).findAny();
if(result.isEmpty()){
return false;
}
}
}
return true;
}
/**
* This method validates if the mp_scope and the mp_app tag names are used for the metric.
* If that is the case this will throw an IllegalArgumentException indicating that those are reserved tag names
* @param tags the array of available tags for the metric before to be created
*/
public static void validateTags(Tag[] tags) {
if(tags != null) {
Optional result = Arrays.stream(tags)
.filter(t -> t.getTagName().equals(MetricUtils.TAG_METRIC_MP_SCOPE_NAME)
|| t.getTagName().equals(MetricUtils.TAG_METRIC_MP_APP_NAME)).findFirst();
if (result.isPresent()) {
throw new IllegalArgumentException("invalid tags: " + tags +
", tags must not contain following reserved tag names: mp_scope and mp_app");
}
}
}
public T register(Metadata metadata, String metricType, T metric, Tag... tags) throws IllegalArgumentException {
return register(metadata, false, metricType, metric, tags);
}
@SuppressWarnings("unchecked")
private T register(Metadata metadata, boolean useExistingMetadata, String metricType, T metric, Tag... tags) {
String name = metadata.getName();
checkNameIsNotNullOrEmpty(name);
if (useExistingMetadata) {
Metadata existingMetadata = getMetadata(name);
if (existingMetadata != null) {
metadata = existingMetadata;
}
}
final Metadata newMetadata = metadata;
//verify here the new properties
final T newMetric = metric != null ? metric:(T) createMetricInstance(newMetadata, metricType);
MetricFamily family = (MetricFamily) metricsFamiliesByName.computeIfAbsent(name,
key -> new MetricFamily<>(newMetadata));
MetricID metricID = new MetricID(name, tags);
if (family.metadata != newMetadata) {
checkSameType(metricID, metricType, family.metrics);
checkReusableMetadata(name, newMetadata, family.metadata);
}
T current = family.metrics.computeIfAbsent(metricID, key -> newMetric);
notifyRegistrationListeners(metricID);
return current;
}
private void notifyRegistrationListeners(MetricID metricID) {
for (MetricRegistrationListener l : listeners) {
try {
l.onRegistration(metricID, scope);
} catch (RuntimeException ex) {
LOGGER.log(Level.WARNING, "Registration listener threw exception:", ex);
}
}
}
private static void checkNameIsNotNullOrEmpty(String name) {
if (name == null || name.trim().isEmpty()) {
throw new IllegalArgumentException("Metric name must not be null or empty");
}
}
private static void checkReusableMetadata(String name, Metadata newMetadata, Metadata existingMetadata) {
if (!existingMetadata.equals(newMetadata)) {
throw new IllegalArgumentException(String.format(
"Metadata ['%s'] already registered, does not match provided ['%s']",
existingMetadata.toString(), newMetadata.toString()
));
}
}
public void checkSameType(MetricID metricID, String metricType, ConcurrentMap metrics) {
Optional> optResult = Optional.empty();
Optional[]> interfacesArrayOpt = metrics.values().stream().map(c -> c.getClass().getInterfaces()).findAny();
if(interfacesArrayOpt.isPresent()) {
optResult = Arrays.stream(interfacesArrayOpt.get()).filter(i->!i.getTypeName().contains(Supplier.class.getName()))
.filter(i->!i.getTypeName().equals(metricType)).findAny();
}
if(optResult.isPresent()) {
throw new IllegalArgumentException(String.format(
"Metric ['%s'] type['%s'] does not match with existing type['%s']",
metricID.getName(), getMetricClassName(metricType), getMetricClassName(optResult.get().getName())
));
}
}
public String getMetricClassName(String name) {
String[] parts = name.split("\\.");
if(parts != null && parts.length > 0) {
return parts[parts.length -1];
}
return name;
}
private Metric createMetricInstance(Metadata metadata, String metricType) {
String name = MetricRegistry.name(metadata.getName());
if(Counter.class.getName().equals(metricType)) {
return new CounterImpl();
}
if(Gauge.class.getName().equals(metricType)) {
throw new IllegalArgumentException(String.format("Unsupported operation for Gauge ['%s']", name));
}
if(Histogram.class.getName().equals(metricType)) {
return new HistogramImpl();
}
if(Timer.class.getName().equals(metricType)) {
return new TimerImpl(name, percentilesConfigMap, timerBucketsConfigMap, clock);
}
throw new IllegalArgumentException("Invalid metric type : "+metricType);
}
@SuppressWarnings("unchecked")
public T getMetricCustomScope(MetricID metricID, Class ofType, String scope) {
return this.getMetric(metricID, ofType);
}
@Override
@SuppressWarnings("unchecked")
public T getMetric(MetricID metricID, Class ofType) {
MetricFamily family = metricsFamiliesByName.get(metricID.getName());
if (family == null) {
return null;
}
Metric metric = family.get(metricID);
if (metric != null && !ofType.isAssignableFrom(metric.getClass())) {
throw new IllegalArgumentException("Invalid metric type : " + ofType);
}
if(metric == null) {
metric = verifyMetrics(metricID, family);
}
return (T) metric;
}
public T verifyMetrics(MetricID metricID, MetricFamily family) {
Metric m = null;
List metricList =
this.getMetrics().entrySet().stream()
.filter(e -> e.getKey().getName().equals(metricID.getName()))
.filter(e -> e.getKey().getTags().size() == metricID.getTags().size())
.map(e -> e.getKey()).collect(Collectors.toList());
if (metricList.size() > 0) {
Optional metricOptional = metricList.stream()
.filter(l -> l.getTags().equals(metricID.getTags())).findAny();
if (metricOptional.isPresent()) {
m = family.get(metricOptional.get());
}
}
return (T) m;
}
@SuppressWarnings("unchecked")
@Override
public SortedMap getMetrics(Class ofType, MetricFilter filter) {
return (SortedMap) findMetrics(
(metricID, metric) -> filter.matches(metricID, metric) && ofType.isAssignableFrom(metric.getClass()));
}
@Override
public SortedMap getMetrics(MetricFilter filter) {
return findMetrics(filter);
}
@Override
public Metadata getMetadata(String name) {
MetricFamily family = metricsFamiliesByName.get(name);
return family == null ? null : family.metadata;
}
/*
* Non-API Methods (Extra Methods)
*/
public Set getMetricsIDs(String name) {
MetricFamily family = metricsFamiliesByName.get(name);
return family == null ? emptySet() : unmodifiableSet(family.metrics.keySet());
}
public Map getMetrics(String name) {
MetricFamily family = metricsFamiliesByName.get(name);
return family == null
? emptyMap()
: unmodifiableMap(family.metrics);
}
@Override
public String toString() {
StringBuilder str = new StringBuilder();
for (Entry> family : metricsFamiliesByName.entrySet()) {
str.append(family.getKey()).append(": ").append(family.getValue().metadata).append('\n');
for (Entry entry : family.getValue().metrics.entrySet()) {
str.append('\t').append(entry.getKey()).append(": ").append(toString(entry.getValue())).append('\n');
}
}
return str.toString();
}
private static String toString(Metric metric) {
if (isLambda(metric) && metric instanceof Gauge) {
return "Gauge["+((Gauge)metric).getValue()+"]";
}
return metric.toString();
}
public static boolean isLambda(Object obj) {
return obj.getClass().toString().contains("$$Lambda$");
}
/**
* This is a workaround to prevent setting display name field as side effect of using
* {@link Metadata#builder(Metadata)}. It does not prevent the issue in case the type needs setting but it can if it
* does not need to be set. There is no API way to make the resulting {@link Metadata} identical in case the type is
* set.
*/
private static Metadata withType(Metadata metadata) {
return Metadata.builder(metadata).build();
}
}