HystrixObservableCommand (Hystrix Javadoc 1.5.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`	`AbstractCommand.CommandState`
`protected static class`	`AbstractCommand.ThreadState`
`protected static class`	`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 long`	`commandStartTimestamp`
`protected java.util.concurrent.atomic.AtomicReference<AbstractCommand.CommandState>`	`commandState`
`protected HystrixConcurrencyStrategy`	`concurrencyStrategy`
`protected HystrixRequestLog`	`currentRequestLog`
`protected rx.functions.Action0`	`endCurrentThreadExecutingCommand`
`protected HystrixEventNotifier`	`eventNotifier` Plugin implementations
`protected HystrixCommandExecutionHook`	`executionHook`
`protected ExecutionResult`	`executionResult`
`protected ExecutionResult`	`executionResultAtTimeOfCancellation`
`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 java.util.concurrent.atomic.AtomicReference<AbstractCommand.TimedOutStatus>`	`isCommandTimedOut`
`protected boolean`	`isResponseFromCache`
`protected HystrixCommandMetrics`	`metrics`
`protected HystrixCommandProperties`	`properties`
`protected HystrixRequestCache`	`requestCache` Instance of RequestCache logic
`protected HystrixThreadPool`	`threadPool`
`protected HystrixThreadPoolKey`	`threadPoolKey`
`protected java.util.concurrent.atomic.AtomicReference<AbstractCommand.ThreadState>`	`threadState`
`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

All Methods Instance Methods Abstract Methods Concrete 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
`ExecutionResult.EventCounts`	`getEventCounts()`
`protected java.lang.Exception`	`getExceptionFromThrowable(java.lang.Throwable t)`
`java.util.List<HystrixEventType>`	`getExecutionEvents()` List of HystrixCommandEventType enums representing events that occurred during execution.
`java.lang.Throwable`	`getExecutionException()` Get the Throwable/Exception emitted by this command instance prior to checking the fallback.
`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 java.lang.String`	`getFallbackMethodName()` Each concrete implementation of AbstractCommand should return the name of the fallback method as a String This will be used to determine if the fallback "exists" for firing the onFallbackStart/onFallbackError hooks
`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`	`getNumberCollapsed()`
`int`	`getNumberEmissions()` Number of emissions of the execution of a command.
`int`	`getNumberFallbackEmissions()` Number of emissions of the execution of a fallback.
`HystrixCollapserKey`	`getOriginatingCollapserKey()`
`HystrixCommandProperties`	`getProperties()` The `HystrixCommandProperties` associated with this `AbstractCommand` instance.
`java.lang.String`	`getPublicCacheKey()`
`HystrixThreadPoolKey`	`getThreadPoolKey()`
`protected void`	`handleThreadEnd(com.netflix.hystrix.AbstractCommand<R> _cmd)`
`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 (either via threadpool or semaphore)
`boolean`	`isResponseSemaphoreRejected()` Whether the response received was a fallback as result of being rejected via sempahore
`boolean`	`isResponseShortCircuited()` Whether the response received was a fallback as result of being short-circuited (meaning `isCircuitBreakerOpen() == true`) and `getFallback()` being called.
`boolean`	`isResponseThreadPoolRejected()` Whether the response received was a fallback as result of being rejected via threadpool
`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 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 interface com.netflix.hystrix.HystrixObservable
observe, toObservable

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

- Field Detail
  - circuitBreaker
```
protected final HystrixCircuitBreaker circuitBreaker
```
  - commandGroup
```
protected final HystrixCommandGroupKey commandGroup
```
  - commandKey
```
protected final HystrixCommandKey commandKey
```
  - commandStartTimestamp
```
protected volatile long commandStartTimestamp
```
  - commandState
```
protected java.util.concurrent.atomic.AtomicReference<AbstractCommand.CommandState> commandState
```
  - concurrencyStrategy
```
protected final HystrixConcurrencyStrategy concurrencyStrategy
```
  - currentRequestLog
```
protected final HystrixRequestLog currentRequestLog
```
  - endCurrentThreadExecutingCommand
```
protected volatile rx.functions.Action0 endCurrentThreadExecutingCommand
```
  - eventNotifier
```
protected final HystrixEventNotifier eventNotifier
```
    Plugin implementations
  - executionHook
```
protected final HystrixCommandExecutionHook executionHook
```
  - executionResult
```
protected volatile ExecutionResult executionResult
```
  - executionResultAtTimeOfCancellation
```
protected volatile ExecutionResult executionResultAtTimeOfCancellation
```
  - 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
```
  - 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
```
  - isCommandTimedOut
```
protected final java.util.concurrent.atomic.AtomicReference<AbstractCommand.TimedOutStatus> isCommandTimedOut
```
  - isResponseFromCache
```
protected volatile boolean isResponseFromCache
```
  - metrics
```
protected final HystrixCommandMetrics metrics
```
  - properties
```
protected final HystrixCommandProperties properties
```
  - requestCache
```
protected final HystrixRequestCache requestCache
```
    Instance of RequestCache logic
  - threadPool
```
protected final HystrixThreadPool threadPool
```
  - threadPoolKey
```
protected final HystrixThreadPoolKey threadPoolKey
```
  - threadState
```
protected java.util.concurrent.atomic.AtomicReference<AbstractCommand.ThreadState> threadState
```
  - timeoutTimer
```
protected final java.util.concurrent.atomic.AtomicReference<java.lang.ref.Reference<com.netflix.hystrix.util.HystrixTimer.TimerListener>> timeoutTimer
```
- 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
  - getFallbackMethodName
```
protected java.lang.String getFallbackMethodName()
```
    Each concrete implementation of AbstractCommand should return the name of the fallback method as a String This will be used to determine if the fallback "exists" for firing the onFallbackStart/onFallbackError hooks
    
    Returns:
    
    method name of fallback
  - 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(com.netflix.hystrix.AbstractCommand<R> _cmd)
```
  - 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
  - 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
  - getPublicCacheKey
```
public java.lang.String getPublicCacheKey()
```
    Specified by:
    
    getPublicCacheKey in interface HystrixInvokableInfo<R>
  - 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. 4 columns are ForcedOpen | ForcedClosed | CircuitBreaker open due to health ||| Expected Result T | T | T ||| OPEN (true) T | T | F ||| OPEN (true) T | F | T ||| OPEN (true) T | F | F ||| OPEN (true) F | T | T ||| CLOSED (false) F | T | F ||| CLOSED (false) F | F | T ||| OPEN (true) F | F | F ||| CLOSED (false)
    
    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
  - getExecutionException
```
public java.lang.Throwable getExecutionException()
```
    Get the Throwable/Exception emitted by this command instance prior to checking the fallback. This exception instance may have been generated via a number of mechanisms: 1) failed execution (in this case, same result as getFailedExecutionException(). 2) timeout 3) short-circuit 4) rejection 5) bad request If the command execution was successful, then this exception instance is null (there was no exception) Note that the caller of the command may not receive this exception, as fallbacks may be served as a response to the exception.
    
    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
  - isResponseSemaphoreRejected
```
public boolean isResponseSemaphoreRejected()
```
    Whether the response received was a fallback as result of being rejected via sempahore
    
    Specified by:
    
    isResponseSemaphoreRejected in interface HystrixInvokableInfo<R>
    
    Returns:
    
    boolean
  - isResponseThreadPoolRejected
```
public boolean isResponseThreadPoolRejected()
```
    Whether the response received was a fallback as result of being rejected via threadpool
    
    Specified by:
    
    isResponseThreadPoolRejected in interface HystrixInvokableInfo<R>
    
    Returns:
    
    boolean
  - isResponseRejected
```
public boolean isResponseRejected()
```
    Whether the response received was a fallback as result of being rejected (either via threadpool or semaphore)
    
    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
  - getNumberCollapsed
```
public int getNumberCollapsed()
```
    Specified by:
    
    getNumberCollapsed in interface HystrixInvokableInfo<R>
  - getOriginatingCollapserKey
```
public HystrixCollapserKey getOriginatingCollapserKey()
```
    Specified by:
    
    getOriginatingCollapserKey in interface HystrixInvokableInfo<R>
  - 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
  - getEventCounts
```
public ExecutionResult.EventCounts getEventCounts()
```
    Specified by:
    
    getEventCounts in interface HystrixInvokableInfo<R>
  - 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 interface com.netflix.hystrix.HystrixInvokableInfo

Methods inherited from interface com.netflix.hystrix.HystrixObservable

Methods inherited from class java.lang.Object

Field Detail

circuitBreaker

commandGroup

commandKey

commandStartTimestamp

commandState

concurrencyStrategy

currentRequestLog

endCurrentThreadExecutingCommand

eventNotifier

executionHook

executionResult

executionResultAtTimeOfCancellation

executionSemaphoreOverride

executionSemaphorePerCircuit

fallbackSemaphoreOverride

fallbackSemaphorePerCircuit

isCommandTimedOut

isResponseFromCache

metrics

properties

requestCache

threadPool

threadPoolKey

threadState

timeoutTimer

Constructor Detail

HystrixObservableCommand

HystrixObservableCommand

Method Detail

shouldOutputOnNextEvents

getFallbackMethodName

construct

resumeWithFallback

getExecutionObservable

getFallbackObservable

observe

toObservable

handleThreadEnd

getFallbackSemaphore

getExecutionSemaphore

getCommandGroup

getCommandKey

getThreadPoolKey

getMetrics

getProperties

decomposeException

getCacheKey

getPublicCacheKey

isRequestCachingEnabled

getLogMessagePrefix

isCircuitBreakerOpen

isExecutionComplete

isExecutedInThread

isSuccessfulExecution

isFailedExecution

getFailedExecutionException

getExecutionException

isResponseFromFallback

isResponseTimedOut

isResponseShortCircuited

isResponseFromCache

isResponseSemaphoreRejected

isResponseThreadPoolRejected

isResponseRejected

getExecutionEvents

getNumberEmissions

getNumberFallbackEmissions

getNumberCollapsed

getOriginatingCollapserKey

getExecutionTimeInMilliseconds