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 :(.