static <T> CompletionStage<T> executeCompletionStageSupplier(Observation observation,
                                                                 Supplier<CompletionStage<T>> supplier) {
        return decorateCompletionStageSupplier(observation, supplier).get();
    }
@Test
    public void shouldExecuteCompletionStageAndReturnWithExceptionAtASyncStage() throws Throwable {
        given(helloWorldService.returnHelloWorld()).willThrow(new HelloWorldException());
        Supplier<CompletionStage<String>> completionStageSupplier =
            () -> CompletableFuture.supplyAsync(helloWorldService::returnHelloWorld);
        CompletionStage<String> stringCompletionStage = Observations
            .executeCompletionStageSupplier(observation, completionStageSupplier);

        assertThatThrownBy(() -> stringCompletionStage.toCompletableFuture().get())
            .isInstanceOf(ExecutionException.class).hasCause(new HelloWorldException());

        Awaitility.await()
            .until(() -> assertThat(observationRegistry)
                .hasSingleObservationThat()
                .hasNameEqualTo(ObservationsTest.class.getName())
                .hasBeenStarted()
                .hasBeenStopped()
                .assertThatError()
                .isInstanceOf(CompletionException.class).hasCause(new HelloWorldException()));
        then(helloWorldService).should().returnHelloWorld();
    }