@Override public StatsLogger createScopeLogger(String scope) { StatsLogger logger = this.statsLoggerRef.get().createScopeLogger(scope); return new StatsLoggerProxy(logger); }
private Collection<Metric> createMetrics(StatsLoggerProxy proxy, String suffix) { return Arrays.asList( proxy.createStats("stats" + suffix), proxy.createCounter("counter" + suffix), proxy.createMeter("meter" + suffix), proxy.registerGauge("gauge+suffix", () -> 1)); }
@Override public OpStatsLogger createStats(String name) { return getOrSet(this.opStatsLoggers, name, this.statsLoggerRef.get()::createStats, OpStatsLoggerProxy::new); }
/** * Verifies the behavior of setLogger with respect to registering/unregistering metrics. */ @Test public void testSetLogger() { val metrics1 = new ArrayList<TestMetric>(); val l1 = new TestLogger(metrics1::add); val proxy = new StatsLoggerProxy(l1); createMetrics(proxy, ""); Assert.assertEquals("Unexpected number of metrics registered with first logger.", METRIC_COUNT, metrics1.size()); Assert.assertFalse("Metrics were not supposed to be closed yet.", metrics1.stream().anyMatch(TestMetric::isClosed)); // Update the logger and verify old instances are closed. val metrics2 = new ArrayList<TestMetric>(); val l2 = new TestLogger(metrics2::add); proxy.setLogger(l2); Assert.assertFalse("Metrics were not supposed to be closed yet.", metrics2.stream().anyMatch(TestMetric::isClosed)); Assert.assertEquals("Unexpected number of metrics registered with second logger.", metrics1.size(), metrics2.size()); Assert.assertTrue("Old metrics were not closed when logger changed.", metrics1.stream().allMatch(TestMetric::isClosed)); }
void setProvider(MetricsConfig config) { if (config.isEnableStatistics()) { log.info("Stats enabled"); instance.set(new StatsProviderImpl(config)); } else { log.info("Stats disabled"); instance.set(new NullStatsProvider()); } statsLoggerProxies.forEach( (proxy, scope) -> { proxy.setLogger(instance.get().createStatsLogger(scope)); }); }
@Override public StatsLogger createStatsLogger(String scope) { StatsLogger logger = instance.get().createStatsLogger(scope); StatsLoggerProxy proxy = new StatsLoggerProxy(logger); statsLoggerProxies.put(proxy, scope); return proxy; }
@Override public Counter createCounter(String name) { return getOrSet(this.counters, name, this.statsLoggerRef.get()::createCounter, CounterProxy::new); }
@Test public void testCloseCreate() { // Verify counter is being closed and then re-created when requested. val metrics = new ArrayList<TestMetric>(); val logger = new TestLogger(metrics::add); val proxy = new StatsLoggerProxy(logger); val proxies = createMetrics(proxy, ""); proxies.forEach(Metric::close); Assert.assertTrue("Expected all metrics to be closed.", metrics.stream().allMatch(TestMetric::isClosed)); // Re-create them and verify new metric instances are created. createMetrics(proxy, ""); Assert.assertEquals("Unexpected number of metrics registered after adding new ones.", 2 * METRIC_COUNT, metrics.size()); Assert.assertFalse("Newly-added metrics were not supposed to be closed.", metrics.stream().skip(METRIC_COUNT).anyMatch(TestMetric::isClosed)); }
@Override public Meter createMeter(String name) { return getOrSet(this.meters, name, this.statsLoggerRef.get()::createMeter, MeterProxy::new); }
/** * Tests the ability to re-use metrics if they're already cached. */ @Test public void testGetOrCreate() { val metrics = new ArrayList<TestMetric>(); val logger = new TestLogger(metrics::add); val proxy = new StatsLoggerProxy(logger); createMetrics(proxy, ""); Assert.assertEquals("Unexpected number of metrics registered initially.", METRIC_COUNT, metrics.size()); // Re-create/request the same metrics. Verify the original ones have not been touched, but we did create (and close) // a new set. createMetrics(proxy, ""); Assert.assertEquals("Unexpected number of metrics registered after re-registering same names.", 2 * METRIC_COUNT, metrics.size()); Assert.assertFalse("Original metrics were not supposed to be closed.", metrics.subList(0, METRIC_COUNT).stream().anyMatch(TestMetric::isClosed)); Assert.assertTrue("Attempted-added metrics were supposed to be closed.", metrics.stream().skip(METRIC_COUNT).allMatch(TestMetric::isClosed)); // Create a new set of metrics and verify the original ones were not touched. createMetrics(proxy, "foo"); Assert.assertEquals("Unexpected number of metrics registered after adding new ones.", 3 * METRIC_COUNT, metrics.size()); Assert.assertFalse("Original metrics were not supposed to be closed.", metrics.subList(0, METRIC_COUNT).stream().anyMatch(TestMetric::isClosed)); Assert.assertFalse("Newly-added metrics were not supposed to be closed.", metrics.stream().skip(2 * METRIC_COUNT).anyMatch(TestMetric::isClosed)); }
@Override public <T extends Number> Gauge registerGauge(String name, Supplier<T> value) { return getOrSet(this.gauges, name, metricName -> this.statsLoggerRef.get().registerGauge(metricName, value), (metric, proxyName, c) -> new GaugeProxy(metric, proxyName, value, c)); }