/** * Register a gauge with nanos as unit. Checks if gauge is already registered * using synchronization. * * @param metricName Name of metric. * @param description Description of gauge. * @return The gauge created or existing if already created. */ @SuppressWarnings("unchecked") static synchronized <T> Gauge<T> registerGauge(Method method, String metricName, String description, Gauge<T> gauge) { String name = String.format(METRIC_NAME_TEMPLATE, method.getDeclaringClass().getName(), method.getName(), metricName); Gauge<T> existing = getMetricRegistry().getGauges().get(name); if (existing == null) { getMetricRegistry().register(new Metadata(name, name, description, MetricType.GAUGE, MetricUnits.NANOSECONDS), gauge); } return existing; } }
counted.unit(), toTags(counted.tags())); registry.counter(meta); LOGGER.log(Level.FINE, () -> "### Registered counter " + metricName); } else if (annotation instanceof Metered) { metered.unit(), toTags(metered.tags())); registry.meter(meta); LOGGER.log(Level.FINE, () -> "### Registered meter " + metricName); } else if (annotation instanceof Timed) { timed.unit(), toTags(timed.tags())); registry.timer(meta); LOGGER.log(Level.FINE, () -> "### Registered timer " + metricName);
/** * Register a histogram with nanos as unit. * * @param name Name of histogram. * @param description Description of histogram. * @return The histogram created. */ static Histogram registerHistogram(String name, String description) { return getMetricRegistry().histogram(new Metadata(name, name, description, MetricType.HISTOGRAM, MetricUnits.NANOSECONDS)); }
@Test @InSequence(1) public void cachedMethodNotCalledYet() { assertThat("Metrics are not registered correctly", registry.getMetrics(), allOf( hasKey(CALLS_METRIC), hasKey(HITS_METRIC), hasKey(CACHE_HITS_METRIC) ) ); Timer calls = registry.getTimers().get(CALLS_METRIC); Meter hits = registry.getMeters().get(HITS_METRIC); @SuppressWarnings("unchecked") Gauge<Double> gauge = (Gauge<Double>) registry.getGauges().get(CACHE_HITS_METRIC); assertThat("Gauge value is incorrect", gauge.getValue(), is(equalTo(((double) hits.getCount() / (double) calls.getCount())))); }
/** * Registers metrics for all field and method producers defined by the application. * * @param adv After deployment validation event. * @param bm Bean manager. */ private void registerProducers(@Observes AfterDeploymentValidation adv, BeanManager bm) { LOGGER.log(Level.FINE, () -> "### registerProducers"); MetricRegistry registry = getMetricRegistry(); producers.entrySet().forEach(entry -> { Metric metric = entry.getValue().getAnnotation(Metric.class); if (metric != null) { String metricName = getMetricName(new AnnotatedElementWrapper(entry.getValue()), entry.getValue().getDeclaringType().getJavaClass(), MetricUtil.MatchingType.METHOD, metric.name(), metric.absolute()); registry.register(metricName, getReference(bm, entry.getValue().getBaseType(), entry.getKey())); } }); producers.clear(); }
Metadata meterMetadata = new Metadata(MetricRegistry.name(metricPrefix, "status", sc.toString()), sc + " responses on " + instrumentationName, "Number of responses with status code " + sc + " on " + instrumentationName, MetricType.METERED, MetricUnits.NONE); metersByStatusCode.put(sc, metricsRegistry.meter(meterMetadata)); Metadata otherMetadata = new Metadata(MetricRegistry.name(metricPrefix, "status", "other"), "Other responses on " + instrumentationName, "Number of responses with other status codes on " + instrumentationName, MetricType.METERED, MetricUnits.NONE); this.otherMeter = metricsRegistry.meter(otherMetadata); Metadata timeoutsMetadata = new Metadata(MetricRegistry.name(metricPrefix, "timeouts"), "Timeouts on " + instrumentationName, "Number of timeouts on " + instrumentationName, MetricType.METERED, MetricUnits.NONE); this.timeoutsMeter = metricsRegistry.meter(timeoutsMetadata); Metadata errorsMetadata = new Metadata(MetricRegistry.name(metricPrefix, "errors"), "Errors on " + instrumentationName, "Number of errors on " + instrumentationName, MetricType.METERED, MetricUnits.NONE); this.errorsMeter = metricsRegistry.meter(errorsMetadata); Metadata activeRequestsMetadata = new Metadata(MetricRegistry.name(metricPrefix, "activeRequests"), "Active requests on " + instrumentationName, "Number of active requests on " + instrumentationName, MetricType.METERED, MetricUnits.NONE); this.activeRequests = metricsRegistry.counter(activeRequestsMetadata);
break; case TIMER: addBean(afterBeanDiscovery, name, Timer.class, new MetricImpl(registration), applicationRegistry.timer(registration)); break; case COUNTER: addBean(afterBeanDiscovery, name, Counter.class, new MetricImpl(registration), applicationRegistry.counter(registration)); break; case METERED: addBean(afterBeanDiscovery, name, Meter.class, new MetricImpl(registration), applicationRegistry.meter(registration)); break; case HISTOGRAM: addBean(afterBeanDiscovery, name, Histogram.class, new MetricImpl(registration), applicationRegistry.histogram(registration)); break; default:
@Test @InSequence(2) public void registerTest() { metrics.register("regCountTemp", countTemp); Assert.assertTrue(metrics.getCounters().containsKey("regCountTemp")); metrics.register("regHistoTemp", histoTemp); Assert.assertTrue(metrics.getHistograms().containsKey("regHistoTemp")); metrics.register("regTimerTemp", timerTemp); Assert.assertTrue(metrics.getTimers().containsKey("regTimerTemp")); metrics.register("regMeterTemp", meterTemp); Assert.assertTrue(metrics.getMeters().containsKey("regMeterTemp")); }
@SuppressWarnings("unchecked") static <T extends Metric> T getMetric(Method method, String name) { String metricName = String.format(METRIC_NAME_TEMPLATE, method.getDeclaringClass().getName(), method.getName(), name); return (T) getMetricRegistry().getMetrics().get(metricName); }
void afterDeploymentValidation(@Observes final AfterDeploymentValidation afterDeploymentValidation, final BeanManager beanManager) { registrations.values().stream().filter(m -> m.getTypeRaw() == MetricType.GAUGE) .forEach(registration -> { final Gauge<?> gauge = gaugeFactories.get(registration.getName()).apply(beanManager); applicationRegistry.register(registration, gauge); }); producersRegistrations.forEach(Runnable::run); producersRegistrations.clear(); gaugeFactories.clear(); registrations.clear(); // mainly for tck, to drop if we add real vendor metrics vendorRegistry.counter("startTime").inc(System.currentTimeMillis()); if (!Boolean.getBoolean("geronimo.metrics.base.skip")) { new BaseMetrics(baseRegistry).register(); } }
/** * Returns the {@link Gauge} matching the criteria from the injection point. * * @param <T> type of the {@code Gauge} * @param registry metric registry * @param ip injection point being resolved * @return requested gauge */ @Produces @VendorDefined @SuppressWarnings("unchecked") private <T> Gauge<T> produceGauge(MetricRegistry registry, InjectionPoint ip) { Metric metric = ip.getAnnotated().getAnnotation(Metric.class); return (Gauge<T>) registry.getGauges().entrySet().stream() .filter(entry -> entry.getKey().equals(metric.name())) .findFirst() .orElseThrow(() -> new IllegalArgumentException("Could not produce Gauge for injection point " + ip.toString())) .getValue(); }
/** * Register a single counter. * * @param name Name of counter. * @param description Description of counter. * @return The counter created. */ private static Counter registerCounter(String name, String description) { return getMetricRegistry().counter(new Metadata(name, name, description, MetricType.COUNTER, MetricUnits.NONE)); }
public void badRegisterReusableMixed() { Metadata metadata = new Metadata("badReusableMixed", MetricType.HISTOGRAM); metadata.setReusable(true); Histogram histogram = registry.histogram(metadata); histogram.update(1); // We register a different metric type - that is forbidden // so we expect an exception Metadata metadata2 = new Metadata("badReusableMixed", MetricType.COUNTER); metadata2.setReusable(true); registry.counter(metadata2); }
@Produces @VendorDefined private Timer produceTimer(MetricRegistry registry, InjectionPoint ip) { Metric metric = ip.getAnnotated().getAnnotation(Metric.class); return registry.timer(newMetadata(ip, metric, MetricType.TIMER)); }
private Counter counterOf(String name) { Counter counter = registry.getCounters().get(name); if (counter == null) { synchronized (operation) { counter = registry.getCounters().get(name); if (counter == null) { counter = registry.counter(metadataOf(name, MetricType.COUNTER)); } } } return counter; }
private Histogram histogramOf(String name) { Histogram histogram = registry.getHistograms().get(name); if (histogram == null) { synchronized (operation) { histogram = registry.getHistograms().get(name); if (histogram == null) { histogram = registry.histogram(MetricsCollectorFactory.metadataOf(name, MetricType.HISTOGRAM)); } } } return histogram; }
@Test @InSequence(1) public void countersNotIncrementedYet() { assertThat("Counters are not registered correctly", registry.getCounters(), allOf( hasKey("counter1"), hasKey("counter2"), not(hasKey("not_registered_counter")) ) ); Counter counter1 = registry.getCounters().get("counter1"); Counter counter2 = registry.getCounters().get("counter2"); assertThat("Gauge is not registered correctly", registry.getGauges(), hasKey("ratioGauge")); @SuppressWarnings("unchecked") Gauge<Double> gauge = (Gauge<Double>) registry.getGauges().get("ratioGauge"); assertThat("Gauge value is incorrect", gauge.getValue(), is(equalTo(((double) counter1.getCount()) / ((double) counter2.getCount())))); }
@Test @InSequence(1) public void overloadedTimedMethodNotCalledYet() { Assert.assertTrue("Metrics are not registered correctly", registry.getMetrics().keySet().containsAll(absoluteMetricNames())); // Make sure that all the timers haven't been called yet assertThat("Timer counts are incorrect", registry.getTimers().values(), hasItem(Matchers.<Timer> hasProperty("count", equalTo(0L)))); }
private void writeMetricsAsPrometheus(StringBuilder builder, String registryName, MetricRegistry registry) { writeMetricMapAsPrometheus(builder, registryName, registry.getMetrics(), registry.getMetadata()); }
@Produces @VendorDefined private Meter produceMeter(MetricRegistry registry, InjectionPoint ip) { Metric metric = ip.getAnnotated().getAnnotation(Metric.class); return registry.meter(newMetadata(ip, metric, MetricType.METERED)); }