Pass Threadlocal across "@Bulkhead" annotation

Hi team,

We are trying to migrate from Hystrix to Resiliency4j. We have context value set in ThreadLocal. Whenever we go across @Bulkhead annotation the ThreadLocal is empty

    @Bulkhead(name = "backendA", type = Type.THREADPOOL)
    public CompletableFuture<String> futureSuccessReqCtx() { 
        //empty thread local here
    }

In Hystrix we were copying thread local using HystrixConcurrencyStrategy . Do we have anything equivalent in Resiliency4j. If not, please suggest any other approach.

[adrilo]

Hi @RobWin,

I actually found a way to pass context to the threads without touching the lib:

// somewhere we define a CorrelationId class, which contains a ThreadLocal value, and some getters/setters

public int test() {
    ThreadPoolBulkhead bulkhead = threadPoolBulkheadRegistry.bulkhead("threadlocal");
    return bulkhead
        .executeSupplier(propagateCorrelationId(() -> {
            assertTrue(CorrelationId.isInitialized());
            return 1;
        }))
        .toCompletableFuture()
        .join();
}

private <T> Supplier<T> propagateCorrelationId(Supplier<T> supplier) {
        UUID correlationId = CorrelationId.get();

        return () -> {
            try {
                CorrelationId.initWith(correlationId);
                return supplier.get();
            } finally {
                // cleanup
                CorrelationId.clear();
            }
        };
    }

This can obviously be extended to pass more context to the executing thread.

Given that we can achieve this result without messing with Resilience4j, I’m now wondering how useful it would be to add such a feature directly in the lib. But if you think it’s still a good idea, it could work this way:

Developers can register ContextPropagators via the BulkheadConfig. A ContextPropagator provides 3 things:

• a supplier to fetch a value
• a callback to call before the execution in the “new” thread
• a callback to call after the execution in the “new” thread

Or translated in code:

public class ContextPropagator<T> {
    private Supplier<Optional<T>> currentThreadSupplier;
    private Consumer<T> before;
    private Consumer<T> after;

Then in the implementation of FixedThreadPoolBulkhead::submit, I would change it to something like that:

	public <T> CompletableFuture<T> submit(Callable<T> callable) {
		final CompletableFuture<T> promise = new CompletableFuture<>();
                // ADDED:
               var threadContexts = config.getContextPropagators()
                                           .stream()
                                           .map(ContextPropagator::captureThreadContext)
                                           .collect(Collectors.toList());

		try {
			CompletableFuture.supplyAsync(() -> {
				try {
					// ADDED:
					threadContexts.forEach(ContextPropagator.CapturedThreadContext::beforeRun);
					publishBulkheadEvent(() -> new BulkheadOnCallPermittedEvent(name));
					return callable.call();
				} catch (Exception e) {
					throw new CompletionException(e);
				} finally {
                                    // ADDED:
                                   threadContexts.forEach(ContextPropagator.CapturedThreadContext::afterRun);
                                }
			}, executorService).whenComplete((result, throwable) -> {
				...
			});
		} catch (RejectedExecutionException rejected) {
			...
		}
		return promise;
	}

This is just a rough idea on how this would work. If that’s interesting, the API must be worked on carefully, as the config now provides hooks and is no longer a value store.

[RobWin]

Thats correct. We need to improve the documentation. Currently the best documentation is our test:

https://github.com/resilience4j/resilience4j/blob/master/resilience4j-spring-boot2/src/test/resources/application.yaml#L163-L164

https://github.com/resilience4j/resilience4j/blob/master/resilience4j-spring-boot2/src/test/java/io/github/resilience4j/TestThreadLocalContextPropagator.java