[BUG] OpenLiberty fails to register Fault Tolerance interceptor on a proxy bean.

[TheEliteGentleman]

This is with regards to the Liberty Car Booking Example in LangChain4J-CDI.

An AI service is applied with any of the MP Fault Tolerance annotations. (See example here).

Unfortunately, in Open Liberty, the interceptor doesn't get triggered on method invocation.

The ApplyFaultToleranceInterceptor, in line 45, it returns an empty list of Interceptors, which it shouldn't.

How does OpenLiberty apply Fault Tolerance interceptors?

Bear in mind that the AI service is an interface and the CDI extension registers it to a proxy bean.

[Azquelt]

How does OpenLiberty apply Fault Tolerance interceptors?

Currently it uses a CDI extension to find classes and methods with FT annotations and adds an extra synthetic annotation which is what actually binds the interceptor.

Edit: it's only going to find discovered types, which in the default discovery mode is only classes with a bean defining annotation, so it's likely it will never see the interface in question.

I can see why that's failing with this:

            List<Annotation> annotations = Langchain4JFaultToleranceExtension.FAULT_TOLERANCE_ANNOTATIONS.stream()
                    .map(annotationClass -> invocationContext.getMethod().getAnnotation(annotationClass))
                    .filter(Objects::nonNull)
                    .collect(Collectors.toList());
            List<jakarta.enterprise.inject.spi.Interceptor<?>> interceptors = beanManager.resolveInterceptors(
                    interception, annotations.toArray(new Annotation[annotations.size()]));

The synthetic annotation which actually binds the interceptor is not on the method.

---

Looking at how you create these intercepted beans...

• Langchain4j (somehow) finds a bunch of interfaces from the application and create synthetic beans for them
• then in your FT extension, when a synthetic bean is registered, if it has one of your annotations on it and any of the methods have fault tolerance annotations, you add a binding to the bean (via your own API) which will bind your ApplyFaultToleranceInterceptor
• when the synthetic bean is created, it passes the instance through an InterceptionFactory with the bindings added to the bean earlier added to the class
  • I'm surprised that here it doesn't automatically find the FT interceptor bindings on the methods and use them to bind interceptors
• then, when your interceptor is called, it finds the FT bindings on the intercepted method, looks up the relevant interceptors from the bean manager and calls the interceptors itself

Is that all correct?

I probably need to have a longer think about what we need to change so that this works.

[Azquelt]

It may work to add our synthetic annotation as a meta-annotation to the FT annotations, though that may just get us past this hurdle and into the next incompatibility.

[Azquelt]

I'm also a little worried that our FT interceptor looks directly at the method and class to read the annotations, so it doesn't work if the annotations are added synthetically or if they're on a stereotype. Not sure if that will be a problem here.

I did wonder if we should change to using InvocationContext.getInterceptorBindings to get the list of interceptor bindings, but this is complicated somewhat by the fact that FT allows configuration at the class and method level, so we need to know where the annotation came from and getInterceptorBindings doesn't give us that.

[TheEliteGentleman]

How does OpenLiberty apply Fault Tolerance interceptors?

Currently it uses a CDI extension to find classes and methods with FT annotations and adds an extra synthetic annotation which is what actually binds the interceptor.

Edit: it's only going to find discovered types, which in the default discovery mode is only classes with a bean defining annotation, so it's likely it will never see the interface in question.

I can see why that's failing with this:

        List<Annotation> annotations = Langchain4JFaultToleranceExtension.FAULT_TOLERANCE_ANNOTATIONS.stream()
                .map(annotationClass -> invocationContext.getMethod().getAnnotation(annotationClass))
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
        List<jakarta.enterprise.inject.spi.Interceptor<?>> interceptors = beanManager.resolveInterceptors(
                interception, annotations.toArray(new Annotation[annotations.size()]));

The synthetic annotation which actually binds the interceptor is not on the method.

Looking at how you create these intercepted beans...

• Langchain4j (somehow) finds a bunch of interfaces from the application and create synthetic beans for them

• then in your FT extension, when a synthetic bean is registered, if it has one of your annotations on it and any of the methods have fault tolerance annotations, you add a binding to the bean (via your own API) which will bind your ApplyFaultToleranceInterceptor

• when the synthetic bean is created, it passes the instance through an InterceptionFactory with the bindings added to the bean earlier added to the class

  • I'm surprised that here it doesn't automatically find the FT interceptor bindings on the methods and use them to bind interceptors

• then, when your interceptor is called, it finds the FT bindings on the intercepted method, looks up the relevant interceptors from the bean manager and calls the interceptors itself

Is that all correct?

I probably need to have a longer think about what we need to change so that this works.

You are pretty much spot on in your analysis, but the extension that does the creation of the synthetic bean is found here.
LangChain4J provides a proxy object for every AI interface that we register on CDI bean creation.

The reason we've gone with this approach is that the FT and CDI annotations that exist on the interface don't propagate to the proxy object it links to.

[TheEliteGentleman]

I can also confirm that SmallRye Fault Tolerance doesn't bind FT interceptors to an interface, but upon interceptor resolution, it will find an InterceptorBinding for all FT interceptor annotations. Hence, the method can be intercepted.