io.micrometer.core.instrument.Measurement Java Examples

private static String measurementName(Meter.Id id, Measurement measurement) {
    final StringBuilder buf = new StringBuilder();

    // Append name.
    buf.append(id.getName());

    // Append statistic.
    buf.append('#');
    buf.append(measurement.getStatistic().getTagValueRepresentation());

    // Append tags if there are any.
    final Iterator<Tag> tagsIterator = id.getTags().iterator();
    if (tagsIterator.hasNext()) {
        buf.append('{');
        tagsIterator.forEachRemaining(tag -> buf.append(tag.getKey()).append('=')
                                                .append(tag.getValue()).append(','));
        buf.setCharAt(buf.length() - 1, '}');
    }
    return buf.toString();
}
 

@Test
void writeCustomMetricWhenCustomMeterHasMixedFiniteAndNonFiniteValuesShouldSkipOnlyNonFiniteValues() {
    Measurement measurement1 = new Measurement(() -> Double.POSITIVE_INFINITY, Statistic.VALUE);
    Measurement measurement2 = new Measurement(() -> Double.NEGATIVE_INFINITY, Statistic.VALUE);
    Measurement measurement3 = new Measurement(() -> Double.NaN, Statistic.VALUE);
    Measurement measurement4 = new Measurement(() -> 1d, Statistic.VALUE);
    Measurement measurement5 = new Measurement(() -> 2d, Statistic.VALUE);
    List<Measurement> measurements = Arrays.asList(measurement1, measurement2, measurement3, measurement4, measurement5);
    Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.meterRegistry);
    assertThat(meterRegistry.writeCustomMetric(meter)).hasSize(2);
}
 

@Test
public void givenCompositeRegistries_whenRecordMeter_thenAllRegistriesRecorded() {
    CompositeMeterRegistry compositeRegistry = new CompositeMeterRegistry();

    SimpleMeterRegistry oneSimpleMeter = new SimpleMeterRegistry();
    AtlasMeterRegistry atlasMeterRegistry = new AtlasMeterRegistry(atlasConfig, Clock.SYSTEM);

    compositeRegistry.add(oneSimpleMeter);
    compositeRegistry.add(atlasMeterRegistry);

    compositeRegistry.gauge("baeldung.heat", 90);

    Optional<Gauge> oneGauge = oneSimpleMeter
      .find("baeldung.heat")
      .gauge();
    assertTrue(oneGauge.isPresent());
    Iterator<Measurement> measurements = oneGauge
      .get()
      .measure()
      .iterator();

    assertTrue(measurements.hasNext());
    assertThat(measurements
      .next()
      .getValue(), equalTo(90.00));

    Optional<Gauge> atlasGauge = atlasMeterRegistry
      .find("baeldung.heat")
      .gauge();
    assertTrue(atlasGauge.isPresent());
    Iterator<Measurement> anotherMeasurements = atlasGauge
      .get()
      .measure()
      .iterator();

    assertTrue(anotherMeasurements.hasNext());
    assertThat(anotherMeasurements
      .next()
      .getValue(), equalTo(90.00));
}
 

public static Map<Meter.Id, Double> getMetrics(ActiveMQServer server) {
   Map<Meter.Id, Double> metrics = new HashMap<>();
   List<Meter> meters = server.getMetricsManager().getMeterRegistry().getMeters();
   assertTrue(meters.size() > 0);
   for (Meter meter : meters) {
      Iterable<Measurement> measurements = meter.measure();
      for (Measurement measurement : measurements) {
         metrics.put(meter.getId(), measurement.getValue());
      }
   }
   return metrics;
}
 

@Test
public void testBuild() {
    // Creating a custom measurement
    Measurement measurement = new Measurement(() -> 1d, Statistic.COUNT);
    final List<MeterId.Tag> tags = Arrays.asList(new MeterId.Tag("skywalking", "custom_counter"));
    final MeterId meterId = new MeterId("test_custom_conter", MeterId.MeterType.COUNTER, tags);
    final Counter counter = new SkywalkingCustomCounter.Builder(meterId, measurement, SkywalkingConfig.DEFAULT).build();

    // Check is counter meter id and value
    assertCounter(counter, "test_custom_conter", tags, 1d);
}
 

/**
 * Check custom measurement
 */
private void testNewMeter(String meterName, Meter.Type type, Statistic statistic, Consumer<MeterData> meterChecker) {
    final SkywalkingMeterRegistry registry = new SkywalkingMeterRegistry();

    // Create measurement
    Meter.builder(meterName, type, Arrays.asList(new Measurement(() -> 1d, statistic)))
        .tag("skywalking", "test")
        .register(registry);
    final List<MeterId.Tag> tags = Arrays.asList(new MeterId.Tag("skywalking", "test"));
    Assert.assertEquals(1, meterMap.size());
    meterChecker.accept(new MeterData(meterMap.values().iterator().next(), tags));

    // clear all data
    cleanup();
}
 

@Override
protected <T> FunctionCounter newFunctionCounter(Meter.Id id, T obj, ToDoubleFunction<T> countFunction) {
    final MeterId meterId = convertId(id);
    FunctionCounter fc = new CumulativeFunctionCounter<>(id, obj, countFunction);

    new SkywalkingCustomCounter.Builder(meterId, new Measurement(() -> countFunction.applyAsDouble(obj), Statistic.COUNT), config).build();
    return fc;
}
 

@Override
protected Meter newMeter(Meter.Id id, Meter.Type type, Iterable<Measurement> measurements) {
    final MeterId meterId = convertId(id);
    final String baseName = meterId.getName();

    measurements.forEach(m -> {
        String meterName = baseName;
        boolean isCounter = false;
        switch (m.getStatistic()) {
            case TOTAL:
            case TOTAL_TIME:
                meterName = baseName + "_sum";
                isCounter = true;
                break;
            case COUNT:
                isCounter = true;
                break;
            case MAX:
                meterName = baseName + "_max";
                break;
            case ACTIVE_TASKS:
                meterName = baseName + "_active_count";
                break;
            case DURATION:
                meterName = baseName + "_duration_sum";
                break;
        }

        if (isCounter) {
            new SkywalkingCustomCounter.Builder(meterId.copyTo(meterName, MeterId.MeterType.COUNTER), m, config).build();
        } else {
            MeterFactory.gauge(meterId.copyTo(meterName, MeterId.MeterType.GAUGE), () -> m.getValue()).build();
        }
    });

    return new DefaultMeter(id, type, measurements);
}
 

@Override
public Iterable<Measurement> measure() {
    return Arrays.asList(
        new Measurement(() -> (double) count(), Statistic.COUNT),
        new Measurement(this::totalAmount, Statistic.TOTAL),
        new Measurement(this::max, Statistic.MAX)
    );
}
 

@Test
void writeCustomMetricWhenCustomMeterHasOnlyNonFiniteValuesShouldNotBeWritten() {
    Measurement measurement1 = new Measurement(() -> Double.POSITIVE_INFINITY, Statistic.VALUE);
    Measurement measurement2 = new Measurement(() -> Double.NEGATIVE_INFINITY, Statistic.VALUE);
    Measurement measurement3 = new Measurement(() -> Double.NaN, Statistic.VALUE);
    List<Measurement> measurements = Arrays.asList(measurement1, measurement2, measurement3);
    Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.meterRegistry);
    assertThat(meterRegistry.writeCustomMetric(meter)).isEmpty();
}
 

@Test
void writeMeterWhenCustomMeterHasMixedFiniteAndNonFiniteValuesShouldSkipOnlyNonFiniteValues() {
    Measurement measurement1 = new Measurement(() -> Double.POSITIVE_INFINITY, Statistic.VALUE);
    Measurement measurement2 = new Measurement(() -> Double.NEGATIVE_INFINITY, Statistic.VALUE);
    Measurement measurement3 = new Measurement(() -> Double.NaN, Statistic.VALUE);
    Measurement measurement4 = new Measurement(() -> 1d, Statistic.VALUE);
    Measurement measurement5 = new Measurement(() -> 2d, Statistic.VALUE);
    List<Measurement> measurements = Arrays.asList(measurement1, measurement2, measurement3, measurement4, measurement5);
    Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.meterRegistry);
    assertThat(meterRegistry.writeMeter(meter)).hasValue("{\"name\":\"my.meter\",\"period\":60,\"value\":1.0,\"tags\":{\"statistic\":\"value\"}},{\"name\":\"my.meter\",\"period\":60,\"value\":2.0,\"tags\":{\"statistic\":\"value\"}}");
}
 

@Test
void writeMeterWhenCustomMeterHasOnlyNonFiniteValuesShouldNotBeWritten() {
    Measurement measurement1 = new Measurement(() -> Double.POSITIVE_INFINITY, Statistic.VALUE);
    Measurement measurement2 = new Measurement(() -> Double.NEGATIVE_INFINITY, Statistic.VALUE);
    Measurement measurement3 = new Measurement(() -> Double.NaN, Statistic.VALUE);
    List<Measurement> measurements = Arrays.asList(measurement1, measurement2, measurement3);
    Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.meterRegistry);
    assertThat(meterRegistry.writeMeter(meter)).isNotPresent();
}
 

@Test
void publishMeterWhenCustomMeterHasMixedFiniteAndNonFiniteValuesShouldSkipOnlyNonFiniteValues() throws IOException {
    Measurement measurement1 = new Measurement(() -> Double.POSITIVE_INFINITY, Statistic.VALUE);
    Measurement measurement2 = new Measurement(() -> Double.NEGATIVE_INFINITY, Statistic.VALUE);
    Measurement measurement3 = new Measurement(() -> Double.NaN, Statistic.VALUE);
    Measurement measurement4 = new Measurement(() -> 1d, Statistic.VALUE);
    Measurement measurement5 = new Measurement(() -> 2d, Statistic.VALUE);
    List<Measurement> measurements = Arrays.asList(measurement1, measurement2, measurement3, measurement4, measurement5);
    Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.registry);
    registry.publishMeter(meter);
    verify(wavefrontSender, times(1)).sendMetric("my.meter", 1d, clock.wallTime(), "host", Collections.singletonMap("statistic", "value"));
    verify(wavefrontSender, times(1)).sendMetric("my.meter", 2d, clock.wallTime(), "host", Collections.singletonMap("statistic", "value"));
    verifyNoMoreInteractions(wavefrontSender);
}
 

@Test
void publishMeterWhenCustomMeterHasOnlyNonFiniteValuesShouldNotBeWritten() {
    Measurement measurement1 = new Measurement(() -> Double.POSITIVE_INFINITY, Statistic.VALUE);
    Measurement measurement2 = new Measurement(() -> Double.NEGATIVE_INFINITY, Statistic.VALUE);
    Measurement measurement3 = new Measurement(() -> Double.NaN, Statistic.VALUE);
    List<Measurement> measurements = Arrays.asList(measurement1, measurement2, measurement3);
    Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.registry);
    registry.publishMeter(meter);
    verifyNoInteractions(wavefrontSender);
}
 

@Test
void writeMeterWhenCustomMeterHasMixedFiniteAndNonFiniteValuesShouldSkipOnlyNonFiniteValues() {
    Measurement measurement1 = new Measurement(() -> Double.POSITIVE_INFINITY, Statistic.VALUE);
    Measurement measurement2 = new Measurement(() -> Double.NEGATIVE_INFINITY, Statistic.VALUE);
    Measurement measurement3 = new Measurement(() -> Double.NaN, Statistic.VALUE);
    Measurement measurement4 = new Measurement(() -> 1d, Statistic.VALUE);
    Measurement measurement5 = new Measurement(() -> 2d, Statistic.VALUE);
    List<Measurement> measurements = Arrays.asList(measurement1, measurement2, measurement3, measurement4, measurement5);
    Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.meterRegistry);
    assertThat(createBatch().writeMeter(meter))
            .isEqualTo("{\"timestamp\":\"1970-01-01T00:00:00.001Z\",\"attributes\":{\"name\":\"my_meter\",\"value\":1,\"value\":2}}");
}
 

@Test
void writeMeterWhenCustomMeterHasOnlyNonFiniteValuesShouldNotBeWritten() {
    Measurement measurement1 = new Measurement(() -> Double.POSITIVE_INFINITY, Statistic.VALUE);
    Measurement measurement2 = new Measurement(() -> Double.NEGATIVE_INFINITY, Statistic.VALUE);
    Measurement measurement3 = new Measurement(() -> Double.NaN, Statistic.VALUE);
    List<Measurement> measurements = Arrays.asList(measurement1, measurement2, measurement3);
    Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.meterRegistry);
    assertThat(createBatch().writeMeter(meter)).isNull();
}
 

@Override
public Iterable<Measurement> measure() {
    return Arrays.asList(
            new Measurement(() -> (double) count(), Statistic.COUNT),
            new Measurement(this::totalAmount, Statistic.TOTAL),
            new Measurement(this::max, Statistic.MAX)
    );
}
 

@Override
protected Meter newMeter(final Meter.Id id, final Meter.Type type, final Iterable<Measurement> measurements) {
    return new NoopCounter(id);
}
 

@Override
protected Meter newMeter(Id id, Type type, Iterable<Measurement> measurements) {
    return new NoopMeter(id);
}
 

protected SkywalkingCustomCounter(MeterId meterId, Measurement measurement, SkywalkingConfig config) {
    super(meterId, MeterBuilder.getCounterMode(meterId, config));
    this.measurement = measurement;
}
 

public Builder(MeterId meterId, Measurement measurement, SkywalkingConfig config) {
    super(meterId);
    this.measurement = measurement;
    this.config = config;
}
 

@Override
public List<Measurement> measure() {
    return emptyList();
}
 

CompositeCustomMeter(Id id, Type type, Iterable<Measurement> measurements) {
    super(id, type, measurements);
}
 

@Override
public Iterable<Measurement> measure() {
    return measurements;
}
 

@Override
protected Meter newMeter(Id id, Type type, Iterable<Measurement> measurements) {
	return new DefaultMeter(id, type, measurements);
}
 

public DefaultMeter(Meter.Id id, Meter.Type type, Iterable<Measurement> measurements) {
    super(id);
    this.type = type;
    this.measurements = measurements;
}