public void operationLogTruncate(int count) { DYNAMIC_LOGGER.incCounterValue(this.operationLogSize, -count); }
public void segmentCount(int count) { DYNAMIC_LOGGER.reportGaugeValue(this.activeSegmentCount, count); } }
public void truncate() { DYNAMIC_LOGGER.recordMeterEvents(this.truncateCount, 1); } }
/** * This method increments the global and Stream-specific counters of seal Stream operations, set the number of open * Transactions to 0, and reports the latency of the operation. * * @param scope Scope. * @param streamName Name of the Stream. * @param latency Latency of the sealStream operation. */ public void sealStream(String scope, String streamName, Duration latency) { DYNAMIC_LOGGER.incCounterValue(SEAL_STREAM, 1); DYNAMIC_LOGGER.reportGaugeValue(nameFromStream(OPEN_TRANSACTIONS, scope, streamName), 0); sealStreamLatency.reportSuccessValue(latency.toMillis()); }
/** * 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")); }
public void operationLogInit() { DYNAMIC_LOGGER.updateCounterValue(this.operationLogSize, 0); }
@Override public void freezeCounter(String name) { this.instance.get().freezeCounter(name); }
@Override public void freezeGaugeValue(String name) { this.instance.get().freezeGaugeValue(name); }
/** * This method increments the global and Stream-specific counters of Stream creations, initializes other * stream-specific metrics and reports the latency of the operation. * * @param scope Scope. * @param streamName Name of the Stream. * @param minNumSegments Initial number of segments for the Stream. * @param latency Latency of the createStream operation. */ public void createStream(String scope, String streamName, int minNumSegments, Duration latency) { DYNAMIC_LOGGER.incCounterValue(CREATE_STREAM, 1); DYNAMIC_LOGGER.reportGaugeValue(nameFromStream(OPEN_TRANSACTIONS, scope, streamName), 0); DYNAMIC_LOGGER.reportGaugeValue(nameFromStream(SEGMENTS_COUNT, scope, streamName), minNumSegments); DYNAMIC_LOGGER.incCounterValue(nameFromStream(SEGMENTS_SPLITS, scope, streamName), 0); DYNAMIC_LOGGER.incCounterValue(nameFromStream(SEGMENTS_MERGES, scope, streamName), 0); createStreamLatency.reportSuccessValue(latency.toMillis()); }
@Override public void updateCounterValue(String name, long value) { this.instance.get().updateCounterValue(name, value); }
@Override public void deleteSegment(DeleteSegment deleteSegment) { String segment = deleteSegment.getSegment(); final String operation = "deleteSegment"; if (!verifyToken(segment, deleteSegment.getRequestId(), deleteSegment.getDelegationToken(), operation)) { return; } log.info(deleteSegment.getRequestId(), "Deleting segment {} ", deleteSegment); segmentStore.deleteStreamSegment(segment, TIMEOUT) .thenRun(() -> { connection.send(new SegmentDeleted(deleteSegment.getRequestId(), segment)); dynamicLogger.freezeCounter(nameFromSegment(SEGMENT_WRITE_BYTES, segment)); dynamicLogger.freezeCounter(nameFromSegment(SEGMENT_WRITE_EVENTS, segment)); dynamicLogger.freezeCounter(nameFromSegment(SEGMENT_READ_BYTES, segment)); }) .exceptionally(e -> handleException(deleteSegment.getRequestId(), segment, operation, e)); }
@Override public void incCounterValue(String name, long delta) { this.instance.get().incCounterValue(name, delta); }
private void reportHostFailures(Host failedHost) { DYNAMIC_LOGGER.incCounterValue(globalMetricName(SEGMENT_STORE_HOST_FAILURES), 1); DYNAMIC_LOGGER.incCounterValue(nameFromHost(SEGMENT_STORE_HOST_FAILURES, failedHost.toString()), 1); // Set to 0 the number of containers for the failed host. DYNAMIC_LOGGER.reportGaugeValue(nameFromHost(SEGMENT_STORE_HOST_CONTAINER_COUNT, failedHost.toString()), 0); }
void ledgerCount(int count) { DYNAMIC_LOGGER.reportGaugeValue(this.ledgerCount, count); }
public void getAttributes() { DYNAMIC_LOGGER.recordMeterEvents(this.getAttributesCount, 1); }
/** * Reports the number of segment splits and merges related to a particular scale operation on a Stream. Both global * and Stream-specific counters are updated. * * @param scope Scope. * @param streamName Name of the Stream. * @param splits Number of segment splits in the scale operation. * @param merges Number of segment merges in the scale operation. */ public static void reportSegmentSplitsAndMerges(String scope, String streamName, long splits, long merges) { DYNAMIC_LOGGER.updateCounterValue(globalMetricName(SEGMENTS_SPLITS), splits); DYNAMIC_LOGGER.updateCounterValue(nameFromStream(SEGMENTS_SPLITS, scope, streamName), splits); DYNAMIC_LOGGER.updateCounterValue(globalMetricName(SEGMENTS_MERGES), merges); DYNAMIC_LOGGER.updateCounterValue(nameFromStream(SEGMENTS_MERGES, scope, streamName), merges); }
@Override public void sealSegment(SealSegment sealSegment) { String segment = sealSegment.getSegment(); final String operation = "sealSegment"; if (!verifyToken(segment, sealSegment.getRequestId(), sealSegment.getDelegationToken(), operation)) { return; } log.info(sealSegment.getRequestId(), "Sealing segment {} ", sealSegment); segmentStore.sealStreamSegment(segment, TIMEOUT) .thenAccept(size -> connection.send(new SegmentSealed(sealSegment.getRequestId(), segment))) .whenComplete((r, e) -> { if (e != null) { handleException(sealSegment.getRequestId(), segment, operation, e); } else { dynamicLogger.freezeCounter(nameFromSegment(SEGMENT_WRITE_BYTES, segment)); dynamicLogger.freezeCounter(nameFromSegment(SEGMENT_WRITE_EVENTS, segment)); if (statsRecorder != null) { statsRecorder.sealSegment(sealSegment.getSegment()); } } }); }
void bookKeeperWriteCompleted(int length, Duration elapsed) { this.writeLatency.reportSuccessEvent(elapsed); DYNAMIC_LOGGER.incCounterValue(MetricsNames.BK_WRITE_BYTES, length); } }
@Override public <T extends Number> void reportGaugeValue(String name, T value) { this.instance.get().reportGaugeValue(name, value); }