Skip to content

Commit 53741d0

Browse files
Ryan Lubketomas-langer
Ryan Lubke
authored and
tomas-langer
committed
Port change for helidon-io#1618 to 2.0
1 parent 4638962 commit 53741d0

4 files changed

Lines changed: 204 additions & 21 deletions

File tree

‎grpc/metrics/src/main/java/io/helidon/grpc/metrics/GrpcMetrics.java‎

Lines changed: 53 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -126,6 +126,17 @@ public GrpcMetrics description(String description) {
126126
return new GrpcMetrics(metricRule.description(description));
127127
}
128128

129+
/**
130+
* Set the display name to apply to the metric.
131+
*
132+
* @param displayName the display name to apply to the metric
133+
* @return a {@link io.helidon.grpc.metrics.GrpcMetrics} interceptor
134+
* @see org.eclipse.microprofile.metrics.Metadata
135+
*/
136+
public GrpcMetrics displayName(String displayName) {
137+
return new GrpcMetrics(metricRule.displayName(displayName));
138+
}
139+
129140
/**
130141
* Set the units to apply to the metric.
131142
*
@@ -137,6 +148,16 @@ public GrpcMetrics units(String units) {
137148
return new GrpcMetrics(metricRule.units(units));
138149
}
139150

151+
/**
152+
* Set the reusability of the metric.
153+
* @param reusable {@code true} if this metric may be reused
154+
* @return a {@link io.helidon.grpc.metrics.GrpcMetrics} interceptor
155+
* @see org.eclipse.microprofile.metrics.Metadata
156+
*/
157+
public GrpcMetrics reusable(boolean reusable) {
158+
return new GrpcMetrics(metricRule.reusable(reusable));
159+
}
160+
140161
/**
141162
* Obtain the {@link org.eclipse.microprofile.metrics.MetricType}.
142163
*
@@ -441,6 +462,13 @@ static class MetricsRules {
441462
*/
442463
private Optional<String> description = Optional.empty();
443464

465+
/**
466+
* The display name of the metric.
467+
*
468+
* @see org.eclipse.microprofile.metrics.Metadata
469+
*/
470+
private String displayName;
471+
444472
/**
445473
* The unit of the metric.
446474
*
@@ -449,6 +477,12 @@ static class MetricsRules {
449477
*/
450478
private Optional<String> units = Optional.empty();
451479

480+
/**
481+
* The reusability status of this metric.
482+
* @see org.eclipse.microprofile.metrics.Metadata
483+
*/
484+
private boolean reusable;
485+
452486
/**
453487
* The function to use to obtain the metric name.
454488
*/
@@ -462,8 +496,10 @@ private MetricsRules(MetricsRules copy) {
462496
this.type = copy.type;
463497
this.tags = copy.tags;
464498
this.description = copy.description;
499+
this.displayName = copy.displayName;
465500
this.units = copy.units;
466501
this.nameFunction = copy.nameFunction;
502+
this.reusable = copy.reusable;
467503
}
468504

469505
/**
@@ -489,6 +525,11 @@ io.helidon.common.metrics.InternalBridge.Metadata metadata(ServiceDescriptor ser
489525
this.description.ifPresent(builder::withDescription);
490526
this.units.ifPresent(builder::withUnit);
491527

528+
String displayName = this.displayName;
529+
builder.withDisplayName(displayName == null ? name : displayName);
530+
531+
builder = this.reusable ? builder.reusable() : builder.notReusable();
532+
492533
return builder.build();
493534
}
494535

@@ -508,6 +549,12 @@ private MetricsRules description(String description) {
508549
return rules;
509550
}
510551

552+
private MetricsRules displayName(String displayName) {
553+
MetricsRules rules = new MetricsRules(this);
554+
rules.displayName = displayName;
555+
return rules;
556+
}
557+
511558
private MetricsRules nameFunction(NamingFunction function) {
512559
MetricsRules rules = new MetricsRules(this);
513560
rules.nameFunction = Optional.of(function);
@@ -520,6 +567,12 @@ private MetricsRules units(String units) {
520567
return rules;
521568
}
522569

570+
private MetricsRules reusable(boolean reusable) {
571+
MetricsRules rules = new MetricsRules(this);
572+
rules.reusable = reusable;
573+
return rules;
574+
}
575+
523576
private Map<String, String> toTags() {
524577
return tags.isPresent() ? tags.get() : Collections.emptyMap();
525578
}

‎microprofile/grpc/metrics/src/main/java/io/helidon/microprofile/grpc/metrics/MetricsConfigurer.java‎

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,7 @@
3333

3434
import org.eclipse.microprofile.metrics.MetricType;
3535
import org.eclipse.microprofile.metrics.annotation.Counted;
36+
import org.eclipse.microprofile.metrics.annotation.Gauge;
3637
import org.eclipse.microprofile.metrics.annotation.Metered;
3738
import org.eclipse.microprofile.metrics.annotation.Timed;
3839

@@ -118,6 +119,36 @@ private void addMetric(ServiceDescriptor.Builder builder,
118119

119120
MetricUtil.LookupResult<? extends Annotation> lookupResult
120121
= MetricUtil.lookupAnnotation(method, annotation.annotationType(), annotatedClass);
122+
123+
if (annotation instanceof Metered) {
124+
Metered metered = (Metered) annotation;
125+
String displayName = metered.displayName().trim();
126+
interceptor = interceptor.description(metered.description());
127+
interceptor = interceptor.displayName(displayName.isEmpty() ? metricName : displayName);
128+
interceptor = interceptor.reusable(metered.reusable());
129+
interceptor = interceptor.units(metered.unit());
130+
} else if (annotation instanceof Gauge) {
131+
Gauge gauge = (Gauge) annotation;
132+
String displayName = gauge.displayName().trim();
133+
interceptor = interceptor.description(gauge.description());
134+
interceptor = interceptor.displayName(displayName.isEmpty() ? metricName : displayName);
135+
interceptor = interceptor.units(gauge.unit());
136+
} else if (annotation instanceof Timed) {
137+
Timed timed = (Timed) annotation;
138+
String displayName = timed.displayName().trim();
139+
interceptor = interceptor.description(timed.description());
140+
interceptor = interceptor.displayName(displayName.isEmpty() ? metricName : displayName);
141+
interceptor = interceptor.reusable(timed.reusable());
142+
interceptor = interceptor.units(timed.unit());
143+
} else if (annotation instanceof Counted) {
144+
Counted counted = (Counted) annotation;
145+
String displayName = counted.displayName().trim();
146+
interceptor = interceptor.description(counted.description());
147+
interceptor = interceptor.displayName(displayName.isEmpty() ? metricName : displayName);
148+
interceptor = interceptor.reusable(counted.reusable());
149+
interceptor = interceptor.units(counted.unit());
150+
}
151+
121152
MetricsCdiExtension.registerMetric(method, annotatedClass, lookupResult);
122153
builder.intercept(grpcMethodName, interceptor.nameFunction(new ConstantNamingFunction(metricName)));
123154
}

‎microprofile/metrics/src/main/java/io/helidon/microprofile/metrics/MetricUtil.java‎

Lines changed: 96 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -26,8 +26,15 @@
2626
import java.util.List;
2727
import java.util.logging.Logger;
2828

29+
import org.eclipse.microprofile.metrics.Metadata;
2930
import org.eclipse.microprofile.metrics.MetricID;
31+
import org.eclipse.microprofile.metrics.MetricRegistry;
32+
import org.eclipse.microprofile.metrics.MetricType;
3033
import org.eclipse.microprofile.metrics.Tag;
34+
import org.eclipse.microprofile.metrics.annotation.ConcurrentGauge;
35+
import org.eclipse.microprofile.metrics.annotation.Counted;
36+
import org.eclipse.microprofile.metrics.annotation.Metered;
37+
import org.eclipse.microprofile.metrics.annotation.Timed;
3138

3239
/**
3340
* Class MetricUtil.
@@ -100,28 +107,113 @@ String getMetricName(E element, Class<?> clazz, MatchingType matchingType, Strin
100107
methods = Arrays.asList(declaringClass.getDeclaredMethods());
101108
}
102109
}
103-
result = declaringClass.getName() + "." + result;
110+
result = declaringClass.getName() + '.' + result;
104111
}
105112
} else if (matchingType == MatchingType.CLASS) {
106113
if (explicitName == null || explicitName.isEmpty()) {
107114
result = getElementName(element, clazz);
108115
if (!absolute) {
109-
result = clazz.getName() + "." + result;
116+
result = clazz.getName() + '.' + result;
110117
}
111118
} else {
112119
// Absolute must be false at class level, issue warning here
113120
if (absolute) {
114121
LOGGER.warning(() -> "Attribute 'absolute=true' in metric annotation ignored at class level");
115122
}
116-
result = clazz.getPackage().getName() + "." + explicitName
117-
+ "." + getElementName(element, clazz);
123+
result = clazz.getPackage().getName() + '.' + explicitName
124+
+ '.' + getElementName(element, clazz);
118125
}
119126
} else {
120127
throw new InternalError("Unknown matching type");
121128
}
122129
return result;
123130
}
124131

132+
/**
133+
* Register a metric.
134+
*
135+
* @param element the annotated element
136+
* @param clazz the annotated class
137+
* @param lookupResult the annotation lookup result
138+
* @param <E> the annotated element type
139+
*/
140+
public static <E extends Member & AnnotatedElement>
141+
void registerMetric(E element, Class<?> clazz, LookupResult<? extends Annotation> lookupResult) {
142+
registerMetric(element, clazz, lookupResult.getAnnotation(), lookupResult.getType());
143+
}
144+
145+
/**
146+
* Register a metric.
147+
*
148+
* @param element the annotated element
149+
* @param clazz the annotated class
150+
* @param annotation the annotation to register
151+
* @param type the {@link MatchingType} indicating the type of annotated element
152+
* @param <E> the annotated element type
153+
*/
154+
public static <E extends Member & AnnotatedElement>
155+
void registerMetric(E element, Class<?> clazz, Annotation annotation, MatchingType type) {
156+
MetricRegistry registry = getMetricRegistry();
157+
158+
if (annotation instanceof Counted) {
159+
Counted counted = (Counted) annotation;
160+
String metricName = getMetricName(element, clazz, type, counted.name().trim(), counted.absolute());
161+
String displayName = counted.displayName().trim();
162+
Metadata meta = Metadata.builder()
163+
.withName(metricName)
164+
.withDisplayName(displayName.isEmpty() ? metricName : displayName)
165+
.withDescription(counted.description().trim())
166+
.withType(MetricType.COUNTER)
167+
.withUnit(counted.unit().trim())
168+
.reusable(counted.reusable()).build();
169+
registry.counter(meta);
170+
LOGGER.fine(() -> "### Registered counter " + metricName);
171+
} else if (annotation instanceof Metered) {
172+
Metered metered = (Metered) annotation;
173+
String metricName = getMetricName(element, clazz, type, metered.name().trim(), metered.absolute());
174+
String displayName = metered.displayName().trim();
175+
Metadata meta = Metadata.builder()
176+
.withName(metricName)
177+
.withDisplayName(displayName.isEmpty() ? metricName : displayName)
178+
.withDescription(metered.description().trim())
179+
.withType(MetricType.METERED)
180+
.withUnit(metered.unit().trim())
181+
.reusable(metered.reusable()).build();
182+
registry.meter(meta);
183+
LOGGER.fine(() -> "### Registered meter " + metricName);
184+
} else if (annotation instanceof ConcurrentGauge) {
185+
ConcurrentGauge concurrentGauge = (ConcurrentGauge) annotation;
186+
String metricName = getMetricName(element, clazz, type, concurrentGauge.name().trim(),
187+
concurrentGauge.absolute());
188+
String displayName = concurrentGauge.displayName().trim();
189+
Metadata meta = Metadata.builder()
190+
.withName(metricName)
191+
.withDisplayName(displayName.isEmpty() ? metricName : displayName)
192+
.withDescription(concurrentGauge.description().trim())
193+
.withType(MetricType.METERED)
194+
.withUnit(concurrentGauge.unit().trim()).build();
195+
registry.concurrentGauge(meta);
196+
LOGGER.fine(() -> "### Registered ConcurrentGauge " + metricName);
197+
} else if (annotation instanceof Timed) {
198+
Timed timed = (Timed) annotation;
199+
String metricName = getMetricName(element, clazz, type, timed.name().trim(), timed.absolute());
200+
String displayName = timed.displayName().trim();
201+
Metadata meta = Metadata.builder()
202+
.withName(metricName)
203+
.withDisplayName(displayName.isEmpty() ? metricName : displayName)
204+
.withDescription(timed.description().trim())
205+
.withType(MetricType.TIMER)
206+
.withUnit(timed.unit().trim())
207+
.reusable(timed.reusable()).build();
208+
registry.timer(meta);
209+
LOGGER.fine(() -> "### Registered timer " + metricName);
210+
}
211+
}
212+
213+
private static MetricRegistry getMetricRegistry() {
214+
return RegistryProducer.getDefaultRegistry();
215+
}
216+
125217
static <E extends Member & AnnotatedElement>
126218
String getElementName(E element, Class<?> clazz) {
127219
return element instanceof Constructor ? clazz.getSimpleName() : element.getName();

‎microprofile/metrics/src/main/java/io/helidon/microprofile/metrics/MetricsCdiExtension.java‎

Lines changed: 24 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -121,46 +121,53 @@ void registerMetric(E element, Class<?> clazz, LookupResult<? extends Annotation
121121

122122
if (annotation instanceof Counted) {
123123
Counted counted = (Counted) annotation;
124-
String metricName = getMetricName(element, clazz, lookupResult.getType(), counted.name(), counted.absolute());
124+
String metricName = getMetricName(element, clazz, lookupResult.getType(), counted.name().trim(),
125+
counted.absolute());
126+
String displayName = counted.displayName().trim();
125127
Metadata meta = new HelidonMetadata(metricName,
126-
counted.displayName(),
127-
counted.description(),
128+
displayName.isEmpty() ? metricName : displayName,
129+
counted.description().trim(),
128130
MetricType.COUNTER,
129-
counted.unit(),
131+
counted.unit().trim(),
130132
counted.reusable());
131133
registry.counter(meta, tags(counted.tags()));
132134
LOGGER.log(Level.FINE, () -> "Registered counter " + metricName);
133135
} else if (annotation instanceof Metered) {
134136
Metered metered = (Metered) annotation;
135-
String metricName = getMetricName(element, clazz, lookupResult.getType(), metered.name(), metered.absolute());
137+
String metricName = getMetricName(element, clazz, lookupResult.getType(), metered.name().trim(),
138+
metered.absolute());
139+
String displayName = metered.displayName().trim();
136140
Metadata meta = new HelidonMetadata(metricName,
137-
metered.displayName(),
138-
metered.description(),
141+
displayName.isEmpty() ? metricName : displayName,
142+
metered.description().trim(),
139143
MetricType.METERED,
140-
metered.unit(),
144+
metered.unit().trim(),
141145
metered.reusable());
142146
registry.meter(meta, tags(metered.tags()));
143147
LOGGER.log(Level.FINE, () -> "Registered meter " + metricName);
144148
} else if (annotation instanceof Timed) {
145149
Timed timed = (Timed) annotation;
146-
String metricName = getMetricName(element, clazz, lookupResult.getType(), timed.name(), timed.absolute());
150+
String metricName = getMetricName(element, clazz, lookupResult.getType(), timed.name().trim(),
151+
timed.absolute());
152+
String displayName = timed.displayName().trim();
147153
Metadata meta = new HelidonMetadata(metricName,
148-
timed.displayName(),
149-
timed.description(),
154+
displayName.isEmpty() ? metricName : displayName,
155+
timed.description().trim(),
150156
MetricType.TIMER,
151-
timed.unit(),
157+
timed.unit().trim(),
152158
timed.reusable());
153159
registry.timer(meta, tags(timed.tags()));
154160
LOGGER.log(Level.FINE, () -> "Registered timer " + metricName);
155161
} else if (annotation instanceof ConcurrentGauge) {
156162
ConcurrentGauge concurrentGauge = (ConcurrentGauge) annotation;
157-
String metricName = getMetricName(element, clazz, lookupResult.getType(), concurrentGauge.name(),
158-
concurrentGauge.absolute());
163+
String metricName = getMetricName(element, clazz, lookupResult.getType(), concurrentGauge.name().trim(),
164+
concurrentGauge.absolute());
165+
String displayName = concurrentGauge.displayName().trim();
159166
Metadata meta = new HelidonMetadata(metricName,
160-
concurrentGauge.displayName(),
161-
concurrentGauge.description(),
167+
displayName.isEmpty() ? metricName : displayName,
168+
concurrentGauge.description().trim(),
162169
MetricType.CONCURRENT_GAUGE,
163-
concurrentGauge.unit(),
170+
concurrentGauge.unit().trim(),
164171
concurrentGauge.reusable());
165172
registry.concurrentGauge(meta, tags(concurrentGauge.tags()));
166173
LOGGER.log(Level.FINE, () -> "Registered concurrent gauge " + metricName);

0 commit comments

Comments
 (0)