/** * 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; } }
/** * 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(); }
private void registerAnnotatedGauges(@Observes AfterDeploymentValidation adv, BeanManager bm) { LOGGER.log(Level.FINE, () -> "### registerGauges"); MetricRegistry registry = getMetricRegistry(); annotatedGaugeSites.entrySet().forEach(gaugeSite -> { LOGGER.log(Level.FINE, () -> "### gaugeSite " + gaugeSite.toString()); String gaugeName = gaugeSite.getKey(); AnnotatedMethodConfigurator<?> site = gaugeSite.getValue(); DelegatingGauge<?> dg = buildDelegatingGauge(gaugeName, site, bm); Gauge gaugeAnnotation = site.getAnnotated().getAnnotation(Gauge.class); Metadata md = new Metadata(gaugeName, gaugeAnnotation.displayName(), gaugeAnnotation.description(), MetricType.GAUGE, gaugeAnnotation.unit(), toTags(gaugeAnnotation.tags())); LOGGER.log(Level.FINE, () -> String.format("### Registering gauge with metadata %s", md.toString())); registry.register(md, dg); }); annotatedGaugeSites.clear(); }
public void gaugeMe() { @SuppressWarnings("unchecked") Gauge<Integer> gaugeManual = metrics.getGauges().get("tck.gaugetest.gaugemanual"); if (gaugeManual == null) { gaugeManual = value::getAndIncrement; metrics.register("tck.gaugetest.gaugemanual", gaugeManual); } }
private void registerNonDropwizardMetrics(MetricRegistry registry, Map<String, Metadata> metadataMap) { ClassLoadingMXBean classLoadingMXBean = ManagementFactory.getClassLoadingMXBean(); registry.register(metadataMap.get("classloader.currentLoadedClass.count"), new ForwardingCounter() { @Override public long getCount() { registry.register(metadataMap.get("classloader.totalLoadedClass.count"), new ForwardingCounter() { @Override public long getCount() { registry.register(metadataMap.get("classloader.totalUnloadedClass.count"), new ForwardingCounter() { @Override public long getCount() { registry.register(metadataMap.get("thread.count"), new ForwardingCounter() { @Override public long getCount() { registry.register(metadataMap.get("thread.daemon.count"), new ForwardingCounter() { @Override public long getCount() { registry.register(metadataMap.get("thread.max.count"), new ForwardingCounter() { @Override public long getCount() { registry.register(metadataMap.get("cpu.availableProcessors"), (Gauge<Integer>) operatingSystemMXBean::getAvailableProcessors); registry.register(metadataMap.get("cpu.systemLoadAverage"), (Gauge<Double>) operatingSystemMXBean::getSystemLoadAverage);
private void gaugeRegister(String name, Supplier<Long> supplier) { Gauge<?> gauge = registry.getGauges().get(name); if (gauge == null) { synchronized (operation) { gauge = registry.getGauges().get(name); if (gauge == null) { registry.register(name, (Gauge<Long>) () -> supplier.get()); } } } }
public void gaugeMe() { @SuppressWarnings("unchecked") Gauge<Long> gauge = metrics.getGauges().get("metricTest.test1.gauge"); if (gauge == null) { gauge = () -> { return 19L; }; Metadata gaugeMetadata = new Metadata("metricTest.test1.gauge",MetricType.GAUGE, MetricUnits.GIGABYTES); metrics.register("metricTest.test1.gauge", gauge, gaugeMetadata); } }
private void registerDropwizardMetrics(MetricRegistry registry, MetricSet metricSet, Map<String, Metadata> metadataMap) { for (Map.Entry<String, Metric> entry : metricSet.getMetrics().entrySet()) { Metadata metadata = metadataMap.get(entry.getKey()); if(metadata != null) { registry.register(metadata, convertMetric(entry.getValue(), metadata.getTypeRaw())); } } }
private void registerProducer(final BeanManager beanManager, final org.eclipse.microprofile.metrics.annotation.Metric config, final Class<?> clazz, final Member javaMember, final Bean<?> bean) { Class<?> beanClass = bean.getBeanClass(); if (beanClass == null) { beanClass = javaMember.getDeclaringClass(); } final Metadata metadata = createMetadata(config, clazz, javaMember, beanClass); applicationRegistry.register(metadata, Metric.class.cast(getInstance(clazz, beanManager, bean))); }
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(); } }
@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")); }
private void registerDropwizardGcMetrics(MetricRegistry registry, GarbageCollectorMetricSet metricSet) { for(Map.Entry<String, Metric> entry : metricSet.getMetrics().entrySet()) { if(entry.getKey().endsWith(".count")) { String garbageCollectorName = entry.getKey().substring(0, entry.getKey().lastIndexOf(".count")); Metadata metadata = new Metadata("gc." + garbageCollectorName + ".count", "Garbage Collection Count", "Displays the total number of collections that have occurred. This attribute lists " + "-1 if the collection count is undefined for this collector.", MetricType.COUNTER, MetricUnits.NONE); registry.register(metadata, convertMetric(entry.getValue(), MetricType.COUNTER)); } else if(entry.getKey().endsWith(".time")) { String garbageCollectorName = entry.getKey().substring(0, entry.getKey().lastIndexOf(".time")); Metadata metadata = new Metadata("gc." + garbageCollectorName + ".time", "Garbage Collection Time", "Displays the approximate accumulated collection elapsed time in milliseconds. " + "This attribute displays -1 if the collection elapsed time is undefined for this " + "collector. The Java virtual machine implementation may use a high resolution " + "timer to measure the elapsed time. This attribute may display the same value " + "even if the collection count has been incremented if the collection elapsed " + "time is very short.", MetricType.GAUGE, MetricUnits.MILLISECONDS); registry.register(metadata, convertMetric(entry.getValue(), MetricType.GAUGE)); } } }
private synchronized <E extends Member & AnnotatedElement> void registerMetrics(Class<?> bean, E element) { if (processedElements.contains(element)) { return; } if (AnnotationMetadata.getAnnotation(bean, element, Counted.class) != null) { Metadata m = AnnotationMetadata.buildMetadata(bean, element, Counted.class); registry.register(m, new CounterImpl()); } if (AnnotationMetadata.getAnnotation(bean, element, Timed.class) != null) { Metadata m = AnnotationMetadata.buildMetadata(bean, element, Timed.class); registry.register(m, new TimerImpl()); } if (AnnotationMetadata.getAnnotation(bean, element, Metered.class) != null) { Metadata m = AnnotationMetadata.buildMetadata(bean, element, Metered.class); registry.register(m, new MeterImpl()); } processedElements.add(element); } }
/** * 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(); }
@AroundConstruct private Object gaugeBeanConstructor(InvocationContext context) throws Exception { Object target = context.proceed(); Class<?> type = context.getConstructor().getDeclaringClass(); do { for (Method method : type.getDeclaredMethods()) { if(method.isAnnotationPresent(org.eclipse.microprofile.metrics.annotation.Gauge.class)) { Metadata metadata = AnnotationMetadata.buildMetadata(type, method, org.eclipse.microprofile.metrics.annotation.Gauge.class); Gauge gauge = applicationRegistry.getGauges().get(metadata.getName()); if (gauge == null) { applicationRegistry.register(metadata, new ForwardingGauge(method, context.getTarget())); } } } type = type.getSuperclass(); } while (!Object.class.equals(type)); return target; } }
private void registerAnnotatedGauges(@Observes AfterDeploymentValidation adv, BeanManager bm) { LOGGER.log(Level.FINE, () -> "### registerGauges"); MetricRegistry registry = getMetricRegistry(); annotatedGaugeSites.entrySet().forEach(gaugeSite -> { LOGGER.log(Level.FINE, () -> "### gaugeSite " + gaugeSite.toString()); String gaugeName = gaugeSite.getKey(); AnnotatedMethodConfigurator<?> site = gaugeSite.getValue(); DelegatingGauge<?> dg = buildDelegatingGauge(gaugeName, site, bm); Gauge gaugeAnnotation = site.getAnnotated().getAnnotation(Gauge.class); Metadata md = new Metadata(gaugeName, gaugeAnnotation.displayName(), gaugeAnnotation.description(), MetricType.GAUGE, gaugeAnnotation.unit(), toTags(gaugeAnnotation.tags())); LOGGER.log(Level.FINE, () -> String.format("### Registering gauge with metadata %s", md.toString())); registry.register(md, dg); }); annotatedGaugeSites.clear(); }
public void register() { final RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean(); registry.register(new Metadata( "jvm.uptime", "JVM Uptime", registry.register(new Metadata( "cpu.availableProcessors", "Available Processors", registry.register(new Metadata( "classloader.currentLoadedClass.count", "Current Loaded Class Count", "Displays the number of classes that are currently loaded in the Java virtual machine.", MetricType.COUNTER, MetricUnits.NONE), counter(classLoadingMXBean::getLoadedClassCount)); registry.register(new Metadata( "classloader.totalLoadedClass.count", "Total Loaded Class Count", "Displays the total number of classes that have been loaded since the Java virtual machine has started execution.", MetricType.COUNTER, MetricUnits.NONE), counter(classLoadingMXBean::getTotalLoadedClassCount)); registry.register(new Metadata( "classloader.totalUnloadedClass.count", "Total Unloaded Loaded Class Count", registry.register(new Metadata( "thread.count", "Thread Count", "Displays the current number of live threads including both daemon and non-daemon threads", MetricType.COUNTER, MetricUnits.NONE), counter(threadMXBean::getThreadCount)); registry.register(new Metadata(
private void registerMetrics(@Observes AfterDeploymentValidation adv, BeanManager manager) { for (ProducerMemberRegistration registration : producerMembers) { if (registration.getBean().getQualifiers().contains(DEFAULT) && !hasInjectionPoints(registration.getMember())) { applicationRegistry.register(registration.getMetadata(), getReference(manager, registration.getMember().getBaseType(), registration.getBean())); } } }