Can expression evaluation be done outside of Micronaut annotations?

[hrothwell]

Was playing around with expression language usage (which also gave way to #10529) and figured this specific question might be better suited as a discussion:

does expression evaluation only work in Micronaut annotations? ie can I not do something like @Timed(value = "my_metric", extraTags = ["custom", "#{this.someProperty}"]) in the core micrometer annotation? (io.micrometer.core.annotation.Timed)

If that is the case, can the annotation processor be configured such that it does look at other annotations to perform expression evaluation on?

[hrothwell]

The docs do state: Expressions can be used anywhere throughout the Micronaut framework and associated modules, but I suppose I was unsure if this meant it is strictly limited to Micronaut annotations or if it could be opened up in any means

[graemerocher]

so general support for expressions is present in the core of the framework, but it is likely that modules need to be updated to handle them (such as micrometer). You can see an example of how they are handled for @Scheduled here

micronaut-core/context/src/main/java/io/micronaut/scheduling/processor/ScheduledMethodProcessor.java

Line 125 in 72a0512

if (finalAnnotationValue instanceof EvaluatedAnnotationValue<Scheduled> evaluated) {

I believe for AOP like @Timed we handle them automatically. See

micronaut-core/aop/src/main/java/io/micronaut/aop/chain/InterceptorChain.java

Line 72 in 72a0512

if (metadata instanceof EvaluatedAnnotationMetadata eam) {

so it should "just work" but I admit I have not tested them with Micrometer annotations.

[hrothwell]

Hm ok, something must be either misconfigured on my side then or the expression is just not properly evaluating. When the meter is created, it shows the tag custom is present, but the value of the tag is just #{this.someProperty} - ie the expression is never evaluated before the meter is created. Example application is here but I'll poke around a bit more before I bother converting to an issue or anything

[hrothwell]

With a breakpoint on the InterceptorChain line you mentioned:

Appears that when the expression is in the method array it is not considered an evaluated expression.

When I instead tried doing the same expression in the value field, it was an EvaluatedAnnotationMetadata, however the expression was still not annotated as I would have expected, meter registry entry:

[graemerocher]

yeah seems we have a gap in string array handling

[hrothwell]

I'm planning on spending most of my day taking a look at it, will hopefully have something to show for it by EOD MST.

[nedelva]

Here's what ChatGPT had to say about it:

In Micronaut, expression evaluation is primarily associated with Micronaut annotations, allowing for dynamic configuration and behavior. However, in the case of Micrometer annotations, such as @Timed from io.micrometer.core.annotation.Timed, expression evaluation is not inherently supported as it is in Micronaut annotations.

Micrometer annotations are designed to provide metrics instrumentation for monitoring purposes and are typically more static in nature. While you cannot directly use expression evaluation within Micrometer annotations like @Timed, you can achieve similar dynamic behavior by programmatically configuring Micrometer meters or using Micronaut's features alongside Micrometer.

For instance, you could dynamically configure metrics at runtime using Micrometer's MeterRegistry API within your Micronaut application code. This would allow you to leverage dynamic properties or configurations from your application's environment or other sources.

Regarding your question about configuring the annotation processor to look at other annotations for expression evaluation, the annotation processor operates within the context of the Micronaut framework and is primarily concerned with processing Micronaut-specific annotations. Therefore, configuring it to handle expression evaluation for non-Micronaut annotations like Micrometer's @Timed may not be straightforward or feasible without modifying the Micronaut framework itself, which could introduce complexity and potential compatibility issues.

In summary, while expression evaluation is primarily associated with Micronaut annotations, you can achieve similar dynamic behavior in other contexts by programmatically interacting with the underlying libraries or by integrating Micronaut features into your application architecture.