io.micrometer.core.instrument.ImmutableTag Java Examples

@Test
public void testWithTagAndBaggageLabels() {
    String metricName = "testWithTagAndBaggageLabels";

    // prepare
    SpanData spanData = defaultMockSpanData();
    MicrometerMetricsReporter reporter = MicrometerMetricsReporter.newMetricsReporter()
            .withName(metricName)
            .withBaggageLabel(BAGGAGE_LABEL_NAME, BAGGAGE_LABEL_VALUE)
            .withTagLabel(TAG_LABEL_NAME, TAG_LABEL_VALUE)
            .withConstLabel("span.kind", Tags.SPAN_KIND_CLIENT)
            .build();

    // test
    reporter.reportSpan(spanData);

    // verify
    List<Tag> tags = defaultTags();
    tags.add(new ImmutableTag(BAGGAGE_LABEL_NAME, BAGGAGE_LABEL_VALUE));
    tags.add(new ImmutableTag(TAG_LABEL_NAME, TAG_LABEL_VALUE));

    assertEquals(100, (long) registry.find(metricName).timer().totalTime(TimeUnit.MILLISECONDS));
    assertEquals(1, Metrics.timer(metricName, tags).count());
}
 

@Test
public void testWithCustomLabel() {
    String metricName = "testWithCustomLabel";

    // prepare
    SpanData spanData = defaultMockSpanData();
    MetricLabel metricLabel = new BaggageMetricLabel(METRIC_LABEL_NAME, METRIC_LABEL_VALUE);
    MicrometerMetricsReporter reporter = MicrometerMetricsReporter.newMetricsReporter()
            .withName(metricName)
            .withCustomLabel(metricLabel)
            .withConstLabel("span.kind", Tags.SPAN_KIND_CLIENT)
            .build();

    // test
    reporter.reportSpan(spanData);

    // verify
    List<Tag> tags = defaultTags();
    tags.add(new ImmutableTag(METRIC_LABEL_NAME, METRIC_LABEL_VALUE));

    assertEquals(100, (long) registry.find(metricName).timer().totalTime(TimeUnit.MILLISECONDS));
    assertEquals(1, Metrics.timer(metricName, tags).count());
}
 

@Override
public void afterJob(JobExecution jobExecution) {
	long jobDuration = jobExecution.getEndTime().getTime() - jobExecution.getStartTime().getTime();
	meterRegistry.gauge(METRIC_NAME, Arrays.asList(//
			new ImmutableTag("context", jobExecution.getJobInstance().getJobName()), //
			new ImmutableTag("name", "duration")//
	), jobDuration);
	// What the f*** is that Thread.sleep doing here? ;-)
	// Metrics are written asynchronously to Spring Boot's repository. In our tests we experienced
	// that sometimes batch execution was so fast that this listener couldn't export the metrics
	// because they hadn't been written. It all happened in the same millisecond. So we added
	// a Thread.sleep of 100 milliseconds which gives us enough safety and doesn't hurt anyone.
	try {
		Thread.sleep(100);
	} catch (InterruptedException e) {
		throw new RuntimeException(e);
	}
	// Export Metrics to Console
	Search search = meterRegistry.find(METRIC_NAME);
	LOGGER.info(metricsOutputFormatter.format(search.gauges(), search.timers()));
}
 

@Test
public void testOverriddenTagAndBaggageLabels() {
    String metricName = "testOverriddenTagAndBaggageLabels";

    // prepare
    SpanData spanData = defaultMockSpanData();
    when(spanData.getBaggageItem(BAGGAGE_LABEL_NAME)).thenReturn("NewBaggageValue");
    when(spanData.getTags()).thenReturn(Collections.singletonMap(TAG_LABEL_NAME, "NewTagValue"));

    MicrometerMetricsReporter reporter = MicrometerMetricsReporter.newMetricsReporter()
            .withName(metricName)
            .withBaggageLabel(BAGGAGE_LABEL_NAME, BAGGAGE_LABEL_VALUE)
            .withTagLabel(TAG_LABEL_NAME, TAG_LABEL_VALUE)
            .withConstLabel("span.kind", Tags.SPAN_KIND_CLIENT)
            .build();

    // test
    reporter.reportSpan(spanData);

    // verify
    List<Tag> tags = defaultTags();
    tags.add(new ImmutableTag(BAGGAGE_LABEL_NAME, "NewBaggageValue"));
    tags.add(new ImmutableTag(TAG_LABEL_NAME, "NewTagValue"));

    assertEquals(100, (long) registry.find(metricName).timer().totalTime(TimeUnit.MILLISECONDS));
    assertEquals(1, Metrics.timer(metricName, tags).count());
}
 

private List<Tag> defaultTags() {
    List<Tag> tags = new ArrayList<>();
    tags.add(new ImmutableTag("error", "false"));
    tags.add(new ImmutableTag("operation", "testop"));
    tags.add(new ImmutableTag("span.kind", Tags.SPAN_KIND_CLIENT));
    return tags;
}
 

protected Object profileMethod(ProceedingJoinPoint pjp) throws Throwable {
	Timer.Sample sample = Timer.start(meterRegistry);
	try {
		return pjp.proceed();
	} finally {
		sample.stop(meterRegistry.timer(MetricsListener.METRIC_NAME, Arrays.asList(//
				new ImmutableTag("context", getStepIdentifier()), //
				new ImmutableTag("method", ClassUtils.getShortName(pjp.getTarget().getClass()) + "."
						+ pjp.getSignature().getName()))));
	}
}
 

@Override
public ExitStatus afterStep(StepExecution stepExecution) {
	// Calculate step execution time
	// Why is stepExecution.getEndTime().getTime() not available here? (see AbstractStep)
	long stepDuration = System.currentTimeMillis() - stepExecution.getStartTime().getTime();
	meterRegistry.gauge(METRIC_NAME, Arrays.asList(//
			new ImmutableTag("context", getStepExecutionIdentifier(stepExecution)), //
			new ImmutableTag("name", "duration")//
	), stepDuration);
	long itemCount = stepExecution.getWriteCount() + stepExecution.getSkipCount();
	meterRegistry.gauge(METRIC_NAME, Arrays.asList(//
			new ImmutableTag("context", getStepExecutionIdentifier(stepExecution)), //
			new ImmutableTag("name", "item.count")//
	), itemCount);
	// Calculate execution time per item
	long durationPerItem = 0;
	if (itemCount > 0) {
		durationPerItem = stepDuration / itemCount;
	}
	meterRegistry.gauge(METRIC_NAME, Arrays.asList(//
			new ImmutableTag("context", getStepExecutionIdentifier(stepExecution)), //
			new ImmutableTag("name", "item.duration")//
	), durationPerItem);
	// Export metrics from StepExecution to MetricRepositories
	Set<Entry<String, Object>> metrics = stepExecution.getExecutionContext().entrySet();
	for (Entry<String, Object> metric : metrics) {
		if (metric.getValue() instanceof Number) {
			meterRegistry.gauge(METRIC_NAME, Arrays.asList(//
					new ImmutableTag("context", getStepExecutionIdentifier(stepExecution)), //
					new ImmutableTag("name", metric.getKey())//
			), (Number) metric.getValue());
		}
	}
	return null;
}
 

public ClassificationMetrics(ClassificationMetricsConfig classificationMetricsConfig) {
    this(classificationMetricsConfig, Arrays.asList(new ImmutableTag("machinelearning","classification")));
}
 

public MultiLabelMetrics(MultiLabelMetricsConfig multiLabelMetricsConfig) {
    this(multiLabelMetricsConfig, Arrays.asList(new ImmutableTag("machinelearning","multilabel")));
}
 

public RegressionMetrics(RegressionMetricsConfig regressionMetricsConfig) {
    this(regressionMetricsConfig, Arrays.asList(new ImmutableTag("machinelearning","regression")));
}
 

@Override
public void reportSpan(SpanData spanData) {
    boolean skip = Arrays.stream(this.metricLabels).anyMatch(m -> m.value(spanData) == null);
    if (skip) {
        return;
    }

    List<Tag> tags = Arrays.stream(this.metricLabels)
        .map(m -> new ImmutableTag(m.name(), m.value(spanData).toString()))
        .collect(Collectors.toList());

    Timer timer = this.registry.find(this.name).tags(tags).timer();
    if (null != timer) {
        // we have a metric registered already, just record the timing:
        timer.record(spanData.getDuration(), TimeUnit.MICROSECONDS);
        return;
    }

    // would be awesome if we could reuse the builder, but looks like we can't, as we can't override the name
    Timer.Builder builder = Timer.builder(this.name).tags(tags);
    if (publishPercentileHistogram) {
        builder.publishPercentileHistogram();
    }

    if (null != percentiles) {
        builder.publishPercentiles(percentiles);
    }

    if (null != sla) {
        builder.sla(sla);
    }

    if (null != minimumExpectedValue) {
        builder.minimumExpectedValue(minimumExpectedValue);
    }

    if (null != maximumExpectedValue) {
        builder.maximumExpectedValue(maximumExpectedValue);
    }

    builder.register(this.registry).record(spanData.getDuration(), TimeUnit.MICROSECONDS);
}