/** * A {@link Gauge} is an instantaneous reading of a particular value. This method leverages * Supplier, a Functional Interface, to get Generics metrics values. With this support, no matter * what our interesting metrics is a Double or a Long, we could pass it to Metrics Parser. * * E.g., in {@link CommonMetrics#setupAllMetrics()}, we construct a supplier lambda by having a * AtomicLong object and its get method, in order to collect dbConnection metric. */ public <T> void addGauge(final String name, final Supplier<T> gaugeFunc) { this.registry.register(name, (Gauge<T>) gaugeFunc::get); }
@Override public void initialize() { metricRegistry.register(MetricRegistry.name(IndexFailuresPeriodical.class, "queueSize"), new Gauge<Integer>() { @Override public Integer getValue() { return messages.getIndexFailureQueue().size(); } }); }
public static <T extends Metric> T safelyRegister(MetricRegistry metricRegistry, String name, T metric) { try { return metricRegistry.register(name, metric); } catch (IllegalArgumentException ignored) { // safely ignore already existing metric, and simply return the one registered previously. // note that we do not guard against differing metric types here, we consider that a programming error for now. //noinspection unchecked return (T) metricRegistry.getMetrics().get(name); } }
private void registerUncommittedGauge(MetricRegistry metricRegistry, String name) { try { metricRegistry.register(name, (Gauge<Long>) () -> Math.max(0, getLogEndOffset() - 1 - committedOffset.get())); } catch (IllegalArgumentException ignored) { // already registered, we'll ignore that. } }
public MetricRegistryProvider() { this.metricRegistry = new MetricRegistry(); metricRegistry.register("jvm.buffers", new BufferPoolMetricSet(ManagementFactory.getPlatformMBeanServer())); metricRegistry.register("jvm.cl", new ClassLoadingGaugeSet()); metricRegistry.register("jvm.gc", new GarbageCollectorMetricSet()); metricRegistry.register("jvm.memory", new MemoryUsageGaugeSet()); metricRegistry.register("jvm.threads", new ThreadStatesGaugeSet()); }
/** * Registers a gauge if it has not been registered. * * @param name the gauge name * @param metric the gauge * @param <T> the type */ public static synchronized <T> void registerGaugeIfAbsent(String name, Gauge<T> metric) { if (!METRIC_REGISTRY.getGauges().containsKey(name)) { METRIC_REGISTRY.register(name, metric); } }
protected void createRollingCountForEvent(final String name, final HystrixRollingNumberEvent event) { metricRegistry.register(createMetricName(name), new Gauge<Long>() { @Override public Long getValue() { return metrics.getRollingCount(event); } }); }
protected void createCumulativeCountForEvent(final String name, final HystrixRollingNumberEvent event) { metricRegistry.register(createMetricName(name), new Gauge<Long>() { @Override public Long getValue() { return metrics.getCumulativeCount(event); } }); }
protected void createCumulativeCountForEvent(final String name, final HystrixRollingNumberEvent event) { metricRegistry.register(createMetricName(name), new Gauge<Long>() { @Override public Long getValue() { return metrics.getCumulativeCount(event); } }); }
protected void createRollingCountForEvent(final String name, final HystrixRollingNumberEvent event) { metricRegistry.register(createMetricName(name), new Gauge<Long>() { @Override public Long getValue() { return metrics.getRollingCount(event); } }); }
protected void safelyCreateCumulativeCountForEvent(final String name, final Func0<HystrixRollingNumberEvent> eventThunk) { metricRegistry.register(createMetricName(name), new Gauge<Long>() { @Override public Long getValue() { try { return metrics.getCumulativeCount(eventThunk.call()); } catch (NoSuchFieldError error) { logger.error("While publishing CodaHale metrics, error looking up eventType for : {}. Please check that all Hystrix versions are the same!", name); return 0L; } } }); }
protected void safelyCreateCumulativeCountForEvent(final String name, final Func0<HystrixRollingNumberEvent> eventThunk) { metricRegistry.register(createMetricName(name), new Gauge<Long>() { @Override public Long getValue() { try { return metrics.getCumulativeCount(eventThunk.call()); } catch (NoSuchFieldError error) { logger.error("While publishing CodaHale metrics, error looking up eventType for : {}. Please check that all Hystrix versions are the same!", name); return 0L; } } }); }
@Override public Meter load(String key) { Meter meter = new Meter(); metricRegistry.register(key, meter); return meter; } }
private Timer registerHdrTimer(MetricRegistry metricRegistry, final String metricName) { Timer timer; try { timer = metricRegistry.register(metricName, new HdrTimer(1, MINUTES, 1)); } catch (IllegalArgumentException e) { final SortedMap<String, Timer> timers = metricRegistry.getTimers((name, metric) -> metricName.equals(name)); timer = Iterables.getOnlyElement(timers.values()); } return timer; }
private RateLimiterMetrics(String prefix, Iterable<RateLimiter> rateLimiters) { requireNonNull(prefix, PREFIX_NULL); requireNonNull(rateLimiters, ITERABLE_NULL); rateLimiters.forEach(rateLimiter -> { String name = rateLimiter.getName(); metricRegistry.register(name(prefix, name, WAITING_THREADS), (Gauge<Integer>) rateLimiter.getMetrics()::getNumberOfWaitingThreads); metricRegistry.register(name(prefix, name, AVAILABLE_PERMISSIONS), (Gauge<Integer>) rateLimiter.getMetrics()::getAvailablePermissions); } ); }
public void initialize() { this.transportMetrics = transport.getMetricSet(); try { if (transportMetrics != null) { metricRegistry.register(getUniqueReadableId(), transportMetrics); } metricRegistry.register(getUniqueReadableId(), localRegistry); } catch (IllegalArgumentException ignored) { // This happens for certain types of inputs, see https://github.com/Graylog2/graylog2-server/issues/1049#issuecomment-88857134 } }
private BulkheadMetrics(String prefix, Iterable<Bulkhead> bulkheads) { requireNonNull(prefix); requireNonNull(bulkheads); bulkheads.forEach(bulkhead -> { String name = bulkhead.getName(); //number of available concurrent calls as an integer metricRegistry.register(name(prefix, name, AVAILABLE_CONCURRENT_CALLS), (Gauge<Integer>) () -> bulkhead.getMetrics().getAvailableConcurrentCalls()); } ); }
public Gauge registerGauge(String name, Gauge gauge) { return StormMetricRegistry.registry().register(metricName(name), gauge); }
public static <T> SimpleGauge<T> gauge( T initialValue, String name, String topologyId, String componentId, Integer taskId, Integer port) { String metricName = metricName(name, topologyId, componentId, taskId, port); if (REGISTRY.getGauges().containsKey(metricName)) { return (SimpleGauge) REGISTRY.getGauges().get(metricName); } else { return REGISTRY.register(metricName, new SimpleGauge<>(initialValue)); } }
@Override public com.codahale.metrics.Timer load(String key) { Timer timer = new Timer(new ExponentiallyDecayingReservoir()); metricRegistry.register(key, timer); return timer; } }