static Metadata gcTimeMeta(String poolName) { return new Metadata("gc." + poolName + ".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); }
static Metadata gcCountMeta(String poolName) { return new Metadata("gc." + poolName + ".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.GAUGE, MetricUnits.NONE); }
@Override public Counter counter(String name) { return counter(new Metadata(name, MetricType.COUNTER)); }
@Override public Meter meter(String name) { return meter(new Metadata(name, MetricType.METERED)); }
@Override public Histogram histogram(String name) { return histogram(new Metadata(name, MetricType.HISTOGRAM)); }
@Override public Timer timer(String name) { return timer(new Metadata(name, MetricType.TIMER)); }
private <T extends Metric> MetricImpl toImpl(String name, T metric) { // Find subtype of Metric, needed for user-defined metrics Class<?> clazz = metric.getClass(); do { Optional<Class<?>> optionalClass = Arrays.stream(clazz.getInterfaces()) .filter(c -> Metric.class.isAssignableFrom(c)) .findFirst(); if (optionalClass.isPresent()) { clazz = optionalClass.get(); break; } clazz = clazz.getSuperclass(); } while (clazz != null); return toImpl(new Metadata(name, MetricType.from(clazz == null ? metric.getClass() : clazz)), metric); }
/** * 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)); }
/** * 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)); }
/** * 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; } }
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(); }
private static Metadata newMetadata(InjectionPoint ip, Metric metric, MetricType metricType) { return metric == null ? new Metadata(getName(ip), "", "", metricType, MetricUnits.NONE) : new Metadata(getName(metric, ip), metric.displayName(), metric.description(), metricType, metric.unit(), toTags(metric.tags())); }
private MetricsSupport(Builder builder) { this.rf = RegistryFactory.create(builder.config); this.base = rf.getARegistry(MetricRegistry.Type.BASE); this.app = rf.getARegistry(MetricRegistry.Type.APPLICATION); this.vendor = rf.getARegistry(MetricRegistry.Type.VENDOR); this.context = builder.context; this.totalCount = vendor.counter(new Metadata("requests.count", "Total number of requests", "Each request (regardless of HTTP method) will increase this counter", MetricType.COUNTER, MetricUnits.NONE)); this.totalMeter = vendor.meter(new Metadata("requests.meter", "Meter for overall requests", "Each request will mark the meter to see overall throughput", MetricType.METERED, MetricUnits.NONE)); }
Counted counted = (Counted) annotation; String metricName = getMetricName(element, clazz, lookupResult.getType(), counted.name(), counted.absolute()); Metadata meta = new Metadata(metricName, counted.displayName(), counted.description(), Metered metered = (Metered) annotation; String metricName = getMetricName(element, clazz, lookupResult.getType(), metered.name(), metered.absolute()); Metadata meta = new Metadata(metricName, metered.displayName(), metered.description(), Timed timed = (Timed) annotation; String metricName = getMetricName(element, clazz, lookupResult.getType(), timed.name(), timed.absolute()); Metadata meta = new Metadata(metricName, timed.displayName(), timed.description(),
@Override public Histogram histogram(String name) { return histogram(new Metadata(name, MetricType.HISTOGRAM)); }
@Override public Histogram histogram(final String name) { return histogram(new Metadata(name, MetricType.HISTOGRAM)); }
static Metadata metadataOf(String name, MetricType metricType) { Metadata res = new Metadata(name, metricType); res.setReusable(true); return res; }
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 Holder(final T metric, final Metadata metadata) { this.metric = metric; this.metadata = new Metadata(metadata.getName(), metadata.getDisplayName(), metadata.getDescription(), metadata.getTypeRaw(), metadata.getUnit()); this.metadata.setReusable(metadata.isReusable()); this.metadata.setTags(metadata.getTags()); } }