HystrixObservableCommand (Hystrix Javadoc 1.4.3)

java.lang.Object
- com.netflix.hystrix.HystrixObservableCommand<R>

Type Parameters:
R - the return type

All Implemented Interfaces:

HystrixInvokable<R>, HystrixInvokableInfo<R>, HystrixObservable<R>
```
public abstract class HystrixObservableCommand<R>
extends java.lang.Object
implements HystrixObservable<R>, HystrixInvokableInfo<R>
```
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 should be used for a purely non-blocking call pattern. The caller of this command will be subscribed to the Observable returned by the run() method.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`com.netflix.hystrix.AbstractCommand.CachedObservableOriginal<R>` Wraps a source Observable and remembers the original HystrixCommand.
`protected static class`	`com.netflix.hystrix.AbstractCommand.CachedObservableResponse<R>` Wraps a CachedObservableOriginal as it is being returned from cache.
`protected static class`	`com.netflix.hystrix.AbstractCommand.ExecutionResult` Immutable holder class for the status of command execution.
`protected static class`	`com.netflix.hystrix.AbstractCommand.ObservableCommand<R>`
`protected static class`	`com.netflix.hystrix.AbstractCommand.TimedOutStatus`
`static class`	`HystrixObservableCommand.Setter` Fluent interface for arguments to the `HystrixObservableCommand` constructor.

Field Summary

Fields
Modifier and Type	Field and Description
`protected HystrixCircuitBreaker`	`circuitBreaker`
`protected HystrixCommandGroupKey`	`commandGroup`
`protected HystrixCommandKey`	`commandKey`
`protected HystrixConcurrencyStrategy`	`concurrencyStrategy`
`protected HystrixRequestLog`	`currentRequestLog`
`protected java.util.concurrent.atomic.AtomicReference<rx.functions.Action0>`	`endCurrentThreadExecutingCommand`
`protected HystrixEventNotifier`	`eventNotifier` Plugin implementations
`protected HystrixCommandExecutionHook`	`executionHook`
`protected com.netflix.hystrix.AbstractCommand.ExecutionResult`	`executionResult`
`protected com.netflix.hystrix.AbstractCommand.TryableSemaphore`	`executionSemaphoreOverride`
`protected static java.util.concurrent.ConcurrentHashMap<java.lang.String,com.netflix.hystrix.AbstractCommand.TryableSemaphore>`	`executionSemaphorePerCircuit`
`protected com.netflix.hystrix.AbstractCommand.TryableSemaphore`	`fallbackSemaphoreOverride`
`protected static java.util.concurrent.ConcurrentHashMap<java.lang.String,com.netflix.hystrix.AbstractCommand.TryableSemaphore>`	`fallbackSemaphorePerCircuit`
`protected long`	`invocationStartTime`
`protected java.util.concurrent.atomic.AtomicReference<com.netflix.hystrix.AbstractCommand.TimedOutStatus>`	`isCommandTimedOut`
`protected java.util.concurrent.atomic.AtomicBoolean`	`isExecutedInThread`
`protected java.util.concurrent.atomic.AtomicBoolean`	`isExecutionComplete`
`protected HystrixCommandMetrics`	`metrics`
`protected HystrixCommandProperties`	`properties`
`protected HystrixRequestCache`	`requestCache` Instance of RequestCache logic
`protected java.util.concurrent.atomic.AtomicBoolean`	`started`
`protected HystrixThreadPool`	`threadPool`
`protected HystrixThreadPoolKey`	`threadPoolKey`
`protected java.util.concurrent.atomic.AtomicReference<java.lang.ref.Reference<com.netflix.hystrix.util.HystrixTimer.TimerListener>>`	`timeoutTimer`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`HystrixObservableCommand(HystrixCommandGroupKey group)` Construct a `HystrixObservableCommand` with defined `HystrixCommandGroupKey`.
`protected`	`HystrixObservableCommand(HystrixObservableCommand.Setter setter)` Construct a `HystrixObservableCommand` with defined `HystrixObservableCommand.Setter` that allows injecting property and strategy overrides and other optional arguments.

Method Summary

Methods
Modifier and Type	Method and Description
`protected abstract rx.Observable<R>`	`construct()` Implement this method with code to be executed when `observe()` or `toObservable()` are invoked.
`protected java.lang.RuntimeException`	`decomposeException(java.lang.Exception e)` Take an Exception and determine whether to throw it, its cause or a new HystrixRuntimeException.
`protected java.lang.String`	`getCacheKey()` Key to be used for request caching.
`HystrixCommandGroupKey`	`getCommandGroup()`
`HystrixCommandKey`	`getCommandKey()`
`long`	`getCommandRunStartTimeInNanos()` Time in Nanos when this command instance's run method was called, or -1 if not executed for e.g., command threw an exception
`protected java.lang.Exception`	`getExceptionFromThrowable(java.lang.Throwable t)`
`java.util.List<HystrixEventType>`	`getExecutionEvents()` List of HystrixCommandEventType enums representing events that occurred during execution.
`protected rx.Observable<R>`	`getExecutionObservable()`
`protected com.netflix.hystrix.AbstractCommand.TryableSemaphore`	`getExecutionSemaphore()` Get the TryableSemaphore this HystrixCommand should use for execution if not running in a separate thread.
`int`	`getExecutionTimeInMilliseconds()` The execution time of this command instance in milliseconds, or -1 if not executed.
`java.lang.Throwable`	`getFailedExecutionException()` Get the Throwable/Exception thrown that caused the failure.
`protected rx.Observable<R>`	`getFallbackObservable()`
`protected com.netflix.hystrix.AbstractCommand.TryableSemaphore`	`getFallbackSemaphore()` Get the TryableSemaphore this HystrixCommand should use if a fallback occurs.
`protected java.lang.String`	`getLogMessagePrefix()`
`HystrixCommandMetrics`	`getMetrics()` The `HystrixCommandMetrics` associated with this `AbstractCommand` instance.
`int`	`getNumberEmissions()` Number of emissions of the execution of a command.
`int`	`getNumberFallbackEmissions()` Number of emissions of the execution of a fallback.
`HystrixCommandProperties`	`getProperties()` The `HystrixCommandProperties` associated with this `AbstractCommand` instance.
`HystrixThreadPoolKey`	`getThreadPoolKey()`
`protected void`	`handleThreadEnd()`
`boolean`	`isCircuitBreakerOpen()` Whether the 'circuit-breaker' is open meaning that `execute()` will immediately return the `getFallback()` response and not attempt a HystrixCommand execution.
`boolean`	`isExecutedInThread()` Whether the execution occurred in a separate thread.
`boolean`	`isExecutionComplete()` If this command has completed execution either successfully, via fallback or failure.
`boolean`	`isFailedExecution()` Whether the `run()` resulted in a failure (exception).
`protected boolean`	`isRequestCachingEnabled()`
`boolean`	`isResponseFromCache()` Whether the response is from cache and `run()` was not invoked.
`boolean`	`isResponseFromFallback()` Whether the response received from was the result of some type of failure and `getFallback()` being called.
`boolean`	`isResponseRejected()` Whether the response received was a fallback as result of being rejected (from thread-pool or semaphore) and `getFallback()` being called.
`boolean`	`isResponseShortCircuited()` Whether the response received was a fallback as result of being short-circuited (meaning `isCircuitBreakerOpen() == true`) and `getFallback()` being called.
`boolean`	`isResponseTimedOut()` Whether the response received was the result of a timeout and `getFallback()` being called.
`boolean`	`isSuccessfulExecution()` Whether the response was returned successfully either by executing `run()` or from cache.
`rx.Observable<R>`	`observe()` Used for asynchronous execution of command with a callback by subscribing to the `Observable`.
`protected void`	`recordExecutedCommand()` Record that this command was executed in the HystrixRequestLog.
`protected void`	`recordTotalExecutionTime(long startTime)` Record the duration of execution as response or exception is being returned to the caller.
`protected rx.Observable<R>`	`resumeWithFallback()` If `observe()` or `toObservable()` fails in any way then this method will be invoked to provide an opportunity to return a fallback response.
`protected boolean`	`shouldOutputOnNextEvents()` Overridden to true so that all onNext emissions are captured
`rx.Observable<R>`	`toObservable()` Used for asynchronous execution of command with a callback by subscribing to the `Observable`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.netflix.hystrix.HystrixObservable
observe, toObservable

- Field Detail
  - circuitBreaker
```
protected final HystrixCircuitBreaker circuitBreaker
```
  - threadPool
```
protected final HystrixThreadPool threadPool
```
  - threadPoolKey
```
protected final HystrixThreadPoolKey threadPoolKey
```
  - properties
```
protected final HystrixCommandProperties properties
```
  - metrics
```
protected final HystrixCommandMetrics metrics
```
  - commandKey
```
protected final HystrixCommandKey commandKey
```
  - commandGroup
```
protected final HystrixCommandGroupKey commandGroup
```
  - eventNotifier
```
protected final HystrixEventNotifier eventNotifier
```
    Plugin implementations
  - concurrencyStrategy
```
protected final HystrixConcurrencyStrategy concurrencyStrategy
```
  - executionHook
```
protected final HystrixCommandExecutionHook executionHook
```
  - fallbackSemaphoreOverride
```
protected final com.netflix.hystrix.AbstractCommand.TryableSemaphore fallbackSemaphoreOverride
```
  - fallbackSemaphorePerCircuit
```
protected static final java.util.concurrent.ConcurrentHashMap<java.lang.String,com.netflix.hystrix.AbstractCommand.TryableSemaphore> fallbackSemaphorePerCircuit
```
  - executionSemaphoreOverride
```
protected final com.netflix.hystrix.AbstractCommand.TryableSemaphore executionSemaphoreOverride
```
  - executionSemaphorePerCircuit
```
protected static final java.util.concurrent.ConcurrentHashMap<java.lang.String,com.netflix.hystrix.AbstractCommand.TryableSemaphore> executionSemaphorePerCircuit
```
  - timeoutTimer
```
protected final java.util.concurrent.atomic.AtomicReference<java.lang.ref.Reference<com.netflix.hystrix.util.HystrixTimer.TimerListener>> timeoutTimer
```
  - started
```
protected java.util.concurrent.atomic.AtomicBoolean started
```
  - invocationStartTime
```
protected volatile long invocationStartTime
```
  - executionResult
```
protected volatile com.netflix.hystrix.AbstractCommand.ExecutionResult executionResult
```
  - isCommandTimedOut
```
protected final java.util.concurrent.atomic.AtomicReference<com.netflix.hystrix.AbstractCommand.TimedOutStatus> isCommandTimedOut
```
  - isExecutionComplete
```
protected final java.util.concurrent.atomic.AtomicBoolean isExecutionComplete
```
  - isExecutedInThread
```
protected final java.util.concurrent.atomic.AtomicBoolean isExecutedInThread
```
  - endCurrentThreadExecutingCommand
```
protected final java.util.concurrent.atomic.AtomicReference<rx.functions.Action0> endCurrentThreadExecutingCommand
```
  - requestCache
```
protected final HystrixRequestCache requestCache
```
    Instance of RequestCache logic
  - currentRequestLog
```
protected final HystrixRequestLog currentRequestLog
```
- Constructor Detail
  - HystrixObservableCommand
```
protected HystrixObservableCommand(HystrixCommandGroupKey group)
```
    Construct a HystrixObservableCommand with defined HystrixCommandGroupKey.
    The HystrixCommandKey will be derived from the implementing class name.
    
    Parameters:
    group - HystrixCommandGroupKey used to group together multiple HystrixObservableCommand objects.
    The 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.
  - HystrixObservableCommand
```
protected HystrixObservableCommand(HystrixObservableCommand.Setter setter)
```
    Construct a HystrixObservableCommand with defined HystrixObservableCommand.Setter that allows injecting property and strategy overrides and other optional arguments.
    NOTE: The HystrixCommandKey is used to associate a HystrixObservableCommand with HystrixCircuitBreaker, HystrixCommandMetrics and other objects.
    Do not create multiple HystrixObservableCommand implementations with the same HystrixCommandKey but different injected default properties as the first instantiated will win.
    Properties passed in via HystrixObservableCommand.Setter.andCommandPropertiesDefaults(com.netflix.hystrix.HystrixCommandProperties.Setter) are cached for the given HystrixCommandKey for the life of the JVM or until Hystrix.reset() is called. Dynamic properties allow runtime changes. Read more on the Hystrix Wiki.
    
    Parameters:
    setter - Fluent interface for constructor arguments
- Method Detail
  - shouldOutputOnNextEvents
```
protected boolean shouldOutputOnNextEvents()
```
    Overridden to true so that all onNext emissions are captured
    
    Returns:
    if onNext events should be reported on This affects HystrixRequestLog, and HystrixEventNotifier currently. Metrics/Hooks later
  - construct
```
protected abstract rx.Observable<R> construct()
```
    Implement this method with code to be executed when observe() or toObservable() are invoked.
    
    Returns:
    R response type
  - resumeWithFallback
```
protected rx.Observable<R> resumeWithFallback()
```
    If observe() or toObservable() fails in any way then this method will be invoked to provide an opportunity to return a fallback response.
    This should do work that does not require network transport to produce.
    In other words, this should be a static or cached result that can immediately be returned upon failure.
    If network traffic is wanted for fallback (such as going to MemCache) then the fallback implementation should invoke another HystrixObservableCommand instance that protects against that network access and possibly has another level of fallback that does not involve network access.
    DEFAULT BEHAVIOR: It throws UnsupportedOperationException.
    
    Returns:
    R or UnsupportedOperationException if not implemented
  - getExecutionObservable
```
protected final rx.Observable<R> getExecutionObservable()
```
  - getFallbackObservable
```
protected final rx.Observable<R> getFallbackObservable()
```
  - observe
```
public rx.Observable<R> observe()
```
    Used for asynchronous execution of command with a callback by subscribing to the Observable.
    This eagerly starts execution of the command the same as HystrixCommand.queue() and HystrixCommand.execute().
    A lazy Observable can be obtained from toObservable().
    See https://github.com/Netflix/RxJava/wiki for more information.
    Specified by:
    
    observe in interface HystrixObservable<R>
    
    Returns:
    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
    
    via Observer#onError if a failure occurs
    
    or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)
    HystrixBadRequestException - via Observer#onError if invalid arguments or state were used representing a user failure, not a system failure
    
    java.lang.IllegalStateException - if invoked more than once
  - toObservable
```
public rx.Observable<R> toObservable()
```
    Used for asynchronous execution of command with a callback by subscribing to the Observable.
    This lazily starts execution of the command once the Observable is subscribed to.
    An eager Observable can be obtained from observe().
    See https://github.com/ReactiveX/RxJava/wiki for more information.
    Specified by:
    
    toObservable in interface HystrixObservable<R>
    
    Returns:
    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
    
    via Observer#onError if a failure occurs
    
    or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)
    HystrixBadRequestException - via Observer#onError if invalid arguments or state were used representing a user failure, not a system failure
    
    java.lang.IllegalStateException - if invoked more than once
  - handleThreadEnd
```
protected void handleThreadEnd()
```
  - getFallbackSemaphore
```
protected com.netflix.hystrix.AbstractCommand.TryableSemaphore getFallbackSemaphore()
```
    Get the TryableSemaphore this HystrixCommand should use if a fallback occurs.
    
    Returns:
    TryableSemaphore
  - getExecutionSemaphore
```
protected com.netflix.hystrix.AbstractCommand.TryableSemaphore getExecutionSemaphore()
```
    Get the TryableSemaphore this HystrixCommand should use for execution if not running in a separate thread.
    
    Returns:
    TryableSemaphore
  - getCommandGroup
```
public HystrixCommandGroupKey getCommandGroup()
```
    Specified by:
    
    getCommandGroup in interface HystrixInvokableInfo<R>
    
    Returns:
    HystrixCommandGroupKey used to group together multiple AbstractCommand objects.
    The 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.
  - getCommandKey
```
public HystrixCommandKey getCommandKey()
```
    Specified by:
    
    getCommandKey in interface HystrixInvokableInfo<R>
    
    Returns:
    HystrixCommandKey identifying this command instance for statistics, circuit-breaker, properties, etc.
  - getThreadPoolKey
```
public HystrixThreadPoolKey getThreadPoolKey()
```
    Specified by:
    
    getThreadPoolKey in interface HystrixInvokableInfo<R>
    
    Returns:
    HystrixThreadPoolKey identifying which thread-pool this command uses (when configured to run on separate threads via HystrixCommandProperties.executionIsolationStrategy()).
  - getMetrics
```
public HystrixCommandMetrics getMetrics()
```
    The HystrixCommandMetrics associated with this AbstractCommand instance.
    
    Specified by:
    
    getMetrics in interface HystrixInvokableInfo<R>
    
    Returns:
    HystrixCommandMetrics
  - getProperties
```
public HystrixCommandProperties getProperties()
```
    The HystrixCommandProperties associated with this AbstractCommand instance.
    
    Specified by:
    
    getProperties in interface HystrixInvokableInfo<R>
    
    Returns:
    HystrixCommandProperties
  - recordTotalExecutionTime
```
protected void recordTotalExecutionTime(long startTime)
```
    Record the duration of execution as response or exception is being returned to the caller.
  - recordExecutedCommand
```
protected void recordExecutedCommand()
```
    Record that this command was executed in the HystrixRequestLog.
    This can be treated as an async operation as it just adds a references to "this" in the log even if the current command is still executing.
  - decomposeException
```
protected java.lang.RuntimeException decomposeException(java.lang.Exception e)
```
    Take an Exception and determine whether to throw it, its cause or a new HystrixRuntimeException.
    This will only throw an HystrixRuntimeException, HystrixBadRequestException or IllegalStateException
    
    Parameters:
    e - initial exception
    
    Returns:
    HystrixRuntimeException, HystrixBadRequestException or IllegalStateException
  - getCacheKey
```
protected java.lang.String getCacheKey()
```
    Key to be used for request caching.
    By default this returns null which means "do not cache".
    To enable caching override this method and return a string key uniquely representing the state of a command instance.
    If multiple command instances in the same request scope match keys then only the first will be executed and all others returned from cache.
    
    Returns:
    cacheKey
  - isRequestCachingEnabled
```
protected boolean isRequestCachingEnabled()
```
  - getLogMessagePrefix
```
protected java.lang.String getLogMessagePrefix()
```
  - isCircuitBreakerOpen
```
public boolean isCircuitBreakerOpen()
```
    Whether the 'circuit-breaker' is open meaning that execute() will immediately return the getFallback() response and not attempt a HystrixCommand execution.
    
    Specified by:
    
    isCircuitBreakerOpen in interface HystrixInvokableInfo<R>
    
    Returns:
    boolean
  - isExecutionComplete
```
public boolean isExecutionComplete()
```
    If this command has completed execution either successfully, via fallback or failure.
    
    Specified by:
    
    isExecutionComplete in interface HystrixInvokableInfo<R>
    
    Returns:
    boolean
  - isExecutedInThread
```
public boolean isExecutedInThread()
```
    Whether the execution occurred in a separate thread.
    This should be called only once execute()/queue()/fireOrForget() are called otherwise it will always return false.
    This specifies if a thread execution actually occurred, not just if it is configured to be executed in a thread.
    
    Specified by:
    
    isExecutedInThread in interface HystrixInvokableInfo<R>
    
    Returns:
    boolean
  - isSuccessfulExecution
```
public boolean isSuccessfulExecution()
```
    Whether the response was returned successfully either by executing run() or from cache.
    
    Specified by:
    
    isSuccessfulExecution in interface HystrixInvokableInfo<R>
    
    Returns:
    boolean
  - isFailedExecution
```
public boolean isFailedExecution()
```
    Whether the run() resulted in a failure (exception).
    
    Specified by:
    
    isFailedExecution in interface HystrixInvokableInfo<R>
    
    Returns:
    boolean
  - getFailedExecutionException
```
public java.lang.Throwable getFailedExecutionException()
```
    Get the Throwable/Exception thrown that caused the failure.
    If isFailedExecution() == true then this would represent the Exception thrown by the run() method.
    If isFailedExecution() == false then this would return null.
    
    Specified by:
    
    getFailedExecutionException in interface HystrixInvokableInfo<R>
    
    Returns:
    Throwable or null
  - isResponseFromFallback
```
public boolean isResponseFromFallback()
```
    Whether the response received from was the result of some type of failure and getFallback() being called.
    
    Specified by:
    
    isResponseFromFallback in interface HystrixInvokableInfo<R>
    
    Returns:
    boolean
  - isResponseTimedOut
```
public boolean isResponseTimedOut()
```
    Whether the response received was the result of a timeout and getFallback() being called.
    
    Specified by:
    
    isResponseTimedOut in interface HystrixInvokableInfo<R>
    
    Returns:
    boolean
  - isResponseShortCircuited
```
public boolean isResponseShortCircuited()
```
    Whether the response received was a fallback as result of being short-circuited (meaning isCircuitBreakerOpen() == true) and getFallback() being called.
    
    Specified by:
    
    isResponseShortCircuited in interface HystrixInvokableInfo<R>
    
    Returns:
    boolean
  - isResponseFromCache
```
public boolean isResponseFromCache()
```
    Whether the response is from cache and run() was not invoked.
    
    Specified by:
    
    isResponseFromCache in interface HystrixInvokableInfo<R>
    
    Returns:
    boolean
  - isResponseRejected
```
public boolean isResponseRejected()
```
    Whether the response received was a fallback as result of being rejected (from thread-pool or semaphore) and getFallback() being called.
    
    Specified by:
    
    isResponseRejected in interface HystrixInvokableInfo<R>
    
    Returns:
    boolean
  - getExecutionEvents
```
public java.util.List<HystrixEventType> getExecutionEvents()
```
    List of HystrixCommandEventType enums representing events that occurred during execution.
    Examples of events are SUCCESS, FAILURE, TIMEOUT, and SHORT_CIRCUITED
    
    Specified by:
    
    getExecutionEvents in interface HystrixInvokableInfo<R>
    
    Returns:
    List<HystrixEventType>
  - getNumberEmissions
```
public int getNumberEmissions()
```
    Number of emissions of the execution of a command. Only interesting in the streaming case.
    
    Specified by:
    
    getNumberEmissions in interface HystrixInvokableInfo<R>
    
    Returns:
    number of OnNext emissions by a streaming command
  - getNumberFallbackEmissions
```
public int getNumberFallbackEmissions()
```
    Number of emissions of the execution of a fallback. Only interesting in the streaming case.
    
    Specified by:
    
    getNumberFallbackEmissions in interface HystrixInvokableInfo<R>
    
    Returns:
    number of OnNext emissions by a streaming fallback
  - getExecutionTimeInMilliseconds
```
public int getExecutionTimeInMilliseconds()
```
    The execution time of this command instance in milliseconds, or -1 if not executed.
    
    Specified by:
    
    getExecutionTimeInMilliseconds in interface HystrixInvokableInfo<R>
    
    Returns:
    int
  - getCommandRunStartTimeInNanos
```
public long getCommandRunStartTimeInNanos()
```
    Time in Nanos when this command instance's run method was called, or -1 if not executed for e.g., command threw an exception
    
    Specified by:
    
    getCommandRunStartTimeInNanos in interface HystrixInvokableInfo<R>
    
    Returns:
    long
  - getExceptionFromThrowable
```
protected java.lang.Exception getExceptionFromThrowable(java.lang.Throwable t)
```

Hystrix: Latency and Fault Tolerance for Distributed Systems

Class HystrixObservableCommand<R>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.netflix.hystrix.HystrixObservable

Methods inherited from interface com.netflix.hystrix.HystrixInvokableInfo

Field Detail

circuitBreaker

threadPool

threadPoolKey

properties

metrics

commandKey

commandGroup

eventNotifier

concurrencyStrategy

executionHook

fallbackSemaphoreOverride

fallbackSemaphorePerCircuit

executionSemaphoreOverride

executionSemaphorePerCircuit

timeoutTimer

started

invocationStartTime

executionResult

isCommandTimedOut

isExecutionComplete

isExecutedInThread

endCurrentThreadExecutingCommand

requestCache

currentRequestLog

Constructor Detail

HystrixObservableCommand

HystrixObservableCommand

Method Detail

shouldOutputOnNextEvents

construct

resumeWithFallback

getExecutionObservable

getFallbackObservable

observe

toObservable

handleThreadEnd

getFallbackSemaphore

getExecutionSemaphore

getCommandGroup

getCommandKey

getThreadPoolKey

getMetrics

getProperties

recordTotalExecutionTime

recordExecutedCommand

decomposeException

getCacheKey

isRequestCachingEnabled

getLogMessagePrefix

isCircuitBreakerOpen

isExecutionComplete

isExecutedInThread

isSuccessfulExecution

isFailedExecution

getFailedExecutionException

isResponseFromFallback

isResponseTimedOut

isResponseShortCircuited

isResponseFromCache

isResponseRejected

getExecutionEvents

getNumberEmissions

getNumberFallbackEmissions

getExecutionTimeInMilliseconds

getCommandRunStartTimeInNanos

getExceptionFromThrowable