diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixExecutableBase.java b/hystrix-core/src/main/java/com/netflix/hystrix/AbstractCommand.java
similarity index 57%
rename from hystrix-core/src/main/java/com/netflix/hystrix/HystrixExecutableBase.java
rename to hystrix-core/src/main/java/com/netflix/hystrix/AbstractCommand.java
index 8a26a39e1..57fe2afc3 100644
--- a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixExecutableBase.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/AbstractCommand.java
@@ -16,14 +16,13 @@
 package com.netflix.hystrix;
 
 import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -32,11 +31,19 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import rx.Notification;
 import rx.Observable;
+import rx.Observer;
+import rx.Observable.OnSubscribe;
+import rx.Observable.Operator;
 import rx.Scheduler;
 import rx.Subscriber;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.schedulers.Schedulers;
 import rx.subjects.ReplaySubject;
+import rx.subscriptions.CompositeSubscription;
 
 import com.netflix.hystrix.HystrixCircuitBreaker.NoOpCircuitBreaker;
 import com.netflix.hystrix.HystrixCommandProperties.ExecutionIsolationStrategy;
@@ -46,6 +53,8 @@
 import com.netflix.hystrix.strategy.HystrixPlugins;
 import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy;
 import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategyDefault;
+import com.netflix.hystrix.strategy.concurrency.HystrixContextRunnable;
+import com.netflix.hystrix.strategy.concurrency.HystrixContextScheduler;
 import com.netflix.hystrix.strategy.concurrency.HystrixRequestContext;
 import com.netflix.hystrix.strategy.eventnotifier.HystrixEventNotifier;
 import com.netflix.hystrix.strategy.executionhook.HystrixCommandExecutionHook;
@@ -53,12 +62,13 @@
 import com.netflix.hystrix.strategy.properties.HystrixPropertiesFactory;
 import com.netflix.hystrix.strategy.properties.HystrixPropertiesStrategy;
 import com.netflix.hystrix.strategy.properties.HystrixProperty;
+import com.netflix.hystrix.util.HystrixTimer;
 import com.netflix.hystrix.util.HystrixTimer.TimerListener;
 
-/* package */abstract class HystrixExecutableBase<R> implements HystrixExecutable<R>, HystrixExecutableInfo<R> {
+/* package */abstract class AbstractCommand<R> implements HystrixExecutableInfo<R>, HystrixObservable<R> {
     // TODO make this package private
 
-    private static final Logger logger = LoggerFactory.getLogger(HystrixExecutableBase.class);
+    private static final Logger logger = LoggerFactory.getLogger(AbstractCommand.class);
     protected final HystrixCircuitBreaker circuitBreaker;
     protected final HystrixThreadPool threadPool;
     protected final HystrixThreadPoolKey threadPoolKey;
@@ -132,7 +142,7 @@ protected static enum TimedOutStatus {
         return name;
     }
 
-    protected HystrixExecutableBase(HystrixCommandGroupKey group, HystrixCommandKey key, HystrixThreadPoolKey threadPoolKey, HystrixCircuitBreaker circuitBreaker, HystrixThreadPool threadPool,
+    protected AbstractCommand(HystrixCommandGroupKey group, HystrixCommandKey key, HystrixThreadPoolKey threadPoolKey, HystrixCircuitBreaker circuitBreaker, HystrixThreadPool threadPool,
             HystrixCommandProperties.Setter commandPropertiesDefaults, HystrixThreadPoolProperties.Setter threadPoolPropertiesDefaults,
             HystrixCommandMetrics metrics, TryableSemaphore fallbackSemaphore, TryableSemaphore executionSemaphore,
             HystrixPropertiesStrategy propertiesStrategy, HystrixCommandExecutionHook executionHook) {
@@ -280,306 +290,701 @@ protected HystrixExecutableBase(HystrixCommandGroupKey group, HystrixCommandKey
     }
 
     /**
-     * Used for synchronous execution of command.
+     * Used for asynchronous execution of command with a callback by subscribing to the {@link Observable}.
+     * <p>
+     * This eagerly starts execution of the command the same as {@link #queue()} and {@link #execute()}.
+     * <p>
+     * A lazy {@link Observable} can be obtained from {@link #toObservable()}.
+     * <p>
+     * See https://github.com/Netflix/RxJava/wiki for more information.
      * 
-     * @return R
-     *         Result of {@link #run()} execution or a fallback from {@link #getFallback()} if the command fails for any reason.
+     * @return {@code Observable<R>} that executes and calls back with the result of command execution or a fallback if the command fails for any reason.
      * @throws HystrixRuntimeException
-     *             if a failure occurs and a fallback cannot be retrieved
+     *             if a fallback does not exist
+     *             <p>
+     *             <ul>
+     *             <li>via {@code Observer#onError} if a failure occurs</li>
+     *             <li>or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)</li>
+     *             </ul>
      * @throws HystrixBadRequestException
-     *             if invalid arguments or state were used representing a user failure, not a system failure
+     *             via {@code Observer#onError} if invalid arguments or state were used representing a user failure, not a system failure
      * @throws IllegalStateException
      *             if invoked more than once
      */
-    public R execute() {
-        try {
-            return queue().get();
-        } catch (Exception e) {
-            throw decomposeException(e);
-        }
+    final public Observable<R> observe() {
+        // us a ReplaySubject to buffer the eagerly subscribed-to Observable
+        ReplaySubject<R> subject = ReplaySubject.create();
+        // eagerly kick off subscription
+        toObservable().subscribe(subject);
+        // return the subject that can be subscribed to later while the execution has already started
+        return subject;
     }
 
     /**
-     * Used for asynchronous execution of command.
+     * Used for asynchronous execution of command with a callback by subscribing to the {@link Observable}.
      * <p>
-     * This will queue up the command on the thread pool and return an {@link Future} to get the result once it completes.
+     * This lazily starts execution of the command once the {@link Observable} is subscribed to.
      * <p>
-     * NOTE: If configured to not run in a separate thread, this will have the same effect as {@link #execute()} and will block.
+     * An eager {@link Observable} can be obtained from {@link #observe()}.
      * <p>
-     * We don't throw an exception but just flip to synchronous execution so code doesn't need to change in order to switch a command from running on a separate thread to the calling thread.
+     * See https://github.com/ReactiveX/RxJava/wiki for more information.
      * 
-     * @return {@code Future<R>} Result of {@link #run()} execution or a fallback from {@link #getFallback()} if the command fails for any reason.
+     * @return {@code Observable<R>} that executes and calls back with the result of command execution or a fallback if the command fails for any reason.
      * @throws HystrixRuntimeException
      *             if a fallback does not exist
      *             <p>
      *             <ul>
-     *             <li>via {@code Future.get()} in {@link ExecutionException#getCause()} if a failure occurs</li>
+     *             <li>via {@code Observer#onError} if a failure occurs</li>
      *             <li>or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)</li>
      *             </ul>
      * @throws HystrixBadRequestException
-     *             via {@code Future.get()} in {@link ExecutionException#getCause()} if invalid arguments or state were used representing a user failure, not a system failure
+     *             via {@code Observer#onError} if invalid arguments or state were used representing a user failure, not a system failure
      * @throws IllegalStateException
      *             if invoked more than once
      */
-    public Future<R> queue() {
-        /*
-         * --- Schedulers.immediate()
-         * 
-         * We use the 'immediate' schedule since Future.get() is blocking so we don't want to bother doing the callback to the Future on a separate thread
-         * as we don't need to separate the Hystrix thread from user threads since they are already providing it via the Future.get() call.
-         * 
-         * --- performAsyncTimeout: false
-         * 
-         * We pass 'false' to tell the Observable we will block on it so it doesn't schedule an async timeout.
-         * 
-         * This optimizes for using the calling thread to do the timeout rather than scheduling another thread.
-         * 
-         * In a tight-loop of executing commands this optimization saves a few microseconds per execution.
-         * It also just makes no sense to use a separate thread to timeout the command when the calling thread
-         * is going to sit waiting on it.
-         */
-        final ObservableCommand<R> o = toObservable(Schedulers.immediate(), false);
-        final Future<R> f = o.toBlocking().toFuture();
+    final public Observable<R> toObservable() {
+        return toObservable(true);
+    }
 
-        /* special handling of error states that throw immediately */
-        if (f.isDone()) {
-            try {
-                f.get();
-                return f;
-            } catch (Exception e) {
-                RuntimeException re = decomposeException(e);
-                if (re instanceof HystrixBadRequestException) {
-                    return f;
-                } else if (re instanceof HystrixRuntimeException) {
-                    HystrixRuntimeException hre = (HystrixRuntimeException) re;
-                    if (hre.getFailureType() == FailureType.COMMAND_EXCEPTION || hre.getFailureType() == FailureType.TIMEOUT) {
-                        // we don't throw these types from queue() only from queue().get() as they are execution errors
-                        return f;
+    protected abstract Observable<R> getExecutionObservable();
+
+    protected abstract Observable<R> getFallbackObservable();
+
+    protected ObservableCommand<R> toObservable(final boolean performAsyncTimeout) {
+        /* this is a stateful object so can only be used once */
+        if (!started.compareAndSet(false, true)) {
+            throw new IllegalStateException("This instance can only be executed once. Please instantiate a new instance.");
+        }
+
+        /* try from cache first */
+        if (isRequestCachingEnabled()) {
+            Observable<R> fromCache = requestCache.get(getCacheKey());
+            if (fromCache != null) {
+                /* mark that we received this response from cache */
+                metrics.markResponseFromCache();
+                return new CachedObservableResponse<R>((CachedObservableOriginal<R>) fromCache, this);
+            }
+        }
+
+        final HystrixInvokable<R> _this = this;
+        final AtomicReference<Action0> endCurrentThreadExecutingCommand = new AtomicReference<Action0>(); // don't like how this is being done
+
+        // create an Observable that will lazily execute when subscribed to
+        Observable<R> o = Observable.create(new OnSubscribe<R>() {
+
+            @Override
+            public void call(Subscriber<? super R> observer) {
+                // async record keeping
+                recordExecutedCommand();
+
+                // mark that we're starting execution on the ExecutionHook
+                executionHook.onStart(_this);
+
+                /* determine if we're allowed to execute */
+                if (circuitBreaker.allowRequest()) {
+                    final TryableSemaphore executionSemaphore = getExecutionSemaphore();
+                    // acquire a permit
+                    if (executionSemaphore.tryAcquire()) {
+                        try {
+                            /* used to track userThreadExecutionTime */
+                            invocationStartTime = System.currentTimeMillis();
+
+                            // store the command that is being run
+                            endCurrentThreadExecutingCommand.set(Hystrix.startCurrentThreadExecutingCommand(getCommandKey()));
+
+                            getRunObservableDecoratedForMetricsAndErrorHandling(performAsyncTimeout)
+                                    .doOnTerminate(new Action0() {
+
+                                        @Override
+                                        public void call() {
+                                            // release the semaphore
+                                            // this is done here instead of below so that the acquire/release happens where it is guaranteed
+                                            // and not affected by the conditional circuit-breaker checks, timeouts, etc
+                                            executionSemaphore.release();
+
+                                        }
+                                    }).unsafeSubscribe(observer);
+                        } catch (RuntimeException e) {
+                            observer.onError(e);
+                        }
                     } else {
-                        // these are errors we throw from queue() as they as rejection type errors
-                        throw hre;
+                        metrics.markSemaphoreRejection();
+                        logger.debug("HystrixCommand Execution Rejection by Semaphore."); // debug only since we're throwing the exception and someone higher will do something with it
+                        // retrieve a fallback or throw an exception if no fallback available
+                        getFallbackOrThrowException(HystrixEventType.SEMAPHORE_REJECTED, FailureType.REJECTED_SEMAPHORE_EXECUTION, "could not acquire a semaphore for execution").unsafeSubscribe(observer);
                     }
                 } else {
-                    throw re;
+                    // record that we are returning a short-circuited fallback
+                    metrics.markShortCircuited();
+                    // short-circuit and go directly to fallback (or throw an exception if no fallback implemented)
+                    try {
+                        getFallbackOrThrowException(HystrixEventType.SHORT_CIRCUITED, FailureType.SHORTCIRCUIT, "short-circuited").unsafeSubscribe(observer);
+                    } catch (Exception e) {
+                        observer.onError(e);
+                    }
                 }
             }
-        }
+        });
 
-        return new Future<R>() {
+        // error handling at very end (this means fallback didn't exist or failed)
+        o = o.onErrorResumeNext(new Func1<Throwable, Observable<R>>() {
 
             @Override
-            public boolean cancel(boolean mayInterruptIfRunning) {
-                return f.cancel(mayInterruptIfRunning);
+            public Observable<R> call(Throwable t) {
+                // count that we are throwing an exception and re-throw it
+                metrics.markExceptionThrown();
+                return Observable.error(t);
             }
 
+        });
+
+        // any final cleanup needed
+        o = o.doOnTerminate(new Action0() {
+
             @Override
-            public boolean isCancelled() {
-                return f.isCancelled();
+            public void call() {
+                Reference<TimerListener> tl = timeoutTimer.get();
+                if (tl != null) {
+                    tl.clear();
+                }
+
+                try {
+                    // if we executed we will record the execution time
+                    if (invocationStartTime > 0 && !isResponseRejected()) {
+                        /* execution time (must occur before terminal state otherwise a race condition can occur if requested by client) */
+                        recordTotalExecutionTime(invocationStartTime);
+                    }
+
+                    // pop the command that is being run
+                    if (endCurrentThreadExecutingCommand.get() != null) {
+                        endCurrentThreadExecutingCommand.get().call();
+                    }
+                } finally {
+                    metrics.decrementConcurrentExecutionCount();
+                    // record that we're completed
+                    isExecutionComplete.set(true);
+                }
             }
 
-            @Override
-            public boolean isDone() {
-                return f.isDone();
+        });
+
+        // put in cache
+        if (isRequestCachingEnabled()) {
+            // wrap it for caching
+            o = new CachedObservableOriginal<R>(o.cache(), this);
+            Observable<R> fromCache = requestCache.putIfAbsent(getCacheKey(), o);
+            if (fromCache != null) {
+                // another thread beat us so we'll use the cached value instead
+                o = new CachedObservableResponse<R>((CachedObservableOriginal<R>) fromCache, this);
             }
+            // we just created an ObservableCommand so we cast and return it
+            return (ObservableCommand<R>) o;
+        } else {
+            // no request caching so a simple wrapper just to pass 'this' along with the Observable
+            return new ObservableCommand<R>(o, this);
+        }
+    }
+
+    /**
+     * This decorate "Hystrix" functionality around the run() Observable.
+     * 
+     * @return R
+     */
+    private Observable<R> getRunObservableDecoratedForMetricsAndErrorHandling(final boolean performAsyncTimeout) {
+        final AbstractCommand<R> _self = this;
+        // allow tracking how many concurrent threads are executing
+        metrics.incrementConcurrentExecutionCount();
+
+        final HystrixRequestContext currentRequestContext = HystrixRequestContext.getContextForCurrentThread();
+
+        Observable<R> run = null;
+        if (properties.executionIsolationStrategy().get().equals(ExecutionIsolationStrategy.THREAD)) {
+            // mark that we are executing in a thread (even if we end up being rejected we still were a THREAD execution and not SEMAPHORE)
+            isExecutedInThread.set(true);
+
+            run = Observable.create(new OnSubscribe<R>() {
+
+                @Override
+                public void call(Subscriber<? super R> s) {
+                    executionHook.onRunStart(_self);
+                    executionHook.onThreadStart(_self);
+                    if (isCommandTimedOut.get() == TimedOutStatus.TIMED_OUT) {
+                        // the command timed out in the wrapping thread so we will return immediately
+                        // and not increment any of the counters below or other such logic
+                        s.onError(new RuntimeException("timed out before executing run()"));
+                    } else {
+                        // not timed out so execute
+                        try {
+                            final Action0 endCurrentThread = Hystrix.startCurrentThreadExecutingCommand(getCommandKey());
+                            getExecutionObservable().doOnTerminate(new Action0() {
+
+                                @Override
+                                public void call() {
+                                    // TODO is this actually the end of the thread?
+                                    executionHook.onThreadComplete(_self);
+                                    endCurrentThread.call();
+                                }
+                            }).unsafeSubscribe(s);
+                        } catch (Throwable t) {
+                            // the run() method is a user provided implementation so can throw instead of using Observable.onError
+                            // so we catch it here and turn it into Observable.error
+                            Observable.<R> error(t).unsafeSubscribe(s);
+                        }
+                    }
+                }
+
+            }).subscribeOn(threadPool.getScheduler());
+        } else {
+            // semaphore isolated
+            executionHook.onRunStart(_self);
+            try {
+                run = getExecutionObservable();
+            } catch (Throwable t) {
+                // the run() method is a user provided implementation so can throw instead of using Observable.onError
+                // so we catch it here and turn it into Observable.error
+                run = Observable.error(t);
+            }
+        }
+
+        run = run.doOnEach(new Action1<Notification<? super R>>() {
 
             @Override
-            public R get() throws InterruptedException, ExecutionException {
-                return performBlockingGetWithTimeout(o, f);
+            public void call(Notification<? super R> n) {
+                setRequestContextIfNeeded(currentRequestContext);
             }
 
-            /**
-             * --- Non-Blocking Timeout (performAsyncTimeout:true) ---
-             * 
-             * When 'toObservable' is done with non-blocking timeout then timeout functionality is provided
-             * by a separate HystrixTimer thread that will "tick" and cancel the underlying async Future inside the Observable.
-             * 
-             * This method allows stealing that responsibility and letting the thread that's going to block anyways
-             * do the work to reduce pressure on the HystrixTimer.
-             * 
-             * Blocking via queue().get() on a non-blocking timeout will work it's just less efficient
-             * as it involves an extra thread and cancels the scheduled action that does the timeout.
-             * 
-             * --- Blocking Timeout (performAsyncTimeout:false) ---
-             * 
-             * When blocking timeout is assumed (default behavior for execute/queue flows) then the async
-             * timeout will not have been scheduled and this will wait in a blocking manner and if a timeout occurs
-             * trigger the timeout logic that comes from inside the Observable/Observer.
-             * 
-             * 
-             * --- Examples
-             * 
-             * Stack for timeout with performAsyncTimeout=false (note the calling thread via get):
-             * 
-             * at com.netflix.hystrix.HystrixCommand$TimeoutObservable$1$1.tick(HystrixCommand.java:788)
-             * at com.netflix.hystrix.HystrixCommand$1.performBlockingGetWithTimeout(HystrixCommand.java:536)
-             * at com.netflix.hystrix.HystrixCommand$1.get(HystrixCommand.java:484)
-             * at com.netflix.hystrix.HystrixCommand.execute(HystrixCommand.java:413)
-             * 
-             * 
-             * Stack for timeout with performAsyncTimeout=true (note the HystrixTimer involved):
-             * 
-             * at com.netflix.hystrix.HystrixCommand$TimeoutObservable$1$1.tick(HystrixCommand.java:799)
-             * at com.netflix.hystrix.util.HystrixTimer$1.run(HystrixTimer.java:101)
-             * 
-             * 
-             * 
-             * @param o
-             * @param f
-             * @throws InterruptedException
-             * @throws ExecutionException
-             */
-            protected R performBlockingGetWithTimeout(final ObservableCommand<R> o, final Future<R> f) throws InterruptedException, ExecutionException {
-                // shortcut if already done
-                if (f.isDone()) {
-                    return f.get();
+        }).lift(new HystrixObservableTimeoutOperator<R>(_self, performAsyncTimeout)).map(new Func1<R, R>() {
+
+            boolean once = false;
+
+            @Override
+            public R call(R t1) {
+                System.out.println("map " + t1);
+                if (!once) {
+                    // report success
+                    executionResult = executionResult.addEvents(HystrixEventType.SUCCESS);
+                    once = true;
                 }
 
-                // it's still working so proceed with blocking/timeout logic
-                HystrixExecutableBase<R> originalCommand = o.getCommand();
-                /**
-                 * One thread will get the timeoutTimer if it's set and clear it then do blocking timeout.
-                 * <p>
-                 * If non-blocking timeout was scheduled this will unschedule it. If it wasn't scheduled it is basically
-                 * a no-op but fits the same interface so blocking and non-blocking flows both work the same.
-                 * <p>
-                 * This "originalCommand" concept exists because of request caching. We only do the work and timeout logic
-                 * on the original, not the cached responses. However, whichever the first thread is that comes in to block
-                 * will be the one who performs the timeout logic.
-                 * <p>
-                 * If request caching is disabled then it will always go into here.
-                 */
-                if (originalCommand != null) {
-                    Reference<TimerListener> timer = originalCommand.timeoutTimer.getAndSet(null);
-                    if (timer != null) {
-                        /**
-                         * If an async timeout was scheduled then:
-                         * 
-                         * - We are going to clear the Reference<TimerListener> so the scheduler threads stop managing the timeout
-                         * and we'll take over instead since we're going to be blocking on it anyways.
-                         * 
-                         * - Other threads (since we won the race) will just wait on the normal Future which will release
-                         * once the Observable is marked as completed (which may come via timeout)
-                         * 
-                         * If an async timeout was not scheduled:
-                         * 
-                         * - We go through the same flow as we receive the same interfaces just the "timer.clear()" will do nothing.
-                         */
-                        // get the timer we'll use to perform the timeout
-                        TimerListener l = timer.get();
-                        // remove the timer from the scheduler
-                        timer.clear();
-
-                        // determine how long we should wait for, taking into account time since work started
-                        // and when this thread came in to block. If invocationTime hasn't been set then assume time remaining is entire timeout value
-                        // as this maybe a case of multiple threads trying to run this command in which one thread wins but even before the winning thread is able to set
-                        // the starttime another thread going via the Cached command route gets here first.
-                        long timeout = originalCommand.properties.executionIsolationThreadTimeoutInMilliseconds().get();
-                        long timeRemaining = timeout;
-                        long currTime = System.currentTimeMillis();
-                        if (originalCommand.invocationStartTime != -1) {
-                            timeRemaining = (originalCommand.invocationStartTime
-                                    + originalCommand.properties.executionIsolationThreadTimeoutInMilliseconds().get())
-                                    - currTime;
+                return executionHook.onRunSuccess(_self, t1);
+            }
 
-                        }
-                        if (timeRemaining > 0) {
-                            // we need to block with the calculated timeout
-                            try {
-                                return f.get(timeRemaining, TimeUnit.MILLISECONDS);
-                            } catch (TimeoutException e) {
-                                if (l != null) {
-                                    // this perform the timeout logic on the Observable/Observer
-                                    l.tick();
-                                }
-                            }
+        }).doOnCompleted(new Action0() {
+
+            @Override
+            public void call() {
+                long duration = System.currentTimeMillis() - invocationStartTime;
+                metrics.addCommandExecutionTime(duration);
+                metrics.markSuccess(duration);
+                circuitBreaker.markSuccess();
+                eventNotifier.markCommandExecution(getCommandKey(), properties.executionIsolationStrategy().get(), (int) duration, executionResult.events);
+            }
+
+        }).onErrorResumeNext(new Func1<Throwable, Observable<R>>() {
+
+            @Override
+            public Observable<R> call(Throwable t) {
+                Exception e = getExceptionFromThrowable(t);
+                if (e instanceof RejectedExecutionException) {
+                    /**
+                     * Rejection handling
+                     */
+                    metrics.markThreadPoolRejection();
+                    // use a fallback instead (or throw exception if not implemented)
+                    return getFallbackOrThrowException(HystrixEventType.THREAD_POOL_REJECTED, FailureType.REJECTED_THREAD_EXECUTION, "could not be queued for execution", e);
+                } else if (t instanceof HystrixObservableTimeoutOperator.HystrixTimeoutException) {
+                    /**
+                     * Timeout handling
+                     * 
+                     * Callback is performed on the HystrixTimer thread.
+                     */
+                    return getFallbackOrThrowException(HystrixEventType.TIMEOUT, FailureType.TIMEOUT, "timed-out", new TimeoutException());
+                } else if (t instanceof HystrixBadRequestException) {
+                    /**
+                     * BadRequest handling
+                     */
+                    try {
+                        Exception decorated = executionHook.onRunError(_self, (Exception) t);
+
+                        if (decorated instanceof HystrixBadRequestException) {
+                            t = (HystrixBadRequestException) decorated;
                         } else {
-                            // this means it should have already timed out so do so if it is not completed
-                            if (!f.isDone()) {
-                                if (l != null) {
-                                    l.tick();
-                                }
-                            }
+                            logger.warn("ExecutionHook.onRunError returned an exception that was not an instance of HystrixBadRequestException so will be ignored.", decorated);
                         }
+                    } catch (Exception hookException) {
+                        logger.warn("Error calling ExecutionHook.onRunError", hookException);
                     }
+
+                    /*
+                     * HystrixBadRequestException is treated differently and allowed to propagate without any stats tracking or fallback logic
+                     */
+                    return Observable.error(t);
+                } else {
+                    /**
+                     * All other error handling
+                     */
+                    try {
+                        e = executionHook.onRunError(_self, e);
+                    } catch (Exception hookException) {
+                        logger.warn("Error calling ExecutionHook.endRunFailure", hookException);
+                    }
+
+                    logger.debug("Error executing HystrixCommand.run(). Proceeding to fallback logic ...", e);
+
+                    // report failure
+                    metrics.markFailure(System.currentTimeMillis() - invocationStartTime);
+                    // record the exception
+                    executionResult = executionResult.setException(e);
+                    return getFallbackOrThrowException(HystrixEventType.FAILURE, FailureType.COMMAND_EXCEPTION, "failed", e);
                 }
-                // other threads will block until the "l.tick" occurs and releases the underlying Future.
-                return f.get();
+            }
+        }).doOnEach(new Action1<Notification<? super R>>() {
+            // setting again as the fallback could have lost the context
+            @Override
+            public void call(Notification<? super R> n) {
+                setRequestContextIfNeeded(currentRequestContext);
             }
 
+        }).map(new Func1<R, R>() {
+
             @Override
-            public R get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
-                return get();
+            public R call(R t1) {
+                // allow transforming the results via the executionHook whether it came from success or fallback
+                return executionHook.onComplete(_self, t1);
             }
 
-        };
+        });
 
+        return run;
     }
 
     /**
-     * Used for asynchronous execution of command with a callback by subscribing to the {@link Observable}.
-     * <p>
-     * This eagerly starts execution of the command the same as {@link #queue()} and {@link #execute()}.
-     * A lazy {@link Observable} can be obtained from {@link #toObservable()}.
-     * <p>
-     * <b>Callback Scheduling</b>
+     * Execute <code>getFallback()</code> within protection of a semaphore that limits number of concurrent executions.
      * <p>
-     * <ul>
-     * <li>When using {@link ExecutionIsolationStrategy#THREAD} this defaults to using {@link Schedulers#threadPoolForComputation()} for callbacks.</li>
-     * <li>When using {@link ExecutionIsolationStrategy#SEMAPHORE} this defaults to using {@link Schedulers#immediate()} for callbacks.</li>
-     * </ul>
-     * Use {@link #toObservable(rx.Scheduler)} to schedule the callback differently.
+     * Fallback implementations shouldn't perform anything that can be blocking, but we protect against it anyways in case someone doesn't abide by the contract.
      * <p>
-     * See https://github.com/Netflix/RxJava/wiki for more information.
+     * If something in the <code>getFallback()</code> implementation is latent (such as a network call) then the semaphore will cause us to start rejecting requests rather than allowing potentially
+     * all threads to pile up and block.
      * 
-     * @return {@code Observable<R>} that executes and calls back with the result of {@link #run()} execution or a fallback from {@link #getFallback()} if the command fails for any reason.
+     * @return K
+     * @throws UnsupportedOperationException
+     *             if getFallback() not implemented
+     * @throws HystrixException
+     *             if getFallback() fails (throws an Exception) or is rejected by the semaphore
+     */
+    private Observable<R> getFallbackWithProtection() {
+        final TryableSemaphore fallbackSemaphore = getFallbackSemaphore();
+
+        // acquire a permit
+        if (fallbackSemaphore.tryAcquire()) {
+            executionHook.onFallbackStart(this);
+            final AbstractCommand<R> _cmd = this;
+
+            Observable<R> fallback = null;
+            try {
+                fallback = getFallbackObservable();
+            } catch (Throwable t) {
+                // getFallback() is user provided and can throw so we catch it and turn it into Observable.error
+                fallback = Observable.error(t);
+            }
+
+            return fallback.map(new Func1<R, R>() {
+
+                @Override
+                public R call(R t1) {
+                    // allow transforming the value
+                    return executionHook.onFallbackSuccess(_cmd, t1);
+                }
+
+            }).onErrorResumeNext(new Func1<Throwable, Observable<R>>() {
+
+                @Override
+                public Observable<R> call(Throwable t) {
+                    Exception e = getExceptionFromThrowable(t);
+                    Exception decorated = executionHook.onFallbackError(_cmd, e);
+
+                    if (decorated instanceof RuntimeException) {
+                        e = (RuntimeException) decorated;
+                    } else {
+                        logger.warn("ExecutionHook.onFallbackError returned an exception that was not an instance of RuntimeException so will be ignored.", decorated);
+                    }
+                    return Observable.error(e);
+                }
+
+            }).doOnTerminate(new Action0() {
+
+                @Override
+                public void call() {
+                    fallbackSemaphore.release();
+                }
+
+            });
+        } else {
+            metrics.markFallbackRejection();
+
+            logger.debug("HystrixCommand Fallback Rejection."); // debug only since we're throwing the exception and someone higher will do something with it
+            // if we couldn't acquire a permit, we "fail fast" by throwing an exception
+            return Observable.error(new HystrixRuntimeException(FailureType.REJECTED_SEMAPHORE_FALLBACK, this.getClass(), getLogMessagePrefix() + " fallback execution rejected.", null, null));
+        }
+    }
+
+    /**
      * @throws HystrixRuntimeException
-     *             if a fallback does not exist
-     *             <p>
-     *             <ul>
-     *             <li>via {@code Observer#onError} if a failure occurs</li>
-     *             <li>or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)</li>
-     *             </ul>
-     * @throws HystrixBadRequestException
-     *             via {@code Observer#onError} if invalid arguments or state were used representing a user failure, not a system failure
-     * @throws IllegalStateException
-     *             if invoked more than once
      */
-    public Observable<R> observe() {
-        // us a ReplaySubject to buffer the eagerly subscribed-to Observable
-        ReplaySubject<R> subject = ReplaySubject.create();
-        // eagerly kick off subscription
-        toObservable().subscribe(subject);
-        // return the subject that can be subscribed to later while the execution has already started
-        return subject;
+    private Observable<R> getFallbackOrThrowException(HystrixEventType eventType, FailureType failureType, String message) {
+        return getFallbackOrThrowException(eventType, failureType, message, null);
     }
 
     /**
-     * A lazy {@link Observable} that will execute the command when subscribed to.
-     * <p>
-     * See https://github.com/Netflix/RxJava/wiki for more information.
-     * 
-     * @param observeOn
-     *            The {@link Scheduler} to execute callbacks on.
-     * @return {@code Observable<R>} that lazily executes and calls back with the result of {@link #run()} execution or a fallback from {@link #getFallback()} if the command fails for any reason.
      * @throws HystrixRuntimeException
-     *             if a fallback does not exist
-     *             <p>
-     *             <ul>
-     *             <li>via {@code Observer#onError} if a failure occurs</li>
-     *             <li>or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)</li>
-     *             </ul>
-     * @throws HystrixBadRequestException
-     *             via {@code Observer#onError} if invalid arguments or state were used representing a user failure, not a system failure
-     * @throws IllegalStateException
-     *             if invoked more than once
      */
-    public Observable<R> toObservable(Scheduler observeOn) {
-        return toObservable(observeOn, true);
+    private Observable<R> getFallbackOrThrowException(final HystrixEventType eventType, final FailureType failureType, final String message, final Exception originalException) {
+        final HystrixRequestContext currentRequestContext = HystrixRequestContext.getContextForCurrentThread();
+
+        if (properties.fallbackEnabled().get()) {
+            /* fallback behavior is permitted so attempt */
+            // record the executionResult
+            // do this before executing fallback so it can be queried from within getFallback (see See https://github.com/Netflix/Hystrix/pull/144)
+            executionResult = executionResult.addEvents(eventType);
+            final AbstractCommand<R> _cmd = this;
+
+            return getFallbackWithProtection().map(new Func1<R, R>() {
+
+                @Override
+                public R call(R t1) {
+                    System.out.println(">>>>>>>>>>>> fallback on thread: " + Thread.currentThread());
+                    return executionHook.onComplete(_cmd, t1);
+                }
+
+            }).doOnCompleted(new Action0() {
+
+                @Override
+                public void call() {
+                    // mark fallback on counter
+                    metrics.markFallbackSuccess();
+                    // record the executionResult
+                    executionResult = executionResult.addEvents(HystrixEventType.FALLBACK_SUCCESS);
+                }
+
+            }).onErrorResumeNext(new Func1<Throwable, Observable<R>>() {
+
+                @Override
+                public Observable<R> call(Throwable t) {
+                    Exception e = originalException;
+                    Exception fe = getExceptionFromThrowable(t);
+
+                    if (fe instanceof UnsupportedOperationException) {
+                        logger.debug("No fallback for HystrixCommand. ", fe); // debug only since we're throwing the exception and someone higher will do something with it
+
+                        /* executionHook for all errors */
+                        try {
+                            e = executionHook.onError(_cmd, failureType, e);
+                        } catch (Exception hookException) {
+                            logger.warn("Error calling ExecutionHook.onError", hookException);
+                        }
+
+                        return Observable.error(new HystrixRuntimeException(failureType, _cmd.getClass(), getLogMessagePrefix() + " " + message + " and no fallback available.", e, fe));
+                    } else {
+                        logger.debug("HystrixCommand execution " + failureType.name() + " and fallback retrieval failed.", fe);
+                        metrics.markFallbackFailure();
+                        // record the executionResult
+                        executionResult = executionResult.addEvents(HystrixEventType.FALLBACK_FAILURE);
+
+                        /* executionHook for all errors */
+                        try {
+                            e = executionHook.onError(_cmd, failureType, e);
+                        } catch (Exception hookException) {
+                            logger.warn("Error calling ExecutionHook.onError", hookException);
+                        }
+
+                        return Observable.error(new HystrixRuntimeException(failureType, _cmd.getClass(), getLogMessagePrefix() + " " + message + " and failed retrieving fallback.", e, fe));
+                    }
+                }
+
+            }).doOnTerminate(new Action0() {
+
+                @Override
+                public void call() {
+                    // record that we're completed (to handle non-successful events we do it here as well as at the end of executeCommand
+                    isExecutionComplete.set(true);
+                }
+
+            }).doOnEach(new Action1<Notification<? super R>>() {
+
+                @Override
+                public void call(Notification<? super R> n) {
+                    setRequestContextIfNeeded(currentRequestContext);
+                }
+
+            });
+        } else {
+            /* fallback is disabled so throw HystrixRuntimeException */
+            Exception e = originalException;
+
+            logger.debug("Fallback disabled for HystrixCommand so will throw HystrixRuntimeException. ", e); // debug only since we're throwing the exception and someone higher will do something with it
+            // record the executionResult
+            executionResult = executionResult.addEvents(eventType);
+
+            /* executionHook for all errors */
+            try {
+                e = executionHook.onError(this, failureType, e);
+            } catch (Exception hookException) {
+                logger.warn("Error calling ExecutionHook.onError", hookException);
+            }
+            return Observable.<R> error(new HystrixRuntimeException(failureType, this.getClass(), getLogMessagePrefix() + " " + message + " and fallback disabled.", e, null)).doOnTerminate(new Action0() {
+
+                @Override
+                public void call() {
+                    // record that we're completed (to handle non-successful events we do it here as well as at the end of executeCommand
+                    isExecutionComplete.set(true);
+                }
+
+            }).doOnEach(new Action1<Notification<? super R>>() {
+
+                @Override
+                public void call(Notification<? super R> n) {
+                    setRequestContextIfNeeded(currentRequestContext);
+                }
+
+            });
+        }
     }
 
-    public abstract Observable<R> toObservable();
+    private static class HystrixObservableTimeoutOperator<R> implements Operator<R, R> {
+
+        final AbstractCommand<R> originalCommand;
+        final boolean isNonBlocking;
+
+        public HystrixObservableTimeoutOperator(final AbstractCommand<R> originalCommand, final boolean isNonBlocking) {
+            this.originalCommand = originalCommand;
+            this.isNonBlocking = isNonBlocking;
+        }
+
+        public static class HystrixTimeoutException extends Exception {
+
+            private static final long serialVersionUID = 7460860948388895401L;
+
+        }
+
+        @Override
+        public Subscriber<? super R> call(final Subscriber<? super R> child) {
+            final CompositeSubscription s = new CompositeSubscription();
+            // if the child unsubscribes we unsubscribe our parent as well
+            child.add(s);
+
+            /*
+             * Define the action to perform on timeout outside of the TimerListener to it can capture the HystrixRequestContext
+             * of the calling thread which doesn't exist on the Timer thread.
+             */
+            final HystrixContextRunnable timeoutRunnable = new HystrixContextRunnable(originalCommand.concurrencyStrategy, new Runnable() {
 
-    protected abstract ObservableCommand<R> toObservable(final Scheduler observeOn, boolean performAsyncTimeout);
+                @Override
+                public void run() {
+                    child.onError(new HystrixTimeoutException());
+                }
+            });
+
+            TimerListener listener = new TimerListener() {
+
+                @Override
+                public void tick() {
+                    // if we can go from NOT_EXECUTED to TIMED_OUT then we do the timeout codepath
+                    // otherwise it means we lost a race and the run() execution completed
+                    if (originalCommand.isCommandTimedOut.compareAndSet(TimedOutStatus.NOT_EXECUTED, TimedOutStatus.TIMED_OUT)) {
+                        // do fallback logic
+                        // report timeout failure
+                        originalCommand.metrics.markTimeout(System.currentTimeMillis() - originalCommand.invocationStartTime);
+
+                        // we record execution time because we are returning before 
+                        originalCommand.recordTotalExecutionTime(originalCommand.invocationStartTime);
+
+                        // shut down the original request
+                        s.unsubscribe();
+
+                        timeoutRunnable.run();
+                    }
+
+                }
+
+                @Override
+                public int getIntervalTimeInMilliseconds() {
+                    return originalCommand.properties.executionIsolationThreadTimeoutInMilliseconds().get();
+                }
+            };
+
+            Reference<TimerListener> _tl = null;
+            if (isNonBlocking) {
+                /*
+                 * Scheduling a separate timer to do timeouts is more expensive
+                 * so we'll only do it if we're being used in a non-blocking manner.
+                 */
+                _tl = HystrixTimer.getInstance().addTimerListener(listener);
+            } else {
+                /*
+                 * Otherwise we just set the hook that queue().get() can trigger if a timeout occurs.
+                 * 
+                 * This allows the blocking and non-blocking approaches to be coded basically the same way
+                 * though it is admittedly awkward if we were just blocking (the use of Reference annoys me for example)
+                 */
+                _tl = new SoftReference<TimerListener>(listener);
+            }
+            final Reference<TimerListener> tl = _tl;
+
+            // set externally so execute/queue can see this
+            originalCommand.timeoutTimer.set(tl);
+
+            /**
+             * If this subscriber receives values it means the parent succeeded/completed
+             */
+            Subscriber<R> parent = new Subscriber<R>() {
+
+                @Override
+                public void onCompleted() {
+                    if (isNotTimedOut()) {
+                        // stop timer and pass notification through
+                        tl.clear();
+                        child.onCompleted();
+                    }
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    if (isNotTimedOut()) {
+                        // stop timer and pass notification through
+                        tl.clear();
+                        child.onError(e);
+                    }
+                }
+
+                @Override
+                public void onNext(R v) {
+                    if (isNotTimedOut()) {
+                        child.onNext(v);
+                    }
+                }
+
+                private boolean isNotTimedOut() {
+                    // if already marked COMPLETED (by onNext) or succeeds in setting to COMPLETED
+                    return originalCommand.isCommandTimedOut.get() == TimedOutStatus.COMPLETED ||
+                            originalCommand.isCommandTimedOut.compareAndSet(TimedOutStatus.NOT_EXECUTED, TimedOutStatus.COMPLETED);
+                }
+
+            };
+
+            // if s is unsubscribed we want to unsubscribe the parent
+            s.add(parent);
+
+            return parent;
+        }
+
+    }
+
+    private static void setRequestContextIfNeeded(final HystrixRequestContext currentRequestContext) {
+        if (!HystrixRequestContext.isCurrentThreadInitialized()) {
+            // even if the user Observable doesn't have context we want it set for chained operators
+            HystrixRequestContext.setContextOnCurrentThread(currentRequestContext);
+        }
+    }
 
     /**
      * Get the TryableSemaphore this HystrixCommand should use if a fallback occurs.
@@ -633,18 +1038,18 @@ protected TryableSemaphore getExecutionSemaphore() {
     }
 
     protected static class ObservableCommand<R> extends Observable<R> {
-        private final HystrixExecutableBase<R> command;
+        private final AbstractCommand<R> command;
 
-        ObservableCommand(OnSubscribe<R> func, final HystrixExecutableBase<R> command) {
+        ObservableCommand(OnSubscribe<R> func, final AbstractCommand<R> command) {
             super(func);
             this.command = command;
         }
 
-        public HystrixExecutableBase<R> getCommand() {
+        public AbstractCommand<R> getCommand() {
             return command;
         }
 
-        ObservableCommand(final Observable<R> originalObservable, final HystrixExecutableBase<R> command) {
+        ObservableCommand(final Observable<R> originalObservable, final AbstractCommand<R> command) {
             super(new OnSubscribe<R>() {
 
                 @Override
@@ -666,9 +1071,9 @@ public void call(Subscriber<? super R> observer) {
      */
     protected static class CachedObservableOriginal<R> extends ObservableCommand<R> {
 
-        final HystrixExecutableBase<R> originalCommand;
+        final AbstractCommand<R> originalCommand;
 
-        CachedObservableOriginal(final Observable<R> actual, HystrixExecutableBase<R> command) {
+        CachedObservableOriginal(final Observable<R> actual, AbstractCommand<R> command) {
             super(new OnSubscribe<R>() {
 
                 @Override
@@ -691,7 +1096,7 @@ public void call(final Subscriber<? super R> observer) {
     protected static class CachedObservableResponse<R> extends ObservableCommand<R> {
         final CachedObservableOriginal<R> originalObservable;
 
-        CachedObservableResponse(final CachedObservableOriginal<R> originalObservable, final HystrixExecutableBase<R> commandOfDuplicateCall) {
+        CachedObservableResponse(final CachedObservableOriginal<R> originalObservable, final AbstractCommand<R> commandOfDuplicateCall) {
             super(new OnSubscribe<R>() {
 
                 @Override
@@ -735,13 +1140,13 @@ private void completeCommand() {
         /*
          * This is a cached response so we want the command of the observable we're wrapping.
          */
-        public HystrixExecutableBase<R> getCommand() {
+        public AbstractCommand<R> getCommand() {
             return originalObservable.originalCommand;
         }
     }
 
     /**
-     * @return {@link HystrixCommandGroupKey} used to group together multiple {@link HystrixObservableCommand} objects.
+     * @return {@link HystrixCommandGroupKey} used to group together multiple {@link HystrixAsyncCommand} objects.
      *         <p>
      *         The {@link HystrixCommandGroupKey} is used to represent a common relationship between commands. For example, a library or team name, the system all related commands interace with,
      *         common business purpose etc.
@@ -770,7 +1175,7 @@ public HystrixThreadPoolKey getThreadPoolKey() {
     }
 
     /**
-     * The {@link HystrixCommandMetrics} associated with this {@link HystrixObservableCommand} instance.
+     * The {@link HystrixCommandMetrics} associated with this {@link HystrixAsyncCommand} instance.
      * 
      * @return HystrixCommandMetrics
      */
@@ -779,7 +1184,7 @@ public HystrixCommandMetrics getMetrics() {
     }
 
     /**
-     * The {@link HystrixCommandProperties} associated with this {@link HystrixObservableCommand} instance.
+     * The {@link HystrixCommandProperties} associated with this {@link HystrixAsyncCommand} instance.
      * 
      * @return HystrixCommandProperties
      */
@@ -1213,7 +1618,7 @@ public <T> void onRunStart(HystrixCommand<T> commandInstance) {
         }
 
         @Override
-        public <T> void onRunStart(HystrixExecutable<T> commandInstance) {
+        public <T> void onRunStart(HystrixInvokable<T> commandInstance) {
             HystrixCommand<T> c = getHystrixCommandFromAbstractIfApplicable(commandInstance);
             if (c != null) {
                 onRunStart(c);
@@ -1228,7 +1633,7 @@ public <T> T onRunSuccess(HystrixCommand<T> commandInstance, T response) {
         }
 
         @Override
-        public <T> T onRunSuccess(HystrixExecutable<T> commandInstance, T response) {
+        public <T> T onRunSuccess(HystrixInvokable<T> commandInstance, T response) {
             HystrixCommand<T> c = getHystrixCommandFromAbstractIfApplicable(commandInstance);
             if (c != null) {
                 response = onRunSuccess(c, response);
@@ -1243,7 +1648,7 @@ public <T> Exception onRunError(HystrixCommand<T> commandInstance, Exception e)
         }
 
         @Override
-        public <T> Exception onRunError(HystrixExecutable<T> commandInstance, Exception e) {
+        public <T> Exception onRunError(HystrixInvokable<T> commandInstance, Exception e) {
             HystrixCommand<T> c = getHystrixCommandFromAbstractIfApplicable(commandInstance);
             if (c != null) {
                 e = onRunError(c, e);
@@ -1258,7 +1663,7 @@ public <T> void onFallbackStart(HystrixCommand<T> commandInstance) {
         }
 
         @Override
-        public <T> void onFallbackStart(HystrixExecutable<T> commandInstance) {
+        public <T> void onFallbackStart(HystrixInvokable<T> commandInstance) {
             HystrixCommand<T> c = getHystrixCommandFromAbstractIfApplicable(commandInstance);
             if (c != null) {
                 onFallbackStart(c);
@@ -1273,7 +1678,7 @@ public <T> T onFallbackSuccess(HystrixCommand<T> commandInstance, T fallbackResp
         }
 
         @Override
-        public <T> T onFallbackSuccess(HystrixExecutable<T> commandInstance, T fallbackResponse) {
+        public <T> T onFallbackSuccess(HystrixInvokable<T> commandInstance, T fallbackResponse) {
             HystrixCommand<T> c = getHystrixCommandFromAbstractIfApplicable(commandInstance);
             if (c != null) {
                 fallbackResponse = onFallbackSuccess(c, fallbackResponse);
@@ -1288,7 +1693,7 @@ public <T> Exception onFallbackError(HystrixCommand<T> commandInstance, Exceptio
         }
 
         @Override
-        public <T> Exception onFallbackError(HystrixExecutable<T> commandInstance, Exception e) {
+        public <T> Exception onFallbackError(HystrixInvokable<T> commandInstance, Exception e) {
             HystrixCommand<T> c = getHystrixCommandFromAbstractIfApplicable(commandInstance);
             if (c != null) {
                 e = onFallbackError(c, e);
@@ -1303,7 +1708,7 @@ public <T> void onStart(HystrixCommand<T> commandInstance) {
         }
 
         @Override
-        public <T> void onStart(HystrixExecutable<T> commandInstance) {
+        public <T> void onStart(HystrixInvokable<T> commandInstance) {
             HystrixCommand<T> c = getHystrixCommandFromAbstractIfApplicable(commandInstance);
             if (c != null) {
                 onStart(c);
@@ -1318,7 +1723,7 @@ public <T> T onComplete(HystrixCommand<T> commandInstance, T response) {
         }
 
         @Override
-        public <T> T onComplete(HystrixExecutable<T> commandInstance, T response) {
+        public <T> T onComplete(HystrixInvokable<T> commandInstance, T response) {
             HystrixCommand<T> c = getHystrixCommandFromAbstractIfApplicable(commandInstance);
             if (c != null) {
                 response = onComplete(c, response);
@@ -1333,7 +1738,7 @@ public <T> Exception onError(HystrixCommand<T> commandInstance, FailureType fail
         }
 
         @Override
-        public <T> Exception onError(HystrixExecutable<T> commandInstance, FailureType failureType, Exception e) {
+        public <T> Exception onError(HystrixInvokable<T> commandInstance, FailureType failureType, Exception e) {
             HystrixCommand<T> c = getHystrixCommandFromAbstractIfApplicable(commandInstance);
             if (c != null) {
                 e = onError(c, failureType, e);
@@ -1348,7 +1753,7 @@ public <T> void onThreadStart(HystrixCommand<T> commandInstance) {
         }
 
         @Override
-        public <T> void onThreadStart(HystrixExecutable<T> commandInstance) {
+        public <T> void onThreadStart(HystrixInvokable<T> commandInstance) {
             HystrixCommand<T> c = getHystrixCommandFromAbstractIfApplicable(commandInstance);
             if (c != null) {
                 onThreadStart(c);
@@ -1363,7 +1768,7 @@ public <T> void onThreadComplete(HystrixCommand<T> commandInstance) {
         }
 
         @Override
-        public <T> void onThreadComplete(HystrixExecutable<T> commandInstance) {
+        public <T> void onThreadComplete(HystrixInvokable<T> commandInstance) {
             HystrixCommand<T> c = getHystrixCommandFromAbstractIfApplicable(commandInstance);
             if (c != null) {
                 onThreadComplete(c);
@@ -1372,9 +1777,9 @@ public <T> void onThreadComplete(HystrixExecutable<T> commandInstance) {
         }
 
         @SuppressWarnings({ "unchecked", "rawtypes" })
-        private <T> HystrixCommand<T> getHystrixCommandFromAbstractIfApplicable(HystrixExecutable<T> commandInstance) {
-            if (commandInstance instanceof HystrixCommand.HystrixCommandFromObservableCommand) {
-                return ((HystrixCommand.HystrixCommandFromObservableCommand) commandInstance).getOriginal();
+        private <T> HystrixCommand<T> getHystrixCommandFromAbstractIfApplicable(HystrixInvokable<T> commandInstance) {
+            if (commandInstance instanceof HystrixCommand) {
+                return (HystrixCommand) commandInstance;
             } else {
                 return null;
             }
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixAsyncCommand.java b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixAsyncCommand.java
new file mode 100644
index 000000000..2816aa002
--- /dev/null
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixAsyncCommand.java
@@ -0,0 +1,537 @@
+/**
+ * Copyright 2012 Netflix, Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.netflix.hystrix;
+
+import java.lang.ref.Reference;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import rx.Observable;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.subjects.ReplaySubject;
+
+import com.netflix.hystrix.HystrixCommandProperties.ExecutionIsolationStrategy;
+import com.netflix.hystrix.exception.HystrixBadRequestException;
+import com.netflix.hystrix.exception.HystrixRuntimeException;
+import com.netflix.hystrix.exception.HystrixRuntimeException.FailureType;
+import com.netflix.hystrix.strategy.executionhook.HystrixCommandExecutionHook;
+import com.netflix.hystrix.strategy.properties.HystrixPropertiesStrategy;
+import com.netflix.hystrix.util.HystrixTimer.TimerListener;
+
+/**
+ * Used to wrap code that will execute potentially risky functionality (typically meaning a service call over the network)
+ * with fault and latency tolerance, statistics and performance metrics capture, circuit breaker and bulkhead functionality.
+ * This command is essentially a blocking command but provides an Observable facade if used with observe()
+ * 
+ * @param <R>
+ *            the return type
+ * 
+ * @ThreadSafe
+ */
+public abstract class HystrixAsyncCommand<R> extends AbstractCommand<R> implements HystrixExecutable<R>, HystrixExecutableInfo<R>, HystrixObservable<R> {
+
+    /**
+     * Construct a {@link HystrixAsyncCommand} with defined {@link HystrixCommandGroupKey}.
+     * <p>
+     * The {@link HystrixCommandKey} will be derived from the implementing class name.
+     * 
+     * @param group
+     *            {@link HystrixCommandGroupKey} used to group together multiple {@link HystrixAsyncCommand} objects.
+     *            <p>
+     *            The {@link HystrixCommandGroupKey} is used to represent a common relationship between commands. For example, a library or team name, the system all related commands interace with,
+     *            common business purpose etc.
+     */
+    protected HystrixAsyncCommand(HystrixCommandGroupKey group) {
+        // use 'null' to specify use the default
+        this(new Setter(group));
+    }
+
+    /**
+     * Construct a {@link HystrixAsyncCommand} with defined {@link Setter} that allows injecting property and strategy overrides and other optional arguments.
+     * <p>
+     * NOTE: The {@link HystrixCommandKey} is used to associate a {@link HystrixAsyncCommand} with {@link HystrixCircuitBreaker}, {@link HystrixCommandMetrics} and other objects.
+     * <p>
+     * Do not create multiple {@link HystrixAsyncCommand} implementations with the same {@link HystrixCommandKey} but different injected default properties as the first instantiated will win.
+     * <p>
+     * Properties passed in via {@link Setter#andCommandPropertiesDefaults} or {@link Setter#andThreadPoolPropertiesDefaults} are cached for the given {@link HystrixCommandKey} for the life of the JVM
+     * or until {@link Hystrix#reset()} is called. Dynamic properties allow runtime changes. Read more on the <a href="https://github.com/Netflix/Hystrix/wiki/Configuration">Hystrix Wiki</a>.
+     * 
+     * @param setter
+     *            Fluent interface for constructor arguments
+     */
+    protected HystrixAsyncCommand(Setter setter) {
+        // use 'null' to specify use the default
+        this(setter.groupKey, setter.commandKey, setter.threadPoolKey, null, null, setter.commandPropertiesDefaults, setter.threadPoolPropertiesDefaults, null, null, null, null, null);
+    }
+
+    /**
+     * Allow constructing a {@link HystrixAsyncCommand} with injection of most aspects of its functionality.
+     * <p>
+     * Some of these never have a legitimate reason for injection except in unit testing.
+     * <p>
+     * Most of the args will revert to a valid default if 'null' is passed in.
+     */
+    /* package for testing */HystrixAsyncCommand(HystrixCommandGroupKey group, HystrixCommandKey key, HystrixThreadPoolKey threadPoolKey, HystrixCircuitBreaker circuitBreaker, HystrixThreadPool threadPool,
+            HystrixCommandProperties.Setter commandPropertiesDefaults, HystrixThreadPoolProperties.Setter threadPoolPropertiesDefaults,
+            HystrixCommandMetrics metrics, TryableSemaphore fallbackSemaphore, TryableSemaphore executionSemaphore,
+            HystrixPropertiesStrategy propertiesStrategy, HystrixCommandExecutionHook executionHook) {
+        super(group, key, threadPoolKey, circuitBreaker, threadPool, commandPropertiesDefaults, threadPoolPropertiesDefaults, metrics, fallbackSemaphore, executionSemaphore, propertiesStrategy, executionHook);
+    }
+
+    /**
+     * Fluent interface for arguments to the {@link HystrixAsyncCommand} constructor.
+     * <p>
+     * The required arguments are set via the 'with' factory method and optional arguments via the 'and' chained methods.
+     * <p>
+     * Example:
+     * <pre> {@code
+     *  Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("GroupName"))
+                .andCommandKey(HystrixCommandKey.Factory.asKey("CommandName"))
+                .andEventNotifier(notifier);
+     * } </pre>
+     * 
+     * @NotThreadSafe
+     */
+    final public static class Setter {
+
+        protected final HystrixCommandGroupKey groupKey;
+        protected HystrixCommandKey commandKey;
+        protected HystrixThreadPoolKey threadPoolKey;
+        protected HystrixCommandProperties.Setter commandPropertiesDefaults;
+        protected HystrixThreadPoolProperties.Setter threadPoolPropertiesDefaults;
+
+        /**
+         * Setter factory method containing required values.
+         * <p>
+         * All optional arguments can be set via the chained methods.
+         * 
+         * @param groupKey
+         *            {@link HystrixCommandGroupKey} used to group together multiple {@link HystrixAsyncCommand} objects.
+         *            <p>
+         *            The {@link HystrixCommandGroupKey} is used to represent a common relationship between commands. For example, a library or team name, the system all related commands interace
+         *            with,
+         *            common business purpose etc.
+         */
+        protected Setter(HystrixCommandGroupKey groupKey) {
+            this.groupKey = groupKey;
+
+            // default to using SEMAPHORE for ObservableCommand
+            commandPropertiesDefaults = setDefaults(HystrixCommandProperties.Setter());
+        }
+
+        /**
+         * Setter factory method with required values.
+         * <p>
+         * All optional arguments can be set via the chained methods.
+         * 
+         * @param groupKey
+         *            {@link HystrixCommandGroupKey} used to group together multiple {@link HystrixAsyncCommand} objects.
+         *            <p>
+         *            The {@link HystrixCommandGroupKey} is used to represent a common relationship between commands. For example, a library or team name, the system all related commands interace
+         *            with,
+         *            common business purpose etc.
+         */
+        public static Setter withGroupKey(HystrixCommandGroupKey groupKey) {
+            return new Setter(groupKey);
+        }
+
+        /**
+         * @param commandKey
+         *            {@link HystrixCommandKey} used to identify a {@link HystrixAsyncCommand} instance for statistics, circuit-breaker, properties, etc.
+         *            <p>
+         *            By default this will be derived from the instance class name.
+         *            <p>
+         *            NOTE: Every unique {@link HystrixCommandKey} will result in new instances of {@link HystrixCircuitBreaker}, {@link HystrixCommandMetrics} and {@link HystrixCommandProperties}.
+         *            Thus,
+         *            the number of variants should be kept to a finite and reasonable number to avoid high-memory usage or memory leacks.
+         *            <p>
+         *            Hundreds of keys is fine, tens of thousands is probably not.
+         * @return Setter for fluent interface via method chaining
+         */
+        public Setter andCommandKey(HystrixCommandKey commandKey) {
+            this.commandKey = commandKey;
+            return this;
+        }
+
+        /**
+         * Optional
+         * 
+         * @param commandPropertiesDefaults
+         *            {@link HystrixCommandProperties.Setter} with property overrides for this specific instance of {@link HystrixAsyncCommand}.
+         *            <p>
+         *            See the {@link HystrixPropertiesStrategy} JavaDocs for more information on properties and order of precedence.
+         * @return Setter for fluent interface via method chaining
+         */
+        public Setter andCommandPropertiesDefaults(HystrixCommandProperties.Setter commandPropertiesDefaults) {
+            this.commandPropertiesDefaults = setDefaults(commandPropertiesDefaults);
+            return this;
+        }
+
+        private HystrixCommandProperties.Setter setDefaults(HystrixCommandProperties.Setter commandPropertiesDefaults) {
+            System.out.println("*********** " + commandPropertiesDefaults.getExecutionIsolationStrategy());
+            if (commandPropertiesDefaults.getExecutionIsolationStrategy() == null) {
+                // default to using SEMAPHORE for ObservableCommand if the user didn't set it
+                commandPropertiesDefaults.withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE);
+            }
+            return commandPropertiesDefaults;
+        }
+
+    }
+
+    public static final class HystrixFuture<R> {
+        final Action0 cancel;
+        private final Promise<R> promise;
+
+        private HystrixFuture(Promise<R> promise, Action0 cancel) {
+            this.promise = promise;
+            this.cancel = cancel;
+        }
+
+        public static <R> HystrixFuture<R> create(Promise<R> promise, Action0 cancel) {
+            return new HystrixFuture<R>(promise, cancel);
+        }
+
+        public static <R> HystrixFuture<R> create(Promise<R> promise) {
+            return new HystrixFuture<R>(promise, null);
+        }
+
+        /**
+         * Attempt cancellation. Not all implementations support this.
+         */
+        public final void cancel() {
+            if (cancel != null) {
+                cancel.call();
+            }
+        }
+
+        public Observable<R> asObservable() {
+            return promise.replay.asObservable();
+        }
+
+        public void addListener(Action1<R> onSuccess, Action1<Throwable> onError) {
+            promise.replay.subscribe(onSuccess, onError);
+        }
+    }
+
+    public static final class Promise<R> {
+        private final ReplaySubject<R> replay = ReplaySubject.createWithSize(1);
+
+        private Promise() {
+        }
+
+        public static <R> Promise<R> create() {
+            return new Promise<R>();
+        }
+
+        public final synchronized void onError(Throwable e) {
+            replay.onError(e);
+        }
+
+        public final synchronized void onSuccess(R response) {
+            replay.onNext(response);
+            replay.onCompleted();
+        }
+
+        public final HystrixFuture<R> createFuture() {
+            return HystrixFuture.create(this);
+        }
+    }
+
+    /**
+     * Implement this method with code to be executed when the command is invoked.
+     * 
+     * @return R response type
+     */
+    protected abstract HystrixFuture<R> run();
+
+    /**
+     * If {@link #execute()} or {@link #queue()} fails in any way then this method will be invoked to provide an opportunity to return a fallback response.
+     * <p>
+     * This should do work that does not require network transport to produce.
+     * <p>
+     * In other words, this should be a static or cached result that can immediately be returned upon failure.
+     * <p>
+     * If network traffic is wanted for fallback (such as going to MemCache) then the fallback implementation should invoke another {@link HystrixAsyncCommand} instance that protects against that
+     * network
+     * access and possibly has another level of fallback that does not involve network access.
+     * <p>
+     * DEFAULT BEHAVIOR: It throws UnsupportedOperationException.
+     * 
+     * @return R or throw UnsupportedOperationException if not implemented
+     */
+    protected HystrixFuture<R> getFallback() {
+        throw new UnsupportedOperationException("No fallback available.");
+    }
+
+    @Override
+    final protected Observable<R> getExecutionObservable() {
+        try {
+            return run().asObservable();
+        } catch (Throwable e) {
+            return Observable.error(e);
+        }
+    }
+
+    @Override
+    final protected Observable<R> getFallbackObservable() {
+        try {
+            return getFallback().asObservable();
+        } catch (Throwable e) {
+            e.printStackTrace();
+            return Observable.error(e);
+        }
+    }
+
+    /**
+     * Used for synchronous execution of command.
+     * 
+     * @return R
+     *         Result of {@link #run()} execution or a fallback from {@link #getFallback()} if the command fails for any reason.
+     * @throws HystrixRuntimeException
+     *             if a failure occurs and a fallback cannot be retrieved
+     * @throws HystrixBadRequestException
+     *             if invalid arguments or state were used representing a user failure, not a system failure
+     * @throws IllegalStateException
+     *             if invoked more than once
+     */
+    final public R execute() {
+        try {
+            return queue().get();
+        } catch (Exception e) {
+            throw decomposeException(e);
+        }
+    }
+
+    /**
+     * Used for asynchronous execution of command.
+     * <p>
+     * This will queue up the command on the thread pool and return an {@link Future} to get the result once it completes.
+     * <p>
+     * NOTE: If configured to not run in a separate thread, this will have the same effect as {@link #execute()} and will block.
+     * <p>
+     * We don't throw an exception but just flip to synchronous execution so code doesn't need to change in order to switch a command from running on a separate thread to the calling thread.
+     * 
+     * @return {@code Future<R>} Result of {@link #run()} execution or a fallback from {@link #getFallback()} if the command fails for any reason.
+     * @throws HystrixRuntimeException
+     *             if a fallback does not exist
+     *             <p>
+     *             <ul>
+     *             <li>via {@code Future.get()} in {@link ExecutionException#getCause()} if a failure occurs</li>
+     *             <li>or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)</li>
+     *             </ul>
+     * @throws HystrixBadRequestException
+     *             via {@code Future.get()} in {@link ExecutionException#getCause()} if invalid arguments or state were used representing a user failure, not a system failure
+     * @throws IllegalStateException
+     *             if invoked more than once
+     */
+    final public Future<R> queue() {
+        /*
+         * --- Schedulers.immediate()
+         * 
+         * We use the 'immediate' schedule since Future.get() is blocking so we don't want to bother doing the callback to the Future on a separate thread
+         * as we don't need to separate the Hystrix thread from user threads since they are already providing it via the Future.get() call.
+         * 
+         * --- performAsyncTimeout: false
+         * 
+         * We pass 'false' to tell the Observable we will block on it so it doesn't schedule an async timeout.
+         * 
+         * This optimizes for using the calling thread to do the timeout rather than scheduling another thread.
+         * 
+         * In a tight-loop of executing commands this optimization saves a few microseconds per execution.
+         * It also just makes no sense to use a separate thread to timeout the command when the calling thread
+         * is going to sit waiting on it.
+         */
+        final ObservableCommand<R> o = toObservable(false);
+        final Future<R> f = o.toBlocking().toFuture();
+
+        /* special handling of error states that throw immediately */
+        if (f.isDone()) {
+            try {
+                f.get();
+                return f;
+            } catch (Exception e) {
+                RuntimeException re = decomposeException(e);
+                if (re instanceof HystrixBadRequestException) {
+                    return f;
+                } else if (re instanceof HystrixRuntimeException) {
+                    HystrixRuntimeException hre = (HystrixRuntimeException) re;
+                    if (hre.getFailureType() == FailureType.COMMAND_EXCEPTION || hre.getFailureType() == FailureType.TIMEOUT) {
+                        // we don't throw these types from queue() only from queue().get() as they are execution errors
+                        return f;
+                    } else {
+                        // these are errors we throw from queue() as they as rejection type errors
+                        throw hre;
+                    }
+                } else {
+                    throw re;
+                }
+            }
+        }
+
+        return new Future<R>() {
+
+            @Override
+            public boolean cancel(boolean mayInterruptIfRunning) {
+                return f.cancel(mayInterruptIfRunning);
+            }
+
+            @Override
+            public boolean isCancelled() {
+                return f.isCancelled();
+            }
+
+            @Override
+            public boolean isDone() {
+                return f.isDone();
+            }
+
+            @Override
+            public R get() throws InterruptedException, ExecutionException {
+                return performBlockingGetWithTimeout(o, f);
+            }
+
+            /**
+             * --- Non-Blocking Timeout (performAsyncTimeout:true) ---
+             * 
+             * When 'toObservable' is done with non-blocking timeout then timeout functionality is provided
+             * by a separate HystrixTimer thread that will "tick" and cancel the underlying async Future inside the Observable.
+             * 
+             * This method allows stealing that responsibility and letting the thread that's going to block anyways
+             * do the work to reduce pressure on the HystrixTimer.
+             * 
+             * Blocking via queue().get() on a non-blocking timeout will work it's just less efficient
+             * as it involves an extra thread and cancels the scheduled action that does the timeout.
+             * 
+             * --- Blocking Timeout (performAsyncTimeout:false) ---
+             * 
+             * When blocking timeout is assumed (default behavior for execute/queue flows) then the async
+             * timeout will not have been scheduled and this will wait in a blocking manner and if a timeout occurs
+             * trigger the timeout logic that comes from inside the Observable/Observer.
+             * 
+             * 
+             * --- Examples
+             * 
+             * Stack for timeout with performAsyncTimeout=false (note the calling thread via get):
+             * 
+             * at com.netflix.hystrix.HystrixCommand$TimeoutObservable$1$1.tick(HystrixCommand.java:788)
+             * at com.netflix.hystrix.HystrixCommand$1.performBlockingGetWithTimeout(HystrixCommand.java:536)
+             * at com.netflix.hystrix.HystrixCommand$1.get(HystrixCommand.java:484)
+             * at com.netflix.hystrix.HystrixCommand.execute(HystrixCommand.java:413)
+             * 
+             * 
+             * Stack for timeout with performAsyncTimeout=true (note the HystrixTimer involved):
+             * 
+             * at com.netflix.hystrix.HystrixCommand$TimeoutObservable$1$1.tick(HystrixCommand.java:799)
+             * at com.netflix.hystrix.util.HystrixTimer$1.run(HystrixTimer.java:101)
+             * 
+             * 
+             * 
+             * @param o
+             * @param f
+             * @throws InterruptedException
+             * @throws ExecutionException
+             */
+            protected R performBlockingGetWithTimeout(final ObservableCommand<R> o, final Future<R> f) throws InterruptedException, ExecutionException {
+                // shortcut if already done
+                if (f.isDone()) {
+                    return f.get();
+                }
+
+                // it's still working so proceed with blocking/timeout logic
+                AbstractCommand<R> originalCommand = o.getCommand();
+                /**
+                 * One thread will get the timeoutTimer if it's set and clear it then do blocking timeout.
+                 * <p>
+                 * If non-blocking timeout was scheduled this will unschedule it. If it wasn't scheduled it is basically
+                 * a no-op but fits the same interface so blocking and non-blocking flows both work the same.
+                 * <p>
+                 * This "originalCommand" concept exists because of request caching. We only do the work and timeout logic
+                 * on the original, not the cached responses. However, whichever the first thread is that comes in to block
+                 * will be the one who performs the timeout logic.
+                 * <p>
+                 * If request caching is disabled then it will always go into here.
+                 */
+                if (originalCommand != null) {
+                    Reference<TimerListener> timer = originalCommand.timeoutTimer.getAndSet(null);
+                    if (timer != null) {
+                        /**
+                         * If an async timeout was scheduled then:
+                         * 
+                         * - We are going to clear the Reference<TimerListener> so the scheduler threads stop managing the timeout
+                         * and we'll take over instead since we're going to be blocking on it anyways.
+                         * 
+                         * - Other threads (since we won the race) will just wait on the normal Future which will release
+                         * once the Observable is marked as completed (which may come via timeout)
+                         * 
+                         * If an async timeout was not scheduled:
+                         * 
+                         * - We go through the same flow as we receive the same interfaces just the "timer.clear()" will do nothing.
+                         */
+                        // get the timer we'll use to perform the timeout
+                        TimerListener l = timer.get();
+                        // remove the timer from the scheduler
+                        timer.clear();
+
+                        // determine how long we should wait for, taking into account time since work started
+                        // and when this thread came in to block. If invocationTime hasn't been set then assume time remaining is entire timeout value
+                        // as this maybe a case of multiple threads trying to run this command in which one thread wins but even before the winning thread is able to set
+                        // the starttime another thread going via the Cached command route gets here first.
+                        long timeout = originalCommand.properties.executionIsolationThreadTimeoutInMilliseconds().get();
+                        long timeRemaining = timeout;
+                        long currTime = System.currentTimeMillis();
+                        if (originalCommand.invocationStartTime != -1) {
+                            timeRemaining = (originalCommand.invocationStartTime
+                                    + originalCommand.properties.executionIsolationThreadTimeoutInMilliseconds().get())
+                                    - currTime;
+
+                        }
+                        if (timeRemaining > 0) {
+                            // we need to block with the calculated timeout
+                            try {
+                                return f.get(timeRemaining, TimeUnit.MILLISECONDS);
+                            } catch (TimeoutException e) {
+                                if (l != null) {
+                                    // this perform the timeout logic on the Observable/Observer
+                                    l.tick();
+                                }
+                            }
+                        } else {
+                            // this means it should have already timed out so do so if it is not completed
+                            if (!f.isDone()) {
+                                if (l != null) {
+                                    l.tick();
+                                }
+                            }
+                        }
+                    }
+                }
+                // other threads will block until the "l.tick" occurs and releases the underlying Future.
+                return f.get();
+            }
+
+            @Override
+            public R get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+                return get();
+            }
+
+        };
+
+    }
+
+}
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCollapser.java b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCollapser.java
index 9aa448947..67904feb3 100644
--- a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCollapser.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCollapser.java
@@ -23,8 +23,8 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import rx.*;
-import rx.Observable.OnSubscribe;
+import rx.Observable;
+import rx.Scheduler;
 import rx.functions.Func1;
 import rx.schedulers.Schedulers;
 import rx.subjects.ReplaySubject;
@@ -59,7 +59,7 @@
  * @param <RequestArgumentType>
  *            The type of the request argument. If multiple arguments are needed, wrap them in another object or a Tuple.
  */
-public abstract class HystrixCollapser<BatchReturnType, ResponseType, RequestArgumentType> implements HystrixExecutable<ResponseType> {
+public abstract class HystrixCollapser<BatchReturnType, ResponseType, RequestArgumentType> implements HystrixExecutable<ResponseType>, HystrixObservable<ResponseType> {
 
     static final Logger logger = LoggerFactory.getLogger(HystrixCollapser.class);
 
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCollapserProperties.java b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCollapserProperties.java
index a2147a39e..567ab5b7c 100644
--- a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCollapserProperties.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCollapserProperties.java
@@ -15,7 +15,7 @@
  */
 package com.netflix.hystrix;
 
-import static com.netflix.hystrix.strategy.properties.HystrixProperty.Factory.*;
+import static com.netflix.hystrix.strategy.properties.HystrixProperty.Factory.asProperty;
 
 import com.netflix.hystrix.strategy.properties.HystrixPropertiesChainedArchaiusProperty;
 import com.netflix.hystrix.strategy.properties.HystrixPropertiesStrategy;
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCommand.java b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCommand.java
index f7ee6a22e..e57a28b2f 100755
--- a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCommand.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCommand.java
@@ -15,22 +15,24 @@
  */
 package com.netflix.hystrix;
 
-import java.util.List;
+import java.lang.ref.Reference;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 
 import rx.Observable;
 import rx.Observable.OnSubscribe;
-import rx.Scheduler;
 import rx.Subscriber;
 import rx.schedulers.Schedulers;
 
 import com.netflix.hystrix.HystrixCommandProperties.ExecutionIsolationStrategy;
-import com.netflix.hystrix.HystrixExecutableBase.ObservableCommand;
-import com.netflix.hystrix.HystrixExecutableBase.TryableSemaphore;
 import com.netflix.hystrix.exception.HystrixBadRequestException;
 import com.netflix.hystrix.exception.HystrixRuntimeException;
+import com.netflix.hystrix.exception.HystrixRuntimeException.FailureType;
 import com.netflix.hystrix.strategy.executionhook.HystrixCommandExecutionHook;
 import com.netflix.hystrix.strategy.properties.HystrixPropertiesStrategy;
+import com.netflix.hystrix.util.HystrixTimer.TimerListener;
 
 /**
  * Used to wrap code that will execute potentially risky functionality (typically meaning a service call over the network)
@@ -39,12 +41,10 @@
  * 
  * @param <R>
  *            the return type
- *            
+ * 
  * @ThreadSafe
  */
-public abstract class HystrixCommand<R> implements HystrixExecutable<R>, HystrixExecutableInfo<R> {
-
-    private final HystrixCommandFromObservableCommand<R> observableCommand;
+public abstract class HystrixCommand<R> extends AbstractCommand<R> implements HystrixExecutable<R>, HystrixExecutableInfo<R>, HystrixObservable<R> {
 
     /**
      * Construct a {@link HystrixCommand} with defined {@link HystrixCommandGroupKey}.
@@ -91,24 +91,11 @@ protected HystrixCommand(Setter setter) {
             HystrixCommandProperties.Setter commandPropertiesDefaults, HystrixThreadPoolProperties.Setter threadPoolPropertiesDefaults,
             HystrixCommandMetrics metrics, TryableSemaphore fallbackSemaphore, TryableSemaphore executionSemaphore,
             HystrixPropertiesStrategy propertiesStrategy, HystrixCommandExecutionHook executionHook) {
-
-        /*
-         * CommandKey initialization
-         */
-        HystrixCommandKey commandKey = null;
-        if (key == null || key.name().trim().equals("")) {
-            // use the HystrixCommand class rather than this ObservableCommand class if we have it
-            final String keyName = HystrixExecutableBase.getDefaultNameFromClass(getClass());
-            commandKey = HystrixCommandKey.Factory.asKey(keyName);
-        } else {
-            commandKey = key;
-        }
-
-        this.observableCommand = new HystrixCommandFromObservableCommand<R>(this, group, commandKey, threadPoolKey, circuitBreaker, threadPool, commandPropertiesDefaults, threadPoolPropertiesDefaults, metrics, fallbackSemaphore, executionSemaphore, propertiesStrategy, executionHook);
+        super(group, key, threadPoolKey, circuitBreaker, threadPool, commandPropertiesDefaults, threadPoolPropertiesDefaults, metrics, fallbackSemaphore, executionSemaphore, propertiesStrategy, executionHook);
     }
 
     /**
-     * Fluent interface for arguments to the {@link HystrixObservableCommand} constructor.
+     * Fluent interface for arguments to the {@link HystrixCommand} constructor.
      * <p>
      * The required arguments are set via the 'with' factory method and optional arguments via the 'and' chained methods.
      * <p>
@@ -121,7 +108,7 @@ protected HystrixCommand(Setter setter) {
      * 
      * @NotThreadSafe
      */
-    public static class Setter {
+    final public static class Setter {
 
         protected final HystrixCommandGroupKey groupKey;
         protected HystrixCommandKey commandKey;
@@ -135,7 +122,7 @@ public static class Setter {
          * All optional arguments can be set via the chained methods.
          * 
          * @param groupKey
-         *            {@link HystrixCommandGroupKey} used to group together multiple {@link HystrixObservableCommand} objects.
+         *            {@link HystrixCommandGroupKey} used to group together multiple {@link HystrixCommand} objects.
          *            <p>
          *            The {@link HystrixCommandGroupKey} is used to represent a common relationship between commands. For example, a library or team name, the system all related commands interace
          *            with,
@@ -151,7 +138,7 @@ protected Setter(HystrixCommandGroupKey groupKey) {
          * All optional arguments can be set via the chained methods.
          * 
          * @param groupKey
-         *            {@link HystrixCommandGroupKey} used to group together multiple {@link HystrixObservableCommand} objects.
+         *            {@link HystrixCommandGroupKey} used to group together multiple {@link HystrixCommand} objects.
          *            <p>
          *            The {@link HystrixCommandGroupKey} is used to represent a common relationship between commands. For example, a library or team name, the system all related commands interace
          *            with,
@@ -163,7 +150,7 @@ public static Setter withGroupKey(HystrixCommandGroupKey groupKey) {
 
         /**
          * @param commandKey
-         *            {@link HystrixCommandKey} used to identify a {@link HystrixObservableCommand} instance for statistics, circuit-breaker, properties, etc.
+         *            {@link HystrixCommandKey} used to identify a {@link HystrixCommand} instance for statistics, circuit-breaker, properties, etc.
          *            <p>
          *            By default this will be derived from the instance class name.
          *            <p>
@@ -197,7 +184,7 @@ public Setter andThreadPoolKey(HystrixThreadPoolKey threadPoolKey) {
          * Optional
          * 
          * @param commandPropertiesDefaults
-         *            {@link HystrixCommandProperties.Setter} with property overrides for this specific instance of {@link HystrixObservableCommand}.
+         *            {@link HystrixCommandProperties.Setter} with property overrides for this specific instance of {@link HystrixCommand}.
          *            <p>
          *            See the {@link HystrixPropertiesStrategy} JavaDocs for more information on properties and order of precedence.
          * @return Setter for fluent interface via method chaining
@@ -211,7 +198,7 @@ public Setter andCommandPropertiesDefaults(HystrixCommandProperties.Setter comma
          * Optional
          * 
          * @param threadPoolPropertiesDefaults
-         *            {@link HystrixThreadPoolProperties.Setter} with property overrides for the {@link HystrixThreadPool} used by this specific instance of {@link HystrixObservableCommand}.
+         *            {@link HystrixThreadPoolProperties.Setter} with property overrides for the {@link HystrixThreadPool} used by this specific instance of {@link HystrixCommand}.
          *            <p>
          *            See the {@link HystrixPropertiesStrategy} JavaDocs for more information on properties and order of precedence.
          * @return Setter for fluent interface via method chaining
@@ -250,252 +237,274 @@ protected R getFallback() {
         throw new UnsupportedOperationException("No fallback available.");
     }
 
-    /**
-     * Key to be used for request caching.
-     * <p>
-     * By default this returns null which means "do not cache".
-     * <p>
-     * To enable caching override this method and return a string key uniquely representing the state of a command instance.
-     * <p>
-     * If multiple command instances in the same request scope match keys then only the first will be executed and all others returned from cache.
-     * 
-     * @return cacheKey
-     */
-    protected String getCacheKey() {
-        return null;
+    @Override
+    final protected Observable<R> getExecutionObservable() {
+        return Observable.create(new OnSubscribe<R>() {
+
+            @Override
+            public void call(Subscriber<? super R> s) {
+                try {
+                    s.onNext(run());
+                    s.onCompleted();
+                } catch (Throwable e) {
+                    s.onError(e);
+                }
+            }
+
+        });
+    }
+
+    @Override
+    final protected Observable<R> getFallbackObservable() {
+        return Observable.create(new OnSubscribe<R>() {
+
+            @Override
+            public void call(Subscriber<? super R> s) {
+                try {
+                    s.onNext(getFallback());
+                    s.onCompleted();
+                } catch (Throwable e) {
+                    s.onError(e);
+                }
+            }
+
+        });
     }
 
     /**
-     * A lazy {@link Observable} that will execute the command when subscribed to.
-     * <p>
-     * <b>Callback Scheduling</b>
-     * <p>
-     * <ul>
-     * <li>When using {@link ExecutionIsolationStrategy#THREAD} this defaults to using {@link Schedulers#threadPoolForComputation()} for callbacks.</li>
-     * <li>When using {@link ExecutionIsolationStrategy#SEMAPHORE} this defaults to using {@link Schedulers#immediate()} for callbacks.</li>
-     * </ul>
-     * <p>
-     * See https://github.com/Netflix/RxJava/wiki for more information.
-     * 
-     * @return {@code Observable<R>} that lazily executes and calls back with the result of {@link #run()} execution or a fallback from {@link #getFallback()} if the command fails for any reason.
+     * Used for synchronous execution of command.
      * 
+     * @return R
+     *         Result of {@link #run()} execution or a fallback from {@link #getFallback()} if the command fails for any reason.
      * @throws HystrixRuntimeException
-     *             if a fallback does not exist
-     *             <p>
-     *             <ul>
-     *             <li>via {@code Observer#onError} if a failure occurs</li>
-     *             <li>or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)</li>
-     *             </ul>
+     *             if a failure occurs and a fallback cannot be retrieved
      * @throws HystrixBadRequestException
-     *             via {@code Observer#onError} if invalid arguments or state were used representing a user failure, not a system failure
+     *             if invalid arguments or state were used representing a user failure, not a system failure
      * @throws IllegalStateException
      *             if invoked more than once
      */
-    public Observable<R> toObservable() {
-        if (observableCommand.properties.executionIsolationStrategy().get().equals(ExecutionIsolationStrategy.THREAD)) {
-            return toObservable(Schedulers.computation());
-        } else {
-            // semaphore isolation is all blocking, no new threads involved
-            // so we'll use the calling thread
-            return toObservable(Schedulers.immediate());
+    final public R execute() {
+        try {
+            return queue().get();
+        } catch (Exception e) {
+            throw decomposeException(e);
         }
     }
 
     /**
-     * A lazy {@link Observable} that will execute the command when subscribed to.
+     * Used for asynchronous execution of command.
      * <p>
-     * See https://github.com/Netflix/RxJava/wiki for more information.
+     * This will queue up the command on the thread pool and return an {@link Future} to get the result once it completes.
+     * <p>
+     * NOTE: If configured to not run in a separate thread, this will have the same effect as {@link #execute()} and will block.
+     * <p>
+     * We don't throw an exception but just flip to synchronous execution so code doesn't need to change in order to switch a command from running on a separate thread to the calling thread.
      * 
-     * @param observeOn
-     *            The {@link Scheduler} to execute callbacks on.
-     * @return {@code Observable<R>} that lazily executes and calls back with the result of {@link #run()} execution or a fallback from {@link #getFallback()} if the command fails for any reason.
+     * @return {@code Future<R>} Result of {@link #run()} execution or a fallback from {@link #getFallback()} if the command fails for any reason.
      * @throws HystrixRuntimeException
      *             if a fallback does not exist
      *             <p>
      *             <ul>
-     *             <li>via {@code Observer#onError} if a failure occurs</li>
+     *             <li>via {@code Future.get()} in {@link ExecutionException#getCause()} if a failure occurs</li>
      *             <li>or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)</li>
      *             </ul>
      * @throws HystrixBadRequestException
-     *             via {@code Observer#onError} if invalid arguments or state were used representing a user failure, not a system failure
+     *             via {@code Future.get()} in {@link ExecutionException#getCause()} if invalid arguments or state were used representing a user failure, not a system failure
      * @throws IllegalStateException
      *             if invoked more than once
      */
-    public Observable<R> toObservable(Scheduler observeOn) {
-        return toObservable(observeOn, true);
-    }
-
-    private ObservableCommand<R> toObservable(final Scheduler observeOn, boolean performAsyncTimeout) {
-        return observableCommand.toObservable(observeOn, performAsyncTimeout);
-    }
-
-    /* package */static class HystrixCommandFromObservableCommand<R> extends HystrixObservableCommand<R> {
-
-        private final HystrixCommand<R> original;
-
-        protected HystrixCommandFromObservableCommand(HystrixCommand<R> o, HystrixCommandGroupKey group, HystrixCommandKey key, HystrixThreadPoolKey threadPoolKey, HystrixCircuitBreaker circuitBreaker, HystrixThreadPool threadPool,
-                HystrixCommandProperties.Setter commandPropertiesDefaults, HystrixThreadPoolProperties.Setter threadPoolPropertiesDefaults,
-                HystrixCommandMetrics metrics, TryableSemaphore fallbackSemaphore, TryableSemaphore executionSemaphore,
-                HystrixPropertiesStrategy propertiesStrategy, HystrixCommandExecutionHook executionHook) {
-            super(group, key, threadPoolKey, circuitBreaker, threadPool, commandPropertiesDefaults, threadPoolPropertiesDefaults, metrics, fallbackSemaphore, executionSemaphore, propertiesStrategy, executionHook);
-            this.original = o;
-        }
-
-        /* package */HystrixCommand<R> getOriginal() {
-            return original;
-        }
-
-        @Override
-        protected Observable<R> run() {
-            return Observable.create(new OnSubscribe<R>() {
-
-                @Override
-                public void call(Subscriber<? super R> s) {
-                    try {
-                        s.onNext(original.run());
-                        s.onCompleted();
-                    } catch (Throwable e) {
-                        s.onError(e);
+    final public Future<R> queue() {
+        /*
+         * --- Schedulers.immediate()
+         * 
+         * We use the 'immediate' schedule since Future.get() is blocking so we don't want to bother doing the callback to the Future on a separate thread
+         * as we don't need to separate the Hystrix thread from user threads since they are already providing it via the Future.get() call.
+         * 
+         * --- performAsyncTimeout: false
+         * 
+         * We pass 'false' to tell the Observable we will block on it so it doesn't schedule an async timeout.
+         * 
+         * This optimizes for using the calling thread to do the timeout rather than scheduling another thread.
+         * 
+         * In a tight-loop of executing commands this optimization saves a few microseconds per execution.
+         * It also just makes no sense to use a separate thread to timeout the command when the calling thread
+         * is going to sit waiting on it.
+         */
+        final ObservableCommand<R> o = toObservable(false);
+        final Future<R> f = o.toBlocking().toFuture();
+
+        /* special handling of error states that throw immediately */
+        if (f.isDone()) {
+            try {
+                f.get();
+                return f;
+            } catch (Exception e) {
+                RuntimeException re = decomposeException(e);
+                if (re instanceof HystrixBadRequestException) {
+                    return f;
+                } else if (re instanceof HystrixRuntimeException) {
+                    HystrixRuntimeException hre = (HystrixRuntimeException) re;
+                    if (hre.getFailureType() == FailureType.COMMAND_EXCEPTION || hre.getFailureType() == FailureType.TIMEOUT) {
+                        // we don't throw these types from queue() only from queue().get() as they are execution errors
+                        return f;
+                    } else {
+                        // these are errors we throw from queue() as they as rejection type errors
+                        throw hre;
                     }
+                } else {
+                    throw re;
                 }
-
-            });
+            }
         }
 
-        @Override
-        protected Observable<R> getFallback() {
-            return Observable.create(new OnSubscribe<R>() {
-
-                @Override
-                public void call(Subscriber<? super R> s) {
-                    try {
-                        s.onNext(original.getFallback());
-                        s.onCompleted();
-                    } catch (Throwable e) {
-                        s.onError(e);
-                    }
+        return new Future<R>() {
+
+            @Override
+            public boolean cancel(boolean mayInterruptIfRunning) {
+                return f.cancel(mayInterruptIfRunning);
+            }
+
+            @Override
+            public boolean isCancelled() {
+                return f.isCancelled();
+            }
+
+            @Override
+            public boolean isDone() {
+                return f.isDone();
+            }
+
+            @Override
+            public R get() throws InterruptedException, ExecutionException {
+                return performBlockingGetWithTimeout(o, f);
+            }
+
+            /**
+             * --- Non-Blocking Timeout (performAsyncTimeout:true) ---
+             * 
+             * When 'toObservable' is done with non-blocking timeout then timeout functionality is provided
+             * by a separate HystrixTimer thread that will "tick" and cancel the underlying async Future inside the Observable.
+             * 
+             * This method allows stealing that responsibility and letting the thread that's going to block anyways
+             * do the work to reduce pressure on the HystrixTimer.
+             * 
+             * Blocking via queue().get() on a non-blocking timeout will work it's just less efficient
+             * as it involves an extra thread and cancels the scheduled action that does the timeout.
+             * 
+             * --- Blocking Timeout (performAsyncTimeout:false) ---
+             * 
+             * When blocking timeout is assumed (default behavior for execute/queue flows) then the async
+             * timeout will not have been scheduled and this will wait in a blocking manner and if a timeout occurs
+             * trigger the timeout logic that comes from inside the Observable/Observer.
+             * 
+             * 
+             * --- Examples
+             * 
+             * Stack for timeout with performAsyncTimeout=false (note the calling thread via get):
+             * 
+             * at com.netflix.hystrix.HystrixCommand$TimeoutObservable$1$1.tick(HystrixCommand.java:788)
+             * at com.netflix.hystrix.HystrixCommand$1.performBlockingGetWithTimeout(HystrixCommand.java:536)
+             * at com.netflix.hystrix.HystrixCommand$1.get(HystrixCommand.java:484)
+             * at com.netflix.hystrix.HystrixCommand.execute(HystrixCommand.java:413)
+             * 
+             * 
+             * Stack for timeout with performAsyncTimeout=true (note the HystrixTimer involved):
+             * 
+             * at com.netflix.hystrix.HystrixCommand$TimeoutObservable$1$1.tick(HystrixCommand.java:799)
+             * at com.netflix.hystrix.util.HystrixTimer$1.run(HystrixTimer.java:101)
+             * 
+             * 
+             * 
+             * @param o
+             * @param f
+             * @throws InterruptedException
+             * @throws ExecutionException
+             */
+            protected R performBlockingGetWithTimeout(final ObservableCommand<R> o, final Future<R> f) throws InterruptedException, ExecutionException {
+                // shortcut if already done
+                if (f.isDone()) {
+                    return f.get();
                 }
 
-            });
-        }
-
-        @Override
-        protected String getCacheKey() {
-            return original.getCacheKey();
-        }
-    }
-
-    @Override
-    public HystrixCommandGroupKey getCommandGroup() {
-        return observableCommand.getCommandGroup();
-    }
-
-    @Override
-    public HystrixCommandKey getCommandKey() {
-        return observableCommand.getCommandKey();
-    }
-
-    @Override
-    public HystrixThreadPoolKey getThreadPoolKey() {
-        return observableCommand.getThreadPoolKey();
-    }
-
-    @Override
-    public HystrixCommandMetrics getMetrics() {
-        return observableCommand.getMetrics();
-    }
-
-    @Override
-    public HystrixCommandProperties getProperties() {
-        return observableCommand.getProperties();
-    }
-
-    @Override
-    public boolean isCircuitBreakerOpen() {
-        return observableCommand.isCircuitBreakerOpen();
-    }
-
-    @Override
-    public boolean isExecutionComplete() {
-        return observableCommand.isExecutionComplete();
-    }
-
-    @Override
-    public boolean isExecutedInThread() {
-        return observableCommand.isExecutedInThread();
-    }
-
-    @Override
-    public boolean isSuccessfulExecution() {
-        return observableCommand.isSuccessfulExecution();
-    }
-
-    @Override
-    public boolean isFailedExecution() {
-        return observableCommand.isFailedExecution();
-    }
-
-    @Override
-    public Throwable getFailedExecutionException() {
-        return observableCommand.getFailedExecutionException();
-    }
-
-    @Override
-    public boolean isResponseFromFallback() {
-        return observableCommand.isResponseFromFallback();
-    }
-
-    @Override
-    public boolean isResponseTimedOut() {
-        return observableCommand.isResponseTimedOut();
-    }
-
-    @Override
-    public boolean isResponseShortCircuited() {
-        return observableCommand.isResponseShortCircuited();
-    }
-
-    @Override
-    public boolean isResponseFromCache() {
-        return observableCommand.isResponseFromCache();
-    }
-
-    @Override
-    public boolean isResponseRejected() {
-        return observableCommand.isResponseRejected();
-    }
-
-    @Override
-    public List<HystrixEventType> getExecutionEvents() {
-        return observableCommand.getExecutionEvents();
-    }
-
-    @Override
-    public int getExecutionTimeInMilliseconds() {
-        return observableCommand.getExecutionTimeInMilliseconds();
-    }
-
-    @Override
-    public Future<R> queue() {
-        return observableCommand.queue();
-    }
-
-    @Override
-    public R execute() {
-        return observableCommand.execute();
-    }
+                // it's still working so proceed with blocking/timeout logic
+                AbstractCommand<R> originalCommand = o.getCommand();
+                /**
+                 * One thread will get the timeoutTimer if it's set and clear it then do blocking timeout.
+                 * <p>
+                 * If non-blocking timeout was scheduled this will unschedule it. If it wasn't scheduled it is basically
+                 * a no-op but fits the same interface so blocking and non-blocking flows both work the same.
+                 * <p>
+                 * This "originalCommand" concept exists because of request caching. We only do the work and timeout logic
+                 * on the original, not the cached responses. However, whichever the first thread is that comes in to block
+                 * will be the one who performs the timeout logic.
+                 * <p>
+                 * If request caching is disabled then it will always go into here.
+                 */
+                if (originalCommand != null) {
+                    Reference<TimerListener> timer = originalCommand.timeoutTimer.getAndSet(null);
+                    if (timer != null) {
+                        /**
+                         * If an async timeout was scheduled then:
+                         * 
+                         * - We are going to clear the Reference<TimerListener> so the scheduler threads stop managing the timeout
+                         * and we'll take over instead since we're going to be blocking on it anyways.
+                         * 
+                         * - Other threads (since we won the race) will just wait on the normal Future which will release
+                         * once the Observable is marked as completed (which may come via timeout)
+                         * 
+                         * If an async timeout was not scheduled:
+                         * 
+                         * - We go through the same flow as we receive the same interfaces just the "timer.clear()" will do nothing.
+                         */
+                        // get the timer we'll use to perform the timeout
+                        TimerListener l = timer.get();
+                        // remove the timer from the scheduler
+                        timer.clear();
+
+                        // determine how long we should wait for, taking into account time since work started
+                        // and when this thread came in to block. If invocationTime hasn't been set then assume time remaining is entire timeout value
+                        // as this maybe a case of multiple threads trying to run this command in which one thread wins but even before the winning thread is able to set
+                        // the starttime another thread going via the Cached command route gets here first.
+                        long timeout = originalCommand.properties.executionIsolationThreadTimeoutInMilliseconds().get();
+                        long timeRemaining = timeout;
+                        long currTime = System.currentTimeMillis();
+                        if (originalCommand.invocationStartTime != -1) {
+                            timeRemaining = (originalCommand.invocationStartTime
+                                    + originalCommand.properties.executionIsolationThreadTimeoutInMilliseconds().get())
+                                    - currTime;
+
+                        }
+                        if (timeRemaining > 0) {
+                            // we need to block with the calculated timeout
+                            try {
+                                return f.get(timeRemaining, TimeUnit.MILLISECONDS);
+                            } catch (TimeoutException e) {
+                                if (l != null) {
+                                    // this perform the timeout logic on the Observable/Observer
+                                    l.tick();
+                                }
+                            }
+                        } else {
+                            // this means it should have already timed out so do so if it is not completed
+                            if (!f.isDone()) {
+                                if (l != null) {
+                                    l.tick();
+                                }
+                            }
+                        }
+                    }
+                }
+                // other threads will block until the "l.tick" occurs and releases the underlying Future.
+                return f.get();
+            }
 
-    @Override
-    public Observable<R> observe() {
-        return observableCommand.observe();
-    }
+            @Override
+            public R get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+                return get();
+            }
 
-    /* package */void markAsCollapsedCommand(int sizeOfBatch) {
-        observableCommand.markAsCollapsedCommand(sizeOfBatch);
-    }
+        };
 
-    /* package */HystrixCircuitBreaker getCircuitBreaker() {
-        return observableCommand.getCircuitBreaker();
     }
 
 }
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCommandProperties.java b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCommandProperties.java
index a8e08a80c..07b88d80a 100644
--- a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCommandProperties.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixCommandProperties.java
@@ -15,7 +15,7 @@
  */
 package com.netflix.hystrix;
 
-import static com.netflix.hystrix.strategy.properties.HystrixProperty.Factory.*;
+import static com.netflix.hystrix.strategy.properties.HystrixProperty.Factory.asProperty;
 
 import java.util.concurrent.Future;
 
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixExecutable.java b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixExecutable.java
index 77785e7c7..a8f1d255b 100644
--- a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixExecutable.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixExecutable.java
@@ -29,7 +29,7 @@
  * 
  * @param <R>
  */
-public interface HystrixExecutable<R> {
+public interface HystrixExecutable<R> extends HystrixInvokable<R> {
 
     /**
      * Used for synchronous execution of command.
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixExecutableInfo.java b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixExecutableInfo.java
index eb387c29d..ea968eae6 100644
--- a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixExecutableInfo.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixExecutableInfo.java
@@ -1,3 +1,18 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package com.netflix.hystrix;
 
 import java.util.List;
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixInvokable.java b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixInvokable.java
new file mode 100644
index 000000000..f90821432
--- /dev/null
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixInvokable.java
@@ -0,0 +1,8 @@
+package com.netflix.hystrix;
+
+/**
+ * Marker interface for Hystrix commands that can be invoked.
+ */
+public interface HystrixInvokable<R> {
+
+}
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixObservable.java b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixObservable.java
new file mode 100644
index 000000000..b72105b4d
--- /dev/null
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixObservable.java
@@ -0,0 +1,96 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.netflix.hystrix;
+
+import rx.Observable;
+import rx.schedulers.Schedulers;
+
+import com.netflix.hystrix.HystrixCommandProperties.ExecutionIsolationStrategy;
+import com.netflix.hystrix.exception.HystrixBadRequestException;
+import com.netflix.hystrix.exception.HystrixRuntimeException;
+
+/**
+ * Common interface for executables that implement the Observable methods {@link #observe()} and {@link #toObservable()} so client code can treat them the same and combine in typed collections if desired.
+ * 
+ * @param <R>
+ */
+public interface HystrixObservable<R> extends HystrixInvokable<R> {
+
+    /**
+     * Used for asynchronous execution of command with a callback by subscribing to the {@link Observable}.
+     * <p>
+     * This eagerly starts execution of the command the same as {@link #queue()} and {@link #execute()}.
+     * <p>
+     * A lazy {@link Observable} can be obtained from {@link #toObservable()}.
+     * <p>
+     * <b>Callback Scheduling</b>
+     * <p>
+     * <ul>
+     * <li>When using {@link ExecutionIsolationStrategy#THREAD} this defaults to using {@link Schedulers#threadPoolForComputation()} for callbacks.</li>
+     * <li>When using {@link ExecutionIsolationStrategy#SEMAPHORE} this defaults to using {@link Schedulers#immediate()} for callbacks.</li>
+     * </ul>
+     * Use {@link HystrixCommand#toObservable(rx.Scheduler)} or {@link HystrixCollapser#toObservable(rx.Scheduler)} to schedule the callback differently.
+     * <p>
+     * See https://github.com/ReactiveX/RxJava/wiki for more information.
+     * 
+     * @return {@code Observable<R>} that executes and calls back with the result of {@link #run()} execution or a fallback from {@link #getFallback()} if the command fails for any reason.
+     * @throws HystrixRuntimeException
+     *             if a fallback does not exist
+     *             <p>
+     *             <ul>
+     *             <li>via {@code Observer#onError} if a failure occurs</li>
+     *             <li>or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)</li>
+     *             </ul>
+     * @throws HystrixBadRequestException
+     *             via {@code Observer#onError} if invalid arguments or state were used representing a user failure, not a system failure
+     * @throws IllegalStateException
+     *             if invoked more than once
+     */
+    public Observable<R> observe();
+    
+    /**
+     * Used for asynchronous execution of command with a callback by subscribing to the {@link Observable}.
+     * <p>
+     * This lazily starts execution of the command only once the {@link Observable} is subscribed to.
+     * <p>
+     * An eager {@link Observable} can be obtained from {@link #observe()}
+     * <p>
+     * <b>Callback Scheduling</b>
+     * <p>
+     * <ul>
+     * <li>When using {@link ExecutionIsolationStrategy#THREAD} this defaults to using {@link Schedulers#threadPoolForComputation()} for callbacks.</li>
+     * <li>When using {@link ExecutionIsolationStrategy#SEMAPHORE} this defaults to using {@link Schedulers#immediate()} for callbacks.</li>
+     * </ul>
+     * Use {@link HystrixCommand#toObservable(rx.Scheduler)} or {@link HystrixCollapser#toObservable(rx.Scheduler)} to schedule the callback differently.
+     * <p>
+     * See https://github.com/ReactiveX/RxJava/wiki for more information.
+     * 
+     * @return {@code Observable<R>} that executes and calls back with the result of {@link #run()} execution or a fallback from {@link #getFallback()} if the command fails for any reason.
+     * @throws HystrixRuntimeException
+     *             if a fallback does not exist
+     *             <p>
+     *             <ul>
+     *             <li>via {@code Observer#onError} if a failure occurs</li>
+     *             <li>or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)</li>
+     *             </ul>
+     * @throws HystrixBadRequestException
+     *             via {@code Observer#onError} if invalid arguments or state were used representing a user failure, not a system failure
+     * @throws IllegalStateException
+     *             if invoked more than once
+     */
+    public Observable<R> toObservable();
+    
+}
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixObservableCollapser.java b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixObservableCollapser.java
index a060453ca..dbaedb9ab 100644
--- a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixObservableCollapser.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixObservableCollapser.java
@@ -15,21 +15,29 @@
  */
 package com.netflix.hystrix;
 
-import java.util.*;
-import java.util.concurrent.*;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
-import org.slf4j.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-import rx.*;
 import rx.Observable;
-import rx.functions.*;
+import rx.Scheduler;
+import rx.functions.Action0;
+import rx.functions.Func1;
 import rx.schedulers.Schedulers;
 import rx.subjects.ReplaySubject;
 
 import com.netflix.hystrix.HystrixCollapser.CollapsedRequest;
 import com.netflix.hystrix.HystrixCommandProperties.ExecutionIsolationStrategy;
-import com.netflix.hystrix.collapser.*;
-import com.netflix.hystrix.exception.HystrixRuntimeException;
+import com.netflix.hystrix.collapser.CollapserTimer;
+import com.netflix.hystrix.collapser.HystrixCollapserBridge;
+import com.netflix.hystrix.collapser.RealCollapserTimer;
+import com.netflix.hystrix.collapser.RequestCollapser;
+import com.netflix.hystrix.collapser.RequestCollapserFactory;
 import com.netflix.hystrix.strategy.HystrixPlugins;
 import com.netflix.hystrix.strategy.concurrency.HystrixRequestContext;
 import com.netflix.hystrix.strategy.properties.HystrixPropertiesStrategy;
@@ -55,7 +63,7 @@
  * @param <RequestArgumentType>
  *            The type of the request argument. If multiple arguments are needed, wrap them in another object or a Tuple.
  */
-public abstract class HystrixObservableCollapser<K, BatchReturnType, ResponseType, RequestArgumentType> implements HystrixExecutable<ResponseType> {
+public abstract class HystrixObservableCollapser<K, BatchReturnType, ResponseType, RequestArgumentType> implements HystrixObservable<ResponseType> {
 
     static final Logger logger = LoggerFactory.getLogger(HystrixObservableCollapser.class);
 
@@ -397,52 +405,6 @@ public Observable<ResponseType> toObservable(Scheduler observeOn) {
         return response;
     }
 
-    /**
-     * Used for synchronous execution.
-     * <p>
-     * If {@link Scope#REQUEST} is being used then synchronous execution will only result in collapsing if other threads are running within the same scope.
-     * 
-     * @return ResponseType
-     *         Result of {@link HystrixCommand}{@code <BatchReturnType>} execution after passing through {@link #mapResponseToRequests} to transform the {@code <BatchReturnType>} into
-     *         {@code <ResponseType>}
-     * @throws HystrixRuntimeException
-     *             if an error occurs and a fallback cannot be retrieved
-     */
-    public ResponseType execute() {
-        try {
-            return queue().get();
-        } catch (Throwable e) {
-            if (e instanceof HystrixRuntimeException) {
-                throw (HystrixRuntimeException) e;
-            }
-            // if we have an exception we know about we'll throw it directly without the threading wrapper exception
-            if (e.getCause() instanceof HystrixRuntimeException) {
-                throw (HystrixRuntimeException) e.getCause();
-            }
-            // we don't know what kind of exception this is so create a generic message and throw a new HystrixRuntimeException
-            String message = getClass().getSimpleName() + " HystrixCollapser failed while executing.";
-            logger.debug(message, e); // debug only since we're throwing the exception and someone higher will do something with it
-            //TODO should this be made a HystrixRuntimeException?
-            throw new RuntimeException(message, e);
-        }
-    }
-
-    /**
-     * Used for asynchronous execution.
-     * <p>
-     * This will queue up the command and return a Future to get the result once it completes.
-     * 
-     * @return ResponseType
-     *         Result of {@link HystrixCommand}{@code <BatchReturnType>} execution after passing through {@link #mapResponseToRequests} to transform the {@code <BatchReturnType>} into
-     *         {@code <ResponseType>}
-     * @throws HystrixRuntimeException
-     *             within an <code>ExecutionException.getCause()</code> (thrown by {@link Future#get}) if an error occurs and a fallback cannot be retrieved
-     */
-    public Future<ResponseType> queue() {
-        final Observable<ResponseType> o = toObservable();
-        return o.toBlocking().toFuture();
-    }
-
     /**
      * Key to be used for request caching.
      * <p>
@@ -550,4 +512,4 @@ public Setter andCollapserPropertiesDefaults(HystrixCollapserProperties.Setter p
     @SuppressWarnings("rawtypes")
     private static ConcurrentHashMap<Class<? extends HystrixObservableCollapser>, String> defaultNameCache = new ConcurrentHashMap<Class<? extends HystrixObservableCollapser>, String>();
 
-}
+}
\ No newline at end of file
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixObservableCommand.java b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixObservableCommand.java
index 9d3491bc9..8a838f7ed 100644
--- a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixObservableCommand.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixObservableCommand.java
@@ -15,27 +15,14 @@
  */
 package com.netflix.hystrix;
 
-import java.lang.ref.*;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicReference;
-
-import org.slf4j.*;
-
-import rx.*;
-import rx.Observable.OnSubscribe;
-import rx.Observable.Operator;
-import rx.functions.*;
+import rx.Observable;
 import rx.schedulers.Schedulers;
-import rx.subscriptions.CompositeSubscription;
 
 import com.netflix.hystrix.HystrixCommandProperties.ExecutionIsolationStrategy;
-import com.netflix.hystrix.exception.*;
-import com.netflix.hystrix.exception.HystrixRuntimeException.FailureType;
-import com.netflix.hystrix.strategy.concurrency.*;
+import com.netflix.hystrix.exception.HystrixBadRequestException;
+import com.netflix.hystrix.exception.HystrixRuntimeException;
 import com.netflix.hystrix.strategy.executionhook.HystrixCommandExecutionHook;
 import com.netflix.hystrix.strategy.properties.HystrixPropertiesStrategy;
-import com.netflix.hystrix.util.*;
-import com.netflix.hystrix.util.HystrixTimer.TimerListener;
 
 /**
  * Used to wrap code that will execute potentially risky functionality (typically meaning a service call over the network)
@@ -47,9 +34,7 @@
  * 
  * @ThreadSafe
  */
-public abstract class HystrixObservableCommand<R> extends HystrixExecutableBase<R> implements HystrixExecutable<R>, HystrixExecutableInfo<R> {
-
-    private static final Logger logger = LoggerFactory.getLogger(HystrixObservableCommand.class);
+public abstract class HystrixObservableCommand<R> extends AbstractCommand<R> implements HystrixObservable<R>, HystrixExecutableInfo<R> {
 
     /**
      * Construct a {@link HystrixObservableCommand} with defined {@link HystrixCommandGroupKey}.
@@ -113,7 +98,7 @@ protected HystrixObservableCommand(Setter setter) {
      * 
      * @NotThreadSafe
      */
-    public static class Setter {
+    final public static class Setter {
 
         protected final HystrixCommandGroupKey groupKey;
         protected HystrixCommandKey commandKey;
@@ -203,7 +188,7 @@ private HystrixCommandProperties.Setter setDefaults(HystrixCommandProperties.Set
      * 
      * @return R response type
      */
-    protected abstract Observable<R> run();
+    protected abstract Observable<R> construct();
 
     /**
      * If {@link #execute()} or {@link #queue()} fails in any way then this method will be invoked to provide an opportunity to return a fallback response.
@@ -220,672 +205,17 @@ private HystrixCommandProperties.Setter setDefaults(HystrixCommandProperties.Set
      * 
      * @return R or UnsupportedOperationException if not implemented
      */
-    protected Observable<R> getFallback() {
+    protected Observable<R> onFailureResumeWithFallback() {
         return Observable.error(new UnsupportedOperationException("No fallback available."));
     }
 
-    /**
-     * A lazy {@link Observable} that will execute the command when subscribed to.
-     * <p>
-     * <b>This defaults to using {@link Schedulers#immediate()} for callbacks.</li>
-     * </ul>
-     * <p>
-     * See https://github.com/Netflix/RxJava/wiki for more information.
-     * 
-     * @return {@code Observable<R>} that lazily executes and calls back with the result of {@link #run()} execution or a fallback from {@link #getFallback()} if the command fails for any reason.
-     * 
-     * @throws HystrixRuntimeException
-     *             if a fallback does not exist
-     *             <p>
-     *             <ul>
-     *             <li>via {@code Observer#onError} if a failure occurs</li>
-     *             <li>or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)</li>
-     *             </ul>
-     * @throws HystrixBadRequestException
-     *             via {@code Observer#onError} if invalid arguments or state were used representing a user failure, not a system failure
-     * @throws IllegalStateException
-     *             if invoked more than once
-     */
-    public Observable<R> toObservable() {
-        return toObservable(Schedulers.immediate());
-    }
-
-    protected ObservableCommand<R> toObservable(final Scheduler observeOn, final boolean performAsyncTimeout) {
-        /* this is a stateful object so can only be used once */
-        if (!started.compareAndSet(false, true)) {
-            throw new IllegalStateException("This instance can only be executed once. Please instantiate a new instance.");
-        }
-
-        /* try from cache first */
-        if (isRequestCachingEnabled()) {
-            Observable<R> fromCache = requestCache.get(getCacheKey());
-            if (fromCache != null) {
-                /* mark that we received this response from cache */
-                metrics.markResponseFromCache();
-                return new CachedObservableResponse<R>((CachedObservableOriginal<R>) fromCache, this);
-            }
-        }
-
-        final HystrixObservableCommand<R> _this = this;
-        final AtomicReference<Action0> endCurrentThreadExecutingCommand = new AtomicReference<Action0>(); // don't like how this is being done
-
-        // create an Observable that will lazily execute when subscribed to
-        Observable<R> o = Observable.create(new OnSubscribe<R>() {
-
-            @Override
-            public void call(Subscriber<? super R> observer) {
-                // async record keeping
-                recordExecutedCommand();
-
-                // mark that we're starting execution on the ExecutionHook
-                executionHook.onStart(_this);
-
-                /* determine if we're allowed to execute */
-                if (circuitBreaker.allowRequest()) {
-                    final TryableSemaphore executionSemaphore = getExecutionSemaphore();
-                    // acquire a permit
-                    if (executionSemaphore.tryAcquire()) {
-                        try {
-                            /* used to track userThreadExecutionTime */
-                            invocationStartTime = System.currentTimeMillis();
-
-                            // store the command that is being run
-                            endCurrentThreadExecutingCommand.set(Hystrix.startCurrentThreadExecutingCommand(getCommandKey()));
-
-                            getRunObservableDecoratedForMetricsAndErrorHandling(observeOn, performAsyncTimeout)
-                                    .doOnTerminate(new Action0() {
-
-                                        @Override
-                                        public void call() {
-                                            // release the semaphore
-                                            // this is done here instead of below so that the acquire/release happens where it is guaranteed
-                                            // and not affected by the conditional circuit-breaker checks, timeouts, etc
-                                            executionSemaphore.release();
-
-                                        }
-                                    }).unsafeSubscribe(observer);
-                        } catch (RuntimeException e) {
-                            observer.onError(e);
-                        }
-                    } else {
-                        metrics.markSemaphoreRejection();
-                        logger.debug("HystrixCommand Execution Rejection by Semaphore."); // debug only since we're throwing the exception and someone higher will do something with it
-                        // retrieve a fallback or throw an exception if no fallback available
-                        getFallbackOrThrowException(HystrixEventType.SEMAPHORE_REJECTED, FailureType.REJECTED_SEMAPHORE_EXECUTION, "could not acquire a semaphore for execution").unsafeSubscribe(observer);
-                    }
-                } else {
-                    // record that we are returning a short-circuited fallback
-                    metrics.markShortCircuited();
-                    // short-circuit and go directly to fallback (or throw an exception if no fallback implemented)
-                    try {
-                        getFallbackOrThrowException(HystrixEventType.SHORT_CIRCUITED, FailureType.SHORTCIRCUIT, "short-circuited").unsafeSubscribe(observer);
-                    } catch (Exception e) {
-                        observer.onError(e);
-                    }
-                }
-            }
-        });
-
-        // error handling at very end (this means fallback didn't exist or failed)
-        o = o.onErrorResumeNext(new Func1<Throwable, Observable<R>>() {
-
-            @Override
-            public Observable<R> call(Throwable t) {
-                // count that we are throwing an exception and re-throw it
-                metrics.markExceptionThrown();
-                return Observable.error(t);
-            }
-
-        });
-
-        // any final cleanup needed
-        o = o.doOnTerminate(new Action0() {
-
-            @Override
-            public void call() {
-                Reference<TimerListener> tl = timeoutTimer.get();
-                if (tl != null) {
-                    tl.clear();
-                }
-
-                try {
-                    // if we executed we will record the execution time
-                    if (invocationStartTime > 0 && !isResponseRejected()) {
-                        /* execution time (must occur before terminal state otherwise a race condition can occur if requested by client) */
-                        recordTotalExecutionTime(invocationStartTime);
-                    }
-
-                    // pop the command that is being run
-                    if (endCurrentThreadExecutingCommand.get() != null) {
-                        endCurrentThreadExecutingCommand.get().call();
-                    }
-                } finally {
-                    metrics.decrementConcurrentExecutionCount();
-                    // record that we're completed
-                    isExecutionComplete.set(true);
-                }
-            }
-
-        });
-
-        // put in cache
-        if (isRequestCachingEnabled()) {
-            // wrap it for caching
-            o = new CachedObservableOriginal<R>(o.cache(), this);
-            Observable<R> fromCache = requestCache.putIfAbsent(getCacheKey(), o);
-            if (fromCache != null) {
-                // another thread beat us so we'll use the cached value instead
-                o = new CachedObservableResponse<R>((CachedObservableOriginal<R>) fromCache, this);
-            }
-            // we just created an ObservableCommand so we cast and return it
-            return (ObservableCommand<R>) o;
-        } else {
-            // no request caching so a simple wrapper just to pass 'this' along with the Observable
-            return new ObservableCommand<R>(o, this);
-        }
-    }
-
-    /**
-     * This decorate "Hystrix" functionality around the run() Observable.
-     * 
-     * @return R
-     */
-    private Observable<R> getRunObservableDecoratedForMetricsAndErrorHandling(final Scheduler observeOn, final boolean performAsyncTimeout) {
-        final HystrixObservableCommand<R> _self = this;
-        // allow tracking how many concurrent threads are executing
-        metrics.incrementConcurrentExecutionCount();
-
-        final HystrixRequestContext currentRequestContext = HystrixRequestContext.getContextForCurrentThread();
-
-        Observable<R> run = null;
-        if (properties.executionIsolationStrategy().get().equals(ExecutionIsolationStrategy.THREAD)) {
-            // mark that we are executing in a thread (even if we end up being rejected we still were a THREAD execution and not SEMAPHORE)
-            isExecutedInThread.set(true);
-
-            run = Observable.create(new OnSubscribe<R>() {
-
-                @Override
-                public void call(Subscriber<? super R> s) {
-                    executionHook.onRunStart(_self);
-                    executionHook.onThreadStart(_self);
-                    if (isCommandTimedOut.get() == TimedOutStatus.TIMED_OUT) {
-                        // the command timed out in the wrapping thread so we will return immediately
-                        // and not increment any of the counters below or other such logic
-                        s.onError(new RuntimeException("timed out before executing run()"));
-                    } else {
-                        // not timed out so execute
-                        try {
-                            final Action0 endCurrentThread = Hystrix.startCurrentThreadExecutingCommand(getCommandKey());
-                            run().doOnTerminate(new Action0() {
-
-                                @Override
-                                public void call() {
-                                    // TODO is this actually the end of the thread?
-                                    executionHook.onThreadComplete(_self);
-                                    endCurrentThread.call();
-                                }
-                            }).unsafeSubscribe(s);
-                        } catch (Throwable t) {
-                            // the run() method is a user provided implementation so can throw instead of using Observable.onError
-                            // so we catch it here and turn it into Observable.error
-                            Observable.<R> error(t).unsafeSubscribe(s);
-                        }
-                    }
-                }
-            }).subscribeOn(threadPool.getScheduler());
-        } else {
-            // semaphore isolated
-            executionHook.onRunStart(_self);
-            try {
-                run = run();
-            } catch (Throwable t) {
-                // the run() method is a user provided implementation so can throw instead of using Observable.onError
-                // so we catch it here and turn it into Observable.error
-                run = Observable.error(t);
-            }
-        }
-
-        run = run.doOnEach(new Action1<Notification<? super R>>() {
-
-            @Override
-            public void call(Notification<? super R> n) {
-                setRequestContextIfNeeded(currentRequestContext);
-            }
-
-        }).lift(new HystrixObservableTimeoutOperator<R>(_self, performAsyncTimeout)).map(new Func1<R, R>() {
-
-            /**
-             * If we get here it means we did not timeout, otherwise it will skip this and go to onErrorResumeNext
-             */
-
-            @Override
-            public R call(R t1) {
-                long duration = System.currentTimeMillis() - invocationStartTime;
-                metrics.addCommandExecutionTime(duration);
-                // report success
-                executionResult = executionResult.addEvents(HystrixEventType.SUCCESS);
-                metrics.markSuccess(duration);
-                circuitBreaker.markSuccess();
-                eventNotifier.markCommandExecution(getCommandKey(), properties.executionIsolationStrategy().get(), (int) duration, executionResult.events);
-                return executionHook.onRunSuccess(_self, t1);
-            }
-
-        }).onErrorResumeNext(new Func1<Throwable, Observable<R>>() {
-
-            @Override
-            public Observable<R> call(Throwable t) {
-                Exception e = getExceptionFromThrowable(t);
-                if (e instanceof RejectedExecutionException) {
-                    /**
-                     * Rejection handling
-                     */
-                    metrics.markThreadPoolRejection();
-                    // use a fallback instead (or throw exception if not implemented)
-                    return getFallbackOrThrowException(HystrixEventType.THREAD_POOL_REJECTED, FailureType.REJECTED_THREAD_EXECUTION, "could not be queued for execution", e);
-                } else if (t instanceof HystrixObservableTimeoutOperator.HystrixTimeoutException) {
-                    /**
-                     * Timeout handling
-                     */
-                    Observable<R> v = getFallbackOrThrowException(HystrixEventType.TIMEOUT, FailureType.TIMEOUT, "timed-out", new TimeoutException());
-                    /*
-                     * we subscribeOn the computation scheduler as we don't want to use the Timer thread, nor can we use the
-                     * THREAD isolation pool as it may be saturated and that's the reason we're in fallback. The fallback logic
-                     * should not perform IO and thus we run on the computation event loops.
-                     */
-                    return v.subscribeOn(new HystrixContextScheduler(concurrencyStrategy, Schedulers.computation()));
-                } else if (t instanceof HystrixBadRequestException) {
-                    /**
-                     * BadRequest handling
-                     */
-                    try {
-                        Exception decorated = executionHook.onRunError(_self, (Exception) t);
-
-                        if (decorated instanceof HystrixBadRequestException) {
-                            t = (HystrixBadRequestException) decorated;
-                        } else {
-                            logger.warn("ExecutionHook.onRunError returned an exception that was not an instance of HystrixBadRequestException so will be ignored.", decorated);
-                        }
-                    } catch (Exception hookException) {
-                        logger.warn("Error calling ExecutionHook.onRunError", hookException);
-                    }
-
-                    /*
-                     * HystrixBadRequestException is treated differently and allowed to propagate without any stats tracking or fallback logic
-                     */
-                    return Observable.error(t);
-                } else {
-                    /**
-                     * All other error handling
-                     */
-                    try {
-                        e = executionHook.onRunError(_self, e);
-                    } catch (Exception hookException) {
-                        logger.warn("Error calling ExecutionHook.endRunFailure", hookException);
-                    }
-
-                    logger.debug("Error executing HystrixCommand.run(). Proceeding to fallback logic ...", e);
-
-                    // report failure
-                    metrics.markFailure(System.currentTimeMillis() - invocationStartTime);
-                    // record the exception
-                    executionResult = executionResult.setException(e);
-                    return getFallbackOrThrowException(HystrixEventType.FAILURE, FailureType.COMMAND_EXCEPTION, "failed", e);
-                }
-            }
-        }).doOnEach(new Action1<Notification<? super R>>() {
-            // setting again as the fallback could have lost the context
-            @Override
-            public void call(Notification<? super R> n) {
-                setRequestContextIfNeeded(currentRequestContext);
-            }
-
-        }).map(new Func1<R, R>() {
-
-            @Override
-            public R call(R t1) {
-                // allow transforming the results via the executionHook whether it came from success or fallback
-                return executionHook.onComplete(_self, t1);
-            }
-
-        });
-
-        if (properties.executionIsolationStrategy().get().equals(ExecutionIsolationStrategy.THREAD)) {
-            // we want to hand off work to a different scheduler so we don't tie up the Hystrix thread
-            if (!Schedulers.immediate().equals(observeOn)) {
-                // don't waste overhead if it's the 'immediate' scheduler
-                // otherwise we'll 'observeOn' and wrap with the HystrixContextScheduler
-                // to copy state across threads (if threads are involved)
-                run = run.observeOn(new HystrixContextScheduler(concurrencyStrategy, observeOn));
-            }
-        }
-
-        return run;
-    }
-
-    /**
-     * Execute <code>getFallback()</code> within protection of a semaphore that limits number of concurrent executions.
-     * <p>
-     * Fallback implementations shouldn't perform anything that can be blocking, but we protect against it anyways in case someone doesn't abide by the contract.
-     * <p>
-     * If something in the <code>getFallback()</code> implementation is latent (such as a network call) then the semaphore will cause us to start rejecting requests rather than allowing potentially
-     * all threads to pile up and block.
-     * 
-     * @return K
-     * @throws UnsupportedOperationException
-     *             if getFallback() not implemented
-     * @throws HystrixException
-     *             if getFallback() fails (throws an Exception) or is rejected by the semaphore
-     */
-    private Observable<R> getFallbackWithProtection() {
-        final TryableSemaphore fallbackSemaphore = getFallbackSemaphore();
-
-        // acquire a permit
-        if (fallbackSemaphore.tryAcquire()) {
-            executionHook.onFallbackStart(this);
-            final HystrixObservableCommand<R> _cmd = this;
-
-            Observable<R> fallback = null;
-            try {
-                fallback = getFallback();
-            } catch (Throwable t) {
-                // getFallback() is user provided and can throw so we catch it and turn it into Observable.error
-                fallback = Observable.error(t);
-            }
-
-            return fallback.map(new Func1<R, R>() {
-
-                @Override
-                public R call(R t1) {
-                    // allow transforming the value
-                    return executionHook.onFallbackSuccess(_cmd, t1);
-                }
-
-            }).onErrorResumeNext(new Func1<Throwable, Observable<R>>() {
-
-                @Override
-                public Observable<R> call(Throwable t) {
-                    Exception e = getExceptionFromThrowable(t);
-                    Exception decorated = executionHook.onFallbackError(_cmd, e);
-
-                    if (decorated instanceof RuntimeException) {
-                        e = (RuntimeException) decorated;
-                    } else {
-                        logger.warn("ExecutionHook.onFallbackError returned an exception that was not an instance of RuntimeException so will be ignored.", decorated);
-                    }
-                    return Observable.error(e);
-                }
-
-            }).doOnTerminate(new Action0() {
-
-                @Override
-                public void call() {
-                    fallbackSemaphore.release();
-                }
-
-            });
-        } else {
-            metrics.markFallbackRejection();
-
-            logger.debug("HystrixCommand Fallback Rejection."); // debug only since we're throwing the exception and someone higher will do something with it
-            // if we couldn't acquire a permit, we "fail fast" by throwing an exception
-            return Observable.error(new HystrixRuntimeException(FailureType.REJECTED_SEMAPHORE_FALLBACK, this.getClass(), getLogMessagePrefix() + " fallback execution rejected.", null, null));
-        }
-    }
-
-    /**
-     * @throws HystrixRuntimeException
-     */
-    private Observable<R> getFallbackOrThrowException(HystrixEventType eventType, FailureType failureType, String message) {
-        return getFallbackOrThrowException(eventType, failureType, message, null);
+    @Override
+    final protected Observable<R> getExecutionObservable() {
+        return construct();
     }
-
-    /**
-     * @throws HystrixRuntimeException
-     */
-    private Observable<R> getFallbackOrThrowException(final HystrixEventType eventType, final FailureType failureType, final String message, final Exception originalException) {
-        final HystrixRequestContext currentRequestContext = HystrixRequestContext.getContextForCurrentThread();
-
-        if (properties.fallbackEnabled().get()) {
-            /* fallback behavior is permitted so attempt */
-            // record the executionResult
-            // do this before executing fallback so it can be queried from within getFallback (see See https://github.com/Netflix/Hystrix/pull/144)
-            executionResult = executionResult.addEvents(eventType);
-            final HystrixObservableCommand<R> _cmd = this;
-
-            return getFallbackWithProtection().map(new Func1<R, R>() {
-
-                @Override
-                public R call(R t1) {
-                    return executionHook.onComplete(_cmd, t1);
-                }
-
-            }).doOnCompleted(new Action0() {
-
-                @Override
-                public void call() {
-                    // mark fallback on counter
-                    metrics.markFallbackSuccess();
-                    // record the executionResult
-                    executionResult = executionResult.addEvents(HystrixEventType.FALLBACK_SUCCESS);
-                }
-
-            }).onErrorResumeNext(new Func1<Throwable, Observable<R>>() {
-
-                @Override
-                public Observable<R> call(Throwable t) {
-                    Exception e = originalException;
-                    Exception fe = getExceptionFromThrowable(t);
-
-                    if (fe instanceof UnsupportedOperationException) {
-                        logger.debug("No fallback for HystrixCommand. ", fe); // debug only since we're throwing the exception and someone higher will do something with it
-
-                        /* executionHook for all errors */
-                        try {
-                            e = executionHook.onError(_cmd, failureType, e);
-                        } catch (Exception hookException) {
-                            logger.warn("Error calling ExecutionHook.onError", hookException);
-                        }
-
-                        return Observable.error(new HystrixRuntimeException(failureType, _cmd.getClass(), getLogMessagePrefix() + " " + message + " and no fallback available.", e, fe));
-                    } else {
-                        logger.debug("HystrixCommand execution " + failureType.name() + " and fallback retrieval failed.", fe);
-                        metrics.markFallbackFailure();
-                        // record the executionResult
-                        executionResult = executionResult.addEvents(HystrixEventType.FALLBACK_FAILURE);
-
-                        /* executionHook for all errors */
-                        try {
-                            e = executionHook.onError(_cmd, failureType, e);
-                        } catch (Exception hookException) {
-                            logger.warn("Error calling ExecutionHook.onError", hookException);
-                        }
-
-                        return Observable.error(new HystrixRuntimeException(failureType, _cmd.getClass(), getLogMessagePrefix() + " " + message + " and failed retrieving fallback.", e, fe));
-                    }
-                }
-
-            }).doOnTerminate(new Action0() {
-
-                @Override
-                public void call() {
-                    // record that we're completed (to handle non-successful events we do it here as well as at the end of executeCommand
-                    isExecutionComplete.set(true);
-                }
-
-            }).doOnEach(new Action1<Notification<? super R>>() {
-
-                @Override
-                public void call(Notification<? super R> n) {
-                    setRequestContextIfNeeded(currentRequestContext);
-                }
-
-            });
-        } else {
-            /* fallback is disabled so throw HystrixRuntimeException */
-            Exception e = originalException;
-
-            logger.debug("Fallback disabled for HystrixCommand so will throw HystrixRuntimeException. ", e); // debug only since we're throwing the exception and someone higher will do something with it
-            // record the executionResult
-            executionResult = executionResult.addEvents(eventType);
-
-            /* executionHook for all errors */
-            try {
-                e = executionHook.onError(this, failureType, e);
-            } catch (Exception hookException) {
-                logger.warn("Error calling ExecutionHook.onError", hookException);
-            }
-            return Observable.<R> error(new HystrixRuntimeException(failureType, this.getClass(), getLogMessagePrefix() + " " + message + " and fallback disabled.", e, null)).doOnTerminate(new Action0() {
-
-                @Override
-                public void call() {
-                    // record that we're completed (to handle non-successful events we do it here as well as at the end of executeCommand
-                    isExecutionComplete.set(true);
-                }
-
-            }).doOnEach(new Action1<Notification<? super R>>() {
-
-                @Override
-                public void call(Notification<? super R> n) {
-                    setRequestContextIfNeeded(currentRequestContext);
-                }
-
-            });
-        }
-    }
-
-    private static class HystrixObservableTimeoutOperator<R> implements Operator<R, R> {
-
-        final HystrixObservableCommand<R> originalCommand;
-        final boolean isNonBlocking;
-
-        public HystrixObservableTimeoutOperator(final HystrixObservableCommand<R> originalCommand, final boolean isNonBlocking) {
-            this.originalCommand = originalCommand;
-            this.isNonBlocking = isNonBlocking;
-        }
-
-        public static class HystrixTimeoutException extends Exception {
-
-            private static final long serialVersionUID = 7460860948388895401L;
-
-        }
-
-        @Override
-        public Subscriber<? super R> call(final Subscriber<? super R> child) {
-            final CompositeSubscription s = new CompositeSubscription();
-            // if the child unsubscribes we unsubscribe our parent as well
-            child.add(s);
-
-            /*
-             * Define the action to perform on timeout outside of the TimerListener to it can capture the HystrixRequestContext
-             * of the calling thread which doesn't exist on the Timer thread.
-             */
-            final HystrixContextRunnable timeoutRunnable = new HystrixContextRunnable(originalCommand.concurrencyStrategy, new Runnable() {
-
-                @Override
-                public void run() {
-                    child.onError(new HystrixTimeoutException());
-                }
-            });
-
-            TimerListener listener = new TimerListener() {
-
-                @Override
-                public void tick() {
-                    // if we can go from NOT_EXECUTED to TIMED_OUT then we do the timeout codepath
-                    // otherwise it means we lost a race and the run() execution completed
-                    if (originalCommand.isCommandTimedOut.compareAndSet(TimedOutStatus.NOT_EXECUTED, TimedOutStatus.TIMED_OUT)) {
-                        // do fallback logic
-                        // report timeout failure
-                        originalCommand.metrics.markTimeout(System.currentTimeMillis() - originalCommand.invocationStartTime);
-
-                        // we record execution time because we are returning before 
-                        originalCommand.recordTotalExecutionTime(originalCommand.invocationStartTime);
-
-                        // shut down the original request
-                        s.unsubscribe();
-
-                        timeoutRunnable.run();
-                    }
-
-                }
-
-                @Override
-                public int getIntervalTimeInMilliseconds() {
-                    return originalCommand.properties.executionIsolationThreadTimeoutInMilliseconds().get();
-                }
-            };
-
-            Reference<TimerListener> _tl = null;
-            if (isNonBlocking) {
-                /*
-                 * Scheduling a separate timer to do timeouts is more expensive
-                 * so we'll only do it if we're being used in a non-blocking manner.
-                 */
-                _tl = HystrixTimer.getInstance().addTimerListener(listener);
-            } else {
-                /*
-                 * Otherwise we just set the hook that queue().get() can trigger if a timeout occurs.
-                 * 
-                 * This allows the blocking and non-blocking approaches to be coded basically the same way
-                 * though it is admittedly awkward if we were just blocking (the use of Reference annoys me for example)
-                 */
-                _tl = new SoftReference<TimerListener>(listener);
-            }
-            final Reference<TimerListener> tl = _tl;
-
-            // set externally so execute/queue can see this
-            originalCommand.timeoutTimer.set(tl);
-
-            /**
-             * If this subscriber receives values it means the parent succeeded/completed
-             */
-            Subscriber<R> parent = new Subscriber<R>() {
-
-                @Override
-                public void onCompleted() {
-                    if (isNotTimedOut()) {
-                        // stop timer and pass notification through
-                        tl.clear();
-                        child.onCompleted();
-                    }
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    if (isNotTimedOut()) {
-                        // stop timer and pass notification through
-                        tl.clear();
-                        child.onError(e);
-                    }
-                }
-
-                @Override
-                public void onNext(R v) {
-                    if (isNotTimedOut()) {
-                        child.onNext(v);
-                    }
-                }
-
-                private boolean isNotTimedOut() {
-                    // if already marked COMPLETED (by onNext) or succeeds in setting to COMPLETED
-                    return originalCommand.isCommandTimedOut.get() == TimedOutStatus.COMPLETED ||
-                            originalCommand.isCommandTimedOut.compareAndSet(TimedOutStatus.NOT_EXECUTED, TimedOutStatus.COMPLETED);
-                }
-
-            };
-            
-            // if s is unsubscribed we want to unsubscribe the parent
-            s.add(parent);
-            
-            return parent;
-        }
-
-    }
-
-    private static void setRequestContextIfNeeded(final HystrixRequestContext currentRequestContext) {
-        if (!HystrixRequestContext.isCurrentThreadInitialized()) {
-            // even if the user Observable doesn't have context we want it set for chained operators
-            HystrixRequestContext.setContextOnCurrentThread(currentRequestContext);
-        }
+    
+    @Override
+    final protected Observable<R> getFallbackObservable() {
+        return onFailureResumeWithFallback();
     }
 }
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixRequestLog.java b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixRequestLog.java
index bdc0d62c8..2bd58f605 100644
--- a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixRequestLog.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixRequestLog.java
@@ -129,9 +129,9 @@ public Collection<HystrixExecutableInfo<?>> getAllExecutedCommands() {
         }
 
         // TODO remove this when deprecation completed
-        if (command instanceof HystrixCommand.HystrixCommandFromObservableCommand) {
+        if (command instanceof HystrixCommand) {
             @SuppressWarnings("rawtypes")
-            HystrixCommand<?> _c = ((HystrixCommand.HystrixCommandFromObservableCommand) command).getOriginal();
+            HystrixCommand<?> _c = (HystrixCommand) command;
             if (!executedCommands.offer(_c)) {
                 // see RequestLog: Reduce Chance of Memory Leak https://github.com/Netflix/Hystrix/issues/53
                 logger.warn("RequestLog ignoring command after reaching limit of " + MAX_STORAGE + ". See https://github.com/Netflix/Hystrix/issues/53 for more information.");
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixThreadPoolProperties.java b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixThreadPoolProperties.java
index aa88eecb8..3c02f10a7 100644
--- a/hystrix-core/src/main/java/com/netflix/hystrix/HystrixThreadPoolProperties.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/HystrixThreadPoolProperties.java
@@ -15,7 +15,7 @@
  */
 package com.netflix.hystrix;
 
-import static com.netflix.hystrix.strategy.properties.HystrixProperty.Factory.*;
+import static com.netflix.hystrix.strategy.properties.HystrixProperty.Factory.asProperty;
 
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/collapser/RequestBatch.java b/hystrix-core/src/main/java/com/netflix/hystrix/collapser/RequestBatch.java
index 95bb9c4c6..c6a47812e 100644
--- a/hystrix-core/src/main/java/com/netflix/hystrix/collapser/RequestBatch.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/collapser/RequestBatch.java
@@ -10,8 +10,8 @@
 import org.slf4j.LoggerFactory;
 
 import rx.Observable;
-import rx.Observer;
-import rx.functions.*;
+import rx.functions.Action0;
+import rx.functions.Action1;
 
 import com.netflix.hystrix.HystrixCollapser;
 import com.netflix.hystrix.HystrixCollapser.CollapsedRequest;
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/collapser/RequestCollapserFactory.java b/hystrix-core/src/main/java/com/netflix/hystrix/collapser/RequestCollapserFactory.java
index f94b98ce7..822e2e9df 100644
--- a/hystrix-core/src/main/java/com/netflix/hystrix/collapser/RequestCollapserFactory.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/collapser/RequestCollapserFactory.java
@@ -6,7 +6,6 @@
 import org.slf4j.LoggerFactory;
 
 import com.netflix.hystrix.HystrixCollapser;
-import com.netflix.hystrix.HystrixCollapser.Scope;
 import com.netflix.hystrix.HystrixCollapserKey;
 import com.netflix.hystrix.HystrixCollapserProperties;
 import com.netflix.hystrix.strategy.HystrixPlugins;
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/exception/HystrixRuntimeException.java b/hystrix-core/src/main/java/com/netflix/hystrix/exception/HystrixRuntimeException.java
index 0792dbd45..6c1dd5052 100644
--- a/hystrix-core/src/main/java/com/netflix/hystrix/exception/HystrixRuntimeException.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/exception/HystrixRuntimeException.java
@@ -16,7 +16,7 @@
 package com.netflix.hystrix.exception;
 
 import com.netflix.hystrix.HystrixCommand;
-import com.netflix.hystrix.HystrixExecutable;
+import com.netflix.hystrix.HystrixInvokable;
 import com.netflix.hystrix.util.ExceptionThreadingUtility;
 
 /**
@@ -27,7 +27,7 @@ public class HystrixRuntimeException extends RuntimeException {
 
     private static final long serialVersionUID = 5219160375476046229L;
 
-    private final Class<? extends HystrixExecutable> commandClass;
+    private final Class<? extends HystrixInvokable> commandClass;
     private final Throwable fallbackException;
     private final FailureType failureCause;
 
@@ -35,7 +35,7 @@ public static enum FailureType {
         COMMAND_EXCEPTION, TIMEOUT, SHORTCIRCUIT, REJECTED_THREAD_EXECUTION, REJECTED_SEMAPHORE_EXECUTION, REJECTED_SEMAPHORE_FALLBACK
     }
 
-    public HystrixRuntimeException(FailureType failureCause, Class<? extends HystrixExecutable> commandClass, String message, Exception cause, Throwable fallbackException) {
+    public HystrixRuntimeException(FailureType failureCause, Class<? extends HystrixInvokable> commandClass, String message, Exception cause, Throwable fallbackException) {
         super(message, cause);
         this.failureCause = failureCause;
         this.commandClass = commandClass;
@@ -43,7 +43,7 @@ public HystrixRuntimeException(FailureType failureCause, Class<? extends Hystrix
         ExceptionThreadingUtility.attachCallingThreadStack(this);
     }
 
-    public HystrixRuntimeException(FailureType failureCause, Class<? extends HystrixExecutable> commandClass, String message, Throwable cause, Throwable fallbackException) {
+    public HystrixRuntimeException(FailureType failureCause, Class<? extends HystrixInvokable> commandClass, String message, Throwable cause, Throwable fallbackException) {
         super(message, cause);
         this.failureCause = failureCause;
         this.commandClass = commandClass;
@@ -65,7 +65,7 @@ public FailureType getFailureType() {
      * 
      * @return {@code Class<? extends HystrixCommand> }
      */
-    public Class<? extends HystrixExecutable> getImplementingClass() {
+    public Class<? extends HystrixInvokable> getImplementingClass() {
         return commandClass;
     }
 
diff --git a/hystrix-core/src/main/java/com/netflix/hystrix/strategy/executionhook/HystrixCommandExecutionHook.java b/hystrix-core/src/main/java/com/netflix/hystrix/strategy/executionhook/HystrixCommandExecutionHook.java
index 1ce80d9b4..2dc847426 100644
--- a/hystrix-core/src/main/java/com/netflix/hystrix/strategy/executionhook/HystrixCommandExecutionHook.java
+++ b/hystrix-core/src/main/java/com/netflix/hystrix/strategy/executionhook/HystrixCommandExecutionHook.java
@@ -17,7 +17,7 @@
 
 import com.netflix.hystrix.HystrixCommand;
 import com.netflix.hystrix.HystrixCommandProperties.ExecutionIsolationStrategy;
-import com.netflix.hystrix.HystrixExecutable;
+import com.netflix.hystrix.HystrixInvokable;
 import com.netflix.hystrix.exception.HystrixRuntimeException;
 import com.netflix.hystrix.exception.HystrixRuntimeException.FailureType;
 import com.netflix.hystrix.strategy.HystrixPlugins;
@@ -52,7 +52,7 @@ public <T> void onRunStart(HystrixCommand<T> commandInstance) {
         // do nothing by default
     }
 
-    public <T> void onRunStart(HystrixExecutable<T> commandInstance) {
+    public <T> void onRunStart(HystrixInvokable<T> commandInstance) {
         // do nothing by default
     }
 
@@ -73,7 +73,7 @@ public <T> T onRunSuccess(HystrixCommand<T> commandInstance, T response) {
         return response;
     }
 
-    public <T> T onRunSuccess(HystrixExecutable<T> commandInstance, T response) {
+    public <T> T onRunSuccess(HystrixInvokable<T> commandInstance, T response) {
         // pass-thru by default
         return response;
     }
@@ -95,7 +95,7 @@ public <T> Exception onRunError(HystrixCommand<T> commandInstance, Exception e)
         return e;
     }
 
-    public <T> Exception onRunError(HystrixExecutable<T> commandInstance, Exception e) {
+    public <T> Exception onRunError(HystrixInvokable<T> commandInstance, Exception e) {
         // pass-thru by default
         return e;
     }
@@ -113,7 +113,7 @@ public <T> void onFallbackStart(HystrixCommand<T> commandInstance) {
         // do nothing by default
     }
 
-    public <T> void onFallbackStart(HystrixExecutable<T> commandInstance) {
+    public <T> void onFallbackStart(HystrixInvokable<T> commandInstance) {
         // do nothing by default
     }
 
@@ -134,7 +134,7 @@ public <T> T onFallbackSuccess(HystrixCommand<T> commandInstance, T fallbackResp
         return fallbackResponse;
     }
 
-    public <T> T onFallbackSuccess(HystrixExecutable<T> commandInstance, T fallbackResponse) {
+    public <T> T onFallbackSuccess(HystrixInvokable<T> commandInstance, T fallbackResponse) {
         // pass-thru by default
         return fallbackResponse;
     }
@@ -156,7 +156,7 @@ public <T> Exception onFallbackError(HystrixCommand<T> commandInstance, Exceptio
         return e;
     }
 
-    public <T> Exception onFallbackError(HystrixExecutable<T> commandInstance, Exception e) {
+    public <T> Exception onFallbackError(HystrixInvokable<T> commandInstance, Exception e) {
         // pass-thru by default
         return e;
     }
@@ -174,7 +174,7 @@ public <T> void onStart(HystrixCommand<T> commandInstance) {
         // do nothing by default
     }
 
-    public <T> void onStart(HystrixExecutable<T> commandInstance) {
+    public <T> void onStart(HystrixInvokable<T> commandInstance) {
         // do nothing by default
     }
 
@@ -197,7 +197,7 @@ public <T> T onComplete(HystrixCommand<T> commandInstance, T response) {
         return response;
     }
 
-    public <T> T onComplete(HystrixExecutable<T> commandInstance, T response) {
+    public <T> T onComplete(HystrixInvokable<T> commandInstance, T response) {
         // pass-thru by default
         return response;
     }
@@ -223,7 +223,7 @@ public <T> Exception onError(HystrixCommand<T> commandInstance, FailureType fail
         return e;
     }
 
-    public <T> Exception onError(HystrixExecutable<T> commandInstance, FailureType failureType, Exception e) {
+    public <T> Exception onError(HystrixInvokable<T> commandInstance, FailureType failureType, Exception e) {
         // pass-thru by default
         return e;
     }
@@ -241,7 +241,7 @@ public <T> void onThreadStart(HystrixCommand<T> commandInstance) {
         // do nothing by default
     }
 
-    public <T> void onThreadStart(HystrixExecutable<T> commandInstance) {
+    public <T> void onThreadStart(HystrixInvokable<T> commandInstance) {
         // do nothing by default
     }
 
@@ -258,7 +258,7 @@ public <T> void onThreadComplete(HystrixCommand<T> commandInstance) {
         // do nothing by default
     }
 
-    public <T> void onThreadComplete(HystrixExecutable<T> commandInstance) {
+    public <T> void onThreadComplete(HystrixInvokable<T> commandInstance) {
         // do nothing by default
     }
 
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixAsyncCommandTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixAsyncCommandTest.java
new file mode 100644
index 000000000..375b64fcc
--- /dev/null
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixAsyncCommandTest.java
@@ -0,0 +1,7084 @@
+package com.netflix.hystrix;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import rx.Notification;
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Observer;
+import rx.Scheduler;
+import rx.Subscriber;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.observers.TestSubscriber;
+import rx.schedulers.Schedulers;
+
+import com.netflix.config.ConfigurationManager;
+import com.netflix.hystrix.AbstractCommand.TryableSemaphoreActual;
+import com.netflix.hystrix.HystrixCircuitBreakerTest.TestCircuitBreaker;
+import com.netflix.hystrix.HystrixCommandProperties.ExecutionIsolationStrategy;
+import com.netflix.hystrix.exception.HystrixBadRequestException;
+import com.netflix.hystrix.exception.HystrixRuntimeException;
+import com.netflix.hystrix.exception.HystrixRuntimeException.FailureType;
+import com.netflix.hystrix.strategy.HystrixPlugins;
+import com.netflix.hystrix.strategy.concurrency.HystrixContextRunnable;
+import com.netflix.hystrix.strategy.concurrency.HystrixContextScheduler;
+import com.netflix.hystrix.strategy.concurrency.HystrixRequestContext;
+import com.netflix.hystrix.strategy.executionhook.HystrixCommandExecutionHook;
+import com.netflix.hystrix.strategy.properties.HystrixPropertiesStrategy;
+import com.netflix.hystrix.strategy.properties.HystrixProperty;
+import com.netflix.hystrix.util.HystrixRollingNumberEvent;
+
+public class HystrixAsyncCommandTest {
+
+    @Before
+    public void prepareForTest() {
+        /* we must call this to simulate a new request lifecycle running and clearing caches */
+        HystrixRequestContext.initializeContext();
+    }
+
+    @After
+    public void cleanup() {
+        // instead of storing the reference from initialize we'll just get the current state and shutdown
+        if (HystrixRequestContext.getContextForCurrentThread() != null) {
+            // it could have been set NULL by the test
+            HystrixRequestContext.getContextForCurrentThread().shutdown();
+        }
+
+        // force properties to be clean as well
+        ConfigurationManager.getConfigInstance().clear();
+
+        /*
+         * RxJava will create one worker for each processor when we schedule Observables in the
+         * Schedulers.computation(). Any leftovers here might lead to a congestion in a following
+         * thread. To ensure all existing threads have completed we now schedule some observables
+         * that will execute in distinct threads due to the latch..
+         */
+        int count = Runtime.getRuntime().availableProcessors();
+        final CountDownLatch latch = new CountDownLatch(count);
+        ArrayList<Future<Boolean>> futures = new ArrayList<Future<Boolean>>();
+        for (int i = 0; i < count; ++i) {
+            futures.add(Observable.create(new OnSubscribe<Boolean>() {
+                @Override
+                public void call(Subscriber<? super Boolean> sub) {
+                    latch.countDown();
+                    try {
+                        latch.await();
+                        sub.onNext(true);
+                        sub.onCompleted();
+                    } catch (InterruptedException e) {
+                        sub.onError(e);
+                    }
+                }
+            }).subscribeOn(Schedulers.computation()).toBlocking().toFuture());
+        }
+        for (Future<Boolean> future : futures) {
+            try {
+                future.get();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            } catch (ExecutionException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        //TODO commented out as it has issues when built from command-line even though it works from IDE
+        //        HystrixCommandKey key = Hystrix.getCurrentThreadExecutingCommand();
+        //        if (key != null) {
+        //            throw new IllegalStateException("should be null but got: " + key);
+        //        }
+    }
+
+    /**
+     * Test a successful command execution.
+     */
+    @Test
+    public void testExecutionSuccess() {
+        try {
+            TestHystrixCommand<Boolean> command = new SuccessfulTestCommand();
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+            assertEquals(true, command.observe().toBlocking().single());
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+
+            assertEquals(null, command.getFailedExecutionException());
+
+            assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+            assertTrue(command.isSuccessfulExecution());
+
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+            assertEquals(0, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+            assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+            // semaphore isolated
+            assertFalse(command.isExecutedInThread());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We received an exception.");
+        }
+    }
+
+    /**
+     * Test that a command can not be executed multiple times.
+     */
+    @Test
+    public void testExecutionMultipleTimes() {
+        SuccessfulTestCommand command = new SuccessfulTestCommand();
+        assertFalse(command.isExecutionComplete());
+        // first should succeed
+        assertEquals(true, command.observe().toBlocking().single());
+        System.out.println(">> completed, checking metrics");
+        assertTrue(command.isExecutionComplete());
+        assertFalse(command.isExecutedInThread());
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isSuccessfulExecution());
+        try {
+            // second should fail
+            command.observe().toBlocking().single();
+            fail("we should not allow this ... it breaks the state of request logs");
+        } catch (IllegalStateException e) {
+            e.printStackTrace();
+            // we want to get here
+        }
+
+        try {
+            // queue should also fail
+            command.observe().toBlocking().toFuture();
+            fail("we should not allow this ... it breaks the state of request logs");
+        } catch (IllegalStateException e) {
+            e.printStackTrace();
+            // we want to get here
+        }
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a command execution that throws an HystrixException and didn't implement getFallback.
+     */
+    @Test
+    public void testExecutionKnownFailureWithNoFallback() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithoutFallback(circuitBreaker);
+        try {
+            command.observe().toBlocking().single();
+            fail("we shouldn't get here");
+        } catch (HystrixRuntimeException e) {
+            e.printStackTrace();
+            assertNotNull(e.getFallbackException());
+            assertNotNull(e.getImplementingClass());
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We should always get an HystrixRuntimeException when an error occurs.");
+        }
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a command execution that throws an unknown exception (not HystrixException) and didn't implement getFallback.
+     */
+    @Test
+    public void testExecutionUnknownFailureWithNoFallback() {
+        TestHystrixCommand<Boolean> command = new UnknownFailureTestCommandWithoutFallback();
+        try {
+            command.observe().toBlocking().single();
+            fail("we shouldn't get here");
+        } catch (HystrixRuntimeException e) {
+            e.printStackTrace();
+            assertNotNull(e.getFallbackException());
+            assertNotNull(e.getImplementingClass());
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We should always get an HystrixRuntimeException when an error occurs.");
+        }
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a command execution that fails but has a fallback.
+     */
+    @Test
+    public void testExecutionFailureWithFallback() {
+        TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithFallback(new TestCircuitBreaker());
+        try {
+            assertEquals(false, command.observe().toBlocking().single());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We should have received a response from the fallback.");
+        }
+
+        assertEquals("we failed with a simulated issue", command.getFailedExecutionException().getMessage());
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a command execution that fails, has getFallback implemented but that fails as well.
+     */
+    @Test
+    public void testExecutionFailureWithFallbackFailure() {
+        TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithFallbackFailure();
+        try {
+            command.observe().toBlocking().single();
+            fail("we shouldn't get here");
+        } catch (HystrixRuntimeException e) {
+            System.out.println("------------------------------------------------");
+            e.printStackTrace();
+            System.out.println("------------------------------------------------");
+            assertNotNull(e.getFallbackException());
+        }
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a successful command execution (asynchronously).
+     */
+    @Test
+    public void testQueueSuccess() {
+        TestHystrixCommand<Boolean> command = new SuccessfulTestCommand();
+        try {
+            Future<Boolean> future = command.observe().toBlocking().toFuture();
+            assertEquals(true, future.get());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We received an exception.");
+        }
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isSuccessfulExecution());
+
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(0, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a command execution (asynchronously) that throws an HystrixException and didn't implement getFallback.
+     */
+    @Test
+    public void testQueueKnownFailureWithNoFallback() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithoutFallback(circuitBreaker);
+        try {
+            command.observe().toBlocking().toFuture().get();
+            fail("we shouldn't get here");
+        } catch (Exception e) {
+            e.printStackTrace();
+            if (e.getCause() instanceof HystrixRuntimeException) {
+                HystrixRuntimeException de = (HystrixRuntimeException) e.getCause();
+
+                assertNotNull(de.getFallbackException());
+                assertNotNull(de.getImplementingClass());
+            } else {
+                fail("the cause should be HystrixRuntimeException");
+            }
+        }
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a command execution (asynchronously) that throws an unknown exception (not HystrixException) and didn't implement getFallback.
+     */
+    @Test
+    public void testQueueUnknownFailureWithNoFallback() {
+        TestHystrixCommand<Boolean> command = new UnknownFailureTestCommandWithoutFallback();
+        try {
+            command.observe().toBlocking().toFuture().get();
+            fail("we shouldn't get here");
+        } catch (Exception e) {
+            e.printStackTrace();
+            if (e.getCause() instanceof HystrixRuntimeException) {
+                HystrixRuntimeException de = (HystrixRuntimeException) e.getCause();
+                assertNotNull(de.getFallbackException());
+                assertNotNull(de.getImplementingClass());
+            } else {
+                fail("the cause should be HystrixRuntimeException");
+            }
+        }
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a command execution (asynchronously) that fails but has a fallback.
+     */
+    @Test
+    public void testQueueFailureWithFallback() {
+        TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithFallback(new TestCircuitBreaker());
+        try {
+            Future<Boolean> future = command.observe().toBlocking().toFuture();
+            assertEquals(false, future.get());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We should have received a response from the fallback.");
+        }
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a command execution (asynchronously) that fails, has getFallback implemented but that fails as well.
+     */
+    @Test
+    public void testQueueFailureWithFallbackFailure() {
+        TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithFallbackFailure();
+        try {
+            command.observe().toBlocking().toFuture().get();
+            fail("we shouldn't get here");
+        } catch (Exception e) {
+            if (e.getCause() instanceof HystrixRuntimeException) {
+                HystrixRuntimeException de = (HystrixRuntimeException) e.getCause();
+                e.printStackTrace();
+                assertNotNull(de.getFallbackException());
+            } else {
+                fail("the cause should be HystrixRuntimeException");
+            }
+        }
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a successful command execution.
+     */
+    @Test
+    public void testObserveSuccess() {
+        try {
+            TestHystrixCommand<Boolean> command = new SuccessfulTestCommand();
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+
+            assertEquals(true, command.observe().toBlocking().single());
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+
+            assertEquals(null, command.getFailedExecutionException());
+
+            assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+            assertTrue(command.isSuccessfulExecution());
+
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+            assertEquals(0, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+            assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+            // semaphore isolated
+            assertFalse(command.isExecutedInThread());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We received an exception.");
+        }
+    }
+
+    /**
+     * Test a successful command execution.
+     * 
+     * @Test
+     *       public void testObserveOnScheduler() throws Exception {
+     * 
+     *       System.out.println("test observeOn begins");
+     *       final AtomicReference<Thread> commandThread = new AtomicReference<Thread>();
+     *       final AtomicReference<Thread> subscribeThread = new AtomicReference<Thread>();
+     * 
+     *       TestHystrixCommand<Boolean> command = new TestHystrixCommand<Boolean>(TestHystrixCommand.testPropsBuilder()) {
+     * @Override
+     *           protected Observable<Boolean> run() {
+     *           commandThread.set(Thread.currentThread());
+     *           return Observable.just(true);
+     *           }
+     *           };
+     * 
+     *           final CountDownLatch latch = new CountDownLatch(1);
+     * 
+     *           Scheduler customScheduler = new Scheduler() {
+     * 
+     *           private final Scheduler self = this;
+     * @Override
+     *           public <T> Subscription schedule(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> action) {
+     *           return schedule(state, action, 0, TimeUnit.MILLISECONDS);
+     *           }
+     * @Override
+     *           public <T> Subscription schedule(final T state, final Func2<? super Scheduler, ? super T, ? extends Subscription> action, long delayTime, TimeUnit unit) {
+     *           new Thread("RxScheduledThread") {
+     * @Override
+     *           public void run() {
+     *           System.out.println("in schedule");
+     *           action.call(self, state);
+     *           }
+     *           }.start();
+     * 
+     *           // not testing unsubscribe behavior
+     *           return Subscriptions.empty();
+     *           }
+     * 
+     *           };
+     * 
+     *           command.toObservable(customScheduler).subscribe(new Observer<Boolean>() {
+     * @Override
+     *           public void onCompleted() {
+     *           latch.countDown();
+     * 
+     *           }
+     * @Override
+     *           public void onError(Throwable e) {
+     *           latch.countDown();
+     *           e.printStackTrace();
+     * 
+     *           }
+     * @Override
+     *           public void onNext(Boolean args) {
+     *           subscribeThread.set(Thread.currentThread());
+     *           }
+     *           });
+     * 
+     *           if (!latch.await(2000, TimeUnit.MILLISECONDS)) {
+     *           fail("timed out");
+     *           }
+     * 
+     *           assertNotNull(commandThread.get());
+     *           assertNotNull(subscribeThread.get());
+     * 
+     *           System.out.println("subscribeThread: " + subscribeThread.get().getName());
+     *           assertTrue(commandThread.get().getName().startsWith("main"));
+     *           //assertTrue(subscribeThread.get().getName().equals("RxScheduledThread"));
+     *           assertTrue(subscribeThread.get().getName().equals("main"));
+     *           }
+     */
+    /**
+     * Test a successful command execution.
+     * 
+     * @Test
+     *       public void testObserveOnComputationSchedulerByDefaultForThreadIsolation() throws Exception {
+     * 
+     *       final AtomicReference<Thread> commandThread = new AtomicReference<Thread>();
+     *       final AtomicReference<Thread> subscribeThread = new AtomicReference<Thread>();
+     * 
+     *       TestHystrixCommand<Boolean> command = new TestHystrixCommand<Boolean>(TestHystrixCommand.testPropsBuilder()) {
+     * @Override
+     *           protected Observable<Boolean> run() {
+     *           commandThread.set(Thread.currentThread());
+     *           return Observable.just(true);
+     *           }
+     *           };
+     * 
+     *           final CountDownLatch latch = new CountDownLatch(1);
+     * 
+     *           command.toObservable().subscribe(new Observer<Boolean>() {
+     * @Override
+     *           public void onCompleted() {
+     *           latch.countDown();
+     * 
+     *           }
+     * @Override
+     *           public void onError(Throwable e) {
+     *           latch.countDown();
+     *           e.printStackTrace();
+     * 
+     *           }
+     * @Override
+     *           public void onNext(Boolean args) {
+     *           subscribeThread.set(Thread.currentThread());
+     *           }
+     *           });
+     * 
+     *           if (!latch.await(2000, TimeUnit.MILLISECONDS)) {
+     *           fail("timed out");
+     *           }
+     * 
+     *           assertNotNull(commandThread.get());
+     *           assertNotNull(subscribeThread.get());
+     * 
+     *           System.out.println("Command Thread: " + commandThread.get());
+     *           System.out.println("Subscribe Thread: " + subscribeThread.get());
+     * 
+     *           //assertTrue(commandThread.get().getName().startsWith("hystrix-"));
+     *           //assertTrue(subscribeThread.get().getName().startsWith("RxComputationThreadPool"));
+     * 
+     *           assertTrue(commandThread.get().getName().startsWith("main"));
+     *           assertTrue(subscribeThread.get().getName().startsWith("main"));
+     *           }
+     */
+
+    /**
+     * Test a successful command execution.
+     */
+    @Test
+    public void testObserveOnImmediateSchedulerByDefaultForSemaphoreIsolation() throws Exception {
+
+        final AtomicReference<Thread> commandThread = new AtomicReference<Thread>();
+        final AtomicReference<Thread> subscribeThread = new AtomicReference<Thread>();
+
+        TestHystrixCommand<Boolean> command = new TestHystrixCommand<Boolean>(TestHystrixCommand.testPropsBuilder()
+                .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE))) {
+
+            @Override
+            protected HystrixFuture<Boolean> run() {
+                commandThread.set(Thread.currentThread());
+                return HystrixFutureUtil.just(true);
+            }
+        };
+
+        final CountDownLatch latch = new CountDownLatch(1);
+
+        command.toObservable().subscribe(new Observer<Boolean>() {
+
+            @Override
+            public void onCompleted() {
+                latch.countDown();
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                latch.countDown();
+                e.printStackTrace();
+
+            }
+
+            @Override
+            public void onNext(Boolean args) {
+                subscribeThread.set(Thread.currentThread());
+            }
+        });
+
+        if (!latch.await(2000, TimeUnit.MILLISECONDS)) {
+            fail("timed out");
+        }
+
+        assertNotNull(commandThread.get());
+        assertNotNull(subscribeThread.get());
+
+        System.out.println("Command Thread: " + commandThread.get());
+        System.out.println("Subscribe Thread: " + subscribeThread.get());
+
+        String mainThreadName = Thread.currentThread().getName();
+
+        // semaphore should be on the calling thread
+        assertTrue(commandThread.get().getName().equals(mainThreadName));
+        System.out.println("testObserveOnImmediateSchedulerByDefaultForSemaphoreIsolation: " + subscribeThread.get() + " => " + mainThreadName);
+        assertTrue(subscribeThread.get().getName().equals(mainThreadName));
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test that the circuit-breaker will 'trip' and prevent command execution on subsequent calls.
+     */
+    @Test
+    public void testCircuitBreakerTripsAfterFailures() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        /* fail 3 times and then it should trip the circuit and stop executing */
+        // failure 1
+        KnownFailureTestCommandWithFallback attempt1 = new KnownFailureTestCommandWithFallback(circuitBreaker);
+        attempt1.observe().toBlocking().single();
+        assertTrue(attempt1.isResponseFromFallback());
+        assertFalse(attempt1.isCircuitBreakerOpen());
+        assertFalse(attempt1.isResponseShortCircuited());
+
+        // failure 2
+        KnownFailureTestCommandWithFallback attempt2 = new KnownFailureTestCommandWithFallback(circuitBreaker);
+        attempt2.observe().toBlocking().single();
+        assertTrue(attempt2.isResponseFromFallback());
+        assertFalse(attempt2.isCircuitBreakerOpen());
+        assertFalse(attempt2.isResponseShortCircuited());
+
+        // failure 3
+        KnownFailureTestCommandWithFallback attempt3 = new KnownFailureTestCommandWithFallback(circuitBreaker);
+        attempt3.observe().toBlocking().single();
+        assertTrue(attempt3.isResponseFromFallback());
+        assertFalse(attempt3.isResponseShortCircuited());
+        // it should now be 'open' and prevent further executions
+        assertTrue(attempt3.isCircuitBreakerOpen());
+
+        // attempt 4
+        KnownFailureTestCommandWithFallback attempt4 = new KnownFailureTestCommandWithFallback(circuitBreaker);
+        attempt4.observe().toBlocking().single();
+        assertTrue(attempt4.isResponseFromFallback());
+        // this should now be true as the response will be short-circuited
+        assertTrue(attempt4.isResponseShortCircuited());
+        // this should remain open
+        assertTrue(attempt4.isCircuitBreakerOpen());
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(3, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(4, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(4, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    /**
+     * Test that the circuit-breaker will 'trip' and prevent command execution on subsequent calls.
+     */
+    @Test
+    public void testCircuitBreakerTripsAfterFailuresViaQueue() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        try {
+            /* fail 3 times and then it should trip the circuit and stop executing */
+            // failure 1
+            KnownFailureTestCommandWithFallback attempt1 = new KnownFailureTestCommandWithFallback(circuitBreaker);
+            attempt1.observe().toBlocking().toFuture().get();
+            assertTrue(attempt1.isResponseFromFallback());
+            assertFalse(attempt1.isCircuitBreakerOpen());
+            assertFalse(attempt1.isResponseShortCircuited());
+
+            // failure 2
+            KnownFailureTestCommandWithFallback attempt2 = new KnownFailureTestCommandWithFallback(circuitBreaker);
+            attempt2.observe().toBlocking().toFuture().get();
+            assertTrue(attempt2.isResponseFromFallback());
+            assertFalse(attempt2.isCircuitBreakerOpen());
+            assertFalse(attempt2.isResponseShortCircuited());
+
+            // failure 3
+            KnownFailureTestCommandWithFallback attempt3 = new KnownFailureTestCommandWithFallback(circuitBreaker);
+            attempt3.observe().toBlocking().toFuture().get();
+            assertTrue(attempt3.isResponseFromFallback());
+            assertFalse(attempt3.isResponseShortCircuited());
+            // it should now be 'open' and prevent further executions
+            assertTrue(attempt3.isCircuitBreakerOpen());
+
+            // attempt 4
+            KnownFailureTestCommandWithFallback attempt4 = new KnownFailureTestCommandWithFallback(circuitBreaker);
+            attempt4.observe().toBlocking().toFuture().get();
+            assertTrue(attempt4.isResponseFromFallback());
+            // this should now be true as the response will be short-circuited
+            assertTrue(attempt4.isResponseShortCircuited());
+            // this should remain open
+            assertTrue(attempt4.isCircuitBreakerOpen());
+
+            assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+            assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+            assertEquals(3, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+            assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+            assertEquals(4, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+            assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+            assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+            assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+            assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+            assertEquals(100, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+            assertEquals(4, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We should have received fallbacks.");
+        }
+    }
+
+    /**
+     * Test that the circuit-breaker is shared across HystrixCommand objects with the same CommandKey.
+     * <p>
+     * This will test HystrixCommand objects with a single circuit-breaker (as if each injected with same CommandKey)
+     * <p>
+     * Multiple HystrixCommand objects with the same dependency use the same circuit-breaker.
+     */
+    @Test
+    public void testCircuitBreakerAcrossMultipleCommandsButSameCircuitBreaker() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        /* fail 3 times and then it should trip the circuit and stop executing */
+        // failure 1
+        KnownFailureTestCommandWithFallback attempt1 = new KnownFailureTestCommandWithFallback(circuitBreaker);
+        attempt1.observe().toBlocking().single();
+        assertTrue(attempt1.isResponseFromFallback());
+        assertFalse(attempt1.isCircuitBreakerOpen());
+        assertFalse(attempt1.isResponseShortCircuited());
+
+        // failure 2 with a different command, same circuit breaker
+        KnownFailureTestCommandWithoutFallback attempt2 = new KnownFailureTestCommandWithoutFallback(circuitBreaker);
+        try {
+            attempt2.observe().toBlocking().single();
+        } catch (Exception e) {
+            // ignore ... this doesn't have a fallback so will throw an exception
+        }
+        assertTrue(attempt2.isFailedExecution());
+        assertFalse(attempt2.isResponseFromFallback()); // false because no fallback
+        assertFalse(attempt2.isCircuitBreakerOpen());
+        assertFalse(attempt2.isResponseShortCircuited());
+
+        // failure 3 of the Hystrix, 2nd for this particular HystrixCommand
+        KnownFailureTestCommandWithFallback attempt3 = new KnownFailureTestCommandWithFallback(circuitBreaker);
+        attempt3.observe().toBlocking().single();
+        assertTrue(attempt2.isFailedExecution());
+        assertTrue(attempt3.isResponseFromFallback());
+        assertFalse(attempt3.isResponseShortCircuited());
+
+        // it should now be 'open' and prevent further executions
+        // after having 3 failures on the Hystrix that these 2 different HystrixCommand objects are for
+        assertTrue(attempt3.isCircuitBreakerOpen());
+
+        // attempt 4
+        KnownFailureTestCommandWithFallback attempt4 = new KnownFailureTestCommandWithFallback(circuitBreaker);
+        attempt4.observe().toBlocking().single();
+        assertTrue(attempt4.isResponseFromFallback());
+        // this should now be true as the response will be short-circuited
+        assertTrue(attempt4.isResponseShortCircuited());
+        // this should remain open
+        assertTrue(attempt4.isCircuitBreakerOpen());
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(3, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(3, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(4, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    /**
+     * Test that the circuit-breaker is different between HystrixCommand objects with a different Hystrix.
+     */
+    @Test
+    public void testCircuitBreakerAcrossMultipleCommandsAndDifferentDependency() {
+        TestCircuitBreaker circuitBreaker_one = new TestCircuitBreaker();
+        TestCircuitBreaker circuitBreaker_two = new TestCircuitBreaker();
+        /* fail 3 times, twice on one Hystrix, once on a different Hystrix ... circuit-breaker should NOT open */
+
+        // failure 1
+        KnownFailureTestCommandWithFallback attempt1 = new KnownFailureTestCommandWithFallback(circuitBreaker_one);
+        attempt1.observe().toBlocking().single();
+        assertTrue(attempt1.isResponseFromFallback());
+        assertFalse(attempt1.isCircuitBreakerOpen());
+        assertFalse(attempt1.isResponseShortCircuited());
+
+        // failure 2 with a different HystrixCommand implementation and different Hystrix
+        KnownFailureTestCommandWithFallback attempt2 = new KnownFailureTestCommandWithFallback(circuitBreaker_two);
+        attempt2.observe().toBlocking().single();
+        assertTrue(attempt2.isResponseFromFallback());
+        assertFalse(attempt2.isCircuitBreakerOpen());
+        assertFalse(attempt2.isResponseShortCircuited());
+
+        // failure 3 but only 2nd of the Hystrix.ONE
+        KnownFailureTestCommandWithFallback attempt3 = new KnownFailureTestCommandWithFallback(circuitBreaker_one);
+        attempt3.observe().toBlocking().single();
+        assertTrue(attempt3.isResponseFromFallback());
+        assertFalse(attempt3.isResponseShortCircuited());
+
+        // it should remain 'closed' since we have only had 2 failures on Hystrix.ONE
+        assertFalse(attempt3.isCircuitBreakerOpen());
+
+        // this one should also remain closed as it only had 1 failure for Hystrix.TWO
+        assertFalse(attempt2.isCircuitBreakerOpen());
+
+        // attempt 4 (3rd attempt for Hystrix.ONE)
+        KnownFailureTestCommandWithFallback attempt4 = new KnownFailureTestCommandWithFallback(circuitBreaker_one);
+        attempt4.observe().toBlocking().single();
+        // this should NOW flip to true as this is the 3rd failure for Hystrix.ONE
+        assertTrue(attempt3.isCircuitBreakerOpen());
+        assertTrue(attempt3.isResponseFromFallback());
+        assertFalse(attempt3.isResponseShortCircuited());
+
+        // Hystrix.TWO should still remain closed
+        assertFalse(attempt2.isCircuitBreakerOpen());
+
+        assertEquals(0, circuitBreaker_one.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker_one.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(3, circuitBreaker_one.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker_one.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker_one.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(3, circuitBreaker_one.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker_one.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker_one.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker_one.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker_one.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker_one.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, circuitBreaker_one.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(0, circuitBreaker_two.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker_two.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(1, circuitBreaker_two.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker_two.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker_two.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, circuitBreaker_two.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker_two.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker_two.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker_two.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker_two.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker_two.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, circuitBreaker_two.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(4, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    /**
+     * Test that the circuit-breaker being disabled doesn't wreak havoc.
+     */
+    @Test
+    public void testExecutionSuccessWithCircuitBreakerDisabled() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithoutCircuitBreaker();
+        try {
+            assertEquals(true, command.observe().toBlocking().single());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We received an exception.");
+        }
+
+        // we'll still get metrics ... just not the circuit breaker opening/closing
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(0, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    /**
+     * Test a command execution timeout where the command didn't implement getFallback.
+     */
+    @Test
+    public void testExecutionTimeoutWithNoFallbackUsingSemaphoreIsolation() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_NOT_IMPLEMENTED, ExecutionIsolationStrategy.SEMAPHORE);
+        try {
+            command.observe().toBlocking().single();
+            fail("we shouldn't get here");
+        } catch (Exception e) {
+            //                e.printStackTrace();
+            if (e instanceof HystrixRuntimeException) {
+                HystrixRuntimeException de = (HystrixRuntimeException) e;
+                assertNotNull(de.getFallbackException());
+                assertTrue(de.getFallbackException() instanceof UnsupportedOperationException);
+                assertNotNull(de.getImplementingClass());
+                assertNotNull(de.getCause());
+                assertTrue(de.getCause() instanceof TimeoutException);
+            } else {
+                fail("the exception should be HystrixRuntimeException");
+            }
+        }
+        // the time should be 50+ since we timeout at 50ms
+        assertTrue("Execution Time is: " + command.getExecutionTimeInMilliseconds(), command.getExecutionTimeInMilliseconds() >= 50);
+
+        assertTrue(command.isResponseTimedOut());
+        assertFalse(command.isResponseFromFallback());
+        assertFalse(command.isResponseRejected());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a command execution timeout where the command implemented getFallback.
+     */
+    @Test
+    public void testExecutionTimeoutWithFallbackUsingSemaphoreIsolation() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_SUCCESS, ExecutionIsolationStrategy.SEMAPHORE);
+        try {
+            assertEquals(false, command.observe().toBlocking().single());
+            // the time should be 50+ since we timeout at 50ms
+            assertTrue("Execution Time is: " + command.getExecutionTimeInMilliseconds(), command.getExecutionTimeInMilliseconds() >= 50);
+            assertTrue(command.isResponseTimedOut());
+            assertTrue(command.isResponseFromFallback());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We should have received a response from the fallback.");
+        }
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a command execution timeout where the command implemented getFallback but it fails.
+     */
+    @Test
+    public void testExecutionTimeoutFallbackFailureUsingSemaphoreIsolation() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_FAILURE, ExecutionIsolationStrategy.SEMAPHORE);
+        try {
+            command.observe().toBlocking().single();
+            fail("we shouldn't get here");
+        } catch (Exception e) {
+            if (e instanceof HystrixRuntimeException) {
+                HystrixRuntimeException de = (HystrixRuntimeException) e;
+                assertNotNull(de.getFallbackException());
+                assertFalse(de.getFallbackException() instanceof UnsupportedOperationException);
+                assertNotNull(de.getImplementingClass());
+                assertNotNull(de.getCause());
+                assertTrue(de.getCause() instanceof TimeoutException);
+            } else {
+                fail("the exception should be HystrixRuntimeException");
+            }
+        }
+        // the time should be 50+ since we timeout at 50ms
+        assertTrue("Execution Time is: " + command.getExecutionTimeInMilliseconds(), command.getExecutionTimeInMilliseconds() >= 50);
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a command execution timeout where the command didn't implement getFallback.
+     */
+    @Test
+    public void testExecutionTimeoutWithNoFallbackUsingThreadIsolation() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_NOT_IMPLEMENTED, ExecutionIsolationStrategy.THREAD);
+        try {
+            command.observe().toBlocking().single();
+            fail("we shouldn't get here");
+        } catch (Exception e) {
+            //                e.printStackTrace();
+            if (e instanceof HystrixRuntimeException) {
+                HystrixRuntimeException de = (HystrixRuntimeException) e;
+                assertNotNull(de.getFallbackException());
+                assertTrue(de.getFallbackException() instanceof UnsupportedOperationException);
+                assertNotNull(de.getImplementingClass());
+                assertNotNull(de.getCause());
+                assertTrue(de.getCause() instanceof TimeoutException);
+            } else {
+                fail("the exception should be HystrixRuntimeException");
+            }
+        }
+        // the time should be 50+ since we timeout at 50ms
+        assertTrue("Execution Time is: " + command.getExecutionTimeInMilliseconds(), command.getExecutionTimeInMilliseconds() >= 50);
+
+        assertTrue(command.isResponseTimedOut());
+        assertFalse(command.isResponseFromFallback());
+        assertFalse(command.isResponseRejected());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // thread isolated
+        assertTrue(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a command execution timeout where the command implemented getFallback.
+     */
+    @Test
+    public void testExecutionTimeoutWithFallbackUsingThreadIsolation() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_SUCCESS, ExecutionIsolationStrategy.THREAD);
+        try {
+            assertEquals(false, command.observe().toBlocking().single());
+            // the time should be 50+ since we timeout at 50ms
+            assertTrue("Execution Time is: " + command.getExecutionTimeInMilliseconds(), command.getExecutionTimeInMilliseconds() >= 50);
+            assertTrue(command.isResponseTimedOut());
+            assertTrue(command.isResponseFromFallback());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We should have received a response from the fallback.");
+        }
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // thread isolated
+        assertTrue(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a command execution timeout where the command implemented getFallback but it fails.
+     */
+    @Test
+    public void testExecutionTimeoutFallbackFailureUsingThreadIsolation() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_FAILURE, ExecutionIsolationStrategy.THREAD);
+        try {
+            command.observe().toBlocking().single();
+            fail("we shouldn't get here");
+        } catch (Exception e) {
+            if (e instanceof HystrixRuntimeException) {
+                HystrixRuntimeException de = (HystrixRuntimeException) e;
+                assertNotNull(de.getFallbackException());
+                assertFalse(de.getFallbackException() instanceof UnsupportedOperationException);
+                assertNotNull(de.getImplementingClass());
+                assertNotNull(de.getCause());
+                assertTrue(de.getCause() instanceof TimeoutException);
+            } else {
+                fail("the exception should be HystrixRuntimeException");
+            }
+        }
+        // the time should be 50+ since we timeout at 50ms
+        assertTrue("Execution Time is: " + command.getExecutionTimeInMilliseconds(), command.getExecutionTimeInMilliseconds() >= 50);
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // thread isolated
+        assertTrue(command.isExecutedInThread());
+    }
+
+    /**
+     * Test that the circuit-breaker counts a command execution timeout as a 'timeout' and not just failure.
+     */
+    @Test
+    public void testCircuitBreakerOnExecutionTimeout() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_SUCCESS);
+        try {
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+
+            command.observe().toBlocking().single();
+
+            assertTrue(command.isResponseFromFallback());
+            assertFalse(command.isCircuitBreakerOpen());
+            assertFalse(command.isResponseShortCircuited());
+
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We should have received a response from the fallback.");
+        }
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isResponseTimedOut());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test that the command finishing AFTER a timeout (because thread continues in background) does not register a SUCCESS
+     */
+    @Test
+    public void testCountersOnExecutionTimeout() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_SUCCESS);
+        try {
+            command.observe().toBlocking().single();
+
+            /* wait long enough for the command to have finished */
+            Thread.sleep(200);
+
+            /* response should still be the same as 'testCircuitBreakerOnExecutionTimeout' */
+            assertTrue(command.isResponseFromFallback());
+            assertFalse(command.isCircuitBreakerOpen());
+            assertFalse(command.isResponseShortCircuited());
+
+            assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+            assertTrue(command.isResponseTimedOut());
+            assertFalse(command.isSuccessfulExecution());
+
+            /* failure and timeout count should be the same as 'testCircuitBreakerOnExecutionTimeout' */
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+
+            /* we should NOT have a 'success' counter */
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We should have received a response from the fallback.");
+        }
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a queued command execution timeout where the command didn't implement getFallback.
+     * <p>
+     * We specifically want to protect against developers queuing commands and using observe().toBlocking().toFuture().get() without a timeout (such as observe().toBlocking().toFuture().get(3000,
+     * TimeUnit.Milliseconds)) and ending up blocking
+     * indefinitely by skipping the timeout protection of the observe().toBlocking().single() command.
+     */
+    @Test
+    public void testQueuedExecutionTimeoutWithNoFallback() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_NOT_IMPLEMENTED);
+        try {
+            command.observe().toBlocking().toFuture().get();
+            fail("we shouldn't get here");
+        } catch (Exception e) {
+            e.printStackTrace();
+            if (e instanceof ExecutionException && e.getCause() instanceof HystrixRuntimeException) {
+                HystrixRuntimeException de = (HystrixRuntimeException) e.getCause();
+                assertNotNull(de.getFallbackException());
+                assertTrue(de.getFallbackException() instanceof UnsupportedOperationException);
+                assertNotNull(de.getImplementingClass());
+                assertNotNull(de.getCause());
+                assertTrue(de.getCause() instanceof TimeoutException);
+            } else {
+                fail("the exception should be ExecutionException with cause as HystrixRuntimeException");
+            }
+        }
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isResponseTimedOut());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a queued command execution timeout where the command implemented getFallback.
+     * <p>
+     * We specifically want to protect against developers queuing commands and using observe().toBlocking().toFuture().get() without a timeout (such as observe().toBlocking().toFuture().get(3000,
+     * TimeUnit.Milliseconds)) and ending up blocking
+     * indefinitely by skipping the timeout protection of the observe().toBlocking().single() command.
+     */
+    @Test
+    public void testQueuedExecutionTimeoutWithFallback() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_SUCCESS);
+        try {
+            assertEquals(false, command.observe().toBlocking().toFuture().get());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We should have received a response from the fallback.");
+        }
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a queued command execution timeout where the command implemented getFallback but it fails.
+     * <p>
+     * We specifically want to protect against developers queuing commands and using observe().toBlocking().toFuture().get() without a timeout (such as observe().toBlocking().toFuture().get(3000,
+     * TimeUnit.Milliseconds)) and ending up blocking
+     * indefinitely by skipping the timeout protection of the observe().toBlocking().single() command.
+     */
+    @Test
+    public void testQueuedExecutionTimeoutFallbackFailure() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_FAILURE);
+        try {
+            command.observe().toBlocking().toFuture().get();
+            fail("we shouldn't get here");
+        } catch (Exception e) {
+            if (e instanceof ExecutionException && e.getCause() instanceof HystrixRuntimeException) {
+                HystrixRuntimeException de = (HystrixRuntimeException) e.getCause();
+                assertNotNull(de.getFallbackException());
+                assertFalse(de.getFallbackException() instanceof UnsupportedOperationException);
+                assertNotNull(de.getImplementingClass());
+                assertNotNull(de.getCause());
+                assertTrue(de.getCause() instanceof TimeoutException);
+            } else {
+                fail("the exception should be ExecutionException with cause as HystrixRuntimeException");
+            }
+        }
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a queued command execution timeout where the command didn't implement getFallback.
+     * <p>
+     * We specifically want to protect against developers queuing commands and using observe().toBlocking().toFuture().get() without a timeout (such as observe().toBlocking().toFuture().get(3000,
+     * TimeUnit.Milliseconds)) and ending up blocking
+     * indefinitely by skipping the timeout protection of the observe().toBlocking().single() command.
+     */
+    @Test
+    public void testObservedExecutionTimeoutWithNoFallback() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_NOT_IMPLEMENTED);
+        try {
+            command.observe().toBlocking().single();
+            fail("we shouldn't get here");
+        } catch (Exception e) {
+            e.printStackTrace();
+            if (e instanceof HystrixRuntimeException) {
+                HystrixRuntimeException de = (HystrixRuntimeException) e;
+                assertNotNull(de.getFallbackException());
+                assertTrue(de.getFallbackException() instanceof UnsupportedOperationException);
+                assertNotNull(de.getImplementingClass());
+                assertNotNull(de.getCause());
+                assertTrue(de.getCause() instanceof TimeoutException);
+            } else {
+                fail("the exception should be ExecutionException with cause as HystrixRuntimeException");
+            }
+        }
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isResponseTimedOut());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a queued command execution timeout where the command implemented getFallback.
+     * <p>
+     * We specifically want to protect against developers queuing commands and using observe().toBlocking().toFuture().get() without a timeout (such as observe().toBlocking().toFuture().get(3000,
+     * TimeUnit.Milliseconds)) and ending up blocking
+     * indefinitely by skipping the timeout protection of the observe().toBlocking().single() command.
+     */
+    @Test
+    public void testObservedExecutionTimeoutWithFallback() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_SUCCESS);
+        try {
+            assertEquals(false, command.observe().toBlocking().single());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We should have received a response from the fallback.");
+        }
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a queued command execution timeout where the command implemented getFallback but it fails.
+     * <p>
+     * We specifically want to protect against developers queuing commands and using observe().toBlocking().toFuture().get() without a timeout (such as observe().toBlocking().toFuture().get(3000,
+     * TimeUnit.Milliseconds)) and ending up blocking
+     * indefinitely by skipping the timeout protection of the observe().toBlocking().single() command.
+     */
+    @Test
+    public void testObservedExecutionTimeoutFallbackFailure() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_FAILURE);
+        try {
+            command.observe().toBlocking().single();
+            fail("we shouldn't get here");
+        } catch (Exception e) {
+            if (e instanceof HystrixRuntimeException) {
+                HystrixRuntimeException de = (HystrixRuntimeException) e;
+                assertNotNull(de.getFallbackException());
+                assertFalse(de.getFallbackException() instanceof UnsupportedOperationException);
+                assertNotNull(de.getImplementingClass());
+                assertNotNull(de.getCause());
+                assertTrue(de.getCause() instanceof TimeoutException);
+            } else {
+                fail("the exception should be ExecutionException with cause as HystrixRuntimeException");
+            }
+        }
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test that the circuit-breaker counts a command execution timeout as a 'timeout' and not just failure.
+     */
+    @Test
+    public void testShortCircuitFallbackCounter() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker().setForceShortCircuit(true);
+        try {
+            new KnownFailureTestCommandWithFallback(circuitBreaker).observe().toBlocking().single();
+
+            assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+
+            KnownFailureTestCommandWithFallback command = new KnownFailureTestCommandWithFallback(circuitBreaker);
+            command.observe().toBlocking().single();
+            assertEquals(2, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+
+            // will be -1 because it never attempted execution
+            assertEquals(-1, command.getExecutionTimeInMilliseconds());
+            assertTrue(command.isResponseShortCircuited());
+            assertFalse(command.isResponseTimedOut());
+
+            // because it was short-circuited to a fallback we don't count an error
+            assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+            assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+
+            // semaphore isolated
+            assertFalse(command.isExecutedInThread());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We should have received a response from the fallback.");
+        }
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(2, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(2, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(2, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    @Test
+    public void testExecutionSemaphoreWithQueue() {
+        final TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        // single thread should work
+        try {
+            boolean result = new TestSemaphoreCommand(circuitBreaker, 1, 200).observe().toBlocking().toFuture().get();
+            assertTrue(result);
+        } catch (Exception e) {
+            // we shouldn't fail on this one
+            throw new RuntimeException(e);
+        }
+
+        final AtomicBoolean exceptionReceived = new AtomicBoolean();
+
+        final TryableSemaphoreActual semaphore =
+                new TryableSemaphoreActual(HystrixProperty.Factory.asProperty(1));
+
+        Runnable r = new HystrixContextRunnable(HystrixPlugins.getInstance().getConcurrencyStrategy(), new Runnable() {
+
+            @Override
+            public void run() {
+                try {
+                    new TestSemaphoreCommand(circuitBreaker, semaphore, 200).observe().toBlocking().toFuture().get();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    exceptionReceived.set(true);
+                }
+            }
+
+        });
+        // 2 threads, the second should be rejected by the semaphore
+        Thread t1 = new Thread(r);
+        Thread t2 = new Thread(r);
+
+        t1.start();
+        t2.start();
+        try {
+            t1.join();
+            t2.join();
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("failed waiting on threads");
+        }
+
+        if (!exceptionReceived.get()) {
+            fail("We expected an exception on the 2nd get");
+        }
+
+        assertEquals(2, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        // we don't have a fallback so threw an exception when rejected
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        // not a failure as the command never executed so can't fail
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        // no fallback failure as there isn't a fallback implemented
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        // we should have rejected via semaphore
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        // the rest should not be involved in this test
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(3, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    @Test
+    public void testExecutionSemaphoreWithExecution() {
+        final TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        // single thread should work
+        try {
+            TestSemaphoreCommand command = new TestSemaphoreCommand(circuitBreaker, 1, 200);
+            boolean result = command.observe().toBlocking().single();
+            assertFalse(command.isExecutedInThread());
+            assertTrue(result);
+        } catch (Exception e) {
+            // we shouldn't fail on this one
+            throw new RuntimeException(e);
+        }
+
+        final ArrayBlockingQueue<Boolean> results = new ArrayBlockingQueue<Boolean>(2);
+
+        final AtomicBoolean exceptionReceived = new AtomicBoolean();
+
+        final TryableSemaphoreActual semaphore =
+                new TryableSemaphoreActual(HystrixProperty.Factory.asProperty(1));
+
+        Runnable r = new HystrixContextRunnable(HystrixPlugins.getInstance().getConcurrencyStrategy(), new Runnable() {
+
+            @Override
+            public void run() {
+                try {
+                    results.add(new TestSemaphoreCommand(circuitBreaker, semaphore, 200).observe().toBlocking().single());
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    exceptionReceived.set(true);
+                }
+            }
+
+        });
+        // 2 threads, the second should be rejected by the semaphore
+        Thread t1 = new Thread(r);
+        Thread t2 = new Thread(r);
+
+        t1.start();
+        t2.start();
+        try {
+            t1.join();
+            t2.join();
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("failed waiting on threads");
+        }
+
+        if (!exceptionReceived.get()) {
+            fail("We expected an exception on the 2nd get");
+        }
+
+        // only 1 value is expected as the other should have thrown an exception
+        assertEquals(1, results.size());
+        // should contain only a true result
+        assertTrue(results.contains(Boolean.TRUE));
+        assertFalse(results.contains(Boolean.FALSE));
+
+        assertEquals(2, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        // no failure ... we throw an exception because of rejection but the command does not fail execution
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        // there is no fallback implemented so no failure can occur on it
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        // we rejected via semaphore
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        // the rest should not be involved in this test
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(3, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    @Test
+    public void testRejectedExecutionSemaphoreWithFallback() {
+        final TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        final ArrayBlockingQueue<Boolean> results = new ArrayBlockingQueue<Boolean>(2);
+
+        final AtomicBoolean exceptionReceived = new AtomicBoolean();
+
+        Runnable r = new HystrixContextRunnable(HystrixPlugins.getInstance().getConcurrencyStrategy(), new Runnable() {
+
+            @Override
+            public void run() {
+                try {
+                    results.add(new TestSemaphoreCommandWithFallback(circuitBreaker, 1, 200, false).observe().toBlocking().single());
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    exceptionReceived.set(true);
+                }
+            }
+
+        });
+
+        // 2 threads, the second should be rejected by the semaphore and return fallback
+        Thread t1 = new Thread(r);
+        Thread t2 = new Thread(r);
+
+        t1.start();
+        t2.start();
+        try {
+            t1.join();
+            t2.join();
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("failed waiting on threads");
+        }
+
+        if (exceptionReceived.get()) {
+            fail("We should have received a fallback response");
+        }
+
+        // both threads should have returned values
+        assertEquals(2, results.size());
+        // should contain both a true and false result
+        assertTrue(results.contains(Boolean.TRUE));
+        assertTrue(results.contains(Boolean.FALSE));
+
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        // the rest should not be involved in this test
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        System.out.println("**** DONE");
+
+        assertEquals(2, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    /**
+     * Tests that semaphores are counted separately for commands with unique keys
+     */
+    @Test
+    public void testSemaphorePermitsInUse() {
+        final TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+
+        // this semaphore will be shared across multiple command instances
+        final TryableSemaphoreActual sharedSemaphore =
+                new TryableSemaphoreActual(HystrixProperty.Factory.asProperty(3));
+
+        // used to wait until all commands have started
+        final CountDownLatch startLatch = new CountDownLatch(sharedSemaphore.numberOfPermits.get() + 1);
+
+        // used to signal that all command can finish
+        final CountDownLatch sharedLatch = new CountDownLatch(1);
+
+        final Runnable sharedSemaphoreRunnable = new HystrixContextRunnable(HystrixPlugins.getInstance().getConcurrencyStrategy(), new Runnable() {
+            public void run() {
+                try {
+                    new LatchedSemaphoreCommand(circuitBreaker, sharedSemaphore, startLatch, sharedLatch).observe().toBlocking().single();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+
+        // creates group of threads each using command sharing a single semaphore
+
+        // I create extra threads and commands so that I can verify that some of them fail to obtain a semaphore
+        final int sharedThreadCount = sharedSemaphore.numberOfPermits.get() * 2;
+        final Thread[] sharedSemaphoreThreads = new Thread[sharedThreadCount];
+        for (int i = 0; i < sharedThreadCount; i++) {
+            sharedSemaphoreThreads[i] = new Thread(sharedSemaphoreRunnable);
+        }
+
+        // creates thread using isolated semaphore
+        final TryableSemaphoreActual isolatedSemaphore =
+                new TryableSemaphoreActual(HystrixProperty.Factory.asProperty(1));
+
+        final CountDownLatch isolatedLatch = new CountDownLatch(1);
+
+        // tracks failures to obtain semaphores
+        final AtomicInteger failureCount = new AtomicInteger();
+
+        final Thread isolatedThread = new Thread(new HystrixContextRunnable(HystrixPlugins.getInstance().getConcurrencyStrategy(), new Runnable() {
+            public void run() {
+                try {
+                    new LatchedSemaphoreCommand(circuitBreaker, isolatedSemaphore, startLatch, isolatedLatch).observe().toBlocking().single();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    failureCount.incrementAndGet();
+                }
+            }
+        }));
+
+        // verifies no permits in use before starting threads
+        assertEquals("wrong number of permits for shared semaphore", 0, sharedSemaphore.getNumberOfPermitsUsed());
+        assertEquals("wrong number of permits for isolated semaphore", 0, isolatedSemaphore.getNumberOfPermitsUsed());
+
+        for (int i = 0; i < sharedThreadCount; i++) {
+            sharedSemaphoreThreads[i].start();
+        }
+        isolatedThread.start();
+
+        // waits until all commands have started
+        try {
+            startLatch.await(1000, TimeUnit.MILLISECONDS);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        // verifies that all semaphores are in use
+        assertEquals("wrong number of permits for shared semaphore",
+                sharedSemaphore.numberOfPermits.get().longValue(), sharedSemaphore.getNumberOfPermitsUsed());
+        assertEquals("wrong number of permits for isolated semaphore",
+                isolatedSemaphore.numberOfPermits.get().longValue(), isolatedSemaphore.getNumberOfPermitsUsed());
+
+        // signals commands to finish
+        sharedLatch.countDown();
+        isolatedLatch.countDown();
+
+        try {
+            for (int i = 0; i < sharedThreadCount; i++) {
+                sharedSemaphoreThreads[i].join();
+            }
+            isolatedThread.join();
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("failed waiting on threads");
+        }
+
+        // verifies no permits in use after finishing threads
+        assertEquals("wrong number of permits for shared semaphore", 0, sharedSemaphore.getNumberOfPermitsUsed());
+        assertEquals("wrong number of permits for isolated semaphore", 0, isolatedSemaphore.getNumberOfPermitsUsed());
+
+        // verifies that some executions failed
+        final int expectedFailures = sharedSemaphore.getNumberOfPermitsUsed();
+        assertEquals("failures expected but did not happen", expectedFailures, failureCount.get());
+    }
+
+    /**
+     * Test that HystrixOwner can be passed in dynamically.
+     */
+    @Test
+    public void testDynamicOwner() {
+        try {
+            TestHystrixCommand<Boolean> command = new DynamicOwnerTestCommand(CommandGroupForUnitTest.OWNER_ONE);
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+            assertEquals(true, command.observe().toBlocking().single());
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+
+            // semaphore isolated
+            assertFalse(command.isExecutedInThread());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We received an exception.");
+        }
+    }
+
+    /**
+     * Test a successful command execution.
+     */
+    @Test
+    public void testDynamicOwnerFails() {
+        try {
+            TestHystrixCommand<Boolean> command = new DynamicOwnerTestCommand(null);
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+            assertEquals(true, command.observe().toBlocking().single());
+            fail("we should have thrown an exception as we need an owner");
+
+            // semaphore isolated
+            assertFalse(command.isExecutedInThread());
+        } catch (Exception e) {
+            // success if we get here
+        }
+    }
+
+    /**
+     * Test that HystrixCommandKey can be passed in dynamically.
+     */
+    @Test
+    public void testDynamicKey() {
+        try {
+            DynamicOwnerAndKeyTestCommand command1 = new DynamicOwnerAndKeyTestCommand(CommandGroupForUnitTest.OWNER_ONE, CommandKeyForUnitTest.KEY_ONE);
+            assertEquals(true, command1.observe().toBlocking().single());
+            DynamicOwnerAndKeyTestCommand command2 = new DynamicOwnerAndKeyTestCommand(CommandGroupForUnitTest.OWNER_ONE, CommandKeyForUnitTest.KEY_TWO);
+            assertEquals(true, command2.observe().toBlocking().single());
+
+            // 2 different circuit breakers should be created
+            assertNotSame(command1.getCircuitBreaker(), command2.getCircuitBreaker());
+
+            // semaphore isolated
+            assertFalse(command1.isExecutedInThread());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We received an exception.");
+        }
+    }
+
+    /**
+     * Test Request scoped caching of commands so that a 2nd duplicate call doesn't execute but returns the previous Future
+     */
+    @Test
+    public void testRequestCache1UsingThreadIsolation() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        SuccessfulCacheableCommand command1 = new SuccessfulCacheableCommand(circuitBreaker, true, "A");
+        SuccessfulCacheableCommand command2 = new SuccessfulCacheableCommand(circuitBreaker, true, "A");
+
+        assertTrue(command1.isCommandRunningInThread());
+
+        Future<String> f1 = command1.observe().toBlocking().toFuture();
+        Future<String> f2 = command2.observe().toBlocking().toFuture();
+
+        try {
+            assertEquals("A", f1.get());
+            assertEquals("A", f2.get());
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        assertTrue(command1.executed);
+        // the second one should not have executed as it should have received the cached value instead
+        assertFalse(command2.executed);
+
+        // the execution log for command1 should show a SUCCESS
+        assertEquals(1, command1.getExecutionEvents().size());
+        assertTrue(command1.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+        assertTrue(command1.getExecutionTimeInMilliseconds() > -1);
+        assertFalse(command1.isResponseFromCache());
+
+        // the execution log for command2 should show it came from cache
+        assertEquals(2, command2.getExecutionEvents().size()); // it will include the SUCCESS + RESPONSE_FROM_CACHE
+        assertTrue(command2.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+        assertTrue(command2.getExecutionEvents().contains(HystrixEventType.RESPONSE_FROM_CACHE));
+        assertTrue(command2.getExecutionTimeInMilliseconds() == -1);
+        assertTrue(command2.isResponseFromCache());
+
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(0, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(2, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    /**
+     * Test Request scoped caching doesn't prevent different ones from executing
+     */
+    @Test
+    public void testRequestCache2UsingThreadIsolation() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        SuccessfulCacheableCommand command1 = new SuccessfulCacheableCommand(circuitBreaker, true, "A");
+        SuccessfulCacheableCommand command2 = new SuccessfulCacheableCommand(circuitBreaker, true, "B");
+
+        assertTrue(command1.isCommandRunningInThread());
+
+        Future<String> f1 = command1.observe().toBlocking().toFuture();
+        Future<String> f2 = command2.observe().toBlocking().toFuture();
+
+        try {
+            assertEquals("A", f1.get());
+            assertEquals("B", f2.get());
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        assertTrue(command1.executed);
+        // both should execute as they are different
+        assertTrue(command2.executed);
+
+        // the execution log for command1 should show a SUCCESS
+        assertEquals(1, command1.getExecutionEvents().size());
+        assertTrue(command1.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        // the execution log for command2 should show a SUCCESS
+        assertEquals(1, command2.getExecutionEvents().size());
+        assertTrue(command2.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+        assertTrue(command2.getExecutionTimeInMilliseconds() > -1);
+        assertFalse(command2.isResponseFromCache());
+
+        assertEquals(2, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(0, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(2, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    /**
+     * Test Request scoped caching with a mixture of commands
+     */
+    @Test
+    public void testRequestCache3UsingThreadIsolation() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        SuccessfulCacheableCommand command1 = new SuccessfulCacheableCommand(circuitBreaker, true, "A");
+        SuccessfulCacheableCommand command2 = new SuccessfulCacheableCommand(circuitBreaker, true, "B");
+        SuccessfulCacheableCommand command3 = new SuccessfulCacheableCommand(circuitBreaker, true, "A");
+
+        assertTrue(command1.isCommandRunningInThread());
+
+        Future<String> f1 = command1.observe().toBlocking().toFuture();
+        Future<String> f2 = command2.observe().toBlocking().toFuture();
+        Future<String> f3 = command3.observe().toBlocking().toFuture();
+
+        try {
+            assertEquals("A", f1.get());
+            assertEquals("B", f2.get());
+            assertEquals("A", f3.get());
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        assertTrue(command1.executed);
+        // both should execute as they are different
+        assertTrue(command2.executed);
+        // but the 3rd should come from cache
+        assertFalse(command3.executed);
+
+        // the execution log for command1 should show a SUCCESS
+        assertEquals(1, command1.getExecutionEvents().size());
+        assertTrue(command1.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        // the execution log for command2 should show a SUCCESS
+        assertEquals(1, command2.getExecutionEvents().size());
+        assertTrue(command2.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        // the execution log for command3 should show it came from cache
+        assertEquals(2, command3.getExecutionEvents().size()); // it will include the SUCCESS + RESPONSE_FROM_CACHE
+        assertTrue(command3.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+        assertTrue(command3.getExecutionEvents().contains(HystrixEventType.RESPONSE_FROM_CACHE));
+        assertTrue(command3.getExecutionTimeInMilliseconds() == -1);
+        assertTrue(command3.isResponseFromCache());
+
+        assertEquals(2, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(0, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        System.out.println("executedCommand: " + HystrixRequestLog.getCurrentRequest().getExecutedCommandsAsString());
+        assertEquals(3, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    /**
+     * Test Request scoped caching of commands so that a 2nd duplicate call doesn't execute but returns the previous Future
+     */
+    @Test
+    public void testRequestCacheWithSlowExecution() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        SlowCacheableCommand command1 = new SlowCacheableCommand(circuitBreaker, "A", 200);
+        SlowCacheableCommand command2 = new SlowCacheableCommand(circuitBreaker, "A", 100);
+        SlowCacheableCommand command3 = new SlowCacheableCommand(circuitBreaker, "A", 100);
+        SlowCacheableCommand command4 = new SlowCacheableCommand(circuitBreaker, "A", 100);
+
+        Future<String> f1 = command1.observe().toBlocking().toFuture();
+        Future<String> f2 = command2.observe().toBlocking().toFuture();
+        Future<String> f3 = command3.observe().toBlocking().toFuture();
+        Future<String> f4 = command4.observe().toBlocking().toFuture();
+
+        try {
+            assertEquals("A", f2.get());
+            assertEquals("A", f3.get());
+            assertEquals("A", f4.get());
+
+            assertEquals("A", f1.get());
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        assertTrue(command1.executed);
+        // the second one should not have executed as it should have received the cached value instead
+        assertFalse(command2.executed);
+        assertFalse(command3.executed);
+        assertFalse(command4.executed);
+
+        // the execution log for command1 should show a SUCCESS
+        assertEquals(1, command1.getExecutionEvents().size());
+        assertTrue(command1.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+        assertTrue(command1.getExecutionTimeInMilliseconds() > -1);
+        assertFalse(command1.isResponseFromCache());
+
+        // the execution log for command2 should show it came from cache
+        assertEquals(2, command2.getExecutionEvents().size()); // it will include the SUCCESS + RESPONSE_FROM_CACHE
+        assertTrue(command2.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+        assertTrue(command2.getExecutionEvents().contains(HystrixEventType.RESPONSE_FROM_CACHE));
+        assertTrue(command2.getExecutionTimeInMilliseconds() == -1);
+        assertTrue(command2.isResponseFromCache());
+
+        assertTrue(command3.isResponseFromCache());
+        assertTrue(command3.getExecutionTimeInMilliseconds() == -1);
+        assertTrue(command4.isResponseFromCache());
+        assertTrue(command4.getExecutionTimeInMilliseconds() == -1);
+
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(3, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(0, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(4, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        System.out.println("HystrixRequestLog: " + HystrixRequestLog.getCurrentRequest().getExecutedCommandsAsString());
+
+        // semaphore isolated
+        assertFalse(command1.isExecutedInThread());
+        assertFalse(command2.isExecutedInThread());
+        assertFalse(command3.isExecutedInThread());
+        assertFalse(command4.isExecutedInThread());
+    }
+
+    /**
+     * Test Request scoped caching with a mixture of commands
+     */
+    @Test
+    public void testNoRequestCache3UsingThreadIsolation() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        SuccessfulCacheableCommand command1 = new SuccessfulCacheableCommand(circuitBreaker, false, "A");
+        SuccessfulCacheableCommand command2 = new SuccessfulCacheableCommand(circuitBreaker, false, "B");
+        SuccessfulCacheableCommand command3 = new SuccessfulCacheableCommand(circuitBreaker, false, "A");
+
+        assertTrue(command1.isCommandRunningInThread());
+
+        Future<String> f1 = command1.observe().toBlocking().toFuture();
+        Future<String> f2 = command2.observe().toBlocking().toFuture();
+        Future<String> f3 = command3.observe().toBlocking().toFuture();
+
+        try {
+            assertEquals("A", f1.get());
+            assertEquals("B", f2.get());
+            assertEquals("A", f3.get());
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        assertTrue(command1.executed);
+        // both should execute as they are different
+        assertTrue(command2.executed);
+        // this should also execute since we disabled the cache
+        assertTrue(command3.executed);
+
+        // the execution log for command1 should show a SUCCESS
+        assertEquals(1, command1.getExecutionEvents().size());
+        assertTrue(command1.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        // the execution log for command2 should show a SUCCESS
+        assertEquals(1, command2.getExecutionEvents().size());
+        assertTrue(command2.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        // the execution log for command3 should show a SUCCESS
+        assertEquals(1, command3.getExecutionEvents().size());
+        assertTrue(command3.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        assertEquals(3, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(0, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(3, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // thread isolated
+        assertTrue(command1.isExecutedInThread());
+        assertTrue(command2.isExecutedInThread());
+        assertTrue(command3.isExecutedInThread());
+    }
+
+    /**
+     * Test Request scoped caching with a mixture of commands
+     */
+    @Test
+    public void testRequestCacheViaQueueUsingSemaphoreIsolation() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        SuccessfulCacheableCommandViaSemaphore command1 = new SuccessfulCacheableCommandViaSemaphore(circuitBreaker, true, "A");
+        SuccessfulCacheableCommandViaSemaphore command2 = new SuccessfulCacheableCommandViaSemaphore(circuitBreaker, true, "B");
+        SuccessfulCacheableCommandViaSemaphore command3 = new SuccessfulCacheableCommandViaSemaphore(circuitBreaker, true, "A");
+
+        assertFalse(command1.isCommandRunningInThread());
+
+        Future<String> f1 = command1.observe().toBlocking().toFuture();
+        Future<String> f2 = command2.observe().toBlocking().toFuture();
+        Future<String> f3 = command3.observe().toBlocking().toFuture();
+
+        try {
+            assertEquals("A", f1.get());
+            assertEquals("B", f2.get());
+            assertEquals("A", f3.get());
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        assertTrue(command1.executed);
+        // both should execute as they are different
+        assertTrue(command2.executed);
+        // but the 3rd should come from cache
+        assertFalse(command3.executed);
+
+        // the execution log for command1 should show a SUCCESS
+        assertEquals(1, command1.getExecutionEvents().size());
+        assertTrue(command1.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        // the execution log for command2 should show a SUCCESS
+        assertEquals(1, command2.getExecutionEvents().size());
+        assertTrue(command2.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        // the execution log for command3 should show it comes from cache
+        assertEquals(2, command3.getExecutionEvents().size()); // it will include the SUCCESS + RESPONSE_FROM_CACHE
+        assertTrue(command3.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+        assertTrue(command3.getExecutionEvents().contains(HystrixEventType.RESPONSE_FROM_CACHE));
+
+        assertTrue(command3.isResponseFromCache());
+        assertTrue(command3.getExecutionTimeInMilliseconds() == -1);
+
+        assertEquals(2, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(0, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(3, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command1.isExecutedInThread());
+        assertFalse(command2.isExecutedInThread());
+        assertFalse(command3.isExecutedInThread());
+    }
+
+    /**
+     * Test Request scoped caching with a mixture of commands
+     */
+    @Test
+    public void testNoRequestCacheViaQueueUsingSemaphoreIsolation() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        SuccessfulCacheableCommandViaSemaphore command1 = new SuccessfulCacheableCommandViaSemaphore(circuitBreaker, false, "A");
+        SuccessfulCacheableCommandViaSemaphore command2 = new SuccessfulCacheableCommandViaSemaphore(circuitBreaker, false, "B");
+        SuccessfulCacheableCommandViaSemaphore command3 = new SuccessfulCacheableCommandViaSemaphore(circuitBreaker, false, "A");
+
+        assertFalse(command1.isCommandRunningInThread());
+
+        Future<String> f1 = command1.observe().toBlocking().toFuture();
+        Future<String> f2 = command2.observe().toBlocking().toFuture();
+        Future<String> f3 = command3.observe().toBlocking().toFuture();
+
+        try {
+            assertEquals("A", f1.get());
+            assertEquals("B", f2.get());
+            assertEquals("A", f3.get());
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        assertTrue(command1.executed);
+        // both should execute as they are different
+        assertTrue(command2.executed);
+        // this should also execute because caching is disabled
+        assertTrue(command3.executed);
+
+        // the execution log for command1 should show a SUCCESS
+        assertEquals(1, command1.getExecutionEvents().size());
+        assertTrue(command1.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        // the execution log for command2 should show a SUCCESS
+        assertEquals(1, command2.getExecutionEvents().size());
+        assertTrue(command2.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        // the execution log for command3 should show a SUCCESS
+        assertEquals(1, command3.getExecutionEvents().size());
+        assertTrue(command3.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        assertEquals(3, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(0, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(3, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command1.isExecutedInThread());
+        assertFalse(command2.isExecutedInThread());
+        assertFalse(command3.isExecutedInThread());
+    }
+
+    /**
+     * Test Request scoped caching with a mixture of commands
+     */
+    @Test
+    public void testRequestCacheViaExecuteUsingSemaphoreIsolation() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        SuccessfulCacheableCommandViaSemaphore command1 = new SuccessfulCacheableCommandViaSemaphore(circuitBreaker, true, "A");
+        SuccessfulCacheableCommandViaSemaphore command2 = new SuccessfulCacheableCommandViaSemaphore(circuitBreaker, true, "B");
+        SuccessfulCacheableCommandViaSemaphore command3 = new SuccessfulCacheableCommandViaSemaphore(circuitBreaker, true, "A");
+
+        assertFalse(command1.isCommandRunningInThread());
+
+        String f1 = command1.observe().toBlocking().single();
+        String f2 = command2.observe().toBlocking().single();
+        String f3 = command3.observe().toBlocking().single();
+
+        assertEquals("A", f1);
+        assertEquals("B", f2);
+        assertEquals("A", f3);
+
+        assertTrue(command1.executed);
+        // both should execute as they are different
+        assertTrue(command2.executed);
+        // but the 3rd should come from cache
+        assertFalse(command3.executed);
+
+        // the execution log for command1 should show a SUCCESS
+        assertEquals(1, command1.getExecutionEvents().size());
+        assertTrue(command1.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        // the execution log for command2 should show a SUCCESS
+        assertEquals(1, command2.getExecutionEvents().size());
+        assertTrue(command2.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        // the execution log for command3 should show it comes from cache
+        assertEquals(2, command3.getExecutionEvents().size()); // it will include the SUCCESS + RESPONSE_FROM_CACHE
+        assertTrue(command3.getExecutionEvents().contains(HystrixEventType.RESPONSE_FROM_CACHE));
+
+        assertEquals(2, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(0, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(3, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command1.isExecutedInThread());
+        assertFalse(command2.isExecutedInThread());
+        assertFalse(command3.isExecutedInThread());
+    }
+
+    /**
+     * Test Request scoped caching with a mixture of commands
+     */
+    @Test
+    public void testNoRequestCacheViaExecuteUsingSemaphoreIsolation() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        SuccessfulCacheableCommandViaSemaphore command1 = new SuccessfulCacheableCommandViaSemaphore(circuitBreaker, false, "A");
+        SuccessfulCacheableCommandViaSemaphore command2 = new SuccessfulCacheableCommandViaSemaphore(circuitBreaker, false, "B");
+        SuccessfulCacheableCommandViaSemaphore command3 = new SuccessfulCacheableCommandViaSemaphore(circuitBreaker, false, "A");
+
+        assertFalse(command1.isCommandRunningInThread());
+
+        String f1 = command1.observe().toBlocking().single();
+        String f2 = command2.observe().toBlocking().single();
+        String f3 = command3.observe().toBlocking().single();
+
+        assertEquals("A", f1);
+        assertEquals("B", f2);
+        assertEquals("A", f3);
+
+        assertTrue(command1.executed);
+        // both should execute as they are different
+        assertTrue(command2.executed);
+        // this should also execute because caching is disabled
+        assertTrue(command3.executed);
+
+        // the execution log for command1 should show a SUCCESS
+        assertEquals(1, command1.getExecutionEvents().size());
+        assertTrue(command1.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        // the execution log for command2 should show a SUCCESS
+        assertEquals(1, command2.getExecutionEvents().size());
+        assertTrue(command2.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        // the execution log for command3 should show a SUCCESS
+        assertEquals(1, command3.getExecutionEvents().size());
+        assertTrue(command3.getExecutionEvents().contains(HystrixEventType.SUCCESS));
+
+        assertEquals(3, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(0, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(3, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command1.isExecutedInThread());
+        assertFalse(command2.isExecutedInThread());
+        assertFalse(command3.isExecutedInThread());
+    }
+
+    @Test
+    public void testNoRequestCacheOnTimeoutThrowsException() throws Exception {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        NoRequestCacheTimeoutWithoutFallback r1 = new NoRequestCacheTimeoutWithoutFallback(circuitBreaker);
+        try {
+            System.out.println("r1 value: " + r1.observe().toBlocking().single());
+            // we should have thrown an exception
+            fail("expected a timeout");
+        } catch (HystrixRuntimeException e) {
+            assertTrue(r1.isResponseTimedOut());
+            // what we want
+        }
+
+        NoRequestCacheTimeoutWithoutFallback r2 = new NoRequestCacheTimeoutWithoutFallback(circuitBreaker);
+        try {
+            r2.observe().toBlocking().single();
+            // we should have thrown an exception
+            fail("expected a timeout");
+        } catch (HystrixRuntimeException e) {
+            assertTrue(r2.isResponseTimedOut());
+            // what we want
+        }
+
+        NoRequestCacheTimeoutWithoutFallback r3 = new NoRequestCacheTimeoutWithoutFallback(circuitBreaker);
+        Future<Boolean> f3 = r3.observe().toBlocking().toFuture();
+        try {
+            f3.get();
+            // we should have thrown an exception
+            fail("expected a timeout");
+        } catch (ExecutionException e) {
+            e.printStackTrace();
+            assertTrue(r3.isResponseTimedOut());
+            // what we want
+        }
+
+        Thread.sleep(500); // timeout on command is set to 200ms
+
+        NoRequestCacheTimeoutWithoutFallback r4 = new NoRequestCacheTimeoutWithoutFallback(circuitBreaker);
+        try {
+            r4.observe().toBlocking().single();
+            // we should have thrown an exception
+            fail("expected a timeout");
+        } catch (HystrixRuntimeException e) {
+            assertTrue(r4.isResponseTimedOut());
+            assertFalse(r4.isResponseFromFallback());
+            // what we want
+        }
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(4, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(4, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(4, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    @Test
+    public void testRequestCacheOnTimeoutCausesNullPointerException() throws Exception {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        // Expect it to time out - all results should be false
+        assertFalse(new RequestCacheNullPointerExceptionCase(circuitBreaker).observe().toBlocking().single());
+        assertFalse(new RequestCacheNullPointerExceptionCase(circuitBreaker).observe().toBlocking().single()); // return from cache #1
+        assertFalse(new RequestCacheNullPointerExceptionCase(circuitBreaker).observe().toBlocking().single()); // return from cache #2
+        Thread.sleep(500); // timeout on command is set to 200ms
+        Boolean value = new RequestCacheNullPointerExceptionCase(circuitBreaker).observe().toBlocking().single(); // return from cache #3
+        assertFalse(value);
+        RequestCacheNullPointerExceptionCase c = new RequestCacheNullPointerExceptionCase(circuitBreaker);
+        Future<Boolean> f = c.observe().toBlocking().toFuture(); // return from cache #4
+        // the bug is that we're getting a null Future back, rather than a Future that returns false
+        assertNotNull(f);
+        assertFalse(f.get());
+
+        assertTrue(c.isResponseFromFallback());
+        assertTrue(c.isResponseTimedOut());
+        assertFalse(c.isFailedExecution());
+        assertFalse(c.isResponseShortCircuited());
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(4, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(5, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        HystrixExecutableInfo<?>[] executeCommands = HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().toArray(new HystrixAsyncCommand<?>[] {});
+
+        System.out.println(":executeCommands[0].getExecutionEvents()" + executeCommands[0].getExecutionEvents());
+        assertEquals(2, executeCommands[0].getExecutionEvents().size());
+        assertTrue(executeCommands[0].getExecutionEvents().contains(HystrixEventType.FALLBACK_SUCCESS));
+        assertTrue(executeCommands[0].getExecutionEvents().contains(HystrixEventType.TIMEOUT));
+        assertTrue(executeCommands[0].getExecutionTimeInMilliseconds() > -1);
+        assertTrue(executeCommands[0].isResponseTimedOut());
+        assertTrue(executeCommands[0].isResponseFromFallback());
+        assertFalse(executeCommands[0].isResponseFromCache());
+
+        assertEquals(3, executeCommands[1].getExecutionEvents().size()); // it will include FALLBACK_SUCCESS/TIMEOUT + RESPONSE_FROM_CACHE
+        assertTrue(executeCommands[1].getExecutionEvents().contains(HystrixEventType.RESPONSE_FROM_CACHE));
+        assertTrue(executeCommands[1].getExecutionTimeInMilliseconds() == -1);
+        assertTrue(executeCommands[1].isResponseFromCache());
+        assertTrue(executeCommands[1].isResponseTimedOut());
+        assertTrue(executeCommands[1].isResponseFromFallback());
+    }
+
+    //
+    @Test
+    public void testRequestCacheOnTimeoutThrowsException() throws Exception {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        RequestCacheTimeoutWithoutFallback r1 = new RequestCacheTimeoutWithoutFallback(circuitBreaker);
+        try {
+            System.out.println("r1 value: " + r1.observe().toBlocking().single());
+            // we should have thrown an exception
+            fail("expected a timeout");
+        } catch (HystrixRuntimeException e) {
+            assertTrue(r1.isResponseTimedOut());
+            // what we want
+        }
+
+        RequestCacheTimeoutWithoutFallback r2 = new RequestCacheTimeoutWithoutFallback(circuitBreaker);
+        try {
+            r2.observe().toBlocking().single();
+            // we should have thrown an exception
+            fail("expected a timeout");
+        } catch (HystrixRuntimeException e) {
+            assertTrue(r2.isResponseTimedOut());
+            // what we want
+        }
+
+        RequestCacheTimeoutWithoutFallback r3 = new RequestCacheTimeoutWithoutFallback(circuitBreaker);
+        Future<Boolean> f3 = r3.observe().toBlocking().toFuture();
+        try {
+            f3.get();
+            // we should have thrown an exception
+            fail("expected a timeout");
+        } catch (ExecutionException e) {
+            e.printStackTrace();
+            assertTrue(r3.isResponseTimedOut());
+            // what we want
+        }
+
+        Thread.sleep(500); // timeout on command is set to 200ms
+
+        RequestCacheTimeoutWithoutFallback r4 = new RequestCacheTimeoutWithoutFallback(circuitBreaker);
+        try {
+            r4.observe().toBlocking().single();
+            // we should have thrown an exception
+            fail("expected a timeout");
+        } catch (HystrixRuntimeException e) {
+            assertTrue(r4.isResponseTimedOut());
+            assertFalse(r4.isResponseFromFallback());
+            // what we want
+        }
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(3, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(4, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    @Test
+    public void testRequestCacheOnThreadRejectionThrowsException() throws Exception {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        CountDownLatch completionLatch = new CountDownLatch(1);
+        RequestCacheThreadRejectionWithoutFallback r1 = new RequestCacheThreadRejectionWithoutFallback(circuitBreaker, completionLatch);
+        try {
+            System.out.println("r1: " + r1.observe().toBlocking().single());
+            // we should have thrown an exception
+            fail("expected a rejection");
+        } catch (HystrixRuntimeException e) {
+            e.printStackTrace();
+            assertTrue(r1.isResponseRejected());
+            // what we want
+        }
+
+        RequestCacheThreadRejectionWithoutFallback r2 = new RequestCacheThreadRejectionWithoutFallback(circuitBreaker, completionLatch);
+        try {
+            System.out.println("r2: " + r2.observe().toBlocking().single());
+            // we should have thrown an exception
+            fail("expected a rejection");
+        } catch (HystrixRuntimeException e) {
+            //                e.printStackTrace();
+            assertTrue(r2.isResponseRejected());
+            // what we want
+        }
+
+        RequestCacheThreadRejectionWithoutFallback r3 = new RequestCacheThreadRejectionWithoutFallback(circuitBreaker, completionLatch);
+        try {
+            System.out.println("f3: " + r3.observe().toBlocking().toFuture().get());
+            // we should have thrown an exception
+            fail("expected a rejection");
+        } catch (ExecutionException e) {
+            assertTrue(r3.isResponseRejected());
+            assertTrue(e.getCause() instanceof HystrixRuntimeException);
+        }
+
+        // let the command finish (only 1 should actually be blocked on this due to the response cache)
+        completionLatch.countDown();
+
+        // then another after the command has completed
+        RequestCacheThreadRejectionWithoutFallback r4 = new RequestCacheThreadRejectionWithoutFallback(circuitBreaker, completionLatch);
+        try {
+            System.out.println("r4: " + r4.observe().toBlocking().single());
+            // we should have thrown an exception
+            fail("expected a rejection");
+        } catch (HystrixRuntimeException e) {
+            //                e.printStackTrace();
+            assertTrue(r4.isResponseRejected());
+            assertFalse(r4.isResponseFromFallback());
+            // what we want
+        }
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(3, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, circuitBreaker.metrics.getHealthCounts().getErrorPercentage());
+
+        //        assertEquals(4, HystrixRequestLog.getCurrentRequest().getExecutedCommands().size());
+    }
+
+    /**
+     * Test that we can do basic execution without a RequestVariable being initialized.
+     */
+    @Test
+    public void testBasicExecutionWorksWithoutRequestVariable() {
+        try {
+            /* force the RequestVariable to not be initialized */
+            HystrixRequestContext.setContextOnCurrentThread(null);
+
+            TestHystrixCommand<Boolean> command = new SuccessfulTestCommand();
+            assertEquals(true, command.observe().toBlocking().single());
+
+            TestHystrixCommand<Boolean> command2 = new SuccessfulTestCommand();
+            assertEquals(true, command2.observe().toBlocking().toFuture().get());
+
+            // we should be able to execute without a RequestVariable if ...
+            // 1) We don't have a cacheKey
+            // 2) We don't ask for the RequestLog
+            // 3) We don't do collapsing
+
+            // semaphore isolated
+            assertFalse(command.isExecutedInThread());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We received an exception => " + e.getMessage());
+        }
+    }
+
+    /**
+     * Test that if we try and execute a command with a cacheKey without initializing RequestVariable that it gives an error.
+     */
+    @Test
+    public void testCacheKeyExecutionRequiresRequestVariable() {
+        try {
+            /* force the RequestVariable to not be initialized */
+            HystrixRequestContext.setContextOnCurrentThread(null);
+
+            TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+
+            SuccessfulCacheableCommand command = new SuccessfulCacheableCommand(circuitBreaker, true, "one");
+            assertEquals(true, command.observe().toBlocking().single());
+
+            SuccessfulCacheableCommand command2 = new SuccessfulCacheableCommand(circuitBreaker, true, "two");
+            assertEquals(true, command2.observe().toBlocking().toFuture().get());
+
+            fail("We expect an exception because cacheKey requires RequestVariable.");
+
+            // semaphore isolated
+            assertFalse(command.isExecutedInThread());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Test that a BadRequestException can be thrown and not count towards errors and bypasses fallback.
+     */
+    @Test
+    public void testBadRequestExceptionViaExecuteInThread() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        try {
+            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.THREAD).observe().toBlocking().single();
+            fail("we expect to receive a " + HystrixBadRequestException.class.getSimpleName());
+        } catch (HystrixBadRequestException e) {
+            // success
+            e.printStackTrace();
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We expect a " + HystrixBadRequestException.class.getSimpleName() + " but got a " + e.getClass().getSimpleName());
+        }
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+    }
+
+    /**
+     * Test that a BadRequestException can be thrown and not count towards errors and bypasses fallback.
+     */
+    @Test
+    public void testBadRequestExceptionViaQueueInThread() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        try {
+            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.THREAD).observe().toBlocking().toFuture().get();
+            fail("we expect to receive a " + HystrixBadRequestException.class.getSimpleName());
+        } catch (ExecutionException e) {
+            e.printStackTrace();
+            if (e.getCause() instanceof HystrixBadRequestException) {
+                // success    
+            } else {
+                fail("We expect a " + HystrixBadRequestException.class.getSimpleName() + " but got a " + e.getClass().getSimpleName());
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail();
+        }
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+    }
+
+    /**
+     * Test that BadRequestException behavior works the same on a cached response.
+     */
+    @Test
+    public void testBadRequestExceptionViaQueueInThreadOnResponseFromCache() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+
+        // execute once to cache the value
+        try {
+            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.THREAD).observe().toBlocking().single();
+        } catch (Throwable e) {
+            // ignore
+        }
+
+        try {
+            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.THREAD).observe().toBlocking().toFuture().get();
+            fail("we expect to receive a " + HystrixBadRequestException.class.getSimpleName());
+        } catch (ExecutionException e) {
+            e.printStackTrace();
+            if (e.getCause() instanceof HystrixBadRequestException) {
+                // success    
+            } else {
+                fail("We expect a " + HystrixBadRequestException.class.getSimpleName() + " but got a " + e.getClass().getSimpleName());
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail();
+        }
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+    }
+
+    /**
+     * Test that a BadRequestException can be thrown and not count towards errors and bypasses fallback.
+     */
+    @Test
+    public void testBadRequestExceptionViaExecuteInSemaphore() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        try {
+            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.SEMAPHORE).observe().toBlocking().single();
+            fail("we expect to receive a " + HystrixBadRequestException.class.getSimpleName());
+        } catch (HystrixBadRequestException e) {
+            // success
+            e.printStackTrace();
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We expect a " + HystrixBadRequestException.class.getSimpleName() + " but got a " + e.getClass().getSimpleName());
+        }
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+    }
+
+    /**
+     * Test that a BadRequestException can be thrown and not count towards errors and bypasses fallback.
+     */
+    @Test
+    public void testBadRequestExceptionViaQueueInSemaphore() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        try {
+            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.SEMAPHORE).observe().toBlocking().toFuture().get();
+            fail("we expect to receive a " + HystrixBadRequestException.class.getSimpleName());
+        } catch (ExecutionException e) {
+            e.printStackTrace();
+            if (e.getCause() instanceof HystrixBadRequestException) {
+                // success    
+            } else {
+                fail("We expect a " + HystrixBadRequestException.class.getSimpleName() + " but got a " + e.getClass().getSimpleName());
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail();
+        }
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+    }
+
+    /**
+     * Test a checked Exception being thrown
+     */
+    @Test
+    public void testCheckedExceptionViaExecute() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        CommandWithCheckedException command = new CommandWithCheckedException(circuitBreaker);
+        try {
+            command.observe().toBlocking().single();
+            fail("we expect to receive a " + Exception.class.getSimpleName());
+        } catch (Exception e) {
+            assertEquals("simulated checked exception message", e.getCause().getMessage());
+        }
+
+        assertEquals("simulated checked exception message", command.getFailedExecutionException().getMessage());
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+    }
+
+    /**
+     * Test a java.lang.Error being thrown
+     * 
+     * @throws InterruptedException
+     */
+    @Test
+    public void testCheckedExceptionViaObserve() throws InterruptedException {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        CommandWithCheckedException command = new CommandWithCheckedException(circuitBreaker);
+        final AtomicReference<Throwable> t = new AtomicReference<Throwable>();
+        final CountDownLatch latch = new CountDownLatch(1);
+        try {
+            command.observe().subscribe(new Observer<Boolean>() {
+
+                @Override
+                public void onCompleted() {
+                    latch.countDown();
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    t.set(e);
+                    latch.countDown();
+                }
+
+                @Override
+                public void onNext(Boolean args) {
+
+                }
+
+            });
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("we should not get anything thrown, it should be emitted via the Observer#onError method");
+        }
+
+        latch.await(1, TimeUnit.SECONDS);
+        assertNotNull(t.get());
+        t.get().printStackTrace();
+
+        assertTrue(t.get() instanceof HystrixRuntimeException);
+        assertEquals("simulated checked exception message", t.get().getCause().getMessage());
+        assertEquals("simulated checked exception message", command.getFailedExecutionException().getMessage());
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a java.lang.Error being thrown
+     */
+    @Test
+    public void testErrorThrownViaExecute() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        CommandWithErrorThrown command = new CommandWithErrorThrown(circuitBreaker);
+        try {
+            command.observe().toBlocking().single();
+            fail("we expect to receive a " + Error.class.getSimpleName());
+        } catch (Exception e) {
+            // the actual error is an extra cause level deep because Hystrix needs to wrap Throwable/Error as it's public
+            // methods only support Exception and it's not a strong enough reason to break backwards compatibility and jump to version 2.x
+            // so HystrixRuntimeException -> wrapper Exception -> actual Error
+            assertEquals("simulated java.lang.Error message", e.getCause().getCause().getMessage());
+        }
+
+        assertEquals("simulated java.lang.Error message", command.getFailedExecutionException().getCause().getMessage());
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a java.lang.Error being thrown
+     */
+    @Test
+    public void testErrorThrownViaQueue() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        CommandWithErrorThrown command = new CommandWithErrorThrown(circuitBreaker);
+        try {
+            command.observe().toBlocking().toFuture().get();
+            fail("we expect to receive an Exception");
+        } catch (Exception e) {
+            // one cause down from ExecutionException to HystrixRuntime
+            // then the actual error is an extra cause level deep because Hystrix needs to wrap Throwable/Error as it's public
+            // methods only support Exception and it's not a strong enough reason to break backwards compatibility and jump to version 2.x
+            // so ExecutionException -> HystrixRuntimeException -> wrapper Exception -> actual Error
+            assertEquals("simulated java.lang.Error message", e.getCause().getCause().getCause().getMessage());
+        }
+
+        assertEquals("simulated java.lang.Error message", command.getFailedExecutionException().getCause().getMessage());
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a java.lang.Error being thrown
+     * 
+     * @throws InterruptedException
+     */
+    @Test
+    public void testErrorThrownViaObserve() throws InterruptedException {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        CommandWithErrorThrown command = new CommandWithErrorThrown(circuitBreaker);
+        final AtomicReference<Throwable> t = new AtomicReference<Throwable>();
+        final CountDownLatch latch = new CountDownLatch(1);
+        try {
+            command.observe().subscribe(new Observer<Boolean>() {
+
+                @Override
+                public void onCompleted() {
+                    latch.countDown();
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    t.set(e);
+                    latch.countDown();
+                }
+
+                @Override
+                public void onNext(Boolean args) {
+
+                }
+
+            });
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("we should not get anything thrown, it should be emitted via the Observer#onError method");
+        }
+
+        latch.await(1, TimeUnit.SECONDS);
+        assertNotNull(t.get());
+        t.get().printStackTrace();
+
+        assertTrue(t.get() instanceof HystrixRuntimeException);
+        // the actual error is an extra cause level deep because Hystrix needs to wrap Throwable/Error as it's public
+        // methods only support Exception and it's not a strong enough reason to break backwards compatibility and jump to version 2.x
+        assertEquals("simulated java.lang.Error message", t.get().getCause().getCause().getMessage());
+        assertEquals("simulated java.lang.Error message", command.getFailedExecutionException().getCause().getMessage());
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Execution hook on successful execution
+     */
+    @Test
+    public void testExecutionHookSuccessfulCommand() {
+        //test with observe().toBlocking().single() 
+        TestHystrixCommand<Boolean> command = new SuccessfulTestCommand();
+        command.observe().toBlocking().single();
+
+        // the run() method should run as we're not short-circuited or rejected
+        assertEquals(1, command.builder.executionHook.startRun.get());
+        // we expect a successful response from run()
+        assertNotNull(command.builder.executionHook.runSuccessResponse);
+        // we do not expect an exception
+        assertNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should not be run as we were successful
+        assertEquals(0, command.builder.executionHook.startFallback.get());
+        // null since it didn't run
+        assertNull(command.builder.executionHook.fallbackSuccessResponse);
+        // null since it didn't run
+        assertNull(command.builder.executionHook.fallbackFailureException);
+
+        // the observe().toBlocking().single() method was used
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should have a response from observe().toBlocking().single() since run() succeeded
+        assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we should not have an exception since run() succeeded
+        assertNull(command.builder.executionHook.endExecuteFailureException);
+
+        // thread execution
+        //        assertEquals(1, command.builder.executionHook.threadStart.get());
+        //        assertEquals(1, command.builder.executionHook.threadComplete.get());
+
+        // test with observe().toBlocking().toFuture() 
+        command = new SuccessfulTestCommand();
+        try {
+            command.observe().toBlocking().toFuture().get();
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        // the run() method should run as we're not short-circuited or rejected
+        assertEquals(1, command.builder.executionHook.startRun.get());
+        // we expect a successful response from run()
+        assertNotNull(command.builder.executionHook.runSuccessResponse);
+        // we do not expect an exception
+        assertNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should not be run as we were successful
+        assertEquals(0, command.builder.executionHook.startFallback.get());
+        // null since it didn't run
+        assertNull(command.builder.executionHook.fallbackSuccessResponse);
+        // null since it didn't run
+        assertNull(command.builder.executionHook.fallbackFailureException);
+
+        // the observe().toBlocking().toFuture() method was used
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should have a response from observe().toBlocking().toFuture() since run() succeeded
+        assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we should not have an exception since run() succeeded
+        assertNull(command.builder.executionHook.endExecuteFailureException);
+
+        // thread execution
+        //    assertEquals(1, command.builder.executionHook.threadStart.get());
+        //   assertEquals(1, command.builder.executionHook.threadComplete.get());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Execution hook on successful execution with "fire and forget" approach
+     */
+    @Test
+    public void testExecutionHookSuccessfulCommandViaFireAndForget() {
+        TestHystrixCommand<Boolean> command = new SuccessfulTestCommand();
+        try {
+            // do not block on "get()" ... fire this asynchronously
+            command.observe().toBlocking().toFuture();
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        // wait for command to execute without calling get on the future
+        while (!command.isExecutionComplete()) {
+            try {
+                Thread.sleep(10);
+            } catch (InterruptedException e) {
+                throw new RuntimeException("interrupted");
+            }
+        }
+
+        /* All the hooks should still work even though we didn't call get() on the future */
+
+        // the run() method should run as we're not short-circuited or rejected
+        assertEquals(1, command.builder.executionHook.startRun.get());
+        // we expect a successful response from run()
+        assertNotNull(command.builder.executionHook.runSuccessResponse);
+        // we do not expect an exception
+        assertNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should not be run as we were successful
+        assertEquals(0, command.builder.executionHook.startFallback.get());
+        // null since it didn't run
+        assertNull(command.builder.executionHook.fallbackSuccessResponse);
+        // null since it didn't run
+        assertNull(command.builder.executionHook.fallbackFailureException);
+
+        // the observe().toBlocking().toFuture() method was used
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should have a response from observe().toBlocking().toFuture() since run() succeeded
+        assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we should not have an exception since run() succeeded
+        assertNull(command.builder.executionHook.endExecuteFailureException);
+
+        // thread execution
+        //        assertEquals(1, command.builder.executionHook.threadStart.get());
+        //        assertEquals(1, command.builder.executionHook.threadComplete.get());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Execution hook on successful execution with multiple get() calls to Future
+     */
+    @Test
+    public void testExecutionHookSuccessfulCommandWithMultipleGetsOnFuture() {
+        TestHystrixCommand<Boolean> command = new SuccessfulTestCommand();
+        try {
+            Future<Boolean> f = command.observe().toBlocking().toFuture();
+            f.get();
+            f.get();
+            f.get();
+            f.get();
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        /* Despite multiple calls to get() we should only have 1 call to the hooks. */
+
+        // the run() method should run as we're not short-circuited or rejected
+        assertEquals(1, command.builder.executionHook.startRun.get());
+        // we expect a successful response from run()
+        assertNotNull(command.builder.executionHook.runSuccessResponse);
+        // we do not expect an exception
+        assertNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should not be run as we were successful
+        assertEquals(0, command.builder.executionHook.startFallback.get());
+        // null since it didn't run
+        assertNull(command.builder.executionHook.fallbackSuccessResponse);
+        // null since it didn't run
+        assertNull(command.builder.executionHook.fallbackFailureException);
+
+        // the observe().toBlocking().toFuture() method was used
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should have a response from observe().toBlocking().toFuture() since run() succeeded
+        assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we should not have an exception since run() succeeded
+        assertNull(command.builder.executionHook.endExecuteFailureException);
+
+        // thread execution
+        //        assertEquals(1, command.builder.executionHook.threadStart.get());
+        //        assertEquals(1, command.builder.executionHook.threadComplete.get());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Execution hook on failed execution without a fallback
+     */
+    @Test
+    public void testExecutionHookRunFailureWithoutFallback() {
+        // test with observe().toBlocking().single() 
+        TestHystrixCommand<Boolean> command = new UnknownFailureTestCommandWithoutFallback();
+        try {
+            command.observe().toBlocking().single();
+            fail("Expecting exception");
+        } catch (Exception e) {
+            // ignore
+        }
+
+        // the run() method should run as we're not short-circuited or rejected
+        assertEquals(1, command.builder.executionHook.startRun.get());
+        // we should not have a response
+        assertNull(command.builder.executionHook.runSuccessResponse);
+        // we should have an exception
+        assertNotNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should be run since run() failed
+        assertEquals(1, command.builder.executionHook.startFallback.get());
+        // no response since fallback is not implemented
+        assertNull(command.builder.executionHook.fallbackSuccessResponse);
+        // not null since it's not implemented and throws an exception
+        assertNotNull(command.builder.executionHook.fallbackFailureException);
+
+        // the observe().toBlocking().single() method was used
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should not have a response from observe().toBlocking().single() since we do not have a fallback and run() failed
+        assertNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we should have an exception since run() failed
+        assertNotNull(command.builder.executionHook.endExecuteFailureException);
+        // run() failure
+        assertEquals(FailureType.COMMAND_EXCEPTION, command.builder.executionHook.endExecuteFailureType);
+
+        // thread execution
+        //        assertEquals(1, command.builder.executionHook.threadStart.get());
+        //        assertEquals(1, command.builder.executionHook.threadComplete.get());
+
+        // test with observe().toBlocking().toFuture() 
+        command = new UnknownFailureTestCommandWithoutFallback();
+        try {
+            command.observe().toBlocking().toFuture().get();
+            fail("Expecting exception");
+        } catch (Exception e) {
+            // ignore
+        }
+
+        // the run() method should run as we're not short-circuited or rejected
+        assertEquals(1, command.builder.executionHook.startRun.get());
+        // we should not have a response
+        assertNull(command.builder.executionHook.runSuccessResponse);
+        // we should have an exception
+        assertNotNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should be run since run() failed
+        assertEquals(1, command.builder.executionHook.startFallback.get());
+        // no response since fallback is not implemented
+        assertNull(command.builder.executionHook.fallbackSuccessResponse);
+        // not null since it's not implemented and throws an exception
+        assertNotNull(command.builder.executionHook.fallbackFailureException);
+
+        // the observe().toBlocking().toFuture() method was used
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should not have a response from observe().toBlocking().toFuture() since we do not have a fallback and run() failed
+        assertNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we should have an exception since run() failed
+        assertNotNull(command.builder.executionHook.endExecuteFailureException);
+        // run() failure
+        assertEquals(FailureType.COMMAND_EXCEPTION, command.builder.executionHook.endExecuteFailureType);
+
+        // thread execution
+        //        assertEquals(1, command.builder.executionHook.threadStart.get());
+        //        assertEquals(1, command.builder.executionHook.threadComplete.get());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+
+    }
+
+    /**
+     * Execution hook on failed execution with a fallback
+     */
+    @Test
+    public void testExecutionHookRunFailureWithFallback() {
+        // test with observe().toBlocking().single() 
+        TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithFallback(new TestCircuitBreaker());
+        command.observe().toBlocking().single();
+
+        // the run() method should run as we're not short-circuited or rejected
+        assertEquals(1, command.builder.executionHook.startRun.get());
+        // we should not have a response from run since run() failed
+        assertNull(command.builder.executionHook.runSuccessResponse);
+        // we should have an exception since run() failed
+        assertNotNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should be run since run() failed
+        assertEquals(1, command.builder.executionHook.startFallback.get());
+        // a response since fallback is implemented
+        assertNotNull(command.builder.executionHook.fallbackSuccessResponse);
+        // null since it's implemented and succeeds
+        assertNull(command.builder.executionHook.fallbackFailureException);
+
+        // the observe().toBlocking().single() method was used
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should have a response from observe().toBlocking().single() since we expect a fallback despite failure of run()
+        assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we should not have an exception because we expect a fallback
+        assertNull(command.builder.executionHook.endExecuteFailureException);
+
+        // thread execution
+        //        assertEquals(1, command.builder.executionHook.threadStart.get());
+        //        assertEquals(1, command.builder.executionHook.threadComplete.get());
+
+        // test with observe().toBlocking().toFuture() 
+        command = new KnownFailureTestCommandWithFallback(new TestCircuitBreaker());
+        try {
+            command.observe().toBlocking().toFuture().get();
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        // the run() method should run as we're not short-circuited or rejected
+        assertEquals(1, command.builder.executionHook.startRun.get());
+        // we should not have a response from run since run() failed
+        assertNull(command.builder.executionHook.runSuccessResponse);
+        // we should have an exception since run() failed
+        assertNotNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should be run since run() failed
+        assertEquals(1, command.builder.executionHook.startFallback.get());
+        // a response since fallback is implemented
+        assertNotNull(command.builder.executionHook.fallbackSuccessResponse);
+        // null since it's implemented and succeeds
+        assertNull(command.builder.executionHook.fallbackFailureException);
+
+        // the observe().toBlocking().toFuture() method was used
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should have a response from observe().toBlocking().toFuture() since we expect a fallback despite failure of run()
+        assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we should not have an exception because we expect a fallback
+        assertNull(command.builder.executionHook.endExecuteFailureException);
+
+        // thread execution
+        //        assertEquals(1, command.builder.executionHook.threadStart.get());
+        //        assertEquals(1, command.builder.executionHook.threadComplete.get());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Execution hook on failed execution with a fallback failure
+     */
+    @Test
+    public void testExecutionHookRunFailureWithFallbackFailure() {
+        // test with observe().toBlocking().single() 
+        TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithFallbackFailure();
+        try {
+            command.observe().toBlocking().single();
+            fail("Expecting exception");
+        } catch (Exception e) {
+            // ignore
+        }
+
+        // the run() method should run as we're not short-circuited or rejected
+        assertEquals(1, command.builder.executionHook.startRun.get());
+        // we should not have a response because run() and fallback fail
+        assertNull(command.builder.executionHook.runSuccessResponse);
+        // we should have an exception because run() and fallback fail
+        assertNotNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should be run since run() failed
+        assertEquals(1, command.builder.executionHook.startFallback.get());
+        // no response since fallback fails
+        assertNull(command.builder.executionHook.fallbackSuccessResponse);
+        // not null since it's implemented but fails
+        assertNotNull(command.builder.executionHook.fallbackFailureException);
+
+        // the observe().toBlocking().single() method was used
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should not have a response because run() and fallback fail
+        assertNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we should have an exception because run() and fallback fail
+        assertNotNull(command.builder.executionHook.endExecuteFailureException);
+        // run() failure
+        assertEquals(FailureType.COMMAND_EXCEPTION, command.builder.executionHook.endExecuteFailureType);
+
+        // thread execution
+        //        assertEquals(1, command.builder.executionHook.threadStart.get());
+        //        assertEquals(1, command.builder.executionHook.threadComplete.get());
+
+        // test with observe().toBlocking().toFuture() 
+        command = new KnownFailureTestCommandWithFallbackFailure();
+        try {
+            command.observe().toBlocking().toFuture().get();
+            fail("Expecting exception");
+        } catch (Exception e) {
+            // ignore
+        }
+
+        // the run() method should run as we're not short-circuited or rejected
+        assertEquals(1, command.builder.executionHook.startRun.get());
+        // we should not have a response because run() and fallback fail
+        assertNull(command.builder.executionHook.runSuccessResponse);
+        // we should have an exception because run() and fallback fail
+        assertNotNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should be run since run() failed
+        assertEquals(1, command.builder.executionHook.startFallback.get());
+        // no response since fallback fails
+        assertNull(command.builder.executionHook.fallbackSuccessResponse);
+        // not null since it's implemented but fails
+        assertNotNull(command.builder.executionHook.fallbackFailureException);
+
+        // the observe().toBlocking().toFuture() method was used
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should not have a response because run() and fallback fail
+        assertNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we should have an exception because run() and fallback fail
+        assertNotNull(command.builder.executionHook.endExecuteFailureException);
+        // run() failure
+        assertEquals(FailureType.COMMAND_EXCEPTION, command.builder.executionHook.endExecuteFailureType);
+
+        // thread execution
+        //        assertEquals(1, command.builder.executionHook.threadStart.get());
+        //        assertEquals(1, command.builder.executionHook.threadComplete.get());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Execution hook on timeout without a fallback
+     */
+    @Test
+    public void testExecutionHookTimeoutWithoutFallback() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_NOT_IMPLEMENTED);
+        try {
+            System.out.println("start at : " + System.currentTimeMillis());
+            command.observe().toBlocking().toFuture().get();
+            fail("Expecting exception");
+        } catch (Exception e) {
+            // ignore
+        }
+
+        // the run() method should run as we're not short-circuited or rejected
+        assertEquals(1, command.builder.executionHook.startRun.get());
+        // we should not have a response because of timeout and no fallback
+        assertNull(command.builder.executionHook.runSuccessResponse);
+        // we should not have an exception because run() didn't fail, it timed out
+        assertNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should be run due to timeout
+        assertEquals(1, command.builder.executionHook.startFallback.get());
+        // no response since no fallback
+        assertNull(command.builder.executionHook.fallbackSuccessResponse);
+        // not null since no fallback implementation
+        assertNotNull(command.builder.executionHook.fallbackFailureException);
+
+        // execution occurred
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should not have a response because of timeout and no fallback
+        assertNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we should have an exception because of timeout and no fallback
+        assertNotNull(command.builder.executionHook.endExecuteFailureException);
+        // timeout failure
+        assertEquals(FailureType.TIMEOUT, command.builder.executionHook.endExecuteFailureType);
+
+        // thread execution
+        //    assertEquals(1, command.builder.executionHook.threadStart.get());
+
+        // we need to wait for the thread to complete before the onThreadComplete hook will be called
+        //        try {
+        //            Thread.sleep(400);
+        //        } catch (InterruptedException e) {
+        //            // ignore
+        //        }
+        //    assertEquals(1, command.builder.executionHook.threadComplete.get());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Execution hook on timeout with a fallback
+     */
+    @Test
+    public void testExecutionHookTimeoutWithFallback() {
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_SUCCESS);
+        try {
+            command.observe().toBlocking().toFuture().get();
+        } catch (Exception e) {
+            throw new RuntimeException("not expecting", e);
+        }
+
+        // the run() method should run as we're not short-circuited or rejected
+        assertEquals(1, command.builder.executionHook.startRun.get());
+        // we should not have a response because of timeout
+        assertNull(command.builder.executionHook.runSuccessResponse);
+        // we should not have an exception because run() didn't fail, it timed out
+        assertNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should be run due to timeout
+        assertEquals(1, command.builder.executionHook.startFallback.get());
+        // response since we have a fallback
+        assertNotNull(command.builder.executionHook.fallbackSuccessResponse);
+        // null since fallback succeeds
+        assertNull(command.builder.executionHook.fallbackFailureException);
+
+        // execution occurred
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should have a response because of fallback
+        assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we should not have an exception because of fallback
+        assertNull(command.builder.executionHook.endExecuteFailureException);
+
+        // thread execution
+        // assertEquals(1, command.builder.executionHook.threadStart.get());
+
+        // we need to wait for the thread to complete before the onThreadComplete hook will be called
+        //        try {
+        //            Thread.sleep(400);
+        //        } catch (InterruptedException e) {
+        //            // ignore
+        //        }
+        //        assertEquals(1, command.builder.executionHook.threadComplete.get());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Execution hook on rejected with a fallback
+     */
+    /*
+     * @Test
+     * public void testExecutionHookRejectedWithFallback() {
+     * TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+     * SingleThreadedPool pool = new SingleThreadedPool(1);
+     * 
+     * try {
+     * // fill the queue
+     * new TestCommandRejection(circuitBreaker, pool, 500, 600, TestCommandRejection.FALLBACK_SUCCESS).observe().toBlocking().toFuture();
+     * new TestCommandRejection(circuitBreaker, pool, 500, 600, TestCommandRejection.FALLBACK_SUCCESS).observe().toBlocking().toFuture();
+     * } catch (Exception e) {
+     * // ignore
+     * }
+     * 
+     * TestCommandRejection command = new TestCommandRejection(circuitBreaker, pool, 500, 600, TestCommandRejection.FALLBACK_SUCCESS);
+     * try {
+     * // now execute one that will be rejected
+     * command.observe().toBlocking().toFuture().get();
+     * } catch (Exception e) {
+     * throw new RuntimeException("not expecting", e);
+     * }
+     * 
+     * assertTrue(command.isResponseRejected());
+     * 
+     * // the run() method should not run as we're rejected
+     * assertEquals(0, command.builder.executionHook.startRun.get());
+     * // we should not have a response because of rejection
+     * assertNull(command.builder.executionHook.runSuccessResponse);
+     * // we should not have an exception because we didn't run
+     * assertNull(command.builder.executionHook.runFailureException);
+     * 
+     * // the fallback() method should be run due to rejection
+     * assertEquals(1, command.builder.executionHook.startFallback.get());
+     * // response since we have a fallback
+     * assertNotNull(command.builder.executionHook.fallbackSuccessResponse);
+     * // null since fallback succeeds
+     * assertNull(command.builder.executionHook.fallbackFailureException);
+     * 
+     * // execution occurred
+     * assertEquals(1, command.builder.executionHook.startExecute.get());
+     * // we should have a response because of fallback
+     * assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
+     * // we should not have an exception because of fallback
+     * assertNull(command.builder.executionHook.endExecuteFailureException);
+     * 
+     * // thread execution
+     * // assertEquals(0, command.builder.executionHook.threadStart.get());
+     * // assertEquals(0, command.builder.executionHook.threadComplete.get());
+     * }
+     */
+    /**
+     * Execution hook on short-circuit with a fallback
+     */
+    @Test
+    public void testExecutionHookShortCircuitedWithFallbackViaQueue() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker().setForceShortCircuit(true);
+        KnownFailureTestCommandWithoutFallback command = new KnownFailureTestCommandWithoutFallback(circuitBreaker);
+        try {
+            // now execute one that will be short-circuited
+            command.observe().toBlocking().toFuture().get();
+            fail("we expect an error as there is no fallback");
+        } catch (Exception e) {
+            // expecting
+        }
+
+        assertTrue(command.isResponseShortCircuited());
+
+        // the run() method should not run as we're rejected
+        assertEquals(0, command.builder.executionHook.startRun.get());
+        // we should not have a response because of rejection
+        assertNull(command.builder.executionHook.runSuccessResponse);
+        // we should not have an exception because we didn't run
+        assertNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should be run due to rejection
+        assertEquals(1, command.builder.executionHook.startFallback.get());
+        // no response since we don't have a fallback
+        assertNull(command.builder.executionHook.fallbackSuccessResponse);
+        // not null since fallback fails and throws an exception
+        assertNotNull(command.builder.executionHook.fallbackFailureException);
+
+        // execution occurred
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should not have a response because fallback fails
+        assertNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we won't have an exception because short-circuit doesn't have one
+        assertNull(command.builder.executionHook.endExecuteFailureException);
+        // but we do expect to receive a onError call with FailureType.SHORTCIRCUIT
+        assertEquals(FailureType.SHORTCIRCUIT, command.builder.executionHook.endExecuteFailureType);
+
+        // thread execution
+        //        assertEquals(0, command.builder.executionHook.threadStart.get());
+        //        assertEquals(0, command.builder.executionHook.threadComplete.get());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Execution hook on short-circuit with a fallback
+     */
+    @Test
+    public void testExecutionHookShortCircuitedWithFallbackViaExecute() {
+        TestCircuitBreaker circuitBreaker = new TestCircuitBreaker().setForceShortCircuit(true);
+        KnownFailureTestCommandWithoutFallback command = new KnownFailureTestCommandWithoutFallback(circuitBreaker);
+        try {
+            // now execute one that will be short-circuited
+            command.observe().toBlocking().single();
+            fail("we expect an error as there is no fallback");
+        } catch (Exception e) {
+            // expecting
+        }
+
+        assertTrue(command.isResponseShortCircuited());
+
+        // the run() method should not run as we're rejected
+        assertEquals(0, command.builder.executionHook.startRun.get());
+        // we should not have a response because of rejection
+        assertNull(command.builder.executionHook.runSuccessResponse);
+        // we should not have an exception because we didn't run
+        assertNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should be run due to rejection
+        assertEquals(1, command.builder.executionHook.startFallback.get());
+        // no response since we don't have a fallback
+        assertNull(command.builder.executionHook.fallbackSuccessResponse);
+        // not null since fallback fails and throws an exception
+        assertNotNull(command.builder.executionHook.fallbackFailureException);
+
+        // execution occurred
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should not have a response because fallback fails
+        assertNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we won't have an exception because short-circuit doesn't have one
+        assertNull(command.builder.executionHook.endExecuteFailureException);
+        // but we do expect to receive a onError call with FailureType.SHORTCIRCUIT
+        assertEquals(FailureType.SHORTCIRCUIT, command.builder.executionHook.endExecuteFailureType);
+
+        // thread execution
+        //        assertEquals(0, command.builder.executionHook.threadStart.get());
+        //        assertEquals(0, command.builder.executionHook.threadComplete.get());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Execution hook on successful execution with semaphore isolation
+     */
+    @Test
+    public void testExecutionHookSuccessfulCommandWithSemaphoreIsolation() {
+        // test with observe().toBlocking().single() 
+        TestSemaphoreCommand command = new TestSemaphoreCommand(new TestCircuitBreaker(), 1, 10);
+        command.observe().toBlocking().single();
+
+        assertFalse(command.isExecutedInThread());
+
+        // the run() method should run as we're not short-circuited or rejected
+        assertEquals(1, command.builder.executionHook.startRun.get());
+        // we expect a successful response from run()
+        assertNotNull(command.builder.executionHook.runSuccessResponse);
+        // we do not expect an exception
+        assertNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should not be run as we were successful
+        assertEquals(0, command.builder.executionHook.startFallback.get());
+        // null since it didn't run
+        assertNull(command.builder.executionHook.fallbackSuccessResponse);
+        // null since it didn't run
+        assertNull(command.builder.executionHook.fallbackFailureException);
+
+        // the observe().toBlocking().single() method was used
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should have a response from observe().toBlocking().single() since run() succeeded
+        assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we should not have an exception since run() succeeded
+        assertNull(command.builder.executionHook.endExecuteFailureException);
+
+        // thread execution
+        assertEquals(0, command.builder.executionHook.threadStart.get());
+        assertEquals(0, command.builder.executionHook.threadComplete.get());
+
+        // test with observe().toBlocking().toFuture() 
+        command = new TestSemaphoreCommand(new TestCircuitBreaker(), 1, 10);
+        try {
+            command.observe().toBlocking().toFuture().get();
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        assertFalse(command.isExecutedInThread());
+
+        // the run() method should run as we're not short-circuited or rejected
+        assertEquals(1, command.builder.executionHook.startRun.get());
+        // we expect a successful response from run()
+        assertNotNull(command.builder.executionHook.runSuccessResponse);
+        // we do not expect an exception
+        assertNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should not be run as we were successful
+        assertEquals(0, command.builder.executionHook.startFallback.get());
+        // null since it didn't run
+        assertNull(command.builder.executionHook.fallbackSuccessResponse);
+        // null since it didn't run
+        assertNull(command.builder.executionHook.fallbackFailureException);
+
+        // the observe().toBlocking().toFuture() method was used
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should have a response from observe().toBlocking().toFuture() since run() succeeded
+        assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we should not have an exception since run() succeeded
+        assertNull(command.builder.executionHook.endExecuteFailureException);
+
+        // thread execution
+        assertEquals(0, command.builder.executionHook.threadStart.get());
+        assertEquals(0, command.builder.executionHook.threadComplete.get());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Execution hook on successful execution with semaphore isolation
+     */
+    @Test
+    public void testExecutionHookFailureWithSemaphoreIsolation() {
+        // test with observe().toBlocking().single() 
+        final TryableSemaphoreActual semaphore =
+                new TryableSemaphoreActual(HystrixProperty.Factory.asProperty(0));
+
+        TestSemaphoreCommand command = new TestSemaphoreCommand(new TestCircuitBreaker(), semaphore, 200);
+        try {
+            command.observe().toBlocking().single();
+            fail("we expect a failure");
+        } catch (Exception e) {
+            // expected
+        }
+
+        assertFalse(command.isExecutedInThread());
+        assertTrue(command.isResponseRejected());
+
+        // the run() method should not run as we are rejected
+        assertEquals(0, command.builder.executionHook.startRun.get());
+        // null as run() does not get invoked
+        assertNull(command.builder.executionHook.runSuccessResponse);
+        // null as run() does not get invoked
+        assertNull(command.builder.executionHook.runFailureException);
+
+        // the fallback() method should run because of rejection
+        assertEquals(1, command.builder.executionHook.startFallback.get());
+        // null since there is no fallback
+        assertNull(command.builder.executionHook.fallbackSuccessResponse);
+        // not null since the fallback is not implemented
+        assertNotNull(command.builder.executionHook.fallbackFailureException);
+
+        // the observe().toBlocking().single() method was used
+        assertEquals(1, command.builder.executionHook.startExecute.get());
+        // we should not have a response since fallback has nothing
+        assertNull(command.builder.executionHook.endExecuteSuccessResponse);
+        // we won't have an exception because rejection doesn't have one
+        assertNull(command.builder.executionHook.endExecuteFailureException);
+        // but we do expect to receive a onError call with FailureType.SHORTCIRCUIT
+        assertEquals(FailureType.REJECTED_SEMAPHORE_EXECUTION, command.builder.executionHook.endExecuteFailureType);
+
+        // thread execution
+        assertEquals(0, command.builder.executionHook.threadStart.get());
+        assertEquals(0, command.builder.executionHook.threadComplete.get());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * Test a command execution that fails but has a fallback.
+     */
+    @Test
+    public void testExecutionFailureWithFallbackImplementedButDisabled() {
+        TestHystrixCommand<Boolean> commandEnabled = new KnownFailureTestCommandWithFallback(new TestCircuitBreaker(), true);
+        try {
+            assertEquals(false, commandEnabled.observe().toBlocking().single());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We should have received a response from the fallback.");
+        }
+
+        TestHystrixCommand<Boolean> commandDisabled = new KnownFailureTestCommandWithFallback(new TestCircuitBreaker(), false);
+        try {
+            assertEquals(false, commandDisabled.observe().toBlocking().single());
+            fail("expect exception thrown");
+        } catch (Exception e) {
+            // expected
+        }
+
+        assertEquals("we failed with a simulated issue", commandDisabled.getFailedExecutionException().getMessage());
+
+        assertTrue(commandDisabled.isFailedExecution());
+
+        assertEquals(0, commandDisabled.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, commandDisabled.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(1, commandDisabled.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, commandDisabled.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, commandDisabled.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, commandDisabled.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, commandDisabled.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, commandDisabled.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, commandDisabled.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, commandDisabled.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, commandDisabled.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, commandDisabled.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        //     assertEquals(2, HystrixRequestLog.getCurrentRequest().getExecutedCommands().size());
+    }
+
+    /**
+     * Test that we can still use thread isolation if desired.
+     */
+    @Test(timeout = 500)
+    public void testSynchronousExecutionTimeoutValueViaExecute() {
+        HystrixAsyncCommand.Setter properties = HystrixAsyncCommand.Setter
+                .withGroupKey(HystrixCommandGroupKey.Factory.asKey("TestKey"))
+                .andCommandPropertiesDefaults(HystrixCommandProperties.Setter()
+                        .withExecutionIsolationStrategy(ExecutionIsolationStrategy.THREAD)
+                        .withExecutionIsolationThreadTimeoutInMilliseconds(50));
+
+        System.out.println(">>>>> Begin: " + System.currentTimeMillis());
+
+        HystrixAsyncCommand<String> command = new HystrixAsyncCommand<String>(properties) {
+            @Override
+            protected HystrixFuture<String> run() {
+                return HystrixFutureUtil.from(new Action1<Promise<String>>() {
+
+                    @Override
+                    public void call(Promise<String> p) {
+                        try {
+                            Thread.sleep(2000);
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                        p.onSuccess("hello");
+                    }
+
+                }, Schedulers.immediate());
+            }
+
+            @Override
+            protected HystrixFuture<String> getFallback() {
+                if (isResponseTimedOut()) {
+                    return HystrixFutureUtil.just("timed-out");
+                } else {
+                    return HystrixFutureUtil.just("abc");
+                }
+            }
+        };
+
+        System.out.println(">>>>> Start: " + System.currentTimeMillis());
+        String value = command.observe().toBlocking().single();
+        System.out.println(">>>>> End: " + System.currentTimeMillis());
+        assertTrue(command.isResponseTimedOut());
+        assertEquals("expected fallback value", "timed-out", value);
+
+        // Thread isolated
+        assertTrue(command.isExecutedInThread());
+    }
+
+    @Test(timeout = 500)
+    public void testSynchronousExecutionUsingThreadIsolationTimeoutValueViaObserve() {
+        HystrixAsyncCommand.Setter properties = HystrixAsyncCommand.Setter
+                .withGroupKey(HystrixCommandGroupKey.Factory.asKey("TestKey"))
+                .andCommandPropertiesDefaults(HystrixCommandProperties.Setter()
+                        .withExecutionIsolationStrategy(ExecutionIsolationStrategy.THREAD)
+                        .withExecutionIsolationThreadTimeoutInMilliseconds(50));
+
+        HystrixAsyncCommand<String> command = new HystrixAsyncCommand<String>(properties) {
+            @Override
+            protected HystrixFuture<String> run() {
+                return HystrixFutureUtil.from(new Action1<Promise<String>>() {
+
+                    @Override
+                    public void call(Promise<String> p) {
+                        try {
+                            Thread.sleep(2000);
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                        p.onSuccess("hello");
+                    }
+
+                }, Schedulers.immediate());
+            }
+
+            @Override
+            protected HystrixFuture<String> getFallback() {
+                if (isResponseTimedOut()) {
+                    return HystrixFutureUtil.just("timed-out");
+                } else {
+                    return HystrixFutureUtil.just("abc");
+                }
+            }
+        };
+
+        String value = command.observe().toBlocking().last();
+        assertTrue(command.isResponseTimedOut());
+        assertEquals("expected fallback value", "timed-out", value);
+
+        // Thread isolated
+        assertTrue(command.isExecutedInThread());
+    }
+
+    @Test(timeout = 500)
+    public void testAsyncExecutionTimeoutValueViaObserve() {
+        HystrixAsyncCommand.Setter properties = HystrixAsyncCommand.Setter
+                .withGroupKey(HystrixCommandGroupKey.Factory.asKey("TestKey"))
+                .andCommandPropertiesDefaults(HystrixCommandProperties.Setter()
+                        .withExecutionIsolationThreadTimeoutInMilliseconds(50));
+
+        HystrixAsyncCommand<String> command = new HystrixAsyncCommand<String>(properties) {
+            @Override
+            protected HystrixFuture<String> run() {
+                return HystrixFutureUtil.from(new Action1<Promise<String>>() {
+
+                    @Override
+                    public void call(Promise<String> p) {
+                        try {
+                            Thread.sleep(2000);
+                        } catch (InterruptedException e) {
+                            System.out.println("********** interrupted on timeout");
+                            e.printStackTrace();
+                        }
+                        // should never reach here
+                        p.onSuccess("hello");
+                    }
+
+                }, Schedulers.newThread());
+            }
+
+            @Override
+            protected HystrixFuture<String> getFallback() {
+                if (isResponseTimedOut()) {
+                    return HystrixFutureUtil.just("timed-out");
+                } else {
+                    return HystrixFutureUtil.just("abc");
+                }
+            }
+        };
+
+        String value = command.observe().toBlocking().last();
+        assertTrue(command.isResponseTimedOut());
+        assertEquals("expected fallback value", "timed-out", value);
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * See https://github.com/Netflix/Hystrix/issues/212
+     */
+    @Test
+    public void testObservableTimeoutNoFallbackThreadContext() {
+        TestSubscriber<Boolean> ts = new TestSubscriber<Boolean>();
+
+        final AtomicReference<Thread> onErrorThread = new AtomicReference<Thread>();
+        final AtomicBoolean isRequestContextInitialized = new AtomicBoolean();
+
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_NOT_IMPLEMENTED);
+        command.toObservable().doOnError(new Action1<Throwable>() {
+
+            @Override
+            public void call(Throwable t1) {
+                System.out.println("onError: " + t1);
+                System.out.println("onError Thread: " + Thread.currentThread());
+                System.out.println("ThreadContext in onError: " + HystrixRequestContext.isCurrentThreadInitialized());
+                onErrorThread.set(Thread.currentThread());
+                isRequestContextInitialized.set(HystrixRequestContext.isCurrentThreadInitialized());
+            }
+
+        }).subscribe(ts);
+
+        ts.awaitTerminalEvent();
+
+        assertTrue(isRequestContextInitialized.get());
+        assertTrue(onErrorThread.get().getName().startsWith("HystrixTimer"));
+
+        List<Throwable> errors = ts.getOnErrorEvents();
+        assertEquals(1, errors.size());
+        Throwable e = errors.get(0);
+        if (errors.get(0) instanceof HystrixRuntimeException) {
+            HystrixRuntimeException de = (HystrixRuntimeException) e;
+            assertNotNull(de.getFallbackException());
+            assertTrue(de.getFallbackException() instanceof UnsupportedOperationException);
+            assertNotNull(de.getImplementingClass());
+            assertNotNull(de.getCause());
+            assertTrue(de.getCause() instanceof TimeoutException);
+        } else {
+            fail("the exception should be ExecutionException with cause as HystrixRuntimeException");
+        }
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isResponseTimedOut());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    /**
+     * See https://github.com/Netflix/Hystrix/issues/212
+     */
+    @Test
+    public void testObservableTimeoutFallbackThreadContext() {
+        TestSubscriber<Boolean> ts = new TestSubscriber<Boolean>();
+
+        final AtomicReference<Thread> onErrorThread = new AtomicReference<Thread>();
+        final AtomicBoolean isRequestContextInitialized = new AtomicBoolean();
+
+        TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_SUCCESS);
+        command.toObservable().doOnNext(new Action1<Boolean>() {
+
+            @Override
+            public void call(Boolean t1) {
+                System.out.println("onNext: " + t1);
+                System.out.println("onNext Thread: " + Thread.currentThread());
+                System.out.println("ThreadContext in onNext: " + HystrixRequestContext.isCurrentThreadInitialized());
+                onErrorThread.set(Thread.currentThread());
+                isRequestContextInitialized.set(HystrixRequestContext.isCurrentThreadInitialized());
+            }
+
+        }).subscribe(ts);
+
+        ts.awaitTerminalEvent();
+
+        System.out.println("events: " + ts.getOnNextEvents());
+
+        assertTrue(isRequestContextInitialized.get());
+        assertTrue(onErrorThread.get().getName().startsWith("HystrixTimer"));
+
+        List<Boolean> onNexts = ts.getOnNextEvents();
+        assertEquals(1, onNexts.size());
+        assertFalse(onNexts.get(0));
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isResponseTimedOut());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        // semaphore isolated
+        assertFalse(command.isExecutedInThread());
+    }
+
+    @Test
+    public void testRejectedViaSemaphoreIsolation() {
+        final TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        final ArrayBlockingQueue<Boolean> results = new ArrayBlockingQueue<Boolean>(2);
+        final List<Thread> executionThreads = Collections.synchronizedList(new ArrayList<Thread>(2));
+        final List<Thread> responseThreads = Collections.synchronizedList(new ArrayList<Thread>(2));
+
+        final AtomicBoolean exceptionReceived = new AtomicBoolean();
+
+        Runnable r = new HystrixContextRunnable(HystrixPlugins.getInstance().getConcurrencyStrategy(), new Runnable() {
+
+            @Override
+            public void run() {
+                try {
+                    executionThreads.add(Thread.currentThread());
+                    results.add(new TestSemaphoreCommand(circuitBreaker, 1, 200).toObservable().map(new Func1<Boolean, Boolean>() {
+
+                        @Override
+                        public Boolean call(Boolean b) {
+                            responseThreads.add(Thread.currentThread());
+                            return b;
+                        }
+
+                    }).toBlocking().single());
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    exceptionReceived.set(true);
+                }
+            }
+
+        });
+
+        // 2 threads, the second should be rejected by the semaphore and return fallback
+        Thread t1 = new Thread(r);
+        Thread t2 = new Thread(r);
+
+        t1.start();
+        t2.start();
+        try {
+            t1.join();
+            t2.join();
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("failed waiting on threads");
+        }
+
+        // one thread should have returned values
+        assertEquals(1, results.size());
+        assertTrue(results.contains(Boolean.TRUE));
+        // the other thread should have thrown an Exception
+        assertTrue(exceptionReceived.get());
+
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        // the rest should not be involved in this test
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        System.out.println("**** DONE");
+
+        assertEquals(2, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    @Test
+    public void testRejectedViaThreadIsolation() throws InterruptedException {
+        final TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
+        final ArrayBlockingQueue<Boolean> results = new ArrayBlockingQueue<Boolean>(10);
+        final List<Thread> executionThreads = Collections.synchronizedList(new ArrayList<Thread>(20));
+        final List<Thread> responseThreads = Collections.synchronizedList(new ArrayList<Thread>(10));
+
+        final AtomicBoolean exceptionReceived = new AtomicBoolean();
+        final CountDownLatch scheduleLatch = new CountDownLatch(2);
+        final CountDownLatch successLatch = new CountDownLatch(1);
+        final AtomicInteger count = new AtomicInteger();
+
+        Runnable r = new HystrixContextRunnable(HystrixPlugins.getInstance().getConcurrencyStrategy(), new Runnable() {
+
+            @Override
+            public void run() {
+                final boolean shouldExecute = count.incrementAndGet() < 3;
+                try {
+                    executionThreads.add(Thread.currentThread());
+                    results.add(new TestThreadIsolationWithSemaphoreSetSmallCommand(circuitBreaker, 2, new Action0() {
+
+                        @Override
+                        public void call() {
+                            // make sure it's deterministic and we put 2 threads into the pool before the 3rd is submitted
+                            if (shouldExecute) {
+                                try {
+                                    scheduleLatch.countDown();
+                                    successLatch.await();
+                                } catch (InterruptedException e) {
+                                }
+                            }
+                        }
+
+                    }).toObservable().map(new Func1<Boolean, Boolean>() {
+
+                        @Override
+                        public Boolean call(Boolean b) {
+                            responseThreads.add(Thread.currentThread());
+                            return b;
+                        }
+
+                    }).finallyDo(new Action0() {
+
+                        @Override
+                        public void call() {
+                            if (!shouldExecute) {
+                                // the final thread that shouldn't execute releases the latch once it has run
+                                // so it is deterministic that the other two fill the thread pool until this one rejects
+                                successLatch.countDown();
+                            }
+                        }
+
+                    }).toBlocking().single());
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    exceptionReceived.set(true);
+                }
+            }
+
+        });
+
+        // 2 threads, the second should be rejected by the semaphore and return fallback
+        Thread t1 = new Thread(r);
+        Thread t2 = new Thread(r);
+        Thread t3 = new Thread(r);
+
+        t1.start();
+        t2.start();
+        // wait for the previous 2 thread to be running before starting otherwise it can race
+        scheduleLatch.await(500, TimeUnit.MILLISECONDS);
+        t3.start();
+        try {
+            t1.join();
+            t2.join();
+            t3.join();
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("failed waiting on threads");
+        }
+
+        // we should have 2 of the 3 return results
+        assertEquals(2, results.size());
+        // the other thread should have thrown an Exception
+        assertTrue(exceptionReceived.get());
+
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(2, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        // the rest should not be involved in this test
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(3, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+    }
+
+    /* ******************************************************************************************************** */
+    /* *************************************** Request Context Testing Below ********************************** */
+    /* ******************************************************************************************************** */
+
+    private RequestContextTestResults testRequestContextOnSuccess(ExecutionIsolationStrategy isolation, final Scheduler userScheduler) {
+        final RequestContextTestResults results = new RequestContextTestResults();
+        TestHystrixCommand<Boolean> command = new TestHystrixCommand<Boolean>(TestHystrixCommand.testPropsBuilder()
+                .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(isolation))) {
+
+            @Override
+            protected HystrixFuture<Boolean> run() {
+                return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                    @Override
+                    public void call(Promise<Boolean> p) {
+                        results.isContextInitialized.set(HystrixRequestContext.isCurrentThreadInitialized());
+                        results.originThread.set(Thread.currentThread());
+                        p.onSuccess(true);
+                    }
+
+                }, userScheduler);
+            }
+
+        };
+
+        results.command = command;
+
+        command.toObservable().doOnEach(new Action1<Notification<? super Boolean>>() {
+
+            @Override
+            public void call(Notification<? super Boolean> n) {
+                results.isContextInitializedObserveOn.set(HystrixRequestContext.isCurrentThreadInitialized());
+                results.observeOnThread.set(Thread.currentThread());
+            }
+
+        }).subscribe(results.ts);
+        results.ts.awaitTerminalEvent();
+
+        System.out.println("Run => Initialized: " + results.isContextInitialized.get() + "  Thread: " + results.originThread.get());
+        System.out.println("Observed => Initialized: " + results.isContextInitializedObserveOn.get() + "  Thread: " + results.observeOnThread.get());
+
+        assertEquals(1, results.ts.getOnNextEvents().size());
+        assertTrue(results.ts.getOnNextEvents().get(0));
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertTrue(command.isSuccessfulExecution());
+
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(0, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        return results;
+    }
+
+    private RequestContextTestResults testRequestContextOnGracefulFailure(ExecutionIsolationStrategy isolation, final Scheduler userScheduler) {
+        final RequestContextTestResults results = new RequestContextTestResults();
+        TestHystrixCommand<Boolean> command = new TestHystrixCommand<Boolean>(TestHystrixCommand.testPropsBuilder()
+                .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(isolation))) {
+
+            @Override
+            protected HystrixFuture<Boolean> run() {
+                return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                    @Override
+                    public void call(Promise<Boolean> p) {
+                        results.isContextInitialized.set(HystrixRequestContext.isCurrentThreadInitialized());
+                        results.originThread.set(Thread.currentThread());
+                        p.onError(new RuntimeException("graceful onError"));
+                    }
+
+                }, userScheduler);
+            }
+
+        };
+
+        results.command = command;
+
+        command.toObservable().doOnEach(new Action1<Notification<? super Boolean>>() {
+
+            @Override
+            public void call(Notification<? super Boolean> n) {
+                results.isContextInitializedObserveOn.set(HystrixRequestContext.isCurrentThreadInitialized());
+                results.observeOnThread.set(Thread.currentThread());
+            }
+
+        }).subscribe(results.ts);
+        results.ts.awaitTerminalEvent();
+
+        System.out.println("Run => Initialized: " + results.isContextInitialized.get() + "  Thread: " + results.originThread.get());
+        System.out.println("Observed => Initialized: " + results.isContextInitializedObserveOn.get() + "  Thread: " + results.observeOnThread.get());
+
+        assertEquals(1, results.ts.getOnErrorEvents().size());
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertFalse(command.isSuccessfulExecution());
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        return results;
+    }
+
+    private RequestContextTestResults testRequestContextOnBadFailure(ExecutionIsolationStrategy isolation, final Scheduler userScheduler) {
+        final RequestContextTestResults results = new RequestContextTestResults();
+        TestHystrixCommand<Boolean> command = new TestHystrixCommand<Boolean>(TestHystrixCommand.testPropsBuilder()
+                .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(isolation))) {
+
+            @Override
+            protected HystrixFuture<Boolean> run() {
+                return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                    @Override
+                    public void call(Promise<Boolean> p) {
+                        results.isContextInitialized.set(HystrixRequestContext.isCurrentThreadInitialized());
+                        results.originThread.set(Thread.currentThread());
+                        throw new RuntimeException("bad onError");
+                    }
+
+                }, userScheduler);
+            }
+
+        };
+
+        results.command = command;
+
+        command.toObservable().doOnEach(new Action1<Notification<? super Boolean>>() {
+
+            @Override
+            public void call(Notification<? super Boolean> n) {
+                results.isContextInitializedObserveOn.set(HystrixRequestContext.isCurrentThreadInitialized());
+                results.observeOnThread.set(Thread.currentThread());
+            }
+
+        }).subscribe(results.ts);
+        results.ts.awaitTerminalEvent();
+
+        System.out.println("Run => Initialized: " + results.isContextInitialized.get() + "  Thread: " + results.originThread.get());
+        System.out.println("Observed => Initialized: " + results.isContextInitializedObserveOn.get() + "  Thread: " + results.observeOnThread.get());
+
+        assertEquals(1, results.ts.getOnErrorEvents().size());
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertFalse(command.isSuccessfulExecution());
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        return results;
+    }
+
+    private RequestContextTestResults testRequestContextOnFailureWithFallback(ExecutionIsolationStrategy isolation, final Scheduler userScheduler) {
+        final RequestContextTestResults results = new RequestContextTestResults();
+        TestHystrixCommand<Boolean> command = new TestHystrixCommand<Boolean>(TestHystrixCommand.testPropsBuilder()
+                .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(isolation))) {
+
+            @Override
+            protected HystrixFuture<Boolean> run() {
+                return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                    @Override
+                    public void call(Promise<Boolean> s) {
+                        s.onError(new RuntimeException("onError"));
+                    }
+
+                }, userScheduler);
+            }
+
+            @Override
+            protected HystrixFuture<Boolean> getFallback() {
+                return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                    @Override
+                    public void call(Promise<Boolean> s) {
+                        results.isContextInitialized.set(HystrixRequestContext.isCurrentThreadInitialized());
+                        results.originThread.set(Thread.currentThread());
+                        s.onSuccess(false);
+                    }
+
+                }, userScheduler);
+            }
+
+        };
+
+        results.command = command;
+
+        command.toObservable().doOnEach(new Action1<Notification<? super Boolean>>() {
+
+            @Override
+            public void call(Notification<? super Boolean> n) {
+                results.isContextInitializedObserveOn.set(HystrixRequestContext.isCurrentThreadInitialized());
+                results.observeOnThread.set(Thread.currentThread());
+            }
+
+        }).subscribe(results.ts);
+        results.ts.awaitTerminalEvent();
+
+        System.out.println("Run => Initialized: " + results.isContextInitialized.get() + "  Thread: " + results.originThread.get());
+        System.out.println("Observed => Initialized: " + results.isContextInitializedObserveOn.get() + "  Thread: " + results.observeOnThread.get());
+
+        assertEquals(0, results.ts.getOnErrorEvents().size());
+        assertEquals(1, results.ts.getOnNextEvents().size());
+        assertEquals(false, results.ts.getOnNextEvents().get(0));
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertFalse(command.isSuccessfulExecution());
+        assertTrue(command.isFailedExecution());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        return results;
+    }
+
+    private RequestContextTestResults testRequestContextOnRejectionWithFallback(ExecutionIsolationStrategy isolation, final Scheduler userScheduler) {
+        final RequestContextTestResults results = new RequestContextTestResults();
+        TestHystrixCommand<Boolean> command = new TestHystrixCommand<Boolean>(TestHystrixCommand.testPropsBuilder()
+                .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter()
+                        .withExecutionIsolationStrategy(isolation)
+                        .withExecutionIsolationSemaphoreMaxConcurrentRequests(0))
+                .setThreadPool(new HystrixThreadPool() {
+
+                    @Override
+                    public ThreadPoolExecutor getExecutor() {
+                        return null;
+                    }
+
+                    @Override
+                    public void markThreadExecution() {
+
+                    }
+
+                    @Override
+                    public void markThreadCompletion() {
+
+                    }
+
+                    @Override
+                    public boolean isQueueSpaceAvailable() {
+                        // always return false so we reject everything
+                        return false;
+                    }
+
+                    @Override
+                    public Scheduler getScheduler() {
+                        return new HystrixContextScheduler(HystrixPlugins.getInstance().getConcurrencyStrategy(), this);
+                    }
+
+                })) {
+
+            @Override
+            protected HystrixFuture<Boolean> run() {
+                return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                    @Override
+                    public void call(Promise<Boolean> s) {
+                        s.onError(new RuntimeException("onError"));
+                    }
+
+                }, userScheduler);
+            }
+
+            @Override
+            protected HystrixFuture<Boolean> getFallback() {
+                return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                    @Override
+                    public void call(Promise<Boolean> s) {
+                        results.isContextInitialized.set(HystrixRequestContext.isCurrentThreadInitialized());
+                        results.originThread.set(Thread.currentThread());
+                        s.onSuccess(false);
+                    }
+
+                }, userScheduler);
+            }
+
+        };
+
+        results.command = command;
+
+        command.toObservable().doOnEach(new Action1<Notification<? super Boolean>>() {
+
+            @Override
+            public void call(Notification<? super Boolean> n) {
+                results.isContextInitializedObserveOn.set(HystrixRequestContext.isCurrentThreadInitialized());
+                results.observeOnThread.set(Thread.currentThread());
+            }
+
+        }).subscribe(results.ts);
+        results.ts.awaitTerminalEvent();
+
+        System.out.println("Run => Initialized: " + results.isContextInitialized.get() + "  Thread: " + results.originThread.get());
+        System.out.println("Observed => Initialized: " + results.isContextInitializedObserveOn.get() + "  Thread: " + results.observeOnThread.get());
+
+        assertEquals(0, results.ts.getOnErrorEvents().size());
+        assertEquals(1, results.ts.getOnNextEvents().size());
+        assertEquals(false, results.ts.getOnNextEvents().get(0));
+
+        assertTrue(command.getExecutionTimeInMilliseconds() == -1);
+        assertFalse(command.isSuccessfulExecution());
+        assertTrue(command.isResponseRejected());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        if (isolation == ExecutionIsolationStrategy.SEMAPHORE) {
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        } else {
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        }
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        return results;
+    }
+
+    private RequestContextTestResults testRequestContextOnShortCircuitedWithFallback(ExecutionIsolationStrategy isolation, final Scheduler userScheduler) {
+        final RequestContextTestResults results = new RequestContextTestResults();
+        TestHystrixCommand<Boolean> command = new TestHystrixCommand<Boolean>(TestHystrixCommand.testPropsBuilder()
+                .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter()
+                        .withExecutionIsolationStrategy(isolation))
+                .setCircuitBreaker(new TestCircuitBreaker().setForceShortCircuit(true))) {
+
+            @Override
+            protected HystrixFuture<Boolean> run() {
+                return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                    @Override
+                    public void call(Promise<Boolean> s) {
+                        s.onError(new RuntimeException("onError"));
+                    }
+
+                }, userScheduler);
+            }
+
+            @Override
+            protected HystrixFuture<Boolean> getFallback() {
+                return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                    @Override
+                    public void call(Promise<Boolean> s) {
+                        results.isContextInitialized.set(HystrixRequestContext.isCurrentThreadInitialized());
+                        results.originThread.set(Thread.currentThread());
+                        s.onSuccess(false);
+                    }
+
+                }, userScheduler);
+            }
+
+        };
+
+        results.command = command;
+
+        command.toObservable().doOnEach(new Action1<Notification<? super Boolean>>() {
+
+            @Override
+            public void call(Notification<? super Boolean> n) {
+                results.isContextInitializedObserveOn.set(HystrixRequestContext.isCurrentThreadInitialized());
+                results.observeOnThread.set(Thread.currentThread());
+            }
+
+        }).subscribe(results.ts);
+        results.ts.awaitTerminalEvent();
+
+        System.out.println("Run => Initialized: " + results.isContextInitialized.get() + "  Thread: " + results.originThread.get());
+        System.out.println("Observed => Initialized: " + results.isContextInitializedObserveOn.get() + "  Thread: " + results.observeOnThread.get());
+
+        assertEquals(0, results.ts.getOnErrorEvents().size());
+        assertEquals(1, results.ts.getOnNextEvents().size());
+        assertEquals(false, results.ts.getOnNextEvents().get(0));
+
+        assertTrue(command.getExecutionTimeInMilliseconds() == -1);
+        assertFalse(command.isSuccessfulExecution());
+        assertTrue(command.isResponseShortCircuited());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        return results;
+    }
+
+    private RequestContextTestResults testRequestContextOnTimeout(ExecutionIsolationStrategy isolation, final Scheduler userScheduler) {
+        final RequestContextTestResults results = new RequestContextTestResults();
+        TestHystrixCommand<Boolean> command = new TestHystrixCommand<Boolean>(TestHystrixCommand.testPropsBuilder()
+                .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(isolation).withExecutionIsolationThreadTimeoutInMilliseconds(50))) {
+
+            @Override
+            protected HystrixFuture<Boolean> run() {
+                return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                    @Override
+                    public void call(Promise<Boolean> s) {
+                        results.isContextInitialized.set(HystrixRequestContext.isCurrentThreadInitialized());
+                        results.originThread.set(Thread.currentThread());
+                        try {
+                            Thread.sleep(500);
+                        } catch (InterruptedException e) {
+                            // ignore the interrupted exception
+                        }
+                    }
+
+                }, userScheduler);
+            }
+
+        };
+
+        results.command = command;
+
+        command.toObservable().doOnEach(new Action1<Notification<? super Boolean>>() {
+
+            @Override
+            public void call(Notification<? super Boolean> n) {
+                results.isContextInitializedObserveOn.set(HystrixRequestContext.isCurrentThreadInitialized());
+                results.observeOnThread.set(Thread.currentThread());
+            }
+
+        }).subscribe(results.ts);
+        results.ts.awaitTerminalEvent();
+
+        System.out.println("Run => Initialized: " + results.isContextInitialized.get() + "  Thread: " + results.originThread.get());
+        System.out.println("Observed => Initialized: " + results.isContextInitializedObserveOn.get() + "  Thread: " + results.observeOnThread.get());
+
+        assertEquals(1, results.ts.getOnErrorEvents().size());
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertFalse(command.isSuccessfulExecution());
+        assertTrue(command.isResponseTimedOut());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        return results;
+    }
+
+    private RequestContextTestResults testRequestContextOnTimeoutWithFallback(ExecutionIsolationStrategy isolation, final Scheduler userScheduler) {
+        final RequestContextTestResults results = new RequestContextTestResults();
+        TestHystrixCommand<Boolean> command = new TestHystrixCommand<Boolean>(TestHystrixCommand.testPropsBuilder()
+                .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(isolation).withExecutionIsolationThreadTimeoutInMilliseconds(50))) {
+
+            @Override
+            protected HystrixFuture<Boolean> run() {
+                return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                    @Override
+                    public void call(Promise<Boolean> s) {
+                        try {
+                            Thread.sleep(500);
+                        } catch (InterruptedException e) {
+                            // ignore the interrupted exception
+                        }
+                    }
+
+                }, userScheduler);
+            }
+
+            @Override
+            protected HystrixFuture<Boolean> getFallback() {
+                return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                    @Override
+                    public void call(Promise<Boolean> s) {
+                        results.isContextInitialized.set(HystrixRequestContext.isCurrentThreadInitialized());
+                        results.originThread.set(Thread.currentThread());
+                        s.onSuccess(false);
+                    }
+
+                }, userScheduler);
+            }
+
+        };
+
+        results.command = command;
+
+        command.toObservable().doOnEach(new Action1<Notification<? super Boolean>>() {
+
+            @Override
+            public void call(Notification<? super Boolean> n) {
+                System.out.println("timeoutWithFallback notification: " + n + "   " + Thread.currentThread());
+                results.isContextInitializedObserveOn.set(HystrixRequestContext.isCurrentThreadInitialized());
+                results.observeOnThread.set(Thread.currentThread());
+            }
+
+        }).subscribe(results.ts);
+        results.ts.awaitTerminalEvent();
+
+        System.out.println("Fallback => Initialized: " + results.isContextInitialized.get() + "  Thread: " + results.originThread.get());
+        System.out.println("Observed => Initialized: " + results.isContextInitializedObserveOn.get() + "  Thread: " + results.observeOnThread.get());
+
+        assertEquals(1, results.ts.getOnNextEvents().size());
+        assertEquals(false, results.ts.getOnNextEvents().get(0));
+
+        assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+        assertFalse(command.isSuccessfulExecution());
+        assertTrue(command.isResponseTimedOut());
+
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+        assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+        assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+        assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+        assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+        return results;
+    }
+
+    private final class RequestContextTestResults {
+        volatile TestHystrixCommand<Boolean> command;
+        final AtomicReference<Thread> originThread = new AtomicReference<Thread>();
+        final AtomicBoolean isContextInitialized = new AtomicBoolean();
+        TestSubscriber<Boolean> ts = new TestSubscriber<Boolean>();
+        final AtomicBoolean isContextInitializedObserveOn = new AtomicBoolean();
+        final AtomicReference<Thread> observeOnThread = new AtomicReference<Thread>();
+    }
+
+    /* *************************************** testSuccessfuleRequestContext *********************************** */
+
+    /**
+     * Synchronous Observable and semaphore isolation. Only [Main] thread is involved in this.
+     */
+    @Test
+    public void testSuccessfulRequestContextWithSemaphoreIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnSuccess(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().equals(Thread.currentThread())); // all synchronous
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().equals(Thread.currentThread())); // all synchronous
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation. User provided thread [RxNewThread] does everything.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testSuccessfulRequestContextWithSemaphoreIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnSuccess(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // we capture and set the context once the user provided Observable emits
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testSuccessfulRequestContextWithSemaphoreIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnSuccess(ExecutionIsolationStrategy.SEMAPHORE, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Synchronous Observable and thread isolation. Work done on [hystrix-OWNER_ONE] thread and then observed on [RxComputation]
+     */
+    @Test
+    public void testSuccessfulRequestContextWithThreadIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnSuccess(ExecutionIsolationStrategy.THREAD, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().getName().startsWith("hystrix-OWNER_ONE")); // thread isolated on a HystrixThreadPool
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().getName().startsWith("hystrix-OWNER_ONE"));
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and thread isolation. User provided thread [RxNetThread] executes Observable and then [RxComputation] observes the onNext calls.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testSuccessfulRequestContextWithThreadIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnSuccess(ExecutionIsolationStrategy.THREAD, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // we capture and set the context once the user provided Observable emits
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread"));
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testSuccessfulRequestContextWithThreadIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnSuccess(ExecutionIsolationStrategy.THREAD, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread"));
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /* *************************************** testGracefulFailureRequestContext *********************************** */
+
+    /**
+     * Synchronous Observable and semaphore isolation. Only [Main] thread is involved in this.
+     */
+    @Test
+    public void testGracefulFailureRequestContextWithSemaphoreIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnGracefulFailure(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().equals(Thread.currentThread())); // all synchronous
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().equals(Thread.currentThread())); // all synchronous
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation. User provided thread [RxNewThread] does everything.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testGracefulFailureRequestContextWithSemaphoreIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnGracefulFailure(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // we capture and set the context once the user provided Observable emits
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testGracefulFailureRequestContextWithSemaphoreIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnGracefulFailure(ExecutionIsolationStrategy.SEMAPHORE, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Synchronous Observable and thread isolation. Work done on [hystrix-OWNER_ONE] thread and then observed on [RxComputation]
+     */
+    @Test
+    public void testGracefulFailureRequestContextWithThreadIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnGracefulFailure(ExecutionIsolationStrategy.THREAD, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().getName().startsWith("hystrix-OWNER_ONE")); // thread isolated on a HystrixThreadPool
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().getName().startsWith("hystrix-OWNER_ONE"));
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and thread isolation. User provided thread [RxNetThread] executes Observable and then [RxComputation] observes the onNext calls.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testGracefulFailureRequestContextWithThreadIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnGracefulFailure(ExecutionIsolationStrategy.THREAD, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // we capture and set the context once the user provided Observable emits
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread"));
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testGracefulFailureRequestContextWithThreadIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnGracefulFailure(ExecutionIsolationStrategy.THREAD, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread"));
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /* *************************************** testBadFailureRequestContext *********************************** */
+
+    /**
+     * Synchronous Observable and semaphore isolation. Only [Main] thread is involved in this.
+     */
+    @Test
+    public void testBadFailureRequestContextWithSemaphoreIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnBadFailure(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().equals(Thread.currentThread())); // all synchronous
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().equals(Thread.currentThread())); // all synchronous
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation. User provided thread [RxNewThread] does everything.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testBadFailureRequestContextWithSemaphoreIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnBadFailure(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // we capture and set the context once the user provided Observable emits
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testBadFailureRequestContextWithSemaphoreIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnBadFailure(ExecutionIsolationStrategy.SEMAPHORE, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Synchronous Observable and thread isolation. Work done on [hystrix-OWNER_ONE] thread and then observed on [RxComputation]
+     */
+    @Test
+    public void testBadFailureRequestContextWithThreadIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnBadFailure(ExecutionIsolationStrategy.THREAD, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().getName().startsWith("hystrix-OWNER_ONE")); // thread isolated on a HystrixThreadPool
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().getName().startsWith("hystrix-OWNER_ONE"));
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and thread isolation. User provided thread [RxNetThread] executes Observable and then [RxComputation] observes the onNext calls.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testBadFailureRequestContextWithThreadIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnBadFailure(ExecutionIsolationStrategy.THREAD, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // we capture and set the context once the user provided Observable emits
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread"));
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testBadFailureRequestContextWithThreadIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnBadFailure(ExecutionIsolationStrategy.THREAD, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread"));
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /* *************************************** testFailureWithFallbackRequestContext *********************************** */
+
+    /**
+     * Synchronous Observable and semaphore isolation. Only [Main] thread is involved in this.
+     */
+    @Test
+    public void testFailureWithFallbackRequestContextWithSemaphoreIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnFailureWithFallback(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().equals(Thread.currentThread())); // all synchronous
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().equals(Thread.currentThread())); // all synchronous
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation. User provided thread [RxNewThread] does everything.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testFailureWithFallbackRequestContextWithSemaphoreIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnFailureWithFallback(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // we capture and set the context once the user provided Observable emits
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testFailureWithFallbackRequestContextWithSemaphoreIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnFailureWithFallback(ExecutionIsolationStrategy.SEMAPHORE, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Synchronous Observable and thread isolation. Work done on [hystrix-OWNER_ONE] thread and then observed on [RxComputation]
+     */
+    @Test
+    public void testFailureWithFallbackRequestContextWithThreadIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnFailureWithFallback(ExecutionIsolationStrategy.THREAD, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().getName().startsWith("hystrix-OWNER_ONE")); // thread isolated on a HystrixThreadPool
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().getName().startsWith("hystrix-OWNER_ONE"));
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and thread isolation. User provided thread [RxNetThread] executes Observable and then [RxComputation] observes the onNext calls.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testFailureWithFallbackRequestContextWithThreadIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnFailureWithFallback(ExecutionIsolationStrategy.THREAD, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // we capture and set the context once the user provided Observable emits
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread"));
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testFailureWithFallbackRequestContextWithThreadIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnFailureWithFallback(ExecutionIsolationStrategy.THREAD, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread"));
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /* *************************************** testRejectionWithFallbackRequestContext *********************************** */
+
+    /**
+     * Synchronous Observable and semaphore isolation. Only [Main] thread is involved in this.
+     */
+    @Test
+    public void testRejectionWithFallbackRequestContextWithSemaphoreIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnRejectionWithFallback(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().equals(Thread.currentThread())); // all synchronous
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().equals(Thread.currentThread())); // all synchronous
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation. User provided thread [RxNewThread] does everything.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testRejectionWithFallbackRequestContextWithSemaphoreIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnRejectionWithFallback(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // we capture and set the context once the user provided Observable emits
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testRejectionWithFallbackRequestContextWithSemaphoreIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnRejectionWithFallback(ExecutionIsolationStrategy.SEMAPHORE, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Synchronous Observable and thread isolation. Work done on [hystrix-OWNER_ONE] thread and then observed on [RxComputation]
+     */
+    @Test
+    public void testRejectionWithFallbackRequestContextWithThreadIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnRejectionWithFallback(ExecutionIsolationStrategy.THREAD, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().equals(Thread.currentThread())); // fallback is performed by the calling thread
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        System.out.println("results.observeOnThread.get(): " + results.observeOnThread.get() + "  " + Thread.currentThread());
+        assertTrue(results.observeOnThread.get().equals(Thread.currentThread())); // rejected so we stay on calling thread
+
+        // thread isolated so even though we're rejected we mark that it attempted execution in a thread
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and thread isolation. User provided thread [RxNetThread] executes Observable and then [RxComputation] observes the onNext calls.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testRejectionWithFallbackRequestContextWithThreadIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnRejectionWithFallback(ExecutionIsolationStrategy.THREAD, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // we capture and set the context once the user provided Observable emits
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread"));
+
+        // thread isolated so even though we're rejected we mark that it attempted execution in a thread
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testRejectionWithFallbackRequestContextWithThreadIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnRejectionWithFallback(ExecutionIsolationStrategy.THREAD, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler for getFallback
+
+        // thread isolated so even though we're rejected we mark that it attempted execution in a thread
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /* *************************************** testShortCircuitedWithFallbackRequestContext *********************************** */
+
+    /**
+     * Synchronous Observable and semaphore isolation. Only [Main] thread is involved in this.
+     */
+    @Test
+    public void testShortCircuitedWithFallbackRequestContextWithSemaphoreIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnShortCircuitedWithFallback(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().equals(Thread.currentThread())); // all synchronous
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().equals(Thread.currentThread())); // all synchronous
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation. User provided thread [RxNewThread] does everything.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testShortCircuitedWithFallbackRequestContextWithSemaphoreIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnShortCircuitedWithFallback(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // we capture and set the context once the user provided Observable emits
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testShortCircuitedWithFallbackRequestContextWithSemaphoreIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnShortCircuitedWithFallback(ExecutionIsolationStrategy.SEMAPHORE, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Synchronous Observable and thread isolation. Work done on [hystrix-OWNER_ONE] thread and then observed on [RxComputation]
+     */
+    @Test
+    public void testShortCircuitedWithFallbackRequestContextWithThreadIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnShortCircuitedWithFallback(ExecutionIsolationStrategy.THREAD, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().equals(Thread.currentThread())); // fallback is performed by the calling thread
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().equals(Thread.currentThread())); // rejected so we stay on calling thread
+
+        // thread isolated ... but rejected so not executed in a thread
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and thread isolation. User provided thread [RxNetThread] executes Observable and then [RxComputation] observes the onNext calls.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testShortCircuitedWithFallbackRequestContextWithThreadIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnShortCircuitedWithFallback(ExecutionIsolationStrategy.THREAD, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // we capture and set the context once the user provided Observable emits
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler from getFallback
+
+        // thread isolated ... but rejected so not executed in a thread
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testShortCircuitedWithFallbackRequestContextWithThreadIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnShortCircuitedWithFallback(ExecutionIsolationStrategy.THREAD, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler from getFallback
+
+        // thread isolated ... but rejected so not executed in a thread
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /* *************************************** testTimeoutRequestContext *********************************** */
+
+    /**
+     * Synchronous Observable and semaphore isolation. Only [Main] thread is involved in this.
+     */
+    @Test
+    public void testTimeoutRequestContextWithSemaphoreIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnTimeout(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().equals(Thread.currentThread())); // all synchronous
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // timeout schedules on HystrixTimer since the original thread was timed out
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation. User provided thread [RxNewThread] does everything.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testTimeoutRequestContextWithSemaphoreIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnTimeout(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the timeout captures the context so it exists
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // timeout schedules on HystrixTimer since the original thread was timed out
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testTimeoutRequestContextWithSemaphoreIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnTimeout(ExecutionIsolationStrategy.SEMAPHORE, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // timeout schedules on HystrixTimer since the original thread was timed out
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Synchronous Observable and thread isolation. Work done on [hystrix-OWNER_ONE] thread and then observed on [RxComputation]
+     */
+    @Test
+    public void testTimeoutRequestContextWithThreadIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnTimeout(ExecutionIsolationStrategy.THREAD, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().getName().startsWith("hystrix-OWNER_ONE")); // thread isolated on a HystrixThreadPool
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // timeout schedules on HystrixTimer since the original thread was timed out
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and thread isolation. User provided thread [RxNetThread] executes Observable and then [RxComputation] observes the onNext calls.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testTimeoutRequestContextWithThreadIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnTimeout(ExecutionIsolationStrategy.THREAD, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the timeout captures the context so it exists
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // timeout schedules on HystrixTimer since the original thread was timed out
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testTimeoutRequestContextWithThreadIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnTimeout(ExecutionIsolationStrategy.THREAD, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // timeout schedules on HystrixTimer since the original thread was timed out
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /* *************************************** testTimeoutWithFallbackRequestContext *********************************** */
+
+    /**
+     * Synchronous Observable and semaphore isolation. Only [Main] thread is involved in this.
+     */
+    @Test
+    public void testTimeoutWithFallbackRequestContextWithSemaphoreIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnTimeoutWithFallback(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().getName().startsWith("HystrixTimer")); // timeout uses HystrixTimer thread to perform fallback 
+        //(this use case is a little odd as it should generally not be the case that we are "timing out" a synchronous observable on semaphore isolation)
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // timeout uses HystrixTimer thread
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation. User provided thread [RxNewThread] does everything.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testTimeoutWithFallbackRequestContextWithSemaphoreIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnTimeoutWithFallback(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the timeout captures the context so it exists
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testTimeoutWithFallbackRequestContextWithSemaphoreIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnTimeoutWithFallback(ExecutionIsolationStrategy.SEMAPHORE, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // semaphore isolated
+        assertFalse(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Synchronous Observable and thread isolation. Work done on [hystrix-OWNER_ONE] thread and then observed on [RxComputation]
+     */
+    @Test
+    public void testTimeoutWithFallbackRequestContextWithThreadIsolatedSynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnTimeoutWithFallback(ExecutionIsolationStrategy.THREAD, Schedulers.immediate());
+
+        assertTrue(results.isContextInitialized.get());
+        assertTrue(results.originThread.get().getName().startsWith("HystrixTimer")); // timeout uses HystrixTimer thread for fallback
+
+        assertTrue(results.isContextInitializedObserveOn.get());
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // fallback uses the timeout thread
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and thread isolation. User provided thread [RxNetThread] executes Observable and then [RxComputation] observes the onNext calls.
+     * 
+     * NOTE: RequestContext will NOT exist on that thread.
+     * 
+     * An async Observable running on its own thread will not have access to the request context unless the user manages the context.
+     */
+    @Test
+    public void testTimeoutWithFallbackRequestContextWithThreadIsolatedAsynchronousObservable() {
+        RequestContextTestResults results = testRequestContextOnTimeoutWithFallback(ExecutionIsolationStrategy.THREAD, Schedulers.newThread());
+
+        assertFalse(results.isContextInitialized.get()); // it won't have request context as it's on a user provided thread/scheduler
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the timeout captures the context so it exists
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /**
+     * Async Observable and semaphore isolation WITH functioning RequestContext
+     * 
+     * Use HystrixContextScheduler to make the user provided scheduler capture context.
+     */
+    @Test
+    public void testTimeoutWithFallbackRequestContextWithThreadIsolatedAsynchronousObservableAndCapturedContextScheduler() {
+        RequestContextTestResults results = testRequestContextOnTimeoutWithFallback(ExecutionIsolationStrategy.THREAD, new HystrixContextScheduler(Schedulers.newThread()));
+
+        assertTrue(results.isContextInitialized.get()); // the user scheduler captures context
+        assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
+        assertTrue(results.observeOnThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
+
+        // thread isolated
+        assertTrue(results.command.isExecutedInThread());
+    }
+
+    /* ******************************************************************************** */
+    /* ******************************************************************************** */
+    /* private HystrixCommand class implementations for unit testing */
+    /* ******************************************************************************** */
+    /* ******************************************************************************** */
+
+    /**
+     * Used by UnitTest command implementations to provide base defaults for constructor and a builder pattern for the arguments being passed in.
+     */
+    /* package */static abstract class TestHystrixCommand<K> extends HystrixAsyncCommand<K> {
+
+        final TestCommandBuilder builder;
+
+        TestHystrixCommand(TestCommandBuilder builder) {
+            super(builder.owner, builder.dependencyKey, builder.threadPoolKey, builder.circuitBreaker, builder.threadPool,
+                    builder.commandPropertiesDefaults, builder.threadPoolPropertiesDefaults, builder.metrics,
+                    builder.fallbackSemaphore, builder.executionSemaphore, TEST_PROPERTIES_FACTORY, builder.executionHook);
+            this.builder = builder;
+        }
+
+        static TestCommandBuilder testPropsBuilder() {
+            return new TestCommandBuilder();
+        }
+
+        static class TestCommandBuilder {
+            TestCircuitBreaker _cb = new TestCircuitBreaker();
+            HystrixCommandGroupKey owner = CommandGroupForUnitTest.OWNER_ONE;
+            HystrixCommandKey dependencyKey = null;
+            HystrixThreadPoolKey threadPoolKey = null;
+            HystrixCircuitBreaker circuitBreaker = _cb;
+            HystrixThreadPool threadPool = null;
+            HystrixCommandProperties.Setter commandPropertiesDefaults = HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE);
+            HystrixThreadPoolProperties.Setter threadPoolPropertiesDefaults = HystrixThreadPoolProperties.Setter.getUnitTestPropertiesBuilder();
+            HystrixCommandMetrics metrics = _cb.metrics;
+            TryableSemaphoreActual fallbackSemaphore = null;
+            TryableSemaphoreActual executionSemaphore = null;
+            TestExecutionHook executionHook = new TestExecutionHook();
+
+            TestCommandBuilder setOwner(HystrixCommandGroupKey owner) {
+                this.owner = owner;
+                return this;
+            }
+
+            TestCommandBuilder setCommandKey(HystrixCommandKey dependencyKey) {
+                this.dependencyKey = dependencyKey;
+                return this;
+            }
+
+            TestCommandBuilder setThreadPoolKey(HystrixThreadPoolKey threadPoolKey) {
+                this.threadPoolKey = threadPoolKey;
+                return this;
+            }
+
+            TestCommandBuilder setCircuitBreaker(HystrixCircuitBreaker circuitBreaker) {
+                this.circuitBreaker = circuitBreaker;
+                return this;
+            }
+
+            TestCommandBuilder setThreadPool(HystrixThreadPool threadPool) {
+                this.threadPool = threadPool;
+                return this;
+            }
+
+            TestCommandBuilder setCommandPropertiesDefaults(HystrixCommandProperties.Setter commandPropertiesDefaults) {
+                this.commandPropertiesDefaults = commandPropertiesDefaults;
+                return this;
+            }
+
+            TestCommandBuilder setThreadPoolPropertiesDefaults(HystrixThreadPoolProperties.Setter threadPoolPropertiesDefaults) {
+                this.threadPoolPropertiesDefaults = threadPoolPropertiesDefaults;
+                return this;
+            }
+
+            TestCommandBuilder setMetrics(HystrixCommandMetrics metrics) {
+                this.metrics = metrics;
+                return this;
+            }
+
+            TestCommandBuilder setFallbackSemaphore(TryableSemaphoreActual fallbackSemaphore) {
+                this.fallbackSemaphore = fallbackSemaphore;
+                return this;
+            }
+
+            TestCommandBuilder setExecutionSemaphore(TryableSemaphoreActual executionSemaphore) {
+                this.executionSemaphore = executionSemaphore;
+                return this;
+            }
+
+        }
+
+    }
+
+    /**
+     * Successful execution - no fallback implementation.
+     */
+    private static class SuccessfulTestCommand extends TestHystrixCommand<Boolean> {
+
+        public SuccessfulTestCommand() {
+            this(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE));
+        }
+
+        public SuccessfulTestCommand(HystrixCommandProperties.Setter properties) {
+            super(testPropsBuilder().setCommandPropertiesDefaults(properties));
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            return HystrixFutureUtil.just(true, Schedulers.computation());
+        }
+
+    }
+
+    /**
+     * Successful execution - no fallback implementation.
+     */
+    private static class DynamicOwnerTestCommand extends TestHystrixCommand<Boolean> {
+
+        public DynamicOwnerTestCommand(HystrixCommandGroupKey owner) {
+            super(testPropsBuilder().setOwner(owner));
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            System.out.println("successfully executed");
+            return HystrixFutureUtil.just(true, Schedulers.computation());
+        }
+
+    }
+
+    /**
+     * Successful execution - no fallback implementation.
+     */
+    private static class DynamicOwnerAndKeyTestCommand extends TestHystrixCommand<Boolean> {
+
+        public DynamicOwnerAndKeyTestCommand(HystrixCommandGroupKey owner, HystrixCommandKey key) {
+            super(testPropsBuilder().setOwner(owner).setCommandKey(key).setCircuitBreaker(null).setMetrics(null));
+            // we specifically are NOT passing in a circuit breaker here so we test that it creates a new one correctly based on the dynamic key
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            System.out.println("successfully executed");
+            return HystrixFutureUtil.just(true, Schedulers.computation());
+        }
+
+    }
+
+    /**
+     * Failed execution with unknown exception (not HystrixException) - no fallback implementation.
+     */
+    private static class UnknownFailureTestCommandWithoutFallback extends TestHystrixCommand<Boolean> {
+
+        private UnknownFailureTestCommandWithoutFallback() {
+            super(testPropsBuilder());
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            // TODO duplicate with error inside async Observable
+            System.out.println("*** simulated failed execution ***");
+            throw new RuntimeException("we failed with an unknown issue");
+        }
+
+    }
+
+    /**
+     * Failed execution with known exception (HystrixException) - no fallback implementation.
+     */
+    private static class KnownFailureTestCommandWithoutFallback extends TestHystrixCommand<Boolean> {
+
+        private KnownFailureTestCommandWithoutFallback(TestCircuitBreaker circuitBreaker) {
+            super(testPropsBuilder().setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics));
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            // TODO duplicate with error inside async Observable
+            System.out.println("*** simulated failed execution ***");
+            throw new RuntimeException("we failed with a simulated issue");
+        }
+
+    }
+
+    /**
+     * Failed execution - fallback implementation successfully returns value.
+     */
+    private static class KnownFailureTestCommandWithFallback extends TestHystrixCommand<Boolean> {
+
+        public KnownFailureTestCommandWithFallback(TestCircuitBreaker circuitBreaker) {
+            super(testPropsBuilder().setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics));
+        }
+
+        public KnownFailureTestCommandWithFallback(TestCircuitBreaker circuitBreaker, boolean fallbackEnabled) {
+            super(testPropsBuilder().setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics)
+                    .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withFallbackEnabled(fallbackEnabled).withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE)));
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            // TODO duplicate with error inside async Observable
+            System.out.println("*** simulated failed execution ***");
+            throw new RuntimeException("we failed with a simulated issue");
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> getFallback() {
+            return HystrixFutureUtil.just(false, Schedulers.computation());
+        }
+    }
+
+    /**
+     * Failed execution - fallback implementation throws exception.
+     */
+    private static class KnownFailureTestCommandWithFallbackFailure extends TestHystrixCommand<Boolean> {
+
+        private KnownFailureTestCommandWithFallbackFailure() {
+            super(testPropsBuilder());
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            System.out.println("*** simulated failed execution ***");
+            throw new RuntimeException("we failed with a simulated issue");
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> getFallback() {
+            // TODO duplicate with error inside async Observable
+            throw new RuntimeException("failed while getting fallback");
+        }
+    }
+
+    /**
+     * A Command implementation that supports caching.
+     */
+    private static class SuccessfulCacheableCommand extends TestHystrixCommand<String> {
+
+        private final boolean cacheEnabled;
+        private volatile boolean executed = false;
+        private final String value;
+
+        public SuccessfulCacheableCommand(TestCircuitBreaker circuitBreaker, boolean cacheEnabled, String value) {
+            super(testPropsBuilder().setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics)
+                    .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.THREAD)));
+            this.value = value;
+            this.cacheEnabled = cacheEnabled;
+        }
+
+        @Override
+        protected HystrixFuture<String> run() {
+            executed = true;
+            System.out.println("successfully executed");
+            return HystrixFutureUtil.just(value, Schedulers.computation());
+        }
+
+        public boolean isCommandRunningInThread() {
+            return super.getProperties().executionIsolationStrategy().get().equals(ExecutionIsolationStrategy.THREAD);
+        }
+
+        @Override
+        public String getCacheKey() {
+            if (cacheEnabled)
+                return value;
+            else
+                return null;
+        }
+    }
+
+    /**
+     * A Command implementation that supports caching.
+     */
+    private static class SuccessfulCacheableCommandViaSemaphore extends TestHystrixCommand<String> {
+
+        private final boolean cacheEnabled;
+        private volatile boolean executed = false;
+        private final String value;
+
+        public SuccessfulCacheableCommandViaSemaphore(TestCircuitBreaker circuitBreaker, boolean cacheEnabled, String value) {
+            super(testPropsBuilder().setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics)
+                    .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE)));
+            this.value = value;
+            this.cacheEnabled = cacheEnabled;
+        }
+
+        @Override
+        protected HystrixFuture<String> run() {
+            executed = true;
+            System.out.println("successfully executed");
+            return HystrixFutureUtil.just(value, Schedulers.computation());
+        }
+
+        public boolean isCommandRunningInThread() {
+            return super.getProperties().executionIsolationStrategy().get().equals(ExecutionIsolationStrategy.THREAD);
+        }
+
+        @Override
+        public String getCacheKey() {
+            if (cacheEnabled)
+                return value;
+            else
+                return null;
+        }
+    }
+
+    /**
+     * A Command implementation that supports caching and execution takes a while.
+     * <p>
+     * Used to test scenario where Futures are returned with a backing call still executing.
+     */
+    private static class SlowCacheableCommand extends TestHystrixCommand<String> {
+
+        private final String value;
+        private final int duration;
+        private volatile boolean executed = false;
+
+        public SlowCacheableCommand(TestCircuitBreaker circuitBreaker, String value, int duration) {
+            super(testPropsBuilder().setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics));
+            this.value = value;
+            this.duration = duration;
+        }
+
+        @Override
+        protected HystrixFuture<String> run() {
+            executed = true;
+            final Promise<String> p = Promise.create();
+            Observable.just(value).delay(duration, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.computation())
+                    .doOnNext(new Action1<String>() {
+
+                        @Override
+                        public void call(String t1) {
+                            System.out.println("successfully executed");
+                            p.onSuccess(t1);
+                        }
+
+                    }).subscribe();
+
+            return p.createFuture();
+        }
+
+        @Override
+        public String getCacheKey() {
+            return value;
+        }
+    }
+
+    /**
+     * Successful execution - no fallback implementation, circuit-breaker disabled.
+     */
+    private static class TestCommandWithoutCircuitBreaker extends TestHystrixCommand<Boolean> {
+
+        private TestCommandWithoutCircuitBreaker() {
+            super(testPropsBuilder().setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE).withCircuitBreakerEnabled(false)));
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            System.out.println("successfully executed");
+            return HystrixFutureUtil.just(true, Schedulers.computation());
+        }
+
+    }
+
+    /**
+     * This should timeout.
+     */
+    private static class TestCommandWithTimeout extends TestHystrixCommand<Boolean> {
+
+        private final long timeout;
+
+        private final static int FALLBACK_NOT_IMPLEMENTED = 1;
+        private final static int FALLBACK_SUCCESS = 2;
+        private final static int FALLBACK_FAILURE = 3;
+
+        private final int fallbackBehavior;
+
+        private TestCommandWithTimeout(long timeout, int fallbackBehavior) {
+            this(timeout, fallbackBehavior, ExecutionIsolationStrategy.SEMAPHORE);
+        }
+
+        private TestCommandWithTimeout(long timeout, int fallbackBehavior, ExecutionIsolationStrategy isolationStrategy) {
+            super(testPropsBuilder().setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(isolationStrategy).withExecutionIsolationThreadTimeoutInMilliseconds((int) timeout)));
+            this.timeout = timeout;
+            this.fallbackBehavior = fallbackBehavior;
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                @Override
+                public void call(Promise<Boolean> p) {
+                    System.out.println("***** running");
+                    try {
+                        Thread.sleep(timeout * 10);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                        // ignore and sleep some more to simulate a dependency that doesn't obey interrupts
+                        try {
+                            Thread.sleep(timeout * 2);
+                        } catch (Exception e2) {
+                            // ignore
+                        }
+                        System.out.println("after interruption with extra sleep");
+                    }
+                    p.onSuccess(true);
+                }
+
+            }, Schedulers.computation());
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> getFallback() {
+            if (fallbackBehavior == FALLBACK_SUCCESS) {
+                return HystrixFutureUtil.just(false);
+            } else if (fallbackBehavior == FALLBACK_FAILURE) {
+                // TODO duplicate with error inside async Observable
+                throw new RuntimeException("failed on fallback");
+            } else {
+                // FALLBACK_NOT_IMPLEMENTED
+                return super.getFallback();
+            }
+        }
+    }
+
+    private static class NoRequestCacheTimeoutWithoutFallback extends TestHystrixCommand<Boolean> {
+        public NoRequestCacheTimeoutWithoutFallback(TestCircuitBreaker circuitBreaker) {
+            super(testPropsBuilder().setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics)
+                    .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE).withExecutionIsolationThreadTimeoutInMilliseconds(200)));
+
+            // we want it to timeout
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                @Override
+                public void call(Promise<Boolean> p) {
+                    try {
+                        Thread.sleep(500);
+                    } catch (InterruptedException e) {
+                        System.out.println(">>>> Sleep Interrupted: " + e.getMessage());
+                        //                    e.printStackTrace();
+                    }
+                    p.onSuccess(true);
+                }
+
+            }, Schedulers.computation());
+        }
+
+        @Override
+        public String getCacheKey() {
+            return null;
+        }
+    }
+
+    /**
+     * The run() will take time. No fallback implementation.
+     */
+    private static class TestSemaphoreCommand extends TestHystrixCommand<Boolean> {
+
+        private final long executionSleep;
+
+        private TestSemaphoreCommand(TestCircuitBreaker circuitBreaker, int executionSemaphoreCount, long executionSleep) {
+            super(testPropsBuilder().setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics)
+                    .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter()
+                            .withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE)
+                            .withExecutionIsolationSemaphoreMaxConcurrentRequests(executionSemaphoreCount)));
+            this.executionSleep = executionSleep;
+        }
+
+        private TestSemaphoreCommand(TestCircuitBreaker circuitBreaker, TryableSemaphoreActual semaphore, long executionSleep) {
+            super(testPropsBuilder().setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics)
+                    .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter()
+                            .withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE))
+                    .setExecutionSemaphore(semaphore));
+            this.executionSleep = executionSleep;
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                @Override
+                public void call(Promise<Boolean> p) {
+                    try {
+                        Thread.sleep(executionSleep);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                    p.onSuccess(true);
+                }
+
+            }, Schedulers.computation());
+        }
+    }
+
+    /**
+     * The run() will take time. No fallback implementation.
+     * 
+     * Used for making sure Thread and Semaphore isolation are separated from each other.
+     */
+    private static class TestThreadIsolationWithSemaphoreSetSmallCommand extends TestHystrixCommand<Boolean> {
+
+        private final Action0 action;
+
+        private TestThreadIsolationWithSemaphoreSetSmallCommand(TestCircuitBreaker circuitBreaker, int poolSize, Action0 action) {
+            super(testPropsBuilder().setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics)
+                    .setThreadPoolKey(HystrixThreadPoolKey.Factory.asKey(TestThreadIsolationWithSemaphoreSetSmallCommand.class.getSimpleName()))
+                    .setThreadPoolPropertiesDefaults(HystrixThreadPoolProperties.Setter.getUnitTestPropertiesBuilder()
+                            .withCoreSize(poolSize).withMaxQueueSize(0))
+                    .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter()
+                            .withExecutionIsolationStrategy(ExecutionIsolationStrategy.THREAD)
+                            .withExecutionIsolationSemaphoreMaxConcurrentRequests(1)));
+            this.action = action;
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                @Override
+                public void call(Promise<Boolean> p) {
+                    action.call();
+                    p.onSuccess(true);
+                }
+
+            }, Schedulers.computation());
+        }
+    }
+
+    /**
+     * Semaphore based command that allows caller to use latches to know when it has started and signal when it
+     * would like the command to finish
+     */
+    private static class LatchedSemaphoreCommand extends TestHystrixCommand<Boolean> {
+
+        private final CountDownLatch startLatch, waitLatch;
+
+        /**
+         * 
+         * @param circuitBreaker
+         * @param semaphore
+         * @param startLatch
+         *            this command calls {@link java.util.concurrent.CountDownLatch#countDown()} immediately
+         *            upon running
+         * @param waitLatch
+         *            this command calls {@link java.util.concurrent.CountDownLatch#await()} once it starts
+         *            to run. The caller can use the latch to signal the command to finish
+         */
+        private LatchedSemaphoreCommand(TestCircuitBreaker circuitBreaker, TryableSemaphoreActual semaphore,
+                CountDownLatch startLatch, CountDownLatch waitLatch) {
+            super(testPropsBuilder().setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics)
+                    .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE))
+                    .setExecutionSemaphore(semaphore));
+            this.startLatch = startLatch;
+            this.waitLatch = waitLatch;
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                @Override
+                public void call(Promise<Boolean> p) {
+                    // signals caller that run has started
+                    startLatch.countDown();
+
+                    try {
+                        // waits for caller to countDown latch
+                        waitLatch.await();
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                        p.onSuccess(false);
+                        return;
+                    }
+
+                    p.onSuccess(true);
+                }
+
+            }, Schedulers.computation());
+        }
+    }
+
+    /**
+     * The run() will take time. Contains fallback.
+     */
+    private static class TestSemaphoreCommandWithFallback extends TestHystrixCommand<Boolean> {
+
+        private final long executionSleep;
+        private final HystrixFuture<Boolean> fallback;
+
+        private TestSemaphoreCommandWithFallback(TestCircuitBreaker circuitBreaker, int executionSemaphoreCount, long executionSleep, Boolean fallback) {
+            super(testPropsBuilder().setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics)
+                    .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE).withExecutionIsolationSemaphoreMaxConcurrentRequests(executionSemaphoreCount)));
+            this.executionSleep = executionSleep;
+            this.fallback = HystrixFutureUtil.just(fallback);
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                @Override
+                public void call(Promise<Boolean> p) {
+                    try {
+                        Thread.sleep(executionSleep);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+
+                    p.onSuccess(true);
+                }
+
+            }, Schedulers.computation());
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> getFallback() {
+            return fallback;
+        }
+
+    }
+
+    private static class RequestCacheNullPointerExceptionCase extends TestHystrixCommand<Boolean> {
+        public RequestCacheNullPointerExceptionCase(TestCircuitBreaker circuitBreaker) {
+            super(testPropsBuilder().setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics)
+                    .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE).withExecutionIsolationThreadTimeoutInMilliseconds(200)));
+            // we want it to timeout
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                @Override
+                public void call(Promise<Boolean> p) {
+                    try {
+                        Thread.sleep(500);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                    p.onSuccess(true);
+                }
+
+            }, Schedulers.computation());
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> getFallback() {
+            return HystrixFutureUtil.just(false, Schedulers.computation());
+        }
+
+        @Override
+        public String getCacheKey() {
+            return "A";
+        }
+    }
+
+    private static class RequestCacheTimeoutWithoutFallback extends TestHystrixCommand<Boolean> {
+        public RequestCacheTimeoutWithoutFallback(TestCircuitBreaker circuitBreaker) {
+            super(testPropsBuilder().setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics)
+                    .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE).withExecutionIsolationThreadTimeoutInMilliseconds(200)));
+            // we want it to timeout
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            return HystrixFutureUtil.from(new Action1<Promise<Boolean>>() {
+
+                @Override
+                public void call(Promise<Boolean> p) {
+                    try {
+                        Thread.sleep(500);
+                    } catch (InterruptedException e) {
+                        System.out.println(">>>> Sleep Interrupted: " + e.getMessage());
+                        //                    e.printStackTrace();
+                    }
+                    p.onSuccess(true);
+                }
+
+            }, Schedulers.computation());
+        }
+
+        @Override
+        public String getCacheKey() {
+            return "A";
+        }
+    }
+
+    private static class RequestCacheThreadRejectionWithoutFallback extends TestHystrixCommand<Boolean> {
+
+        final CountDownLatch completionLatch;
+
+        public RequestCacheThreadRejectionWithoutFallback(TestCircuitBreaker circuitBreaker, CountDownLatch completionLatch) {
+            super(testPropsBuilder()
+                    .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.THREAD))
+                    .setCircuitBreaker(circuitBreaker)
+                    .setMetrics(circuitBreaker.metrics)
+                    .setThreadPool(new HystrixThreadPool() {
+
+                        @Override
+                        public ThreadPoolExecutor getExecutor() {
+                            return null;
+                        }
+
+                        @Override
+                        public void markThreadExecution() {
+
+                        }
+
+                        @Override
+                        public void markThreadCompletion() {
+
+                        }
+
+                        @Override
+                        public boolean isQueueSpaceAvailable() {
+                            // always return false so we reject everything
+                            return false;
+                        }
+
+                        @Override
+                        public Scheduler getScheduler() {
+                            return new HystrixContextScheduler(HystrixPlugins.getInstance().getConcurrencyStrategy(), this);
+                        }
+
+                    }));
+            this.completionLatch = completionLatch;
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            try {
+                if (completionLatch.await(1000, TimeUnit.MILLISECONDS)) {
+                    throw new RuntimeException("timed out waiting on completionLatch");
+                }
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+            return HystrixFutureUtil.just(true);
+        }
+
+        @Override
+        public String getCacheKey() {
+            return "A";
+        }
+    }
+
+    private static class BadRequestCommand extends TestHystrixCommand<Boolean> {
+
+        public BadRequestCommand(TestCircuitBreaker circuitBreaker, ExecutionIsolationStrategy isolationType) {
+            super(testPropsBuilder()
+                    .setCircuitBreaker(circuitBreaker)
+                    .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE).withExecutionIsolationStrategy(isolationType)));
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            throw new HystrixBadRequestException("Message to developer that they passed in bad data or something like that.");
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> getFallback() {
+            return HystrixFutureUtil.just(false, Schedulers.computation());
+        }
+
+        @Override
+        protected String getCacheKey() {
+            return "one";
+        }
+
+    }
+
+    private static class CommandWithErrorThrown extends TestHystrixCommand<Boolean> {
+
+        public CommandWithErrorThrown(TestCircuitBreaker circuitBreaker) {
+            super(testPropsBuilder()
+                    .setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics));
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            // TODO duplicate with error inside async Observable
+            throw new Error("simulated java.lang.Error message");
+        }
+
+    }
+
+    private static class CommandWithCheckedException extends TestHystrixCommand<Boolean> {
+
+        public CommandWithCheckedException(TestCircuitBreaker circuitBreaker) {
+            super(testPropsBuilder()
+                    .setCircuitBreaker(circuitBreaker).setMetrics(circuitBreaker.metrics));
+        }
+
+        @Override
+        protected HystrixFuture<Boolean> run() {
+            return HystrixFutureUtil.error(new IOException("simulated checked exception message"));
+        }
+
+    }
+
+    enum CommandKeyForUnitTest implements HystrixCommandKey {
+        KEY_ONE, KEY_TWO;
+    }
+
+    enum CommandGroupForUnitTest implements HystrixCommandGroupKey {
+        OWNER_ONE, OWNER_TWO;
+    }
+
+    enum ThreadPoolKeyForUnitTest implements HystrixThreadPoolKey {
+        THREAD_POOL_ONE, THREAD_POOL_TWO;
+    }
+
+    private static HystrixPropertiesStrategy TEST_PROPERTIES_FACTORY = new TestPropertiesFactory();
+
+    private static class TestPropertiesFactory extends HystrixPropertiesStrategy {
+
+        @Override
+        public HystrixCommandProperties getCommandProperties(HystrixCommandKey commandKey, HystrixCommandProperties.Setter builder) {
+            if (builder == null) {
+                builder = HystrixCommandPropertiesTest.getUnitTestPropertiesSetter();
+            }
+            return HystrixCommandPropertiesTest.asMock(builder);
+        }
+
+        @Override
+        public HystrixThreadPoolProperties getThreadPoolProperties(HystrixThreadPoolKey threadPoolKey, HystrixThreadPoolProperties.Setter builder) {
+            if (builder == null) {
+                builder = HystrixThreadPoolProperties.Setter.getUnitTestPropertiesBuilder();
+            }
+            return HystrixThreadPoolProperties.Setter.asMock(builder);
+        }
+
+        @Override
+        public HystrixCollapserProperties getCollapserProperties(HystrixCollapserKey collapserKey, HystrixCollapserProperties.Setter builder) {
+            throw new IllegalStateException("not expecting collapser properties");
+        }
+
+        @Override
+        public String getCommandPropertiesCacheKey(HystrixCommandKey commandKey, HystrixCommandProperties.Setter builder) {
+            return null;
+        }
+
+        @Override
+        public String getThreadPoolPropertiesCacheKey(HystrixThreadPoolKey threadPoolKey, com.netflix.hystrix.HystrixThreadPoolProperties.Setter builder) {
+            return null;
+        }
+
+        @Override
+        public String getCollapserPropertiesCacheKey(HystrixCollapserKey collapserKey, com.netflix.hystrix.HystrixCollapserProperties.Setter builder) {
+            return null;
+        }
+
+    }
+
+    private static class TestExecutionHook extends HystrixCommandExecutionHook {
+
+        AtomicInteger startExecute = new AtomicInteger();
+
+        @Override
+        public <T> void onStart(HystrixInvokable<T> commandInstance) {
+            super.onStart(commandInstance);
+            startExecute.incrementAndGet();
+        }
+
+        Object endExecuteSuccessResponse = null;
+
+        @Override
+        public <T> T onComplete(HystrixInvokable<T> commandInstance, T response) {
+            endExecuteSuccessResponse = response;
+            return super.onComplete(commandInstance, response);
+        }
+
+        Exception endExecuteFailureException = null;
+        FailureType endExecuteFailureType = null;
+
+        @Override
+        public <T> Exception onError(HystrixInvokable<T> commandInstance, FailureType failureType, Exception e) {
+            endExecuteFailureException = e;
+            endExecuteFailureType = failureType;
+            return super.onError(commandInstance, failureType, e);
+        }
+
+        AtomicInteger startRun = new AtomicInteger();
+
+        @Override
+        public <T> void onRunStart(HystrixInvokable<T> commandInstance) {
+            super.onRunStart(commandInstance);
+            startRun.incrementAndGet();
+        }
+
+        Object runSuccessResponse = null;
+
+        @Override
+        public <T> T onRunSuccess(HystrixInvokable<T> commandInstance, T response) {
+            runSuccessResponse = response;
+            return super.onRunSuccess(commandInstance, response);
+        }
+
+        Exception runFailureException = null;
+
+        @Override
+        public <T> Exception onRunError(HystrixInvokable<T> commandInstance, Exception e) {
+            runFailureException = e;
+            return super.onRunError(commandInstance, e);
+        }
+
+        AtomicInteger startFallback = new AtomicInteger();
+
+        @Override
+        public <T> void onFallbackStart(HystrixInvokable<T> commandInstance) {
+            super.onFallbackStart(commandInstance);
+            startFallback.incrementAndGet();
+        }
+
+        Object fallbackSuccessResponse = null;
+
+        @Override
+        public <T> T onFallbackSuccess(HystrixInvokable<T> commandInstance, T response) {
+            fallbackSuccessResponse = response;
+            return super.onFallbackSuccess(commandInstance, response);
+        }
+
+        Exception fallbackFailureException = null;
+
+        @Override
+        public <T> Exception onFallbackError(HystrixInvokable<T> commandInstance, Exception e) {
+            fallbackFailureException = e;
+            return super.onFallbackError(commandInstance, e);
+        }
+
+        AtomicInteger threadStart = new AtomicInteger();
+
+        @Override
+        public <T> void onThreadStart(HystrixInvokable<T> commandInstance) {
+            super.onThreadStart(commandInstance);
+            threadStart.incrementAndGet();
+        }
+
+        AtomicInteger threadComplete = new AtomicInteger();
+
+        @Override
+        public <T> void onThreadComplete(HystrixInvokable<T> commandInstance) {
+            super.onThreadComplete(commandInstance);
+            threadComplete.incrementAndGet();
+        }
+
+    }
+
+}
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCircuitBreakerTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCircuitBreakerTest.java
index 6e83c42cc..3ee9783e1 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCircuitBreakerTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCircuitBreakerTest.java
@@ -574,7 +574,7 @@ protected String getFallback() {
     public class MyHystrixCommandExecutionHook extends HystrixCommandExecutionHook {
 
         @Override
-        public <T> T onComplete(final HystrixExecutable<T> command, final T response) {
+        public <T> T onComplete(final HystrixInvokable<T> command, final T response) {
 
             logHC(command, response);
 
@@ -583,7 +583,7 @@ public <T> T onComplete(final HystrixExecutable<T> command, final T response) {
 
         private int counter = 0;
 
-        private <T> void logHC(HystrixExecutable<T> command, T response) {
+        private <T> void logHC(HystrixInvokable<T> command, T response) {
 
             if(command instanceof HystrixExecutableInfo) {
                 HystrixExecutableInfo<T> commandInfo = (HystrixExecutableInfo<T>)command;
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCollapserTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCollapserTest.java
index dc04fb0d5..a00e4e671 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCollapserTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCollapserTest.java
@@ -1,6 +1,11 @@
 package com.netflix.hystrix;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 import java.lang.ref.Reference;
 import java.lang.ref.SoftReference;
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCommandMetricsTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCommandMetricsTest.java
index 5e9cd4ed0..7ee149be2 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCommandMetricsTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCommandMetricsTest.java
@@ -1,6 +1,7 @@
 package com.netflix.hystrix;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
 
 import org.junit.Test;
 
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCommandPropertiesTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCommandPropertiesTest.java
index 47d6b8ccd..019e21ca4 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCommandPropertiesTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCommandPropertiesTest.java
@@ -1,6 +1,6 @@
 package com.netflix.hystrix;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import org.junit.After;
 import org.junit.Test;
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCommandTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCommandTest.java
index c439bbd07..2dbf0a28a 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCommandTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCommandTest.java
@@ -34,10 +34,10 @@
 import rx.schedulers.Schedulers;
 
 import com.netflix.config.ConfigurationManager;
+import com.netflix.hystrix.AbstractCommand.TryableSemaphore;
+import com.netflix.hystrix.AbstractCommand.TryableSemaphoreActual;
 import com.netflix.hystrix.HystrixCircuitBreakerTest.TestCircuitBreaker;
 import com.netflix.hystrix.HystrixCommandProperties.ExecutionIsolationStrategy;
-import com.netflix.hystrix.HystrixExecutableBase.TryableSemaphore;
-import com.netflix.hystrix.HystrixExecutableBase.TryableSemaphoreActual;
 import com.netflix.hystrix.exception.HystrixBadRequestException;
 import com.netflix.hystrix.exception.HystrixRuntimeException;
 import com.netflix.hystrix.exception.HystrixRuntimeException.FailureType;
@@ -530,64 +530,7 @@ public void testObserveSuccess() {
      * Test a successful command execution.
      */
     @Test
-    public void testObserveOnScheduler() throws Exception {
-        for (int i = 0; i < 5; i++) {
-            final AtomicReference<Thread> commandThread = new AtomicReference<Thread>();
-            final AtomicReference<Thread> subscribeThread = new AtomicReference<Thread>();
-
-            TestHystrixCommand<Boolean> command = new TestHystrixCommand<Boolean>(TestHystrixCommand.testPropsBuilder()) {
-
-                @Override
-                protected Boolean run() {
-                    commandThread.set(Thread.currentThread());
-                    return true;
-                }
-            };
-
-            final CountDownLatch latch = new CountDownLatch(1);
-
-            command.toObservable(Schedulers.newThread()).subscribe(new Observer<Boolean>() {
-
-                @Override
-                public void onCompleted() {
-                    latch.countDown();
-
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    latch.countDown();
-                    e.printStackTrace();
-
-                }
-
-                @Override
-                public void onNext(Boolean args) {
-                    subscribeThread.set(Thread.currentThread());
-                }
-            });
-
-            if (!latch.await(2000, TimeUnit.MILLISECONDS)) {
-                fail("timed out");
-            }
-
-            assertNotNull(commandThread.get());
-            assertNotNull(subscribeThread.get());
-
-            System.out.println("Command Thread: " + commandThread.get());
-            System.out.println("Subscribe Thread: " + subscribeThread.get());
-
-            assertTrue(commandThread.get().getName().startsWith("hystrix-"));
-            assertFalse(subscribeThread.get().getName().startsWith("hystrix-"));
-            assertTrue(subscribeThread.get().getName().startsWith("Rx"));
-        }
-    }
-
-    /**
-     * Test a successful command execution.
-     */
-    @Test
-    public void testObserveOnComputationSchedulerByDefaultForThreadIsolation() throws Exception {
+    public void testCallbackThreadForThreadIsolation() throws Exception {
 
         final AtomicReference<Thread> commandThread = new AtomicReference<Thread>();
         final AtomicReference<Thread> subscribeThread = new AtomicReference<Thread>();
@@ -635,14 +578,14 @@ public void onNext(Boolean args) {
         System.out.println("Subscribe Thread: " + subscribeThread.get());
 
         assertTrue(commandThread.get().getName().startsWith("hystrix-"));
-        assertTrue(subscribeThread.get().getName().startsWith("RxComputationThreadPool"));
+        assertTrue(subscribeThread.get().getName().startsWith("hystrix-"));
     }
 
     /**
      * Test a successful command execution.
      */
     @Test
-    public void testObserveOnImmediateSchedulerByDefaultForSemaphoreIsolation() throws Exception {
+    public void testCallbackThreadForSemaphoreIsolation() throws Exception {
 
         final AtomicReference<Thread> commandThread = new AtomicReference<Thread>();
         final AtomicReference<Thread> subscribeThread = new AtomicReference<Thread>();
@@ -4261,7 +4204,7 @@ public void call(Throwable t1) {
         ts.awaitTerminalEvent();
 
         assertTrue(isRequestContextInitialized.get());
-        assertTrue(onErrorThread.get().getName().startsWith("RxComputationThreadPool"));
+        assertTrue(onErrorThread.get().getName().startsWith("HystrixTimer"));
 
         List<Throwable> errors = ts.getOnErrorEvents();
         assertEquals(1, errors.size());
@@ -5201,7 +5144,7 @@ private static class TestExecutionHook extends HystrixCommandExecutionHook {
         AtomicInteger startExecute = new AtomicInteger();
 
         @Override
-        public <T> void onStart(HystrixExecutable<T> commandInstance) {
+        public <T> void onStart(HystrixInvokable<T> commandInstance) {
             super.onStart(commandInstance);
             startExecute.incrementAndGet();
         }
@@ -5209,7 +5152,7 @@ public <T> void onStart(HystrixExecutable<T> commandInstance) {
         Object endExecuteSuccessResponse = null;
 
         @Override
-        public <T> T onComplete(HystrixExecutable<T> commandInstance, T response) {
+        public <T> T onComplete(HystrixInvokable<T> commandInstance, T response) {
             endExecuteSuccessResponse = response;
             return super.onComplete(commandInstance, response);
         }
@@ -5218,7 +5161,7 @@ public <T> T onComplete(HystrixExecutable<T> commandInstance, T response) {
         FailureType endExecuteFailureType = null;
 
         @Override
-        public <T> Exception onError(HystrixExecutable<T> commandInstance, FailureType failureType, Exception e) {
+        public <T> Exception onError(HystrixInvokable<T> commandInstance, FailureType failureType, Exception e) {
             endExecuteFailureException = e;
             endExecuteFailureType = failureType;
             return super.onError(commandInstance, failureType, e);
@@ -5227,7 +5170,7 @@ public <T> Exception onError(HystrixExecutable<T> commandInstance, FailureType f
         AtomicInteger startRun = new AtomicInteger();
 
         @Override
-        public <T> void onRunStart(HystrixExecutable<T> commandInstance) {
+        public <T> void onRunStart(HystrixInvokable<T> commandInstance) {
             super.onRunStart(commandInstance);
             startRun.incrementAndGet();
         }
@@ -5235,7 +5178,7 @@ public <T> void onRunStart(HystrixExecutable<T> commandInstance) {
         Object runSuccessResponse = null;
 
         @Override
-        public <T> T onRunSuccess(HystrixExecutable<T> commandInstance, T response) {
+        public <T> T onRunSuccess(HystrixInvokable<T> commandInstance, T response) {
             runSuccessResponse = response;
             return super.onRunSuccess(commandInstance, response);
         }
@@ -5243,7 +5186,7 @@ public <T> T onRunSuccess(HystrixExecutable<T> commandInstance, T response) {
         Exception runFailureException = null;
 
         @Override
-        public <T> Exception onRunError(HystrixExecutable<T> commandInstance, Exception e) {
+        public <T> Exception onRunError(HystrixInvokable<T> commandInstance, Exception e) {
             runFailureException = e;
             return super.onRunError(commandInstance, e);
         }
@@ -5251,7 +5194,7 @@ public <T> Exception onRunError(HystrixExecutable<T> commandInstance, Exception
         AtomicInteger startFallback = new AtomicInteger();
 
         @Override
-        public <T> void onFallbackStart(HystrixExecutable<T> commandInstance) {
+        public <T> void onFallbackStart(HystrixInvokable<T> commandInstance) {
             super.onFallbackStart(commandInstance);
             startFallback.incrementAndGet();
         }
@@ -5259,7 +5202,7 @@ public <T> void onFallbackStart(HystrixExecutable<T> commandInstance) {
         Object fallbackSuccessResponse = null;
 
         @Override
-        public <T> T onFallbackSuccess(HystrixExecutable<T> commandInstance, T response) {
+        public <T> T onFallbackSuccess(HystrixInvokable<T> commandInstance, T response) {
             fallbackSuccessResponse = response;
             return super.onFallbackSuccess(commandInstance, response);
         }
@@ -5267,7 +5210,7 @@ public <T> T onFallbackSuccess(HystrixExecutable<T> commandInstance, T response)
         Exception fallbackFailureException = null;
 
         @Override
-        public <T> Exception onFallbackError(HystrixExecutable<T> commandInstance, Exception e) {
+        public <T> Exception onFallbackError(HystrixInvokable<T> commandInstance, Exception e) {
             fallbackFailureException = e;
             return super.onFallbackError(commandInstance, e);
         }
@@ -5275,7 +5218,7 @@ public <T> Exception onFallbackError(HystrixExecutable<T> commandInstance, Excep
         AtomicInteger threadStart = new AtomicInteger();
 
         @Override
-        public <T> void onThreadStart(HystrixExecutable<T> commandInstance) {
+        public <T> void onThreadStart(HystrixInvokable<T> commandInstance) {
             super.onThreadStart(commandInstance);
             threadStart.incrementAndGet();
         }
@@ -5283,7 +5226,7 @@ public <T> void onThreadStart(HystrixExecutable<T> commandInstance) {
         AtomicInteger threadComplete = new AtomicInteger();
 
         @Override
-        public <T> void onThreadComplete(HystrixExecutable<T> commandInstance) {
+        public <T> void onThreadComplete(HystrixInvokable<T> commandInstance) {
             super.onThreadComplete(commandInstance);
             threadComplete.incrementAndGet();
         }
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixFutureUtil.java b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixFutureUtil.java
new file mode 100644
index 000000000..281b6a6ff
--- /dev/null
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixFutureUtil.java
@@ -0,0 +1,61 @@
+package com.netflix.hystrix;
+
+import rx.Scheduler;
+import rx.Scheduler.Worker;
+import rx.functions.Action0;
+import rx.functions.Action1;
+
+import com.netflix.hystrix.HystrixAsyncCommand.HystrixFuture;
+import com.netflix.hystrix.HystrixAsyncCommand.Promise;
+
+public class HystrixFutureUtil {
+
+    public static <T> HystrixFuture<T> just(T t) {
+        Promise<T> p = Promise.create();
+        p.onSuccess(t);
+        return HystrixFuture.create(p);
+    }
+    
+    public static <T> HystrixFuture<T> error(Throwable t) {
+        Promise<T> p = Promise.create();
+        p.onError(t);
+        return HystrixFuture.create(p);
+    }
+
+    public static <T> HystrixFuture<T> just(final T t, Scheduler s) {
+        return from(new Action1<Promise<T>>() {
+
+            @Override
+            public void call(Promise<T> p) {
+                p.onSuccess(t);
+            }
+        }, s);
+    }
+
+    public static <T> HystrixFuture<T> from(final Action1<Promise<T>> action, Scheduler s) {
+        final Promise<T> p = Promise.create();
+        final Worker worker = s.createWorker();
+        worker.schedule(new Action0() {
+
+            @Override
+            public void call() {
+                try {
+                    action.call(p);
+                } catch (Exception e) {
+                    p.onError(e);
+                } finally {
+                    worker.unsubscribe();
+                }
+            }
+
+        });
+        return HystrixFuture.create(p, new Action0() {
+
+            @Override
+            public void call() {
+                worker.unsubscribe();
+            }
+
+        });
+    }
+}
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixObservableCollapserTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixObservableCollapserTest.java
index a154cb92e..7597915fe 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixObservableCollapserTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixObservableCollapserTest.java
@@ -17,9 +17,7 @@
 
 import static org.junit.Assert.assertEquals;
 
-import java.util.ArrayList;
 import java.util.Collection;
-import java.util.List;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -63,8 +61,8 @@ public void cleanup() {
     @Test
     public void testTwoRequests() throws Exception {
         TestCollapserTimer timer = new TestCollapserTimer();
-        Future<String> response1 = new TestRequestCollapser(timer, counter, 1).queue();
-        Future<String> response2 = new TestRequestCollapser(timer, counter, 2).queue();
+        Future<String> response1 = new TestRequestCollapser(timer, counter, 1).observe().toBlocking().toFuture();
+        Future<String> response2 = new TestRequestCollapser(timer, counter, 2).observe().toBlocking().toFuture();
         timer.incrementTime(10); // let time pass that equals the default delay/period
 
         assertEquals("1", response1.get());
@@ -200,7 +198,7 @@ private static class TestCollapserCommand extends TestHystrixCommand<String> {
         }
 
         @Override
-        protected Observable<String> run() {
+        protected Observable<String> construct() {
             return Observable.create(new OnSubscribe<String>() {
 
                 @Override
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixObservableCommandTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixObservableCommandTest.java
index c74cb5ffc..0551bc69d 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixObservableCommandTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixObservableCommandTest.java
@@ -10,6 +10,7 @@
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.ArrayBlockingQueue;
@@ -40,9 +41,9 @@
 import rx.schedulers.Schedulers;
 
 import com.netflix.config.ConfigurationManager;
+import com.netflix.hystrix.AbstractCommand.TryableSemaphoreActual;
 import com.netflix.hystrix.HystrixCircuitBreakerTest.TestCircuitBreaker;
 import com.netflix.hystrix.HystrixCommandProperties.ExecutionIsolationStrategy;
-import com.netflix.hystrix.HystrixExecutableBase.TryableSemaphoreActual;
 import com.netflix.hystrix.exception.HystrixBadRequestException;
 import com.netflix.hystrix.exception.HystrixRuntimeException;
 import com.netflix.hystrix.exception.HystrixRuntimeException.FailureType;
@@ -125,7 +126,7 @@ public void testExecutionSuccess() {
             assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
             assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
             assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
-            assertEquals(true, command.execute());
+            assertEquals(true, command.observe().toBlocking().single());
             assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
             assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
             assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
@@ -164,7 +165,7 @@ public void testExecutionMultipleTimes() {
         SuccessfulTestCommand command = new SuccessfulTestCommand();
         assertFalse(command.isExecutionComplete());
         // first should succeed
-        assertEquals(true, command.execute());
+        assertEquals(true, command.observe().toBlocking().single());
         System.out.println(">> completed, checking metrics");
         assertTrue(command.isExecutionComplete());
         assertFalse(command.isExecutedInThread());
@@ -172,7 +173,7 @@ public void testExecutionMultipleTimes() {
         assertTrue(command.isSuccessfulExecution());
         try {
             // second should fail
-            command.execute();
+            command.observe().toBlocking().single();
             fail("we should not allow this ... it breaks the state of request logs");
         } catch (IllegalStateException e) {
             e.printStackTrace();
@@ -181,7 +182,7 @@ public void testExecutionMultipleTimes() {
 
         try {
             // queue should also fail
-            command.queue();
+            command.observe().toBlocking().toFuture();
             fail("we should not allow this ... it breaks the state of request logs");
         } catch (IllegalStateException e) {
             e.printStackTrace();
@@ -200,7 +201,7 @@ public void testExecutionKnownFailureWithNoFallback() {
         TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithoutFallback(circuitBreaker);
         try {
-            command.execute();
+            command.observe().toBlocking().single();
             fail("we shouldn't get here");
         } catch (HystrixRuntimeException e) {
             e.printStackTrace();
@@ -244,7 +245,7 @@ public void testExecutionKnownFailureWithNoFallback() {
     public void testExecutionUnknownFailureWithNoFallback() {
         TestHystrixCommand<Boolean> command = new UnknownFailureTestCommandWithoutFallback();
         try {
-            command.execute();
+            command.observe().toBlocking().single();
             fail("we shouldn't get here");
         } catch (HystrixRuntimeException e) {
             e.printStackTrace();
@@ -286,7 +287,7 @@ public void testExecutionUnknownFailureWithNoFallback() {
     public void testExecutionFailureWithFallback() {
         TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithFallback(new TestCircuitBreaker());
         try {
-            assertEquals(false, command.execute());
+            assertEquals(false, command.observe().toBlocking().single());
         } catch (Exception e) {
             e.printStackTrace();
             fail("We should have received a response from the fallback.");
@@ -324,7 +325,7 @@ public void testExecutionFailureWithFallback() {
     public void testExecutionFailureWithFallbackFailure() {
         TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithFallbackFailure();
         try {
-            command.execute();
+            command.observe().toBlocking().single();
             fail("we shouldn't get here");
         } catch (HystrixRuntimeException e) {
             System.out.println("------------------------------------------------");
@@ -363,7 +364,7 @@ public void testExecutionFailureWithFallbackFailure() {
     public void testQueueSuccess() {
         TestHystrixCommand<Boolean> command = new SuccessfulTestCommand();
         try {
-            Future<Boolean> future = command.queue();
+            Future<Boolean> future = command.observe().toBlocking().toFuture();
             assertEquals(true, future.get());
         } catch (Exception e) {
             e.printStackTrace();
@@ -401,7 +402,7 @@ public void testQueueKnownFailureWithNoFallback() {
         TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithoutFallback(circuitBreaker);
         try {
-            command.queue().get();
+            command.observe().toBlocking().toFuture().get();
             fail("we shouldn't get here");
         } catch (Exception e) {
             e.printStackTrace();
@@ -445,7 +446,7 @@ public void testQueueKnownFailureWithNoFallback() {
     public void testQueueUnknownFailureWithNoFallback() {
         TestHystrixCommand<Boolean> command = new UnknownFailureTestCommandWithoutFallback();
         try {
-            command.queue().get();
+            command.observe().toBlocking().toFuture().get();
             fail("we shouldn't get here");
         } catch (Exception e) {
             e.printStackTrace();
@@ -488,7 +489,7 @@ public void testQueueUnknownFailureWithNoFallback() {
     public void testQueueFailureWithFallback() {
         TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithFallback(new TestCircuitBreaker());
         try {
-            Future<Boolean> future = command.queue();
+            Future<Boolean> future = command.observe().toBlocking().toFuture();
             assertEquals(false, future.get());
         } catch (Exception e) {
             e.printStackTrace();
@@ -525,7 +526,7 @@ public void testQueueFailureWithFallback() {
     public void testQueueFailureWithFallbackFailure() {
         TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithFallbackFailure();
         try {
-            command.queue().get();
+            command.observe().toBlocking().toFuture().get();
             fail("we shouldn't get here");
         } catch (Exception e) {
             if (e.getCause() instanceof HystrixRuntimeException) {
@@ -744,7 +745,7 @@ public void testObserveOnImmediateSchedulerByDefaultForSemaphoreIsolation() thro
                 .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE))) {
 
             @Override
-            protected Observable<Boolean> run() {
+            protected Observable<Boolean> construct() {
                 commandThread.set(Thread.currentThread());
                 return Observable.just(true);
             }
@@ -803,21 +804,21 @@ public void testCircuitBreakerTripsAfterFailures() {
         /* fail 3 times and then it should trip the circuit and stop executing */
         // failure 1
         KnownFailureTestCommandWithFallback attempt1 = new KnownFailureTestCommandWithFallback(circuitBreaker);
-        attempt1.execute();
+        attempt1.observe().toBlocking().single();
         assertTrue(attempt1.isResponseFromFallback());
         assertFalse(attempt1.isCircuitBreakerOpen());
         assertFalse(attempt1.isResponseShortCircuited());
 
         // failure 2
         KnownFailureTestCommandWithFallback attempt2 = new KnownFailureTestCommandWithFallback(circuitBreaker);
-        attempt2.execute();
+        attempt2.observe().toBlocking().single();
         assertTrue(attempt2.isResponseFromFallback());
         assertFalse(attempt2.isCircuitBreakerOpen());
         assertFalse(attempt2.isResponseShortCircuited());
 
         // failure 3
         KnownFailureTestCommandWithFallback attempt3 = new KnownFailureTestCommandWithFallback(circuitBreaker);
-        attempt3.execute();
+        attempt3.observe().toBlocking().single();
         assertTrue(attempt3.isResponseFromFallback());
         assertFalse(attempt3.isResponseShortCircuited());
         // it should now be 'open' and prevent further executions
@@ -825,7 +826,7 @@ public void testCircuitBreakerTripsAfterFailures() {
 
         // attempt 4
         KnownFailureTestCommandWithFallback attempt4 = new KnownFailureTestCommandWithFallback(circuitBreaker);
-        attempt4.execute();
+        attempt4.observe().toBlocking().single();
         assertTrue(attempt4.isResponseFromFallback());
         // this should now be true as the response will be short-circuited
         assertTrue(attempt4.isResponseShortCircuited());
@@ -859,21 +860,21 @@ public void testCircuitBreakerTripsAfterFailuresViaQueue() {
             /* fail 3 times and then it should trip the circuit and stop executing */
             // failure 1
             KnownFailureTestCommandWithFallback attempt1 = new KnownFailureTestCommandWithFallback(circuitBreaker);
-            attempt1.queue().get();
+            attempt1.observe().toBlocking().toFuture().get();
             assertTrue(attempt1.isResponseFromFallback());
             assertFalse(attempt1.isCircuitBreakerOpen());
             assertFalse(attempt1.isResponseShortCircuited());
 
             // failure 2
             KnownFailureTestCommandWithFallback attempt2 = new KnownFailureTestCommandWithFallback(circuitBreaker);
-            attempt2.queue().get();
+            attempt2.observe().toBlocking().toFuture().get();
             assertTrue(attempt2.isResponseFromFallback());
             assertFalse(attempt2.isCircuitBreakerOpen());
             assertFalse(attempt2.isResponseShortCircuited());
 
             // failure 3
             KnownFailureTestCommandWithFallback attempt3 = new KnownFailureTestCommandWithFallback(circuitBreaker);
-            attempt3.queue().get();
+            attempt3.observe().toBlocking().toFuture().get();
             assertTrue(attempt3.isResponseFromFallback());
             assertFalse(attempt3.isResponseShortCircuited());
             // it should now be 'open' and prevent further executions
@@ -881,7 +882,7 @@ public void testCircuitBreakerTripsAfterFailuresViaQueue() {
 
             // attempt 4
             KnownFailureTestCommandWithFallback attempt4 = new KnownFailureTestCommandWithFallback(circuitBreaker);
-            attempt4.queue().get();
+            attempt4.observe().toBlocking().toFuture().get();
             assertTrue(attempt4.isResponseFromFallback());
             // this should now be true as the response will be short-circuited
             assertTrue(attempt4.isResponseShortCircuited());
@@ -922,7 +923,7 @@ public void testCircuitBreakerAcrossMultipleCommandsButSameCircuitBreaker() {
         /* fail 3 times and then it should trip the circuit and stop executing */
         // failure 1
         KnownFailureTestCommandWithFallback attempt1 = new KnownFailureTestCommandWithFallback(circuitBreaker);
-        attempt1.execute();
+        attempt1.observe().toBlocking().single();
         assertTrue(attempt1.isResponseFromFallback());
         assertFalse(attempt1.isCircuitBreakerOpen());
         assertFalse(attempt1.isResponseShortCircuited());
@@ -930,7 +931,7 @@ public void testCircuitBreakerAcrossMultipleCommandsButSameCircuitBreaker() {
         // failure 2 with a different command, same circuit breaker
         KnownFailureTestCommandWithoutFallback attempt2 = new KnownFailureTestCommandWithoutFallback(circuitBreaker);
         try {
-            attempt2.execute();
+            attempt2.observe().toBlocking().single();
         } catch (Exception e) {
             // ignore ... this doesn't have a fallback so will throw an exception
         }
@@ -941,7 +942,7 @@ public void testCircuitBreakerAcrossMultipleCommandsButSameCircuitBreaker() {
 
         // failure 3 of the Hystrix, 2nd for this particular HystrixCommand
         KnownFailureTestCommandWithFallback attempt3 = new KnownFailureTestCommandWithFallback(circuitBreaker);
-        attempt3.execute();
+        attempt3.observe().toBlocking().single();
         assertTrue(attempt2.isFailedExecution());
         assertTrue(attempt3.isResponseFromFallback());
         assertFalse(attempt3.isResponseShortCircuited());
@@ -952,7 +953,7 @@ public void testCircuitBreakerAcrossMultipleCommandsButSameCircuitBreaker() {
 
         // attempt 4
         KnownFailureTestCommandWithFallback attempt4 = new KnownFailureTestCommandWithFallback(circuitBreaker);
-        attempt4.execute();
+        attempt4.observe().toBlocking().single();
         assertTrue(attempt4.isResponseFromFallback());
         // this should now be true as the response will be short-circuited
         assertTrue(attempt4.isResponseShortCircuited());
@@ -987,21 +988,21 @@ public void testCircuitBreakerAcrossMultipleCommandsAndDifferentDependency() {
 
         // failure 1
         KnownFailureTestCommandWithFallback attempt1 = new KnownFailureTestCommandWithFallback(circuitBreaker_one);
-        attempt1.execute();
+        attempt1.observe().toBlocking().single();
         assertTrue(attempt1.isResponseFromFallback());
         assertFalse(attempt1.isCircuitBreakerOpen());
         assertFalse(attempt1.isResponseShortCircuited());
 
         // failure 2 with a different HystrixCommand implementation and different Hystrix
         KnownFailureTestCommandWithFallback attempt2 = new KnownFailureTestCommandWithFallback(circuitBreaker_two);
-        attempt2.execute();
+        attempt2.observe().toBlocking().single();
         assertTrue(attempt2.isResponseFromFallback());
         assertFalse(attempt2.isCircuitBreakerOpen());
         assertFalse(attempt2.isResponseShortCircuited());
 
         // failure 3 but only 2nd of the Hystrix.ONE
         KnownFailureTestCommandWithFallback attempt3 = new KnownFailureTestCommandWithFallback(circuitBreaker_one);
-        attempt3.execute();
+        attempt3.observe().toBlocking().single();
         assertTrue(attempt3.isResponseFromFallback());
         assertFalse(attempt3.isResponseShortCircuited());
 
@@ -1013,7 +1014,7 @@ public void testCircuitBreakerAcrossMultipleCommandsAndDifferentDependency() {
 
         // attempt 4 (3rd attempt for Hystrix.ONE)
         KnownFailureTestCommandWithFallback attempt4 = new KnownFailureTestCommandWithFallback(circuitBreaker_one);
-        attempt4.execute();
+        attempt4.observe().toBlocking().single();
         // this should NOW flip to true as this is the 3rd failure for Hystrix.ONE
         assertTrue(attempt3.isCircuitBreakerOpen());
         assertTrue(attempt3.isResponseFromFallback());
@@ -1060,7 +1061,7 @@ public void testCircuitBreakerAcrossMultipleCommandsAndDifferentDependency() {
     public void testExecutionSuccessWithCircuitBreakerDisabled() {
         TestHystrixCommand<Boolean> command = new TestCommandWithoutCircuitBreaker();
         try {
-            assertEquals(true, command.execute());
+            assertEquals(true, command.observe().toBlocking().single());
         } catch (Exception e) {
             e.printStackTrace();
             fail("We received an exception.");
@@ -1091,7 +1092,7 @@ public void testExecutionSuccessWithCircuitBreakerDisabled() {
     public void testExecutionTimeoutWithNoFallbackUsingSemaphoreIsolation() {
         TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_NOT_IMPLEMENTED, ExecutionIsolationStrategy.SEMAPHORE);
         try {
-            command.execute();
+            command.observe().toBlocking().single();
             fail("we shouldn't get here");
         } catch (Exception e) {
             //                e.printStackTrace();
@@ -1140,7 +1141,7 @@ public void testExecutionTimeoutWithNoFallbackUsingSemaphoreIsolation() {
     public void testExecutionTimeoutWithFallbackUsingSemaphoreIsolation() {
         TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_SUCCESS, ExecutionIsolationStrategy.SEMAPHORE);
         try {
-            assertEquals(false, command.execute());
+            assertEquals(false, command.observe().toBlocking().single());
             // the time should be 50+ since we timeout at 50ms
             assertTrue("Execution Time is: " + command.getExecutionTimeInMilliseconds(), command.getExecutionTimeInMilliseconds() >= 50);
             assertTrue(command.isResponseTimedOut());
@@ -1177,7 +1178,7 @@ public void testExecutionTimeoutWithFallbackUsingSemaphoreIsolation() {
     public void testExecutionTimeoutFallbackFailureUsingSemaphoreIsolation() {
         TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_FAILURE, ExecutionIsolationStrategy.SEMAPHORE);
         try {
-            command.execute();
+            command.observe().toBlocking().single();
             fail("we shouldn't get here");
         } catch (Exception e) {
             if (e instanceof HystrixRuntimeException) {
@@ -1220,7 +1221,7 @@ public void testExecutionTimeoutFallbackFailureUsingSemaphoreIsolation() {
     public void testExecutionTimeoutWithNoFallbackUsingThreadIsolation() {
         TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_NOT_IMPLEMENTED, ExecutionIsolationStrategy.THREAD);
         try {
-            command.execute();
+            command.observe().toBlocking().single();
             fail("we shouldn't get here");
         } catch (Exception e) {
             //                e.printStackTrace();
@@ -1269,7 +1270,7 @@ public void testExecutionTimeoutWithNoFallbackUsingThreadIsolation() {
     public void testExecutionTimeoutWithFallbackUsingThreadIsolation() {
         TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_SUCCESS, ExecutionIsolationStrategy.THREAD);
         try {
-            assertEquals(false, command.execute());
+            assertEquals(false, command.observe().toBlocking().single());
             // the time should be 50+ since we timeout at 50ms
             assertTrue("Execution Time is: " + command.getExecutionTimeInMilliseconds(), command.getExecutionTimeInMilliseconds() >= 50);
             assertTrue(command.isResponseTimedOut());
@@ -1306,7 +1307,7 @@ public void testExecutionTimeoutWithFallbackUsingThreadIsolation() {
     public void testExecutionTimeoutFallbackFailureUsingThreadIsolation() {
         TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_FAILURE, ExecutionIsolationStrategy.THREAD);
         try {
-            command.execute();
+            command.observe().toBlocking().single();
             fail("we shouldn't get here");
         } catch (Exception e) {
             if (e instanceof HystrixRuntimeException) {
@@ -1351,7 +1352,7 @@ public void testCircuitBreakerOnExecutionTimeout() {
         try {
             assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
 
-            command.execute();
+            command.observe().toBlocking().single();
 
             assertTrue(command.isResponseFromFallback());
             assertFalse(command.isCircuitBreakerOpen());
@@ -1397,7 +1398,7 @@ public void testCircuitBreakerOnExecutionTimeout() {
     public void testCountersOnExecutionTimeout() {
         TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_SUCCESS);
         try {
-            command.execute();
+            command.observe().toBlocking().single();
 
             /* wait long enough for the command to have finished */
             Thread.sleep(200);
@@ -1446,14 +1447,15 @@ public void testCountersOnExecutionTimeout() {
     /**
      * Test a queued command execution timeout where the command didn't implement getFallback.
      * <p>
-     * We specifically want to protect against developers queuing commands and using queue().get() without a timeout (such as queue().get(3000, TimeUnit.Milliseconds)) and ending up blocking
-     * indefinitely by skipping the timeout protection of the execute() command.
+     * We specifically want to protect against developers queuing commands and using observe().toBlocking().toFuture().get() without a timeout (such as observe().toBlocking().toFuture().get(3000,
+     * TimeUnit.Milliseconds)) and ending up blocking
+     * indefinitely by skipping the timeout protection of the observe().toBlocking().single() command.
      */
     @Test
     public void testQueuedExecutionTimeoutWithNoFallback() {
         TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_NOT_IMPLEMENTED);
         try {
-            command.queue().get();
+            command.observe().toBlocking().toFuture().get();
             fail("we shouldn't get here");
         } catch (Exception e) {
             e.printStackTrace();
@@ -1495,14 +1497,15 @@ public void testQueuedExecutionTimeoutWithNoFallback() {
     /**
      * Test a queued command execution timeout where the command implemented getFallback.
      * <p>
-     * We specifically want to protect against developers queuing commands and using queue().get() without a timeout (such as queue().get(3000, TimeUnit.Milliseconds)) and ending up blocking
-     * indefinitely by skipping the timeout protection of the execute() command.
+     * We specifically want to protect against developers queuing commands and using observe().toBlocking().toFuture().get() without a timeout (such as observe().toBlocking().toFuture().get(3000,
+     * TimeUnit.Milliseconds)) and ending up blocking
+     * indefinitely by skipping the timeout protection of the observe().toBlocking().single() command.
      */
     @Test
     public void testQueuedExecutionTimeoutWithFallback() {
         TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_SUCCESS);
         try {
-            assertEquals(false, command.queue().get());
+            assertEquals(false, command.observe().toBlocking().toFuture().get());
         } catch (Exception e) {
             e.printStackTrace();
             fail("We should have received a response from the fallback.");
@@ -1531,14 +1534,15 @@ public void testQueuedExecutionTimeoutWithFallback() {
     /**
      * Test a queued command execution timeout where the command implemented getFallback but it fails.
      * <p>
-     * We specifically want to protect against developers queuing commands and using queue().get() without a timeout (such as queue().get(3000, TimeUnit.Milliseconds)) and ending up blocking
-     * indefinitely by skipping the timeout protection of the execute() command.
+     * We specifically want to protect against developers queuing commands and using observe().toBlocking().toFuture().get() without a timeout (such as observe().toBlocking().toFuture().get(3000,
+     * TimeUnit.Milliseconds)) and ending up blocking
+     * indefinitely by skipping the timeout protection of the observe().toBlocking().single() command.
      */
     @Test
     public void testQueuedExecutionTimeoutFallbackFailure() {
         TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_FAILURE);
         try {
-            command.queue().get();
+            command.observe().toBlocking().toFuture().get();
             fail("we shouldn't get here");
         } catch (Exception e) {
             if (e instanceof ExecutionException && e.getCause() instanceof HystrixRuntimeException) {
@@ -1576,8 +1580,9 @@ public void testQueuedExecutionTimeoutFallbackFailure() {
     /**
      * Test a queued command execution timeout where the command didn't implement getFallback.
      * <p>
-     * We specifically want to protect against developers queuing commands and using queue().get() without a timeout (such as queue().get(3000, TimeUnit.Milliseconds)) and ending up blocking
-     * indefinitely by skipping the timeout protection of the execute() command.
+     * We specifically want to protect against developers queuing commands and using observe().toBlocking().toFuture().get() without a timeout (such as observe().toBlocking().toFuture().get(3000,
+     * TimeUnit.Milliseconds)) and ending up blocking
+     * indefinitely by skipping the timeout protection of the observe().toBlocking().single() command.
      */
     @Test
     public void testObservedExecutionTimeoutWithNoFallback() {
@@ -1625,8 +1630,9 @@ public void testObservedExecutionTimeoutWithNoFallback() {
     /**
      * Test a queued command execution timeout where the command implemented getFallback.
      * <p>
-     * We specifically want to protect against developers queuing commands and using queue().get() without a timeout (such as queue().get(3000, TimeUnit.Milliseconds)) and ending up blocking
-     * indefinitely by skipping the timeout protection of the execute() command.
+     * We specifically want to protect against developers queuing commands and using observe().toBlocking().toFuture().get() without a timeout (such as observe().toBlocking().toFuture().get(3000,
+     * TimeUnit.Milliseconds)) and ending up blocking
+     * indefinitely by skipping the timeout protection of the observe().toBlocking().single() command.
      */
     @Test
     public void testObservedExecutionTimeoutWithFallback() {
@@ -1661,8 +1667,9 @@ public void testObservedExecutionTimeoutWithFallback() {
     /**
      * Test a queued command execution timeout where the command implemented getFallback but it fails.
      * <p>
-     * We specifically want to protect against developers queuing commands and using queue().get() without a timeout (such as queue().get(3000, TimeUnit.Milliseconds)) and ending up blocking
-     * indefinitely by skipping the timeout protection of the execute() command.
+     * We specifically want to protect against developers queuing commands and using observe().toBlocking().toFuture().get() without a timeout (such as observe().toBlocking().toFuture().get(3000,
+     * TimeUnit.Milliseconds)) and ending up blocking
+     * indefinitely by skipping the timeout protection of the observe().toBlocking().single() command.
      */
     @Test
     public void testObservedExecutionTimeoutFallbackFailure() {
@@ -1710,12 +1717,12 @@ public void testObservedExecutionTimeoutFallbackFailure() {
     public void testShortCircuitFallbackCounter() {
         TestCircuitBreaker circuitBreaker = new TestCircuitBreaker().setForceShortCircuit(true);
         try {
-            new KnownFailureTestCommandWithFallback(circuitBreaker).execute();
+            new KnownFailureTestCommandWithFallback(circuitBreaker).observe().toBlocking().single();
 
             assertEquals(1, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
 
             KnownFailureTestCommandWithFallback command = new KnownFailureTestCommandWithFallback(circuitBreaker);
-            command.execute();
+            command.observe().toBlocking().single();
             assertEquals(2, circuitBreaker.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
 
             // will be -1 because it never attempted execution
@@ -1757,7 +1764,7 @@ public void testExecutionSemaphoreWithQueue() {
         final TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         // single thread should work
         try {
-            boolean result = new TestSemaphoreCommand(circuitBreaker, 1, 200).queue().get();
+            boolean result = new TestSemaphoreCommand(circuitBreaker, 1, 200).observe().toBlocking().toFuture().get();
             assertTrue(result);
         } catch (Exception e) {
             // we shouldn't fail on this one
@@ -1774,7 +1781,7 @@ public void testExecutionSemaphoreWithQueue() {
             @Override
             public void run() {
                 try {
-                    new TestSemaphoreCommand(circuitBreaker, semaphore, 200).queue().get();
+                    new TestSemaphoreCommand(circuitBreaker, semaphore, 200).observe().toBlocking().toFuture().get();
                 } catch (Exception e) {
                     e.printStackTrace();
                     exceptionReceived.set(true);
@@ -1826,7 +1833,7 @@ public void testExecutionSemaphoreWithExecution() {
         // single thread should work
         try {
             TestSemaphoreCommand command = new TestSemaphoreCommand(circuitBreaker, 1, 200);
-            boolean result = command.execute();
+            boolean result = command.observe().toBlocking().single();
             assertFalse(command.isExecutedInThread());
             assertTrue(result);
         } catch (Exception e) {
@@ -1846,7 +1853,7 @@ public void testExecutionSemaphoreWithExecution() {
             @Override
             public void run() {
                 try {
-                    results.add(new TestSemaphoreCommand(circuitBreaker, semaphore, 200).execute());
+                    results.add(new TestSemaphoreCommand(circuitBreaker, semaphore, 200).observe().toBlocking().single());
                 } catch (Exception e) {
                     e.printStackTrace();
                     exceptionReceived.set(true);
@@ -1909,7 +1916,7 @@ public void testRejectedExecutionSemaphoreWithFallback() {
             @Override
             public void run() {
                 try {
-                    results.add(new TestSemaphoreCommandWithFallback(circuitBreaker, 1, 200, false).execute());
+                    results.add(new TestSemaphoreCommandWithFallback(circuitBreaker, 1, 200, false).observe().toBlocking().single());
                 } catch (Exception e) {
                     e.printStackTrace();
                     exceptionReceived.set(true);
@@ -1980,7 +1987,7 @@ public void testSemaphorePermitsInUse() {
         final Runnable sharedSemaphoreRunnable = new HystrixContextRunnable(HystrixPlugins.getInstance().getConcurrencyStrategy(), new Runnable() {
             public void run() {
                 try {
-                    new LatchedSemaphoreCommand(circuitBreaker, sharedSemaphore, startLatch, sharedLatch).execute();
+                    new LatchedSemaphoreCommand(circuitBreaker, sharedSemaphore, startLatch, sharedLatch).observe().toBlocking().single();
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
@@ -2008,7 +2015,7 @@ public void run() {
         final Thread isolatedThread = new Thread(new HystrixContextRunnable(HystrixPlugins.getInstance().getConcurrencyStrategy(), new Runnable() {
             public void run() {
                 try {
-                    new LatchedSemaphoreCommand(circuitBreaker, isolatedSemaphore, startLatch, isolatedLatch).execute();
+                    new LatchedSemaphoreCommand(circuitBreaker, isolatedSemaphore, startLatch, isolatedLatch).observe().toBlocking().single();
                 } catch (Exception e) {
                     e.printStackTrace();
                     failureCount.incrementAndGet();
@@ -2071,7 +2078,7 @@ public void testDynamicOwner() {
             assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
             assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
             assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
-            assertEquals(true, command.execute());
+            assertEquals(true, command.observe().toBlocking().single());
             assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
             assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
             assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
@@ -2094,7 +2101,7 @@ public void testDynamicOwnerFails() {
             assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
             assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
             assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
-            assertEquals(true, command.execute());
+            assertEquals(true, command.observe().toBlocking().single());
             fail("we should have thrown an exception as we need an owner");
 
             // semaphore isolated
@@ -2111,9 +2118,9 @@ public void testDynamicOwnerFails() {
     public void testDynamicKey() {
         try {
             DynamicOwnerAndKeyTestCommand command1 = new DynamicOwnerAndKeyTestCommand(CommandGroupForUnitTest.OWNER_ONE, CommandKeyForUnitTest.KEY_ONE);
-            assertEquals(true, command1.execute());
+            assertEquals(true, command1.observe().toBlocking().single());
             DynamicOwnerAndKeyTestCommand command2 = new DynamicOwnerAndKeyTestCommand(CommandGroupForUnitTest.OWNER_ONE, CommandKeyForUnitTest.KEY_TWO);
-            assertEquals(true, command2.execute());
+            assertEquals(true, command2.observe().toBlocking().single());
 
             // 2 different circuit breakers should be created
             assertNotSame(command1.getCircuitBreaker(), command2.getCircuitBreaker());
@@ -2137,8 +2144,8 @@ public void testRequestCache1UsingThreadIsolation() {
 
         assertTrue(command1.isCommandRunningInThread());
 
-        Future<String> f1 = command1.queue();
-        Future<String> f2 = command2.queue();
+        Future<String> f1 = command1.observe().toBlocking().toFuture();
+        Future<String> f2 = command2.observe().toBlocking().toFuture();
 
         try {
             assertEquals("A", f1.get());
@@ -2192,8 +2199,8 @@ public void testRequestCache2UsingThreadIsolation() {
 
         assertTrue(command1.isCommandRunningInThread());
 
-        Future<String> f1 = command1.queue();
-        Future<String> f2 = command2.queue();
+        Future<String> f1 = command1.observe().toBlocking().toFuture();
+        Future<String> f2 = command2.observe().toBlocking().toFuture();
 
         try {
             assertEquals("A", f1.get());
@@ -2245,9 +2252,9 @@ public void testRequestCache3UsingThreadIsolation() {
 
         assertTrue(command1.isCommandRunningInThread());
 
-        Future<String> f1 = command1.queue();
-        Future<String> f2 = command2.queue();
-        Future<String> f3 = command3.queue();
+        Future<String> f1 = command1.observe().toBlocking().toFuture();
+        Future<String> f2 = command2.observe().toBlocking().toFuture();
+        Future<String> f3 = command3.observe().toBlocking().toFuture();
 
         try {
             assertEquals("A", f1.get());
@@ -2307,10 +2314,10 @@ public void testRequestCacheWithSlowExecution() {
         SlowCacheableCommand command3 = new SlowCacheableCommand(circuitBreaker, "A", 100);
         SlowCacheableCommand command4 = new SlowCacheableCommand(circuitBreaker, "A", 100);
 
-        Future<String> f1 = command1.queue();
-        Future<String> f2 = command2.queue();
-        Future<String> f3 = command3.queue();
-        Future<String> f4 = command4.queue();
+        Future<String> f1 = command1.observe().toBlocking().toFuture();
+        Future<String> f2 = command2.observe().toBlocking().toFuture();
+        Future<String> f3 = command3.observe().toBlocking().toFuture();
+        Future<String> f4 = command4.observe().toBlocking().toFuture();
 
         try {
             assertEquals("A", f2.get());
@@ -2383,9 +2390,9 @@ public void testNoRequestCache3UsingThreadIsolation() {
 
         assertTrue(command1.isCommandRunningInThread());
 
-        Future<String> f1 = command1.queue();
-        Future<String> f2 = command2.queue();
-        Future<String> f3 = command3.queue();
+        Future<String> f1 = command1.observe().toBlocking().toFuture();
+        Future<String> f2 = command2.observe().toBlocking().toFuture();
+        Future<String> f3 = command3.observe().toBlocking().toFuture();
 
         try {
             assertEquals("A", f1.get());
@@ -2447,9 +2454,9 @@ public void testRequestCacheViaQueueUsingSemaphoreIsolation() {
 
         assertFalse(command1.isCommandRunningInThread());
 
-        Future<String> f1 = command1.queue();
-        Future<String> f2 = command2.queue();
-        Future<String> f3 = command3.queue();
+        Future<String> f1 = command1.observe().toBlocking().toFuture();
+        Future<String> f2 = command2.observe().toBlocking().toFuture();
+        Future<String> f3 = command3.observe().toBlocking().toFuture();
 
         try {
             assertEquals("A", f1.get());
@@ -2515,9 +2522,9 @@ public void testNoRequestCacheViaQueueUsingSemaphoreIsolation() {
 
         assertFalse(command1.isCommandRunningInThread());
 
-        Future<String> f1 = command1.queue();
-        Future<String> f2 = command2.queue();
-        Future<String> f3 = command3.queue();
+        Future<String> f1 = command1.observe().toBlocking().toFuture();
+        Future<String> f2 = command2.observe().toBlocking().toFuture();
+        Future<String> f3 = command3.observe().toBlocking().toFuture();
 
         try {
             assertEquals("A", f1.get());
@@ -2579,9 +2586,9 @@ public void testRequestCacheViaExecuteUsingSemaphoreIsolation() {
 
         assertFalse(command1.isCommandRunningInThread());
 
-        String f1 = command1.execute();
-        String f2 = command2.execute();
-        String f3 = command3.execute();
+        String f1 = command1.observe().toBlocking().single();
+        String f2 = command2.observe().toBlocking().single();
+        String f3 = command3.observe().toBlocking().single();
 
         assertEquals("A", f1);
         assertEquals("B", f2);
@@ -2639,9 +2646,9 @@ public void testNoRequestCacheViaExecuteUsingSemaphoreIsolation() {
 
         assertFalse(command1.isCommandRunningInThread());
 
-        String f1 = command1.execute();
-        String f2 = command2.execute();
-        String f3 = command3.execute();
+        String f1 = command1.observe().toBlocking().single();
+        String f2 = command2.observe().toBlocking().single();
+        String f3 = command3.observe().toBlocking().single();
 
         assertEquals("A", f1);
         assertEquals("B", f2);
@@ -2692,7 +2699,7 @@ public void testNoRequestCacheOnTimeoutThrowsException() throws Exception {
         TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         NoRequestCacheTimeoutWithoutFallback r1 = new NoRequestCacheTimeoutWithoutFallback(circuitBreaker);
         try {
-            System.out.println("r1 value: " + r1.execute());
+            System.out.println("r1 value: " + r1.observe().toBlocking().single());
             // we should have thrown an exception
             fail("expected a timeout");
         } catch (HystrixRuntimeException e) {
@@ -2702,7 +2709,7 @@ public void testNoRequestCacheOnTimeoutThrowsException() throws Exception {
 
         NoRequestCacheTimeoutWithoutFallback r2 = new NoRequestCacheTimeoutWithoutFallback(circuitBreaker);
         try {
-            r2.execute();
+            r2.observe().toBlocking().single();
             // we should have thrown an exception
             fail("expected a timeout");
         } catch (HystrixRuntimeException e) {
@@ -2711,7 +2718,7 @@ public void testNoRequestCacheOnTimeoutThrowsException() throws Exception {
         }
 
         NoRequestCacheTimeoutWithoutFallback r3 = new NoRequestCacheTimeoutWithoutFallback(circuitBreaker);
-        Future<Boolean> f3 = r3.queue();
+        Future<Boolean> f3 = r3.observe().toBlocking().toFuture();
         try {
             f3.get();
             // we should have thrown an exception
@@ -2726,7 +2733,7 @@ public void testNoRequestCacheOnTimeoutThrowsException() throws Exception {
 
         NoRequestCacheTimeoutWithoutFallback r4 = new NoRequestCacheTimeoutWithoutFallback(circuitBreaker);
         try {
-            r4.execute();
+            r4.observe().toBlocking().single();
             // we should have thrown an exception
             fail("expected a timeout");
         } catch (HystrixRuntimeException e) {
@@ -2756,14 +2763,14 @@ public void testNoRequestCacheOnTimeoutThrowsException() throws Exception {
     public void testRequestCacheOnTimeoutCausesNullPointerException() throws Exception {
         TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         // Expect it to time out - all results should be false
-        assertFalse(new RequestCacheNullPointerExceptionCase(circuitBreaker).execute());
-        assertFalse(new RequestCacheNullPointerExceptionCase(circuitBreaker).execute()); // return from cache #1
-        assertFalse(new RequestCacheNullPointerExceptionCase(circuitBreaker).execute()); // return from cache #2
+        assertFalse(new RequestCacheNullPointerExceptionCase(circuitBreaker).observe().toBlocking().single());
+        assertFalse(new RequestCacheNullPointerExceptionCase(circuitBreaker).observe().toBlocking().single()); // return from cache #1
+        assertFalse(new RequestCacheNullPointerExceptionCase(circuitBreaker).observe().toBlocking().single()); // return from cache #2
         Thread.sleep(500); // timeout on command is set to 200ms
-        Boolean value = new RequestCacheNullPointerExceptionCase(circuitBreaker).execute(); // return from cache #3
+        Boolean value = new RequestCacheNullPointerExceptionCase(circuitBreaker).observe().toBlocking().single(); // return from cache #3
         assertFalse(value);
         RequestCacheNullPointerExceptionCase c = new RequestCacheNullPointerExceptionCase(circuitBreaker);
-        Future<Boolean> f = c.queue(); // return from cache #4
+        Future<Boolean> f = c.observe().toBlocking().toFuture(); // return from cache #4
         // the bug is that we're getting a null Future back, rather than a Future that returns false
         assertNotNull(f);
         assertFalse(f.get());
@@ -2814,7 +2821,7 @@ public void testRequestCacheOnTimeoutThrowsException() throws Exception {
         TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         RequestCacheTimeoutWithoutFallback r1 = new RequestCacheTimeoutWithoutFallback(circuitBreaker);
         try {
-            System.out.println("r1 value: " + r1.execute());
+            System.out.println("r1 value: " + r1.observe().toBlocking().single());
             // we should have thrown an exception
             fail("expected a timeout");
         } catch (HystrixRuntimeException e) {
@@ -2824,7 +2831,7 @@ public void testRequestCacheOnTimeoutThrowsException() throws Exception {
 
         RequestCacheTimeoutWithoutFallback r2 = new RequestCacheTimeoutWithoutFallback(circuitBreaker);
         try {
-            r2.execute();
+            r2.observe().toBlocking().single();
             // we should have thrown an exception
             fail("expected a timeout");
         } catch (HystrixRuntimeException e) {
@@ -2833,7 +2840,7 @@ public void testRequestCacheOnTimeoutThrowsException() throws Exception {
         }
 
         RequestCacheTimeoutWithoutFallback r3 = new RequestCacheTimeoutWithoutFallback(circuitBreaker);
-        Future<Boolean> f3 = r3.queue();
+        Future<Boolean> f3 = r3.observe().toBlocking().toFuture();
         try {
             f3.get();
             // we should have thrown an exception
@@ -2848,7 +2855,7 @@ public void testRequestCacheOnTimeoutThrowsException() throws Exception {
 
         RequestCacheTimeoutWithoutFallback r4 = new RequestCacheTimeoutWithoutFallback(circuitBreaker);
         try {
-            r4.execute();
+            r4.observe().toBlocking().single();
             // we should have thrown an exception
             fail("expected a timeout");
         } catch (HystrixRuntimeException e) {
@@ -2880,7 +2887,7 @@ public void testRequestCacheOnThreadRejectionThrowsException() throws Exception
         CountDownLatch completionLatch = new CountDownLatch(1);
         RequestCacheThreadRejectionWithoutFallback r1 = new RequestCacheThreadRejectionWithoutFallback(circuitBreaker, completionLatch);
         try {
-            System.out.println("r1: " + r1.execute());
+            System.out.println("r1: " + r1.observe().toBlocking().single());
             // we should have thrown an exception
             fail("expected a rejection");
         } catch (HystrixRuntimeException e) {
@@ -2891,7 +2898,7 @@ public void testRequestCacheOnThreadRejectionThrowsException() throws Exception
 
         RequestCacheThreadRejectionWithoutFallback r2 = new RequestCacheThreadRejectionWithoutFallback(circuitBreaker, completionLatch);
         try {
-            System.out.println("r2: " + r2.execute());
+            System.out.println("r2: " + r2.observe().toBlocking().single());
             // we should have thrown an exception
             fail("expected a rejection");
         } catch (HystrixRuntimeException e) {
@@ -2902,13 +2909,12 @@ public void testRequestCacheOnThreadRejectionThrowsException() throws Exception
 
         RequestCacheThreadRejectionWithoutFallback r3 = new RequestCacheThreadRejectionWithoutFallback(circuitBreaker, completionLatch);
         try {
-            System.out.println("f3: " + r3.queue().get());
+            System.out.println("f3: " + r3.observe().toBlocking().toFuture().get());
             // we should have thrown an exception
             fail("expected a rejection");
-        } catch (HystrixRuntimeException e) {
-            //                e.printStackTrace();
+        } catch (ExecutionException e) {
             assertTrue(r3.isResponseRejected());
-            // what we want
+            assertTrue(e.getCause() instanceof HystrixRuntimeException);
         }
 
         // let the command finish (only 1 should actually be blocked on this due to the response cache)
@@ -2917,7 +2923,7 @@ public void testRequestCacheOnThreadRejectionThrowsException() throws Exception
         // then another after the command has completed
         RequestCacheThreadRejectionWithoutFallback r4 = new RequestCacheThreadRejectionWithoutFallback(circuitBreaker, completionLatch);
         try {
-            System.out.println("r4: " + r4.execute());
+            System.out.println("r4: " + r4.observe().toBlocking().single());
             // we should have thrown an exception
             fail("expected a rejection");
         } catch (HystrixRuntimeException e) {
@@ -2954,10 +2960,10 @@ public void testBasicExecutionWorksWithoutRequestVariable() {
             HystrixRequestContext.setContextOnCurrentThread(null);
 
             TestHystrixCommand<Boolean> command = new SuccessfulTestCommand();
-            assertEquals(true, command.execute());
+            assertEquals(true, command.observe().toBlocking().single());
 
             TestHystrixCommand<Boolean> command2 = new SuccessfulTestCommand();
-            assertEquals(true, command2.queue().get());
+            assertEquals(true, command2.observe().toBlocking().toFuture().get());
 
             // we should be able to execute without a RequestVariable if ...
             // 1) We don't have a cacheKey
@@ -2984,10 +2990,10 @@ public void testCacheKeyExecutionRequiresRequestVariable() {
             TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
 
             SuccessfulCacheableCommand command = new SuccessfulCacheableCommand(circuitBreaker, true, "one");
-            assertEquals(true, command.execute());
+            assertEquals(true, command.observe().toBlocking().single());
 
             SuccessfulCacheableCommand command2 = new SuccessfulCacheableCommand(circuitBreaker, true, "two");
-            assertEquals(true, command2.queue().get());
+            assertEquals(true, command2.observe().toBlocking().toFuture().get());
 
             fail("We expect an exception because cacheKey requires RequestVariable.");
 
@@ -3005,7 +3011,7 @@ public void testCacheKeyExecutionRequiresRequestVariable() {
     public void testBadRequestExceptionViaExecuteInThread() {
         TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         try {
-            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.THREAD).execute();
+            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.THREAD).observe().toBlocking().single();
             fail("we expect to receive a " + HystrixBadRequestException.class.getSimpleName());
         } catch (HystrixBadRequestException e) {
             // success
@@ -3027,7 +3033,7 @@ public void testBadRequestExceptionViaExecuteInThread() {
     public void testBadRequestExceptionViaQueueInThread() {
         TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         try {
-            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.THREAD).queue().get();
+            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.THREAD).observe().toBlocking().toFuture().get();
             fail("we expect to receive a " + HystrixBadRequestException.class.getSimpleName());
         } catch (ExecutionException e) {
             e.printStackTrace();
@@ -3055,13 +3061,13 @@ public void testBadRequestExceptionViaQueueInThreadOnResponseFromCache() {
 
         // execute once to cache the value
         try {
-            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.THREAD).execute();
+            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.THREAD).observe().toBlocking().single();
         } catch (Throwable e) {
             // ignore
         }
 
         try {
-            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.THREAD).queue().get();
+            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.THREAD).observe().toBlocking().toFuture().get();
             fail("we expect to receive a " + HystrixBadRequestException.class.getSimpleName());
         } catch (ExecutionException e) {
             e.printStackTrace();
@@ -3087,7 +3093,7 @@ public void testBadRequestExceptionViaQueueInThreadOnResponseFromCache() {
     public void testBadRequestExceptionViaExecuteInSemaphore() {
         TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         try {
-            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.SEMAPHORE).execute();
+            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.SEMAPHORE).observe().toBlocking().single();
             fail("we expect to receive a " + HystrixBadRequestException.class.getSimpleName());
         } catch (HystrixBadRequestException e) {
             // success
@@ -3109,7 +3115,7 @@ public void testBadRequestExceptionViaExecuteInSemaphore() {
     public void testBadRequestExceptionViaQueueInSemaphore() {
         TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         try {
-            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.SEMAPHORE).queue().get();
+            new BadRequestCommand(circuitBreaker, ExecutionIsolationStrategy.SEMAPHORE).observe().toBlocking().toFuture().get();
             fail("we expect to receive a " + HystrixBadRequestException.class.getSimpleName());
         } catch (ExecutionException e) {
             e.printStackTrace();
@@ -3136,7 +3142,7 @@ public void testCheckedExceptionViaExecute() {
         TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         CommandWithCheckedException command = new CommandWithCheckedException(circuitBreaker);
         try {
-            command.execute();
+            command.observe().toBlocking().single();
             fail("we expect to receive a " + Exception.class.getSimpleName());
         } catch (Exception e) {
             assertEquals("simulated checked exception message", e.getCause().getMessage());
@@ -3215,7 +3221,7 @@ public void testErrorThrownViaExecute() {
         TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         CommandWithErrorThrown command = new CommandWithErrorThrown(circuitBreaker);
         try {
-            command.execute();
+            command.observe().toBlocking().single();
             fail("we expect to receive a " + Error.class.getSimpleName());
         } catch (Exception e) {
             // the actual error is an extra cause level deep because Hystrix needs to wrap Throwable/Error as it's public
@@ -3245,7 +3251,7 @@ public void testErrorThrownViaQueue() {
         TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         CommandWithErrorThrown command = new CommandWithErrorThrown(circuitBreaker);
         try {
-            command.queue().get();
+            command.observe().toBlocking().toFuture().get();
             fail("we expect to receive an Exception");
         } catch (Exception e) {
             // one cause down from ExecutionException to HystrixRuntime
@@ -3330,9 +3336,9 @@ public void onNext(Boolean args) {
      */
     @Test
     public void testExecutionHookSuccessfulCommand() {
-        //test with execute() 
+        //test with observe().toBlocking().single() 
         TestHystrixCommand<Boolean> command = new SuccessfulTestCommand();
-        command.execute();
+        command.observe().toBlocking().single();
 
         // the run() method should run as we're not short-circuited or rejected
         assertEquals(1, command.builder.executionHook.startRun.get());
@@ -3348,9 +3354,9 @@ public void testExecutionHookSuccessfulCommand() {
         // null since it didn't run
         assertNull(command.builder.executionHook.fallbackFailureException);
 
-        // the execute() method was used
+        // the observe().toBlocking().single() method was used
         assertEquals(1, command.builder.executionHook.startExecute.get());
-        // we should have a response from execute() since run() succeeded
+        // we should have a response from observe().toBlocking().single() since run() succeeded
         assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
         // we should not have an exception since run() succeeded
         assertNull(command.builder.executionHook.endExecuteFailureException);
@@ -3359,10 +3365,10 @@ public void testExecutionHookSuccessfulCommand() {
         //        assertEquals(1, command.builder.executionHook.threadStart.get());
         //        assertEquals(1, command.builder.executionHook.threadComplete.get());
 
-        // test with queue() 
+        // test with observe().toBlocking().toFuture() 
         command = new SuccessfulTestCommand();
         try {
-            command.queue().get();
+            command.observe().toBlocking().toFuture().get();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
@@ -3381,9 +3387,9 @@ public void testExecutionHookSuccessfulCommand() {
         // null since it didn't run
         assertNull(command.builder.executionHook.fallbackFailureException);
 
-        // the queue() method was used
+        // the observe().toBlocking().toFuture() method was used
         assertEquals(1, command.builder.executionHook.startExecute.get());
-        // we should have a response from queue() since run() succeeded
+        // we should have a response from observe().toBlocking().toFuture() since run() succeeded
         assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
         // we should not have an exception since run() succeeded
         assertNull(command.builder.executionHook.endExecuteFailureException);
@@ -3404,7 +3410,7 @@ public void testExecutionHookSuccessfulCommandViaFireAndForget() {
         TestHystrixCommand<Boolean> command = new SuccessfulTestCommand();
         try {
             // do not block on "get()" ... fire this asynchronously
-            command.queue();
+            command.observe().toBlocking().toFuture();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
@@ -3434,9 +3440,9 @@ public void testExecutionHookSuccessfulCommandViaFireAndForget() {
         // null since it didn't run
         assertNull(command.builder.executionHook.fallbackFailureException);
 
-        // the queue() method was used
+        // the observe().toBlocking().toFuture() method was used
         assertEquals(1, command.builder.executionHook.startExecute.get());
-        // we should have a response from queue() since run() succeeded
+        // we should have a response from observe().toBlocking().toFuture() since run() succeeded
         assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
         // we should not have an exception since run() succeeded
         assertNull(command.builder.executionHook.endExecuteFailureException);
@@ -3456,7 +3462,7 @@ public void testExecutionHookSuccessfulCommandViaFireAndForget() {
     public void testExecutionHookSuccessfulCommandWithMultipleGetsOnFuture() {
         TestHystrixCommand<Boolean> command = new SuccessfulTestCommand();
         try {
-            Future<Boolean> f = command.queue();
+            Future<Boolean> f = command.observe().toBlocking().toFuture();
             f.get();
             f.get();
             f.get();
@@ -3481,9 +3487,9 @@ public void testExecutionHookSuccessfulCommandWithMultipleGetsOnFuture() {
         // null since it didn't run
         assertNull(command.builder.executionHook.fallbackFailureException);
 
-        // the queue() method was used
+        // the observe().toBlocking().toFuture() method was used
         assertEquals(1, command.builder.executionHook.startExecute.get());
-        // we should have a response from queue() since run() succeeded
+        // we should have a response from observe().toBlocking().toFuture() since run() succeeded
         assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
         // we should not have an exception since run() succeeded
         assertNull(command.builder.executionHook.endExecuteFailureException);
@@ -3501,10 +3507,10 @@ public void testExecutionHookSuccessfulCommandWithMultipleGetsOnFuture() {
      */
     @Test
     public void testExecutionHookRunFailureWithoutFallback() {
-        // test with execute() 
+        // test with observe().toBlocking().single() 
         TestHystrixCommand<Boolean> command = new UnknownFailureTestCommandWithoutFallback();
         try {
-            command.execute();
+            command.observe().toBlocking().single();
             fail("Expecting exception");
         } catch (Exception e) {
             // ignore
@@ -3524,9 +3530,9 @@ public void testExecutionHookRunFailureWithoutFallback() {
         // not null since it's not implemented and throws an exception
         assertNotNull(command.builder.executionHook.fallbackFailureException);
 
-        // the execute() method was used
+        // the observe().toBlocking().single() method was used
         assertEquals(1, command.builder.executionHook.startExecute.get());
-        // we should not have a response from execute() since we do not have a fallback and run() failed
+        // we should not have a response from observe().toBlocking().single() since we do not have a fallback and run() failed
         assertNull(command.builder.executionHook.endExecuteSuccessResponse);
         // we should have an exception since run() failed
         assertNotNull(command.builder.executionHook.endExecuteFailureException);
@@ -3537,10 +3543,10 @@ public void testExecutionHookRunFailureWithoutFallback() {
         //        assertEquals(1, command.builder.executionHook.threadStart.get());
         //        assertEquals(1, command.builder.executionHook.threadComplete.get());
 
-        // test with queue() 
+        // test with observe().toBlocking().toFuture() 
         command = new UnknownFailureTestCommandWithoutFallback();
         try {
-            command.queue().get();
+            command.observe().toBlocking().toFuture().get();
             fail("Expecting exception");
         } catch (Exception e) {
             // ignore
@@ -3560,9 +3566,9 @@ public void testExecutionHookRunFailureWithoutFallback() {
         // not null since it's not implemented and throws an exception
         assertNotNull(command.builder.executionHook.fallbackFailureException);
 
-        // the queue() method was used
+        // the observe().toBlocking().toFuture() method was used
         assertEquals(1, command.builder.executionHook.startExecute.get());
-        // we should not have a response from queue() since we do not have a fallback and run() failed
+        // we should not have a response from observe().toBlocking().toFuture() since we do not have a fallback and run() failed
         assertNull(command.builder.executionHook.endExecuteSuccessResponse);
         // we should have an exception since run() failed
         assertNotNull(command.builder.executionHook.endExecuteFailureException);
@@ -3583,9 +3589,9 @@ public void testExecutionHookRunFailureWithoutFallback() {
      */
     @Test
     public void testExecutionHookRunFailureWithFallback() {
-        // test with execute() 
+        // test with observe().toBlocking().single() 
         TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithFallback(new TestCircuitBreaker());
-        command.execute();
+        command.observe().toBlocking().single();
 
         // the run() method should run as we're not short-circuited or rejected
         assertEquals(1, command.builder.executionHook.startRun.get());
@@ -3601,9 +3607,9 @@ public void testExecutionHookRunFailureWithFallback() {
         // null since it's implemented and succeeds
         assertNull(command.builder.executionHook.fallbackFailureException);
 
-        // the execute() method was used
+        // the observe().toBlocking().single() method was used
         assertEquals(1, command.builder.executionHook.startExecute.get());
-        // we should have a response from execute() since we expect a fallback despite failure of run()
+        // we should have a response from observe().toBlocking().single() since we expect a fallback despite failure of run()
         assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
         // we should not have an exception because we expect a fallback
         assertNull(command.builder.executionHook.endExecuteFailureException);
@@ -3612,10 +3618,10 @@ public void testExecutionHookRunFailureWithFallback() {
         //        assertEquals(1, command.builder.executionHook.threadStart.get());
         //        assertEquals(1, command.builder.executionHook.threadComplete.get());
 
-        // test with queue() 
+        // test with observe().toBlocking().toFuture() 
         command = new KnownFailureTestCommandWithFallback(new TestCircuitBreaker());
         try {
-            command.queue().get();
+            command.observe().toBlocking().toFuture().get();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
@@ -3634,9 +3640,9 @@ public void testExecutionHookRunFailureWithFallback() {
         // null since it's implemented and succeeds
         assertNull(command.builder.executionHook.fallbackFailureException);
 
-        // the queue() method was used
+        // the observe().toBlocking().toFuture() method was used
         assertEquals(1, command.builder.executionHook.startExecute.get());
-        // we should have a response from queue() since we expect a fallback despite failure of run()
+        // we should have a response from observe().toBlocking().toFuture() since we expect a fallback despite failure of run()
         assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
         // we should not have an exception because we expect a fallback
         assertNull(command.builder.executionHook.endExecuteFailureException);
@@ -3654,10 +3660,10 @@ public void testExecutionHookRunFailureWithFallback() {
      */
     @Test
     public void testExecutionHookRunFailureWithFallbackFailure() {
-        // test with execute() 
+        // test with observe().toBlocking().single() 
         TestHystrixCommand<Boolean> command = new KnownFailureTestCommandWithFallbackFailure();
         try {
-            command.execute();
+            command.observe().toBlocking().single();
             fail("Expecting exception");
         } catch (Exception e) {
             // ignore
@@ -3677,7 +3683,7 @@ public void testExecutionHookRunFailureWithFallbackFailure() {
         // not null since it's implemented but fails
         assertNotNull(command.builder.executionHook.fallbackFailureException);
 
-        // the execute() method was used
+        // the observe().toBlocking().single() method was used
         assertEquals(1, command.builder.executionHook.startExecute.get());
         // we should not have a response because run() and fallback fail
         assertNull(command.builder.executionHook.endExecuteSuccessResponse);
@@ -3690,10 +3696,10 @@ public void testExecutionHookRunFailureWithFallbackFailure() {
         //        assertEquals(1, command.builder.executionHook.threadStart.get());
         //        assertEquals(1, command.builder.executionHook.threadComplete.get());
 
-        // test with queue() 
+        // test with observe().toBlocking().toFuture() 
         command = new KnownFailureTestCommandWithFallbackFailure();
         try {
-            command.queue().get();
+            command.observe().toBlocking().toFuture().get();
             fail("Expecting exception");
         } catch (Exception e) {
             // ignore
@@ -3713,7 +3719,7 @@ public void testExecutionHookRunFailureWithFallbackFailure() {
         // not null since it's implemented but fails
         assertNotNull(command.builder.executionHook.fallbackFailureException);
 
-        // the queue() method was used
+        // the observe().toBlocking().toFuture() method was used
         assertEquals(1, command.builder.executionHook.startExecute.get());
         // we should not have a response because run() and fallback fail
         assertNull(command.builder.executionHook.endExecuteSuccessResponse);
@@ -3738,7 +3744,7 @@ public void testExecutionHookTimeoutWithoutFallback() {
         TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_NOT_IMPLEMENTED);
         try {
             System.out.println("start at : " + System.currentTimeMillis());
-            command.queue().get();
+            command.observe().toBlocking().toFuture().get();
             fail("Expecting exception");
         } catch (Exception e) {
             // ignore
@@ -3789,7 +3795,7 @@ public void testExecutionHookTimeoutWithoutFallback() {
     public void testExecutionHookTimeoutWithFallback() {
         TestHystrixCommand<Boolean> command = new TestCommandWithTimeout(50, TestCommandWithTimeout.FALLBACK_SUCCESS);
         try {
-            command.queue().get();
+            command.observe().toBlocking().toFuture().get();
         } catch (Exception e) {
             throw new RuntimeException("not expecting", e);
         }
@@ -3841,8 +3847,8 @@ public void testExecutionHookTimeoutWithFallback() {
      * 
      * try {
      * // fill the queue
-     * new TestCommandRejection(circuitBreaker, pool, 500, 600, TestCommandRejection.FALLBACK_SUCCESS).queue();
-     * new TestCommandRejection(circuitBreaker, pool, 500, 600, TestCommandRejection.FALLBACK_SUCCESS).queue();
+     * new TestCommandRejection(circuitBreaker, pool, 500, 600, TestCommandRejection.FALLBACK_SUCCESS).observe().toBlocking().toFuture();
+     * new TestCommandRejection(circuitBreaker, pool, 500, 600, TestCommandRejection.FALLBACK_SUCCESS).observe().toBlocking().toFuture();
      * } catch (Exception e) {
      * // ignore
      * }
@@ -3850,7 +3856,7 @@ public void testExecutionHookTimeoutWithFallback() {
      * TestCommandRejection command = new TestCommandRejection(circuitBreaker, pool, 500, 600, TestCommandRejection.FALLBACK_SUCCESS);
      * try {
      * // now execute one that will be rejected
-     * command.queue().get();
+     * command.observe().toBlocking().toFuture().get();
      * } catch (Exception e) {
      * throw new RuntimeException("not expecting", e);
      * }
@@ -3892,7 +3898,7 @@ public void testExecutionHookShortCircuitedWithFallbackViaQueue() {
         KnownFailureTestCommandWithoutFallback command = new KnownFailureTestCommandWithoutFallback(circuitBreaker);
         try {
             // now execute one that will be short-circuited
-            command.queue().get();
+            command.observe().toBlocking().toFuture().get();
             fail("we expect an error as there is no fallback");
         } catch (Exception e) {
             // expecting
@@ -3940,7 +3946,7 @@ public void testExecutionHookShortCircuitedWithFallbackViaExecute() {
         KnownFailureTestCommandWithoutFallback command = new KnownFailureTestCommandWithoutFallback(circuitBreaker);
         try {
             // now execute one that will be short-circuited
-            command.execute();
+            command.observe().toBlocking().single();
             fail("we expect an error as there is no fallback");
         } catch (Exception e) {
             // expecting
@@ -3984,9 +3990,9 @@ public void testExecutionHookShortCircuitedWithFallbackViaExecute() {
      */
     @Test
     public void testExecutionHookSuccessfulCommandWithSemaphoreIsolation() {
-        // test with execute() 
+        // test with observe().toBlocking().single() 
         TestSemaphoreCommand command = new TestSemaphoreCommand(new TestCircuitBreaker(), 1, 10);
-        command.execute();
+        command.observe().toBlocking().single();
 
         assertFalse(command.isExecutedInThread());
 
@@ -4004,9 +4010,9 @@ public void testExecutionHookSuccessfulCommandWithSemaphoreIsolation() {
         // null since it didn't run
         assertNull(command.builder.executionHook.fallbackFailureException);
 
-        // the execute() method was used
+        // the observe().toBlocking().single() method was used
         assertEquals(1, command.builder.executionHook.startExecute.get());
-        // we should have a response from execute() since run() succeeded
+        // we should have a response from observe().toBlocking().single() since run() succeeded
         assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
         // we should not have an exception since run() succeeded
         assertNull(command.builder.executionHook.endExecuteFailureException);
@@ -4015,10 +4021,10 @@ public void testExecutionHookSuccessfulCommandWithSemaphoreIsolation() {
         assertEquals(0, command.builder.executionHook.threadStart.get());
         assertEquals(0, command.builder.executionHook.threadComplete.get());
 
-        // test with queue() 
+        // test with observe().toBlocking().toFuture() 
         command = new TestSemaphoreCommand(new TestCircuitBreaker(), 1, 10);
         try {
-            command.queue().get();
+            command.observe().toBlocking().toFuture().get();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
@@ -4039,9 +4045,9 @@ public void testExecutionHookSuccessfulCommandWithSemaphoreIsolation() {
         // null since it didn't run
         assertNull(command.builder.executionHook.fallbackFailureException);
 
-        // the queue() method was used
+        // the observe().toBlocking().toFuture() method was used
         assertEquals(1, command.builder.executionHook.startExecute.get());
-        // we should have a response from queue() since run() succeeded
+        // we should have a response from observe().toBlocking().toFuture() since run() succeeded
         assertNotNull(command.builder.executionHook.endExecuteSuccessResponse);
         // we should not have an exception since run() succeeded
         assertNull(command.builder.executionHook.endExecuteFailureException);
@@ -4059,13 +4065,13 @@ public void testExecutionHookSuccessfulCommandWithSemaphoreIsolation() {
      */
     @Test
     public void testExecutionHookFailureWithSemaphoreIsolation() {
-        // test with execute() 
+        // test with observe().toBlocking().single() 
         final TryableSemaphoreActual semaphore =
                 new TryableSemaphoreActual(HystrixProperty.Factory.asProperty(0));
 
         TestSemaphoreCommand command = new TestSemaphoreCommand(new TestCircuitBreaker(), semaphore, 200);
         try {
-            command.execute();
+            command.observe().toBlocking().single();
             fail("we expect a failure");
         } catch (Exception e) {
             // expected
@@ -4088,7 +4094,7 @@ public void testExecutionHookFailureWithSemaphoreIsolation() {
         // not null since the fallback is not implemented
         assertNotNull(command.builder.executionHook.fallbackFailureException);
 
-        // the execute() method was used
+        // the observe().toBlocking().single() method was used
         assertEquals(1, command.builder.executionHook.startExecute.get());
         // we should not have a response since fallback has nothing
         assertNull(command.builder.executionHook.endExecuteSuccessResponse);
@@ -4112,7 +4118,7 @@ public void testExecutionHookFailureWithSemaphoreIsolation() {
     public void testExecutionFailureWithFallbackImplementedButDisabled() {
         TestHystrixCommand<Boolean> commandEnabled = new KnownFailureTestCommandWithFallback(new TestCircuitBreaker(), true);
         try {
-            assertEquals(false, commandEnabled.execute());
+            assertEquals(false, commandEnabled.observe().toBlocking().single());
         } catch (Exception e) {
             e.printStackTrace();
             fail("We should have received a response from the fallback.");
@@ -4120,7 +4126,7 @@ public void testExecutionFailureWithFallbackImplementedButDisabled() {
 
         TestHystrixCommand<Boolean> commandDisabled = new KnownFailureTestCommandWithFallback(new TestCircuitBreaker(), false);
         try {
-            assertEquals(false, commandDisabled.execute());
+            assertEquals(false, commandDisabled.observe().toBlocking().single());
             fail("expect exception thrown");
         } catch (Exception e) {
             // expected
@@ -4162,7 +4168,7 @@ public void testSynchronousExecutionTimeoutValueViaExecute() {
 
         HystrixObservableCommand<String> command = new HystrixObservableCommand<String>(properties) {
             @Override
-            protected Observable<String> run() {
+            protected Observable<String> construct() {
                 return Observable.create(new OnSubscribe<String>() {
 
                     @Override
@@ -4180,7 +4186,7 @@ public void call(Subscriber<? super String> t1) {
             }
 
             @Override
-            protected Observable<String> getFallback() {
+            protected Observable<String> onFailureResumeWithFallback() {
                 if (isResponseTimedOut()) {
                     return Observable.just("timed-out");
                 } else {
@@ -4190,7 +4196,7 @@ protected Observable<String> getFallback() {
         };
 
         System.out.println(">>>>> Start: " + System.currentTimeMillis());
-        String value = command.execute();
+        String value = command.observe().toBlocking().single();
         System.out.println(">>>>> End: " + System.currentTimeMillis());
         assertTrue(command.isResponseTimedOut());
         assertEquals("expected fallback value", "timed-out", value);
@@ -4209,7 +4215,7 @@ public void testSynchronousExecutionUsingThreadIsolationTimeoutValueViaObserve()
 
         HystrixObservableCommand<String> command = new HystrixObservableCommand<String>(properties) {
             @Override
-            protected Observable<String> run() {
+            protected Observable<String> construct() {
                 return Observable.create(new OnSubscribe<String>() {
 
                     @Override
@@ -4227,7 +4233,7 @@ public void call(Subscriber<? super String> t1) {
             }
 
             @Override
-            protected Observable<String> getFallback() {
+            protected Observable<String> onFailureResumeWithFallback() {
                 if (isResponseTimedOut()) {
                     return Observable.just("timed-out");
                 } else {
@@ -4253,7 +4259,7 @@ public void testAsyncExecutionTimeoutValueViaObserve() {
 
         HystrixObservableCommand<String> command = new HystrixObservableCommand<String>(properties) {
             @Override
-            protected Observable<String> run() {
+            protected Observable<String> construct() {
                 return Observable.create(new OnSubscribe<String>() {
 
                     @Override
@@ -4272,7 +4278,7 @@ public void call(Subscriber<? super String> t1) {
             }
 
             @Override
-            protected Observable<String> getFallback() {
+            protected Observable<String> onFailureResumeWithFallback() {
                 if (isResponseTimedOut()) {
                     return Observable.just("timed-out");
                 } else {
@@ -4316,7 +4322,7 @@ public void call(Throwable t1) {
         ts.awaitTerminalEvent();
 
         assertTrue(isRequestContextInitialized.get());
-        assertTrue(onErrorThread.get().getName().startsWith("RxComputationThreadPool"));
+        assertTrue(onErrorThread.get().getName().startsWith("HystrixTimer"));
 
         List<Throwable> errors = ts.getOnErrorEvents();
         assertEquals(1, errors.size());
@@ -4384,7 +4390,7 @@ public void call(Boolean t1) {
         System.out.println("events: " + ts.getOnNextEvents());
 
         assertTrue(isRequestContextInitialized.get());
-        assertTrue(onErrorThread.get().getName().startsWith("RxComputationThreadPool"));
+        assertTrue(onErrorThread.get().getName().startsWith("HystrixTimer"));
 
         List<Boolean> onNexts = ts.getOnNextEvents();
         assertEquals(1, onNexts.size());
@@ -4595,7 +4601,7 @@ private RequestContextTestResults testRequestContextOnSuccess(ExecutionIsolation
                 .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(isolation))) {
 
             @Override
-            protected Observable<Boolean> run() {
+            protected Observable<Boolean> construct() {
                 return Observable.create(new OnSubscribe<Boolean>() {
 
                     @Override
@@ -4658,7 +4664,7 @@ private RequestContextTestResults testRequestContextOnGracefulFailure(ExecutionI
                 .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(isolation))) {
 
             @Override
-            protected Observable<Boolean> run() {
+            protected Observable<Boolean> construct() {
                 return Observable.create(new OnSubscribe<Boolean>() {
 
                     @Override
@@ -4720,7 +4726,7 @@ private RequestContextTestResults testRequestContextOnBadFailure(ExecutionIsolat
                 .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(isolation))) {
 
             @Override
-            protected Observable<Boolean> run() {
+            protected Observable<Boolean> construct() {
                 return Observable.create(new OnSubscribe<Boolean>() {
 
                     @Override
@@ -4782,7 +4788,7 @@ private RequestContextTestResults testRequestContextOnFailureWithFallback(Execut
                 .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(isolation))) {
 
             @Override
-            protected Observable<Boolean> run() {
+            protected Observable<Boolean> construct() {
                 return Observable.create(new OnSubscribe<Boolean>() {
 
                     @Override
@@ -4794,7 +4800,7 @@ public void call(Subscriber<? super Boolean> s) {
             }
 
             @Override
-            protected Observable<Boolean> getFallback() {
+            protected Observable<Boolean> onFailureResumeWithFallback() {
                 return Observable.create(new OnSubscribe<Boolean>() {
 
                     @Override
@@ -4890,7 +4896,7 @@ public Scheduler getScheduler() {
                 })) {
 
             @Override
-            protected Observable<Boolean> run() {
+            protected Observable<Boolean> construct() {
                 return Observable.create(new OnSubscribe<Boolean>() {
 
                     @Override
@@ -4902,7 +4908,7 @@ public void call(Subscriber<? super Boolean> s) {
             }
 
             @Override
-            protected Observable<Boolean> getFallback() {
+            protected Observable<Boolean> onFailureResumeWithFallback() {
                 return Observable.create(new OnSubscribe<Boolean>() {
 
                     @Override
@@ -4975,7 +4981,7 @@ private RequestContextTestResults testRequestContextOnShortCircuitedWithFallback
                 .setCircuitBreaker(new TestCircuitBreaker().setForceShortCircuit(true))) {
 
             @Override
-            protected Observable<Boolean> run() {
+            protected Observable<Boolean> construct() {
                 return Observable.create(new OnSubscribe<Boolean>() {
 
                     @Override
@@ -4987,7 +4993,7 @@ public void call(Subscriber<? super Boolean> s) {
             }
 
             @Override
-            protected Observable<Boolean> getFallback() {
+            protected Observable<Boolean> onFailureResumeWithFallback() {
                 return Observable.create(new OnSubscribe<Boolean>() {
 
                     @Override
@@ -5052,7 +5058,7 @@ private RequestContextTestResults testRequestContextOnTimeout(ExecutionIsolation
                 .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(isolation).withExecutionIsolationThreadTimeoutInMilliseconds(50))) {
 
             @Override
-            protected Observable<Boolean> run() {
+            protected Observable<Boolean> construct() {
                 return Observable.create(new OnSubscribe<Boolean>() {
 
                     @Override
@@ -5118,7 +5124,7 @@ private RequestContextTestResults testRequestContextOnTimeoutWithFallback(Execut
                 .setCommandPropertiesDefaults(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(isolation).withExecutionIsolationThreadTimeoutInMilliseconds(50))) {
 
             @Override
-            protected Observable<Boolean> run() {
+            protected Observable<Boolean> construct() {
                 return Observable.create(new OnSubscribe<Boolean>() {
 
                     @Override
@@ -5134,7 +5140,7 @@ public void call(Subscriber<? super Boolean> s) {
             }
 
             @Override
-            protected Observable<Boolean> getFallback() {
+            protected Observable<Boolean> onFailureResumeWithFallback() {
                 return Observable.create(new OnSubscribe<Boolean>() {
 
                     @Override
@@ -5912,7 +5918,7 @@ public void testTimeoutRequestContextWithSemaphoreIsolatedSynchronousObservable(
         assertTrue(results.originThread.get().equals(Thread.currentThread())); // all synchronous
 
         assertTrue(results.isContextInitializedObserveOn.get());
-        assertTrue(results.observeOnThread.get().getName().startsWith("RxComputation")); // timeout schedules on RxComputation since the original thread was timed out
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // timeout schedules on HystrixTimer since the original thread was timed out
 
         // semaphore isolated
         assertFalse(results.command.isExecutedInThread());
@@ -5933,7 +5939,7 @@ public void testTimeoutRequestContextWithSemaphoreIsolatedAsynchronousObservable
         assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
 
         assertTrue(results.isContextInitializedObserveOn.get()); // the timeout captures the context so it exists
-        assertTrue(results.observeOnThread.get().getName().startsWith("RxComputation")); // timeout schedules on RxComputation since the original thread was timed out
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // timeout schedules on HystrixTimer since the original thread was timed out
 
         // semaphore isolated
         assertFalse(results.command.isExecutedInThread());
@@ -5952,7 +5958,7 @@ public void testTimeoutRequestContextWithSemaphoreIsolatedAsynchronousObservable
         assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
 
         assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
-        assertTrue(results.observeOnThread.get().getName().startsWith("RxComputation")); // timeout schedules on RxComputation since the original thread was timed out
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // timeout schedules on HystrixTimer since the original thread was timed out
 
         // semaphore isolated
         assertFalse(results.command.isExecutedInThread());
@@ -5969,7 +5975,7 @@ public void testTimeoutRequestContextWithThreadIsolatedSynchronousObservable() {
         assertTrue(results.originThread.get().getName().startsWith("hystrix-OWNER_ONE")); // thread isolated on a HystrixThreadPool
 
         assertTrue(results.isContextInitializedObserveOn.get());
-        assertTrue(results.observeOnThread.get().getName().startsWith("RxComputation")); // timeout schedules on RxComputation since the original thread was timed out
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // timeout schedules on HystrixTimer since the original thread was timed out
 
         // thread isolated
         assertTrue(results.command.isExecutedInThread());
@@ -5990,7 +5996,7 @@ public void testTimeoutRequestContextWithThreadIsolatedAsynchronousObservable()
         assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
 
         assertTrue(results.isContextInitializedObserveOn.get()); // the timeout captures the context so it exists
-        assertTrue(results.observeOnThread.get().getName().startsWith("RxComputation")); // timeout schedules on RxComputation since the original thread was timed out
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // timeout schedules on HystrixTimer since the original thread was timed out
 
         // thread isolated
         assertTrue(results.command.isExecutedInThread());
@@ -6009,7 +6015,7 @@ public void testTimeoutRequestContextWithThreadIsolatedAsynchronousObservableAnd
         assertTrue(results.originThread.get().getName().startsWith("RxNewThread")); // the user provided thread/scheduler
 
         assertTrue(results.isContextInitializedObserveOn.get()); // the user scheduler captures context
-        assertTrue(results.observeOnThread.get().getName().startsWith("RxComputation")); // timeout schedules on RxComputation since the original thread was timed out
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // timeout schedules on HystrixTimer since the original thread was timed out
 
         // thread isolated
         assertTrue(results.command.isExecutedInThread());
@@ -6018,18 +6024,18 @@ public void testTimeoutRequestContextWithThreadIsolatedAsynchronousObservableAnd
     /* *************************************** testTimeoutWithFallbackRequestContext *********************************** */
 
     /**
-     * Synchronous Observable and semaphore isolation. Only [Main] thread is involved in this.
+     * Synchronous Observable and semaphore isolation. 
      */
     @Test
     public void testTimeoutWithFallbackRequestContextWithSemaphoreIsolatedSynchronousObservable() {
         RequestContextTestResults results = testRequestContextOnTimeoutWithFallback(ExecutionIsolationStrategy.SEMAPHORE, Schedulers.immediate());
 
         assertTrue(results.isContextInitialized.get());
-        assertTrue(results.originThread.get().getName().startsWith("RxComputation")); // timeout uses RxComputation thread 
+        assertTrue(results.originThread.get().getName().startsWith("HystrixTimer")); // timeout uses HystrixTimer thread 
         //(this use case is a little odd as it should generally not be the case that we are "timing out" a synchronous observable on semaphore isolation)
 
         assertTrue(results.isContextInitializedObserveOn.get());
-        assertTrue(results.observeOnThread.get().getName().startsWith("RxComputation")); // timeout uses RxComputation thread
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // timeout uses HystrixTimer thread
 
         // semaphore isolated
         assertFalse(results.command.isExecutedInThread());
@@ -6076,17 +6082,17 @@ public void testTimeoutWithFallbackRequestContextWithSemaphoreIsolatedAsynchrono
     }
 
     /**
-     * Synchronous Observable and thread isolation. Work done on [hystrix-OWNER_ONE] thread and then observed on [RxComputation]
+     * Synchronous Observable and thread isolation. Work done on [hystrix-OWNER_ONE] thread and then observed on [HystrixTimer]
      */
     @Test
     public void testTimeoutWithFallbackRequestContextWithThreadIsolatedSynchronousObservable() {
         RequestContextTestResults results = testRequestContextOnTimeoutWithFallback(ExecutionIsolationStrategy.THREAD, Schedulers.immediate());
 
         assertTrue(results.isContextInitialized.get());
-        assertTrue(results.originThread.get().getName().startsWith("RxComputation")); // timeout uses RxComputation thread for fallback
+        assertTrue(results.originThread.get().getName().startsWith("HystrixTimer")); // timeout uses HystrixTimer thread for fallback
 
         assertTrue(results.isContextInitializedObserveOn.get());
-        assertTrue(results.observeOnThread.get().getName().startsWith("RxComputation")); // fallback uses the timeout thread
+        assertTrue(results.observeOnThread.get().getName().startsWith("HystrixTimer")); // fallback uses the timeout thread
 
         // thread isolated
         assertTrue(results.command.isExecutedInThread());
@@ -6132,6 +6138,198 @@ public void testTimeoutWithFallbackRequestContextWithThreadIsolatedAsynchronousO
         assertTrue(results.command.isExecutedInThread());
     }
 
+    /**
+     * Test support of multiple onNext events.
+     */
+    @Test
+    public void testExecutionSuccessWithMultipleEvents() {
+        try {
+            TestCommandWithMultipleValues command = new TestCommandWithMultipleValues();
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+            assertEquals(Arrays.asList(1, 2, 3), command.observe().toList().toBlocking().single());
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+
+            assertEquals(null, command.getFailedExecutionException());
+
+            assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+            assertTrue(command.isSuccessfulExecution());
+
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+            assertEquals(0, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+            assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+            // semaphore isolated
+            assertFalse(command.isExecutedInThread());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We received an exception.");
+        }
+    }
+
+    /**
+     * Test behavior when some onNext are received and then a failure.
+     */
+    @Test
+    public void testExecutionPartialSuccess() {
+        try {
+            TestPartialSuccess command = new TestPartialSuccess();
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+            TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+            command.toObservable().subscribe(ts);
+            ts.awaitTerminalEvent();
+            ts.assertReceivedOnNext(Arrays.asList(1, 2, 3));
+            assertEquals(1, ts.getOnErrorEvents().size());
+            // it ends as a failure so we see the metrics count as FAILURE
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+            
+            // but it will say it is both SUCCESSful and FAILED
+            assertTrue(command.isSuccessfulExecution());
+            assertTrue(command.isFailedExecution());
+
+            // we will have an exception
+            assertNotNull(command.getFailedExecutionException());
+
+            assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+            assertTrue(command.isSuccessfulExecution());
+
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+            assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+            assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+            // semaphore isolated
+            assertFalse(command.isExecutedInThread());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We received an exception.");
+        }
+    }
+    
+    /**
+     * Test behavior when some onNext are received and then a failure.
+     */
+    @Test
+    public void testExecutionPartialSuccessWithFallback() {
+        try {
+            TestPartialSuccessWithFallback command = new TestPartialSuccessWithFallback();
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+            TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+            command.toObservable().subscribe(ts);
+            ts.awaitTerminalEvent();
+            ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 1, 2, 3, 4));
+            ts.assertNoErrors();
+            
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+
+            // but it will say it is both SUCCESSful and FAILED
+            assertTrue(command.isSuccessfulExecution());
+            assertTrue(command.isFailedExecution());
+            
+            assertNotNull(command.getFailedExecutionException());
+
+            assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+            assertTrue(command.isSuccessfulExecution());
+
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+            assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+            assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+            // semaphore isolated
+            assertFalse(command.isExecutedInThread());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We received an exception.");
+        }
+    }
+    
+    /**
+     * Test behavior when some onNext are received and then a failure.
+     */
+    @Test
+    public void testExecutionPartialSuccessWithMoreIntelligentFallback() {
+        try {
+            TestPartialSuccessWithIntelligentFallback command = new TestPartialSuccessWithIntelligentFallback();
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+            TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+            command.toObservable().subscribe(ts);
+            ts.awaitTerminalEvent();
+            ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4));
+            ts.assertNoErrors();
+            
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
+
+            // but it will say it is both SUCCESSful and FAILED
+            assertTrue(command.isSuccessfulExecution());
+            assertTrue(command.isFailedExecution());
+            
+            assertNotNull(command.getFailedExecutionException());
+
+            assertTrue(command.getExecutionTimeInMilliseconds() > -1);
+            assertTrue(command.isSuccessfulExecution());
+
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
+            assertEquals(1, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
+            assertEquals(0, command.builder.metrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
+
+            assertEquals(100, command.builder.metrics.getHealthCounts().getErrorPercentage());
+
+            assertEquals(1, HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size());
+
+            // semaphore isolated
+            assertFalse(command.isExecutedInThread());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("We received an exception.");
+        }
+    }
+
     /* ******************************************************************************** */
     /* ******************************************************************************** */
     /* private HystrixCommand class implementations for unit testing */
@@ -6141,7 +6339,7 @@ public void testTimeoutWithFallbackRequestContextWithThreadIsolatedAsynchronousO
     /**
      * Used by UnitTest command implementations to provide base defaults for constructor and a builder pattern for the arguments being passed in.
      */
-    /* package */ static abstract class TestHystrixCommand<K> extends HystrixObservableCommand<K> {
+    /* package */static abstract class TestHystrixCommand<K> extends HystrixObservableCommand<K> {
 
         final TestCommandBuilder builder;
 
@@ -6238,12 +6436,105 @@ public SuccessfulTestCommand(HystrixCommandProperties.Setter properties) {
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             return Observable.just(true).subscribeOn(Schedulers.computation());
         }
 
     }
 
+    /**
+     * Successful execution - no fallback implementation.
+     */
+    private static class TestCommandWithMultipleValues extends TestHystrixCommand<Integer> {
+
+        public TestCommandWithMultipleValues() {
+            this(HystrixCommandPropertiesTest.getUnitTestPropertiesSetter().withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE));
+        }
+
+        public TestCommandWithMultipleValues(HystrixCommandProperties.Setter properties) {
+            super(testPropsBuilder().setCommandPropertiesDefaults(properties));
+        }
+
+        @Override
+        protected Observable<Integer> construct() {
+            return Observable.just(1, 2, 3).subscribeOn(Schedulers.computation());
+        }
+
+    }
+
+    private static class TestPartialSuccess extends TestHystrixCommand<Integer> {
+
+        TestPartialSuccess() {
+            super(TestHystrixCommand.testPropsBuilder());
+        }
+
+        @Override
+        protected Observable<Integer> construct() {
+            return Observable.just(1, 2, 3)
+                    .concatWith(Observable.<Integer> error(new RuntimeException("forced error")))
+                    .subscribeOn(Schedulers.computation());
+        }
+
+    }
+    
+    private static class TestPartialSuccessWithFallback extends TestHystrixCommand<Integer> {
+
+        TestPartialSuccessWithFallback() {
+            super(TestHystrixCommand.testPropsBuilder());
+        }
+
+        @Override
+        protected Observable<Integer> construct() {
+            return Observable.just(1, 2, 3)
+                    .concatWith(Observable.<Integer> error(new RuntimeException("forced error")))
+                    .subscribeOn(Schedulers.computation());
+        }
+        
+        @Override
+        protected Observable<Integer> onFailureResumeWithFallback() {
+            return Observable.just(1, 2, 3, 4);
+        }
+
+    }
+    
+    /**
+     * Test how a fallback could be done on a streaming response where it is partially successful
+     * by retaining state of what has been seen.
+     */
+    private static class TestPartialSuccessWithIntelligentFallback extends TestHystrixCommand<Integer> {
+
+        TestPartialSuccessWithIntelligentFallback() {
+            super(TestHystrixCommand.testPropsBuilder());
+        }
+
+        volatile int lastSeen = 0;
+        
+        @Override
+        protected Observable<Integer> construct() {
+            return Observable.just(1, 2, 3)
+                    .concatWith(Observable.<Integer> error(new RuntimeException("forced error")))
+                    .doOnNext(new Action1<Integer>() {
+
+                        @Override
+                        public void call(Integer t1) {
+                            lastSeen = t1;
+                        }
+                        
+                    })
+                    .subscribeOn(Schedulers.computation());
+        }
+        
+        @Override
+        protected Observable<Integer> onFailureResumeWithFallback() {
+            if (lastSeen < 4) {
+                return Observable.range(lastSeen + 1, 4 - lastSeen);
+            } else {
+                return Observable.empty();
+            }
+        }
+
+    }
+
     /**
      * Successful execution - no fallback implementation.
      */
@@ -6254,7 +6545,7 @@ public DynamicOwnerTestCommand(HystrixCommandGroupKey owner) {
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             System.out.println("successfully executed");
             return Observable.just(true).subscribeOn(Schedulers.computation());
         }
@@ -6272,7 +6563,7 @@ public DynamicOwnerAndKeyTestCommand(HystrixCommandGroupKey owner, HystrixComman
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             System.out.println("successfully executed");
             return Observable.just(true).subscribeOn(Schedulers.computation());
         }
@@ -6289,7 +6580,7 @@ private UnknownFailureTestCommandWithoutFallback() {
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             // TODO duplicate with error inside async Observable
             System.out.println("*** simulated failed execution ***");
             throw new RuntimeException("we failed with an unknown issue");
@@ -6307,7 +6598,7 @@ private KnownFailureTestCommandWithoutFallback(TestCircuitBreaker circuitBreaker
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             // TODO duplicate with error inside async Observable
             System.out.println("*** simulated failed execution ***");
             throw new RuntimeException("we failed with a simulated issue");
@@ -6330,14 +6621,14 @@ public KnownFailureTestCommandWithFallback(TestCircuitBreaker circuitBreaker, bo
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             // TODO duplicate with error inside async Observable
             System.out.println("*** simulated failed execution ***");
             throw new RuntimeException("we failed with a simulated issue");
         }
 
         @Override
-        protected Observable<Boolean> getFallback() {
+        protected Observable<Boolean> onFailureResumeWithFallback() {
             return Observable.just(false).subscribeOn(Schedulers.computation());
         }
     }
@@ -6352,13 +6643,13 @@ private KnownFailureTestCommandWithFallbackFailure() {
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             System.out.println("*** simulated failed execution ***");
             throw new RuntimeException("we failed with a simulated issue");
         }
 
         @Override
-        protected Observable<Boolean> getFallback() {
+        protected Observable<Boolean> onFailureResumeWithFallback() {
             // TODO duplicate with error inside async Observable
             throw new RuntimeException("failed while getting fallback");
         }
@@ -6381,7 +6672,7 @@ public SuccessfulCacheableCommand(TestCircuitBreaker circuitBreaker, boolean cac
         }
 
         @Override
-        protected Observable<String> run() {
+        protected Observable<String> construct() {
             executed = true;
             System.out.println("successfully executed");
             return Observable.just(value).subscribeOn(Schedulers.computation());
@@ -6417,7 +6708,7 @@ public SuccessfulCacheableCommandViaSemaphore(TestCircuitBreaker circuitBreaker,
         }
 
         @Override
-        protected Observable<String> run() {
+        protected Observable<String> construct() {
             executed = true;
             System.out.println("successfully executed");
             return Observable.just(value).subscribeOn(Schedulers.computation());
@@ -6454,7 +6745,7 @@ public SlowCacheableCommand(TestCircuitBreaker circuitBreaker, String value, int
         }
 
         @Override
-        protected Observable<String> run() {
+        protected Observable<String> construct() {
             executed = true;
             return Observable.just(value).delay(duration, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.computation())
                     .doOnNext(new Action1<String>() {
@@ -6483,7 +6774,7 @@ private TestCommandWithoutCircuitBreaker() {
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             System.out.println("successfully executed");
             return Observable.just(true).subscribeOn(Schedulers.computation());
         }
@@ -6514,7 +6805,7 @@ private TestCommandWithTimeout(long timeout, int fallbackBehavior, ExecutionIsol
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             return Observable.create(new OnSubscribe<Boolean>() {
 
                 @Override
@@ -6540,7 +6831,7 @@ public void call(Subscriber<? super Boolean> sub) {
         }
 
         @Override
-        protected Observable<Boolean> getFallback() {
+        protected Observable<Boolean> onFailureResumeWithFallback() {
             if (fallbackBehavior == FALLBACK_SUCCESS) {
                 return Observable.just(false);
             } else if (fallbackBehavior == FALLBACK_FAILURE) {
@@ -6548,7 +6839,7 @@ protected Observable<Boolean> getFallback() {
                 throw new RuntimeException("failed on fallback");
             } else {
                 // FALLBACK_NOT_IMPLEMENTED
-                return super.getFallback();
+                return super.onFailureResumeWithFallback();
             }
         }
     }
@@ -6562,7 +6853,7 @@ public NoRequestCacheTimeoutWithoutFallback(TestCircuitBreaker circuitBreaker) {
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             return Observable.create(new OnSubscribe<Boolean>() {
 
                 @Override
@@ -6610,7 +6901,7 @@ private TestSemaphoreCommand(TestCircuitBreaker circuitBreaker, TryableSemaphore
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             return Observable.create(new OnSubscribe<Boolean>() {
 
                 @Override
@@ -6649,7 +6940,7 @@ private TestThreadIsolationWithSemaphoreSetSmallCommand(TestCircuitBreaker circu
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             return Observable.create(new OnSubscribe<Boolean>() {
 
                 @Override
@@ -6692,7 +6983,7 @@ private LatchedSemaphoreCommand(TestCircuitBreaker circuitBreaker, TryableSemaph
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             return Observable.create(new OnSubscribe<Boolean>() {
 
                 @Override
@@ -6734,7 +7025,7 @@ private TestSemaphoreCommandWithFallback(TestCircuitBreaker circuitBreaker, int
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             return Observable.create(new OnSubscribe<Boolean>() {
 
                 @Override
@@ -6753,7 +7044,7 @@ public void call(Subscriber<? super Boolean> s) {
         }
 
         @Override
-        protected Observable<Boolean> getFallback() {
+        protected Observable<Boolean> onFailureResumeWithFallback() {
             return fallback;
         }
 
@@ -6767,7 +7058,7 @@ public RequestCacheNullPointerExceptionCase(TestCircuitBreaker circuitBreaker) {
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             return Observable.create(new OnSubscribe<Boolean>() {
 
                 @Override
@@ -6786,7 +7077,7 @@ public void call(Subscriber<? super Boolean> s) {
         }
 
         @Override
-        protected Observable<Boolean> getFallback() {
+        protected Observable<Boolean> onFailureResumeWithFallback() {
             return Observable.just(false).subscribeOn(Schedulers.computation());
         }
 
@@ -6804,7 +7095,7 @@ public RequestCacheTimeoutWithoutFallback(TestCircuitBreaker circuitBreaker) {
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             return Observable.create(new OnSubscribe<Boolean>() {
 
                 @Override
@@ -6871,7 +7162,7 @@ public Scheduler getScheduler() {
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             try {
                 if (completionLatch.await(1000, TimeUnit.MILLISECONDS)) {
                     throw new RuntimeException("timed out waiting on completionLatch");
@@ -6897,12 +7188,12 @@ public BadRequestCommand(TestCircuitBreaker circuitBreaker, ExecutionIsolationSt
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             throw new HystrixBadRequestException("Message to developer that they passed in bad data or something like that.");
         }
 
         @Override
-        protected Observable<Boolean> getFallback() {
+        protected Observable<Boolean> onFailureResumeWithFallback() {
             return Observable.just(false).subscribeOn(Schedulers.computation());
         }
 
@@ -6921,7 +7212,7 @@ public CommandWithErrorThrown(TestCircuitBreaker circuitBreaker) {
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             // TODO duplicate with error inside async Observable
             throw new Error("simulated java.lang.Error message");
         }
@@ -6936,7 +7227,7 @@ public CommandWithCheckedException(TestCircuitBreaker circuitBreaker) {
         }
 
         @Override
-        protected Observable<Boolean> run() {
+        protected Observable<Boolean> construct() {
             return Observable.error(new IOException("simulated checked exception message"));
         }
 
@@ -7001,7 +7292,7 @@ private static class TestExecutionHook extends HystrixCommandExecutionHook {
         AtomicInteger startExecute = new AtomicInteger();
 
         @Override
-        public <T> void onStart(HystrixExecutable<T> commandInstance) {
+        public <T> void onStart(HystrixInvokable<T> commandInstance) {
             super.onStart(commandInstance);
             startExecute.incrementAndGet();
         }
@@ -7009,7 +7300,7 @@ public <T> void onStart(HystrixExecutable<T> commandInstance) {
         Object endExecuteSuccessResponse = null;
 
         @Override
-        public <T> T onComplete(HystrixExecutable<T> commandInstance, T response) {
+        public <T> T onComplete(HystrixInvokable<T> commandInstance, T response) {
             endExecuteSuccessResponse = response;
             return super.onComplete(commandInstance, response);
         }
@@ -7018,7 +7309,7 @@ public <T> T onComplete(HystrixExecutable<T> commandInstance, T response) {
         FailureType endExecuteFailureType = null;
 
         @Override
-        public <T> Exception onError(HystrixExecutable<T> commandInstance, FailureType failureType, Exception e) {
+        public <T> Exception onError(HystrixInvokable<T> commandInstance, FailureType failureType, Exception e) {
             endExecuteFailureException = e;
             endExecuteFailureType = failureType;
             return super.onError(commandInstance, failureType, e);
@@ -7027,7 +7318,7 @@ public <T> Exception onError(HystrixExecutable<T> commandInstance, FailureType f
         AtomicInteger startRun = new AtomicInteger();
 
         @Override
-        public <T> void onRunStart(HystrixExecutable<T> commandInstance) {
+        public <T> void onRunStart(HystrixInvokable<T> commandInstance) {
             super.onRunStart(commandInstance);
             startRun.incrementAndGet();
         }
@@ -7035,7 +7326,7 @@ public <T> void onRunStart(HystrixExecutable<T> commandInstance) {
         Object runSuccessResponse = null;
 
         @Override
-        public <T> T onRunSuccess(HystrixExecutable<T> commandInstance, T response) {
+        public <T> T onRunSuccess(HystrixInvokable<T> commandInstance, T response) {
             runSuccessResponse = response;
             return super.onRunSuccess(commandInstance, response);
         }
@@ -7043,7 +7334,7 @@ public <T> T onRunSuccess(HystrixExecutable<T> commandInstance, T response) {
         Exception runFailureException = null;
 
         @Override
-        public <T> Exception onRunError(HystrixExecutable<T> commandInstance, Exception e) {
+        public <T> Exception onRunError(HystrixInvokable<T> commandInstance, Exception e) {
             runFailureException = e;
             return super.onRunError(commandInstance, e);
         }
@@ -7051,7 +7342,7 @@ public <T> Exception onRunError(HystrixExecutable<T> commandInstance, Exception
         AtomicInteger startFallback = new AtomicInteger();
 
         @Override
-        public <T> void onFallbackStart(HystrixExecutable<T> commandInstance) {
+        public <T> void onFallbackStart(HystrixInvokable<T> commandInstance) {
             super.onFallbackStart(commandInstance);
             startFallback.incrementAndGet();
         }
@@ -7059,7 +7350,7 @@ public <T> void onFallbackStart(HystrixExecutable<T> commandInstance) {
         Object fallbackSuccessResponse = null;
 
         @Override
-        public <T> T onFallbackSuccess(HystrixExecutable<T> commandInstance, T response) {
+        public <T> T onFallbackSuccess(HystrixInvokable<T> commandInstance, T response) {
             fallbackSuccessResponse = response;
             return super.onFallbackSuccess(commandInstance, response);
         }
@@ -7067,7 +7358,7 @@ public <T> T onFallbackSuccess(HystrixExecutable<T> commandInstance, T response)
         Exception fallbackFailureException = null;
 
         @Override
-        public <T> Exception onFallbackError(HystrixExecutable<T> commandInstance, Exception e) {
+        public <T> Exception onFallbackError(HystrixInvokable<T> commandInstance, Exception e) {
             fallbackFailureException = e;
             return super.onFallbackError(commandInstance, e);
         }
@@ -7075,7 +7366,7 @@ public <T> Exception onFallbackError(HystrixExecutable<T> commandInstance, Excep
         AtomicInteger threadStart = new AtomicInteger();
 
         @Override
-        public <T> void onThreadStart(HystrixExecutable<T> commandInstance) {
+        public <T> void onThreadStart(HystrixInvokable<T> commandInstance) {
             super.onThreadStart(commandInstance);
             threadStart.incrementAndGet();
         }
@@ -7083,7 +7374,7 @@ public <T> void onThreadStart(HystrixExecutable<T> commandInstance) {
         AtomicInteger threadComplete = new AtomicInteger();
 
         @Override
-        public <T> void onThreadComplete(HystrixExecutable<T> commandInstance) {
+        public <T> void onThreadComplete(HystrixInvokable<T> commandInstance) {
             super.onThreadComplete(commandInstance);
             threadComplete.incrementAndGet();
         }
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixRequestCacheTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixRequestCacheTest.java
index 4e5b17585..50bde1348 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixRequestCacheTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixRequestCacheTest.java
@@ -1,6 +1,8 @@
 package com.netflix.hystrix;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
 
 import org.junit.Test;
 
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixRequestLogTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixRequestLogTest.java
index e744a7418..e856bec47 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixRequestLogTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixRequestLogTest.java
@@ -1,6 +1,6 @@
 package com.netflix.hystrix;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import org.junit.Test;
 
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixTest.java
index 9af48d5ea..030bfa16f 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixTest.java
@@ -1,6 +1,8 @@
 package com.netflix.hystrix;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 
 import org.junit.Test;
 
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixThreadPoolTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixThreadPoolTest.java
index df8d66076..605895d51 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/HystrixThreadPoolTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/HystrixThreadPoolTest.java
@@ -1,6 +1,8 @@
 package com.netflix.hystrix;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 import java.util.concurrent.TimeUnit;
 
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/collapser/CollapsedRequestObservableFunctionTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/collapser/CollapsedRequestObservableFunctionTest.java
index 6710dab3b..a1fffbe98 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/collapser/CollapsedRequestObservableFunctionTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/collapser/CollapsedRequestObservableFunctionTest.java
@@ -1,6 +1,7 @@
 package com.netflix.hystrix.collapser;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
 
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.ExecutionException;
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/strategy/HystrixPluginsTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/strategy/HystrixPluginsTest.java
index 0acaed4aa..8e7aba177 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/strategy/HystrixPluginsTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/strategy/HystrixPluginsTest.java
@@ -1,12 +1,11 @@
 package com.netflix.hystrix.strategy;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import java.util.concurrent.Callable;
 import java.util.concurrent.atomic.AtomicReference;
 
-import com.netflix.hystrix.strategy.executionhook.HystrixCommandExecutionHook;
-import com.netflix.hystrix.strategy.executionhook.HystrixCommandExecutionHookDefault;
 import org.junit.After;
 import org.junit.Test;
 
@@ -20,6 +19,8 @@
 import com.netflix.hystrix.strategy.concurrency.HystrixRequestContext;
 import com.netflix.hystrix.strategy.eventnotifier.HystrixEventNotifier;
 import com.netflix.hystrix.strategy.eventnotifier.HystrixEventNotifierDefault;
+import com.netflix.hystrix.strategy.executionhook.HystrixCommandExecutionHook;
+import com.netflix.hystrix.strategy.executionhook.HystrixCommandExecutionHookDefault;
 import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher;
 import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisherDefault;
 import com.netflix.hystrix.strategy.properties.HystrixPropertiesStrategy;
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/strategy/concurrency/HystrixConcurrencyStrategyTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/strategy/concurrency/HystrixConcurrencyStrategyTest.java
index e0b295a83..5b7ccbc9e 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/strategy/concurrency/HystrixConcurrencyStrategyTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/strategy/concurrency/HystrixConcurrencyStrategyTest.java
@@ -1,6 +1,6 @@
 package com.netflix.hystrix.strategy.concurrency;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import java.util.concurrent.atomic.AtomicBoolean;
 
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/strategy/metrics/HystrixMetricsPublisherFactoryTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/strategy/metrics/HystrixMetricsPublisherFactoryTest.java
index 352d7479a..4fad24064 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/strategy/metrics/HystrixMetricsPublisherFactoryTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/strategy/metrics/HystrixMetricsPublisherFactoryTest.java
@@ -1,6 +1,6 @@
 package com.netflix.hystrix.strategy.metrics;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import java.util.ArrayList;
 import java.util.concurrent.atomic.AtomicInteger;
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/strategy/properties/HystrixPropertiesChainedArchaiusPropertyTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/strategy/properties/HystrixPropertiesChainedArchaiusPropertyTest.java
index b9ec9c87c..b932575be 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/strategy/properties/HystrixPropertiesChainedArchaiusPropertyTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/strategy/properties/HystrixPropertiesChainedArchaiusPropertyTest.java
@@ -1,6 +1,7 @@
 package com.netflix.hystrix.strategy.properties;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/strategy/properties/HystrixPropertyTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/strategy/properties/HystrixPropertyTest.java
index eb9e987cb..ebb2da304 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/strategy/properties/HystrixPropertyTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/strategy/properties/HystrixPropertyTest.java
@@ -1,6 +1,6 @@
 package com.netflix.hystrix.strategy.properties;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import org.junit.Test;
 
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/util/ExceptionThreadingUtilityTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/util/ExceptionThreadingUtilityTest.java
index 6aa68e84d..a59bfc7a9 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/util/ExceptionThreadingUtilityTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/util/ExceptionThreadingUtilityTest.java
@@ -1,6 +1,6 @@
 package com.netflix.hystrix.util;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import org.junit.Test;
 
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/util/HystrixRollingNumberTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/util/HystrixRollingNumberTest.java
index 86d61d56f..3338468f8 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/util/HystrixRollingNumberTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/util/HystrixRollingNumberTest.java
@@ -1,6 +1,7 @@
 package com.netflix.hystrix.util;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/util/HystrixRollingPercentileTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/util/HystrixRollingPercentileTest.java
index 492a4f68f..6a82e1d3a 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/util/HystrixRollingPercentileTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/util/HystrixRollingPercentileTest.java
@@ -1,6 +1,7 @@
 package com.netflix.hystrix.util;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
diff --git a/hystrix-core/src/test/java/com/netflix/hystrix/util/HystrixTimerTest.java b/hystrix-core/src/test/java/com/netflix/hystrix/util/HystrixTimerTest.java
index 680f0697c..a87478180 100644
--- a/hystrix-core/src/test/java/com/netflix/hystrix/util/HystrixTimerTest.java
+++ b/hystrix-core/src/test/java/com/netflix/hystrix/util/HystrixTimerTest.java
@@ -1,6 +1,9 @@
 package com.netflix.hystrix.util;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 
 import java.lang.ref.Reference;
 import java.util.concurrent.atomic.AtomicInteger;