Java tutorial
// Copyright (C) 2015 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package com.google.gerrit.metrics.dropwizard; import static com.google.common.base.Preconditions.checkArgument; import static com.google.gerrit.metrics.dropwizard.MetricResource.METRIC_KIND; import static com.google.gerrit.server.config.ConfigResource.CONFIG_KIND; import com.codahale.metrics.Metric; import com.codahale.metrics.MetricRegistry; import com.google.common.collect.FluentIterable; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.gerrit.extensions.registration.DynamicMap; import com.google.gerrit.extensions.registration.RegistrationHandle; import com.google.gerrit.extensions.restapi.RestApiModule; import com.google.gerrit.metrics.CallbackMetric; import com.google.gerrit.metrics.CallbackMetric0; import com.google.gerrit.metrics.CallbackMetric1; import com.google.gerrit.metrics.Counter0; import com.google.gerrit.metrics.Counter1; import com.google.gerrit.metrics.Counter2; import com.google.gerrit.metrics.Counter3; import com.google.gerrit.metrics.Description; import com.google.gerrit.metrics.Description.FieldOrdering; import com.google.gerrit.metrics.Field; import com.google.gerrit.metrics.Histogram0; import com.google.gerrit.metrics.Histogram1; import com.google.gerrit.metrics.Histogram2; import com.google.gerrit.metrics.Histogram3; import com.google.gerrit.metrics.MetricMaker; import com.google.gerrit.metrics.Timer0; import com.google.gerrit.metrics.Timer1; import com.google.gerrit.metrics.Timer2; import com.google.gerrit.metrics.Timer3; import com.google.gerrit.metrics.proc.JGitMetricModule; import com.google.gerrit.metrics.proc.ProcMetricModule; import com.google.gerrit.server.cache.CacheMetrics; import com.google.inject.Inject; import com.google.inject.Scopes; import com.google.inject.Singleton; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.TimeUnit; import java.util.regex.Pattern; /** * Connects Gerrit metric package onto DropWizard. * * @see <a href="http://www.dropwizard.io/">DropWizard</a> */ @Singleton public class DropWizardMetricMaker extends MetricMaker { public static class ApiModule extends RestApiModule { @Override protected void configure() { bind(MetricRegistry.class).in(Scopes.SINGLETON); bind(DropWizardMetricMaker.class).in(Scopes.SINGLETON); bind(MetricMaker.class).to(DropWizardMetricMaker.class); install(new ProcMetricModule()); install(new JGitMetricModule()); } } public static class RestModule extends RestApiModule { @Override protected void configure() { DynamicMap.mapOf(binder(), METRIC_KIND); child(CONFIG_KIND, "metrics").to(MetricsCollection.class); get(METRIC_KIND).to(GetMetric.class); bind(CacheMetrics.class); } } private final MetricRegistry registry; private final Map<String, BucketedMetric> bucketed; private final Map<String, ImmutableMap<String, String>> descriptions; @Inject DropWizardMetricMaker(MetricRegistry registry) { this.registry = registry; this.bucketed = new ConcurrentHashMap<>(); this.descriptions = new ConcurrentHashMap<>(); } Iterable<String> getMetricNames() { return descriptions.keySet(); } /** Get the underlying metric implementation. */ public Metric getMetric(String name) { Metric m = bucketed.get(name); return m != null ? m : registry.getMetrics().get(name); } /** Lookup annotations from a metric's {@link Description}. */ public ImmutableMap<String, String> getAnnotations(String name) { return descriptions.get(name); } @Override public synchronized Counter0 newCounter(String name, Description desc) { checkCounterDescription(name, desc); define(name, desc); return newCounterImpl(name, desc.isRate()); } @Override public synchronized <F1> Counter1<F1> newCounter(String name, Description desc, Field<F1> field1) { checkCounterDescription(name, desc); CounterImpl1<F1> m = new CounterImpl1<>(this, name, desc, field1); define(name, desc); bucketed.put(name, m); return m.counter(); } @Override public synchronized <F1, F2> Counter2<F1, F2> newCounter(String name, Description desc, Field<F1> field1, Field<F2> field2) { checkCounterDescription(name, desc); CounterImplN m = new CounterImplN(this, name, desc, field1, field2); define(name, desc); bucketed.put(name, m); return m.counter2(); } @Override public synchronized <F1, F2, F3> Counter3<F1, F2, F3> newCounter(String name, Description desc, Field<F1> field1, Field<F2> field2, Field<F3> field3) { checkCounterDescription(name, desc); CounterImplN m = new CounterImplN(this, name, desc, field1, field2, field3); define(name, desc); bucketed.put(name, m); return m.counter3(); } private static void checkCounterDescription(String name, Description desc) { checkMetricName(name); checkArgument(!desc.isConstant(), "counters must not be constant"); checkArgument(!desc.isGauge(), "counters must not be gauge"); } CounterImpl newCounterImpl(String name, boolean isRate) { if (isRate) { final com.codahale.metrics.Meter m = registry.meter(name); return new CounterImpl(name, m) { @Override public void incrementBy(long delta) { checkArgument(delta >= 0, "counter delta must be >= 0"); m.mark(delta); } }; } final com.codahale.metrics.Counter m = registry.counter(name); return new CounterImpl(name, m) { @Override public void incrementBy(long delta) { checkArgument(delta >= 0, "counter delta must be >= 0"); m.inc(delta); } }; } @Override public synchronized Timer0 newTimer(String name, Description desc) { checkTimerDescription(name, desc); define(name, desc); return newTimerImpl(name); } @Override public synchronized <F1> Timer1<F1> newTimer(String name, Description desc, Field<F1> field1) { checkTimerDescription(name, desc); TimerImpl1<F1> m = new TimerImpl1<>(this, name, desc, field1); define(name, desc); bucketed.put(name, m); return m.timer(); } @Override public synchronized <F1, F2> Timer2<F1, F2> newTimer(String name, Description desc, Field<F1> field1, Field<F2> field2) { checkTimerDescription(name, desc); TimerImplN m = new TimerImplN(this, name, desc, field1, field2); define(name, desc); bucketed.put(name, m); return m.timer2(); } @Override public synchronized <F1, F2, F3> Timer3<F1, F2, F3> newTimer(String name, Description desc, Field<F1> field1, Field<F2> field2, Field<F3> field3) { checkTimerDescription(name, desc); TimerImplN m = new TimerImplN(this, name, desc, field1, field2, field3); define(name, desc); bucketed.put(name, m); return m.timer3(); } private static void checkTimerDescription(String name, Description desc) { checkMetricName(name); checkArgument(!desc.isConstant(), "timer must not be constant"); checkArgument(!desc.isGauge(), "timer must not be a gauge"); checkArgument(!desc.isRate(), "timer must not be a rate"); checkArgument(desc.isCumulative(), "timer must be cumulative"); checkArgument(desc.getTimeUnit() != null, "timer must have a unit"); } TimerImpl newTimerImpl(String name) { return new TimerImpl(name, registry.timer(name)); } @Override public synchronized Histogram0 newHistogram(String name, Description desc) { checkHistogramDescription(name, desc); define(name, desc); return newHistogramImpl(name); } @Override public synchronized <F1> Histogram1<F1> newHistogram(String name, Description desc, Field<F1> field1) { checkHistogramDescription(name, desc); HistogramImpl1<F1> m = new HistogramImpl1<>(this, name, desc, field1); define(name, desc); bucketed.put(name, m); return m.histogram1(); } @Override public synchronized <F1, F2> Histogram2<F1, F2> newHistogram(String name, Description desc, Field<F1> field1, Field<F2> field2) { checkHistogramDescription(name, desc); HistogramImplN m = new HistogramImplN(this, name, desc, field1, field2); define(name, desc); bucketed.put(name, m); return m.histogram2(); } @Override public synchronized <F1, F2, F3> Histogram3<F1, F2, F3> newHistogram(String name, Description desc, Field<F1> field1, Field<F2> field2, Field<F3> field3) { checkHistogramDescription(name, desc); HistogramImplN m = new HistogramImplN(this, name, desc, field1, field2, field3); define(name, desc); bucketed.put(name, m); return m.histogram3(); } private static void checkHistogramDescription(String name, Description desc) { checkMetricName(name); checkArgument(!desc.isConstant(), "histogram must not be constant"); checkArgument(!desc.isGauge(), "histogram must not be a gauge"); checkArgument(!desc.isRate(), "histogram must not be a rate"); checkArgument(desc.isCumulative(), "histogram must be cumulative"); } HistogramImpl newHistogramImpl(String name) { return new HistogramImpl(name, registry.histogram(name)); } @Override public <V> CallbackMetric0<V> newCallbackMetric(String name, Class<V> valueClass, Description desc) { checkMetricName(name); define(name, desc); return new CallbackMetricImpl0<>(this, registry, name, valueClass); } @Override public <F1, V> CallbackMetric1<F1, V> newCallbackMetric(String name, Class<V> valueClass, Description desc, Field<F1> field1) { checkMetricName(name); CallbackMetricImpl1<F1, V> m = new CallbackMetricImpl1<>(this, registry, name, valueClass, desc, field1); define(name, desc); bucketed.put(name, m); return m.create(); } @Override public synchronized RegistrationHandle newTrigger(Set<CallbackMetric<?>> metrics, Runnable trigger) { ImmutableSet<CallbackMetricGlue> all = FluentIterable.from(metrics).transform(m -> (CallbackMetricGlue) m) .toSet(); trigger = new CallbackGroup(trigger, all); for (CallbackMetricGlue m : all) { m.register(trigger); } trigger.run(); return new RegistrationHandle() { @Override public void remove() { for (CallbackMetricGlue m : all) { m.remove(); } } }; } synchronized void remove(String name) { bucketed.remove(name); descriptions.remove(name); } private synchronized void define(String name, Description desc) { if (descriptions.containsKey(name)) { ImmutableMap<String, String> annotations = descriptions.get(name); if (!desc.getAnnotations().get(Description.DESCRIPTION) .equals(annotations.get(Description.DESCRIPTION))) { throw new IllegalStateException(String.format("metric %s already defined", name)); } } else { descriptions.put(name, desc.getAnnotations()); } } private static final Pattern METRIC_NAME_PATTERN = Pattern.compile("[a-zA-Z0-9_-]+(/[a-zA-Z0-9_-]+)*"); private static void checkMetricName(String name) { checkArgument(METRIC_NAME_PATTERN.matcher(name).matches(), "metric name must match %s", METRIC_NAME_PATTERN.pattern()); } static String name(Description.FieldOrdering ordering, String codeName, String fieldValues) { if (ordering == FieldOrdering.PREFIX_FIELDS_BASENAME) { int s = codeName.lastIndexOf('/'); if (s > 0) { String prefix = codeName.substring(0, s); String metric = codeName.substring(s + 1); return prefix + '/' + fieldValues + '/' + metric; } } return codeName + '/' + fieldValues; } abstract class CounterImpl extends Counter0 { private final String name; final Metric metric; CounterImpl(String name, Metric metric) { this.name = name; this.metric = metric; } @Override public void remove() { descriptions.remove(name); registry.remove(name); } } class TimerImpl extends Timer0 { private final String name; final com.codahale.metrics.Timer metric; private TimerImpl(String name, com.codahale.metrics.Timer metric) { this.name = name; this.metric = metric; } @Override public void record(long value, TimeUnit unit) { checkArgument(value >= 0, "timer delta must be >= 0"); metric.update(value, unit); } @Override public void remove() { descriptions.remove(name); registry.remove(name); } } class HistogramImpl extends Histogram0 { private final String name; final com.codahale.metrics.Histogram metric; private HistogramImpl(String name, com.codahale.metrics.Histogram metric) { this.name = name; this.metric = metric; } @Override public void record(long value) { metric.update(value); } @Override public void remove() { descriptions.remove(name); registry.remove(name); } } }