Is there a good way to add FutureLocal.java to custom Future.java extending CompletableFuture? (example code below)

I have the following code which was kind of close except when I call super.thenCompose and it returns a CompletableFuture instead of my Custom Future.java which is kind of critical. I am trying to copy twitter's scala futures that

1. Be able to add cancellation chaining like twitter scala's futures

2. can have a request context flow through the thenApply and thenCompose chains to fix MDC in slf4j (much like a ThreadLocal but it is re-applied just before each lambda is run as seen in the code below)

   public class Future<T> extends CompletableFuture<T> {

   @Override
   public <U> CompletableFuture<U> thenApply(Function<? super T, ? extends U> fn) {
   Map<String, Object> state = FutureLocal.fetchState();
   MyFunction f = new MyFunction(state, fn);		
   return super.thenApply(f);
   }
   @Override
   public <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn) {
   Map<String, Object> state = FutureLocal.fetchState();
   MyFunction f = new MyFunction(state, fn);
   return super.thenCompose(f);
   }
   @SuppressWarnings("hiding")
   private class MyFunction implements Function {
   private Map<String, Object> state;
   private Function fn;
   public MyFunction(Map<String, Object> state, @SuppressWarnings("rawtypes") Function fn) {
   this.state = state;
   this.fn = fn;
   }
   @Override
   public Object apply(Object t) {
   try {
   FutureLocal.restoreState(state);
   return fn.apply(t);
   } finally {
   FutureLocal.restoreState(null);
   }
   }
   }
   @Override
   public boolean complete(T value) {
   return super.complete(value);
   }
   @Override
   public boolean completeExceptionally(Throwable ex) {
   return super.completeExceptionally(ex);
   }
   

   }

Here is some code I use to run that code but logging the "test" in the map starts failing on the 3rd remote call meaning slf4j MDC will break down.

public class TestCustomFutures {
private Executor exec = Executors.newFixedThreadPool(3);
@Test
public void testFutureContext() throws InterruptedException, ExecutionException {
Set<Integer> hashSet = new HashSet<Integer>();
FutureLocal.put("test", 100);
CompletableFuture<Integer> f = myRemoteCall(4)
.thenCompose(s -> myRemoteCall(3))
.thenCompose(s -> myRemoteCall(2));
f.get();
}
private Future<Integer> myRemoteCall(int i) {
System.out.println("result="+i+" map="+FutureLocal.get("test")+" thread="+Thread.currentThread().getName());
Future<Integer> f = new Future<Integer>();
exec.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
f.completeExceptionally(e);
}
f.complete(i);
}
});
return f;
}
}

The output then is this

result=4 map=100 thread=main
result=3 map=100 thread=pool-1-thread-1
result=2 map=null thread=pool-1-thread-2

notice that last value we do not want to be null

ahhh, I was missing one simple thing BECAUSE I was in jdk8. In jdk11 however, you can override this...

@Override
public <U> CompletableFuture<U> newIncompleteFuture() {
return new Future<U>();
}

In jdk8, for some reason, this would not compile and it would not invoke this :(. Crap, I didn't want to upgrade to 11 yet as some usages are stilll on jdk8 :(.