org.eclipse.microprofile.metrics.MetricFilter Java Examples

@Override
public SortedMap<MetricID, Metric> getMetrics(MetricFilter filter) {
    SortedMap<MetricID, Metric> out = new TreeMap<>();
    for (Map.Entry<MetricID, Metric> entry : metricMap.entrySet()) {
        if (filter.matches(entry.getKey(), entry.getValue())) {
            out.put(entry.getKey(), entry.getValue());
        }
    }
    return out;
}
 

private <T extends Metric> SortedMap<MetricID, T> getMetrics(MetricType type, MetricFilter filter) {
    SortedMap<MetricID, T> out = new TreeMap<>();

    for (Map.Entry<MetricID, Metric> entry : metricMap.entrySet()) {
        if (isSameType(entry.getValue(), type)) {
            if (filter.matches(entry.getKey(), entry.getValue())) {
                out.put(entry.getKey(), (T) entry.getValue());
            }
        }
    }
    return out;
}
 

/**
 * One set of threads is registering new metrics and removing them after a short while,
 * at the same time, another set of threads is retrieving a list of metrics conforming to a filter.
 * None of the threads should be getting any exceptions.
 */
@Test
public void tryRegisteringRemovingAndReadingAtTheSameTime() throws InterruptedException {
    for (int i = 0; i < 20; i++) {
        cleanup();
        final ExecutorService executor = Executors.newFixedThreadPool(10);
        final CompletableFuture[] futures = IntStream.range(0, 200)
                .parallel()
                .mapToObj(j -> CompletableFuture.runAsync(
                        () -> {
                            try {
                                if (j % 2 == 0) {
                                    MetricID metricID = new MetricID("mycounter", new Tag("number", String.valueOf(j)));
                                    registry.counter("mycounter", new Tag("number", String.valueOf(j)));
                                    registry.remove(metricID);
                                } else {
                                    registry.getCounters(MetricFilter.ALL);
                                }
                            } catch (Throwable t) {
                                t.printStackTrace();
                                throw t;
                            }
                        }, executor))
                .toArray(CompletableFuture[]::new);
        executor.shutdown();
        executor.awaitTermination(10, TimeUnit.SECONDS);

        assertEquals("All threads should finish without exceptions",
                0, Arrays.stream(futures).filter(CompletableFuture::isCompletedExceptionally).count());
    }
}
 

@Override
public void removeMatching(MetricFilter metricFilter) {
    Iterator<Map.Entry<MetricID, Metric>> iterator = metricMap.entrySet().iterator();
    while (iterator.hasNext()) {
        Map.Entry<MetricID, Metric> entry = iterator.next();
        if (metricFilter.matches(entry.getKey(), entry.getValue())) {
            remove(entry.getKey());
        }
    }
}
 

@Override
public java.util.SortedMap<MetricID, Timer> getTimers() {
    return getTimers(MetricFilter.ALL);
}
 

@Override
public java.util.SortedMap<MetricID, Meter> getMeters(MetricFilter metricFilter) {
    return getMetrics(MetricType.METERED, metricFilter);
}
 

@Override
public java.util.SortedMap<MetricID, Timer> getTimers(MetricFilter metricFilter) {
    return getMetrics(MetricType.TIMER, metricFilter);
}
 

@Override
public SortedMap<MetricID, SimpleTimer> getSimpleTimers() {
    return getSimpleTimers(MetricFilter.ALL);

}
 

@Override
public SortedMap<MetricID, SimpleTimer> getSimpleTimers(MetricFilter filter) {
    return getMetrics(MetricType.SIMPLE_TIMER, filter);
}
 

@Override
public <T extends Metric> SortedMap<MetricID, T> getMetrics(Class<T> ofType, MetricFilter filter) {
    return (SortedMap<MetricID, T>) getMetrics(
            (metricID, metric) -> filter.matches(metricID, metric)
                    && ofType.isAssignableFrom(metric.getClass()));
}
 

@After
public void cleanup() {
    registry.removeMatching(MetricFilter.ALL);
}
 

@After
public void cleanupApplicationMetrics() {
    registry.removeMatching(MetricFilter.ALL);
}
 

@After
public void cleanupApplicationMetrics() {
    registry.removeMatching(MetricFilter.ALL);
}
 

@After
public void cleanup() {
    registry.removeMatching(MetricFilter.ALL);
}
 

@After
public void cleanupApplicationMetrics() {
    registry.removeMatching(MetricFilter.ALL);
}
 

@After
public void cleanup() {
    MetricRegistries.get(MetricRegistry.Type.APPLICATION).removeMatching(MetricFilter.ALL);
}
 

@After
public void cleanupApplicationMetrics() {
    MetricRegistries.get(MetricRegistry.Type.APPLICATION).removeMatching(MetricFilter.ALL);
}
 

@After
public void cleanupApplicationMetrics() {
    MetricRegistries.get(MetricRegistry.Type.APPLICATION).removeMatching(MetricFilter.ALL);
    MetricRegistries.get(MetricRegistry.Type.BASE).removeMatching(MetricFilter.ALL);
    MetricRegistries.get(MetricRegistry.Type.VENDOR).removeMatching(MetricFilter.ALL);
}
 

@After
public void cleanupApplicationMetrics() {
    MetricRegistries.get(MetricRegistry.Type.APPLICATION).removeMatching(MetricFilter.ALL);
}
 

@Test
public void theAllFilterMatchesAllMetrics() throws Exception {
    Assert.assertTrue(MetricFilter.ALL.matches(new MetricID(""), metric));
}
 

@After
public void cleanupApplicationMetrics() {
    registry.removeMatching(MetricFilter.ALL);
}
 

@Override
public SortedMap<MetricID, Gauge> getGauges() {
    return getGauges(MetricFilter.ALL);
}
 

@Override
public SortedMap<MetricID, Gauge> getGauges(MetricFilter filter) {
    throw new UnsupportedOperationException("unimplemented");
}
 

@Override
public SortedMap<MetricID, Counter> getCounters(MetricFilter filter) {
    throw new UnsupportedOperationException("unimplemented");
}
 

@Override
public SortedMap<MetricID, ConcurrentGauge> getConcurrentGauges(MetricFilter filter) {
    throw new UnsupportedOperationException("unimplemented");
}
 

@Override
public SortedMap<MetricID, Histogram> getHistograms(MetricFilter filter) {
    throw new UnsupportedOperationException("unimplemented");
}
 

@Override
public SortedMap<MetricID, Meter> getMeters(MetricFilter filter) {
    throw new UnsupportedOperationException("unimplemented");
}
 

@Override
public SortedMap<MetricID, Timer> getTimers(MetricFilter filter) {
    throw new UnsupportedOperationException("unimplemented");
}
 

@Override
public SortedMap<MetricID, SimpleTimer> getSimpleTimers(MetricFilter filter) {
    throw new UnsupportedOperationException("unimplemented");
}
 

@After
public void cleanupApplicationMetrics() {
    MetricRegistries.get(MetricRegistry.Type.APPLICATION).removeMatching(MetricFilter.ALL);
}