How to use

DynamicLogger

in

io.pravega.shared.metrics

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);
}