void setLogger(StatsLogger logger) { this.statsLoggerRef.set(logger); this.opStatsLoggers.values().forEach(v -> v.updateInstance(this.statsLoggerRef.get().createStats(v.getProxyName()))); this.counters.values().forEach(v -> v.updateInstance(this.statsLoggerRef.get().createCounter(v.getProxyName()))); this.meters.values().forEach(v -> v.updateInstance(this.statsLoggerRef.get().createMeter(v.getProxyName()))); this.gauges.values().forEach(v -> v.updateInstance(this.statsLoggerRef.get().registerGauge(v.getProxyName(), v.getValueSupplier()))); }
@Override public StatsLogger createScopeLogger(String scope) { StatsLogger logger = this.statsLoggerRef.get().createScopeLogger(scope); return new StatsLoggerProxy(logger); }
public ThreadPool(ScheduledExecutorService executor) { this.executor = Preconditions.checkNotNull(executor, "executor"); this.queueSize = STATS_LOGGER.createStats(MetricsNames.THREAD_POOL_QUEUE_SIZE); this.activeThreads = STATS_LOGGER.createStats(MetricsNames.THREAD_POOL_ACTIVE_THREADS); this.reporter = executor.scheduleWithFixedDelay(this::report, 1000, 1000, TimeUnit.MILLISECONDS); }
@Override public Counter call() throws Exception { return underlying.createCounter(counterName); } });
@Override public <T extends Number> void reportGaugeValue(String name, T value) { Exceptions.checkNotNullOrEmpty(name, "name"); Preconditions.checkNotNull(value); Gauge newGauge = null; String gaugeName = name + ".Gauge"; if (value instanceof Float) { newGauge = underlying.registerGauge(gaugeName, value::floatValue); } else if (value instanceof Double) { newGauge = underlying.registerGauge(gaugeName, value::doubleValue); } else if (value instanceof Byte) { newGauge = underlying.registerGauge(gaugeName, value::byteValue); } else if (value instanceof Short) { newGauge = underlying.registerGauge(gaugeName, value::shortValue); } else if (value instanceof Integer) { newGauge = underlying.registerGauge(gaugeName, value::intValue); } else if (value instanceof Long) { newGauge = underlying.registerGauge(gaugeName, value::longValue); } if (null == newGauge) { log.error("Unsupported Number type: {}.", value.getClass().getName()); } else { gaugesCache.put(gaugeName, newGauge); } }
@Override public Meter call() throws Exception { return underlying.createMeter(meterName); } });
BookKeeperLog(int containerId) { this.ledgerCount = MetricsNames.nameFromContainer(MetricsNames.BK_LEDGER_COUNT, containerId); this.writeQueueSize = STATS_LOGGER.createStats(MetricsNames.nameFromContainer(MetricsNames.BK_WRITE_QUEUE_SIZE, containerId)); this.writeQueueFillRate = STATS_LOGGER.createStats(MetricsNames.nameFromContainer(MetricsNames.BK_WRITE_QUEUE_FILL_RATE, containerId)); this.writeLatency = STATS_LOGGER.createStats(MetricsNames.nameFromContainer(MetricsNames.BK_WRITE_LATENCY, containerId)); this.totalWriteLatency = STATS_LOGGER.createStats(MetricsNames.nameFromContainer(MetricsNames.BK_TOTAL_WRITE_LATENCY, containerId)); }
@Override public void updateCounterValue(String name, long value) { Exceptions.checkNotNullOrEmpty(name, "name"); String counterName = name + ".Counter"; Counter counter = countersCache.getIfPresent(counterName); if (counter != null) { counter.clear(); } else { counter = underlying.createCounter(counterName); } counter.add(value); countersCache.put(name, counter); }
@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)); }
/** * Test Meter registered and worked well with StatsLogger. */ @Test public void testMeter() { Meter testMeter = statsLogger.createMeter("testMeter"); testMeter.recordEvent(); testMeter.recordEvent(); assertEquals(2, testMeter.getCount()); testMeter.recordEvents(27); assertEquals(29, testMeter.getCount()); // test dynamic meter int sum = 0; for (int i = 1; i < 10; i++) { sum += i; dynamicLogger.recordMeterEvents("dynamicMeter", i); assertEquals(sum, MetricRegistryUtils.getMeter("pravega.dynamicMeter.Meter").getCount()); } }
public OperationProcessor(int containerId) { this.operationQueueSize = STATS_LOGGER.createStats(MetricsNames.nameFromContainer(MetricsNames.OPERATION_QUEUE_SIZE, containerId)); this.operationsInFlight = STATS_LOGGER.createStats(MetricsNames.nameFromContainer(MetricsNames.OPERATION_PROCESSOR_IN_FLIGHT, containerId)); this.operationQueueWaitTime = STATS_LOGGER.createStats(MetricsNames.nameFromContainer(MetricsNames.OPERATION_QUEUE_WAIT_TIME, containerId)); this.operationProcessorDelay = STATS_LOGGER.createStats(MetricsNames.nameFromContainer(MetricsNames.OPERATION_PROCESSOR_DELAY_MILLIS, containerId)); this.operationCommitLatency = STATS_LOGGER.createStats(MetricsNames.nameFromContainer(MetricsNames.OPERATION_COMMIT_LATENCY, containerId)); this.operationLatency = STATS_LOGGER.createStats(MetricsNames.nameFromContainer(MetricsNames.OPERATION_LATENCY, containerId)); this.memoryCommitLatency = STATS_LOGGER.createStats(MetricsNames.nameFromContainer(MetricsNames.OPERATION_COMMIT_MEMORY_LATENCY, containerId)); this.metadataCommitTxnCount = STATS_LOGGER.createStats(MetricsNames.nameFromContainer(MetricsNames.OPERATION_COMMIT_METADATA_TXN_COUNT, containerId)); this.processOperationsLatency = STATS_LOGGER.createStats(MetricsNames.nameFromContainer(MetricsNames.PROCESS_OPERATIONS_LATENCY, containerId)); this.processOperationsBatchSize = STATS_LOGGER.createStats(MetricsNames.nameFromContainer(MetricsNames.PROCESS_OPERATIONS_BATCH_SIZE, containerId)); this.operationLogSize = "segmentstore." + MetricsNames.nameFromContainer(MetricsNames.OPERATION_LOG_SIZE, containerId); }
/** * Test counter registered and worked well with StatsLogger. */ @Test public void testCounter() { Counter testCounter = statsLogger.createCounter("testCounter"); testCounter.add(17); assertEquals(17, testCounter.get()); // test dynamic counter int sum = 0; for (int i = 1; i < 10; i++) { sum += i; dynamicLogger.incCounterValue("dynamicCounter", i); assertEquals(sum, MetricRegistryUtils.getCounter("pravega.dynamicCounter.Counter").getCount()); } dynamicLogger.freezeCounter("dynamicCounter"); assertEquals(null, MetricRegistryUtils.getCounter("pravega.dynamicCounter.Counter")); }
/** * Test gauge registered and worked well with StatsLogger. */ @Test public void testGauge() { AtomicInteger value = new AtomicInteger(1); statsLogger.registerGauge("testGauge", value::get); value.set(2); assertEquals(value.get(), MetricRegistryUtils.getGauge("pravega.testStatsLogger.testGauge").getValue()); for (int i = 1; i < 10; i++) { dynamicLogger.reportGaugeValue("dynamicGauge", i); assertEquals(i, MetricRegistryUtils.getGauge("pravega.dynamicGauge.Gauge").getValue()); } dynamicLogger.freezeGaugeValue("dynamicGauge"); assertEquals(null, MetricRegistryUtils.getGauge("pravega.dynamicGauge.Gauge")); }
/** * Test Event and Value registered and worked well with OpStats. */ @Test public void testOpStatsData() { Timer startTime = new Timer(); OpStatsLogger opStatsLogger = statsLogger.createStats("testOpStatsLogger"); // register 2 event: 1 success, 1 fail. opStatsLogger.reportSuccessEvent(startTime.getElapsed()); opStatsLogger.reportFailEvent(startTime.getElapsed()); opStatsLogger.reportSuccessValue(startTime.getElapsedMillis()); opStatsLogger.reportFailValue(startTime.getElapsedMillis()); opStatsLogger.reportSuccessValue(1); opStatsLogger.reportFailValue(1); opStatsLogger.reportSuccessValue(1); OpStatsData statsData = opStatsLogger.toOpStatsData(); // 2 = 2 event + 2 value assertEquals(4, statsData.getNumSuccessfulEvents()); assertEquals(3, statsData.getNumFailedEvents()); }
/** * Test that we can transition from stats enabled, to disabled, to enabled. */ @Test public void testMultipleInitialization() { MetricsConfig config = MetricsConfig.builder() .with(MetricsConfig.ENABLE_STATISTICS, false) .build(); MetricsProvider.initialize(config); statsLogger.createCounter("counterDisabled"); assertEquals(null, MetricRegistryUtils.getCounter("counterDisabled")); config = MetricsConfig.builder() .with(MetricsConfig.ENABLE_STATISTICS, true) .build(); MetricsProvider.initialize(config); statsLogger.createCounter("counterEnabled"); Assert.assertNotNull( MetricRegistryUtils.getCounter("pravega.testStatsLogger.counterEnabled")); }
/** * Test that we can transition from stats enabled, to disabled, to enabled. */ @Test public void testContinuity() { statsLogger.createCounter("continuity-counter"); Assert.assertNotNull("Not registered before disabling.", MetricRegistryUtils.getCounter("pravega.testStatsLogger.continuity-counter")); MetricsConfig disableConfig = MetricsConfig.builder() .with(MetricsConfig.ENABLE_STATISTICS, false) .build(); MetricsProvider.initialize(disableConfig); Assert.assertNull("Still registered after disabling.", MetricRegistryUtils.getCounter("pravega.testStatsLogger.continuity-counter")); MetricsConfig enableConfig = MetricsConfig.builder() .with(MetricsConfig.ENABLE_STATISTICS, true) .build(); MetricsProvider.initialize(enableConfig); Assert.assertNotNull("Not registered after re-enabling.", MetricRegistryUtils.getCounter("pravega.testStatsLogger.continuity-counter")); }
/** * Test transition back to null provider. */ @Test public void testTransitionBackToNullProvider() { MetricsConfig config = MetricsConfig.builder() .with(MetricsConfig.ENABLE_STATISTICS, false) .build(); MetricsProvider.initialize(config); Counter counter = statsLogger.createCounter("continuity-counter"); counter.add(1L); assertEquals(0L, counter.get()); config = MetricsConfig.builder() .with(MetricsConfig.ENABLE_STATISTICS, true) .build(); MetricsProvider.initialize(config); counter.add(1L); assertEquals(1L, counter.get()); } }