microprofile | microprofile - embeddable CPU/GPU profiler | Monitoring library

You can just pass it using standard configuration for consumers and producers, prefixed with kafka-streams:

For the time being (see environment info in the question) mvn liberty:dev throws an error if maven.compiler.source or maven.compiler.target is used together with maven.compiler.release even if the version numbers are aligned. So you either have to use

• maven.compiler.source and/or maven.compiler.target without maven.compiler.release or
• maven.compiler.release without maven.compiler.source and/or maven.compiler.target

If you are working in a maven-multi-module project where the above properties were defined in parent modules you can workaround this issue by overriding the properties appropriately.

Oh i spend a couple of hours to get rid of this problem.. but only minutes after writing this post, i found the "bad guy". The Microprofile Version 3.3 (on Wildfly 20) ignored annotations (like @Timed) at interface-methods. The new Version 4.1 (Wildfly 26) regards them..

pretty easy, afterwards :)

marginal note: If you have more than one WAR deployed on your Wildfly and one of them is using the public API of an other one, then you'll run into problems with hot-deployments. I assume, in my case it occurs because i have placed the Timed-annotation at the implementation-class and not at the interface, that is used as ResteasyClient-proxy. Every time i deploy the depending WAR after the rest-api-defining WAR, i got an exception: no metric mapped. A redeployment of the rest-api-defining WAR fixes this issue :)

The problem here is that the API and SPI bundles that start with io.openliberty have not been publishing to DHE and maven as part of the Liberty publishing tasks that run when a new version is released. We are looking to have this resolved with 22.0.0.2 which is scheduled to be available tomorrow if we don't run into any additional snags and the io.openliberty publishing goes well.

You need to run mvn install, or the artifact for the core module is built but never installed into the local repository and cannot be resolved when building the webapp module.

You are using Java 16 (as shown in the log file) with Maven. In this case, you should use TomEE in version 8.0.9 as this release contains important fixes regarding illegal reflective access (due to the use of Unsafe for proxy creation) in higher versions of Java. You find some details in https://issues.apache.org/jira/browse/TOMEE-3795

It looks like you are using a lower Java version for running your standalone TomEE deployment, which works as it isn't as restrictive as newer Java versions.

Side Note: Java 16 is end-of-life and you should better switch to Java 17.

It looks like there was a bug filed for this, but it was fixed in WildFly 25. That said I do not see the reference in the default README.

That said it does require the standalone-microprofile.xml. You can also add the subsystem with CLI to standalone.xml and runt it that way as well. The following CLI commands will add the microprofile-health-smallrye to any configuration you start with that does not already include the subsystem.

This is not caused by the update, Quarkus 2.6.2.Final did not change anything regarding the fault tolerance stuff.

To facilitate negative testing, you can inject CircuitBreakerMaintenance and reset all circuit breakers in the application using resetAll (see https://smallrye.io/docs/smallrye-fault-tolerance/5.2.1/usage/extra.html#_circuit_breaker_maintenance).

Alternatively, there's a configuration property that disables all fault tolerance except fallbacks: MP_Fault_Tolerance_NonFallback_Enabled (see https://download.eclipse.org/microprofile/microprofile-fault-tolerance-3.0/microprofile-fault-tolerance-spec-3.0.html#_disable_a_group_of_fault_tolerance_annotations_on_the_global_level).

So, first things first. To run things asynchronously Jakarta EE has the annotation @Asynchronous. So, create a CDI bean with @RequestScoped, and put there your business method annotated with @Asynchronous.

Add @ApplicationScoped CDI annotation to your JAXRS service so you can inject ypur business bean.

Then, for monitoring the task, you have a couple of possibilities.

1. If you keep the state in a database you just make the @GET method to check the state in the database. But I asume this is not your case.

2. If the first approach doesn't fit then you have to keep the state of the different inProgress tasks somehow. I would have another @ApplicationScoped CDI bean for that. This would contain a ConcurrentHashMap, with a UUID as the key, and as the value an Object of your own that contains the current state of any specific async job.

The UUID has to be generated in the @POST method, and sent as a parameter to the @Asynchronous, method. This way the @POST method can return the UUID, which will be used then in the @GET to request the state of the task (querying the @ApplicationScoped bean).

So the application-wide async tasks state holder should be something like this