reactor.core.publisher

Class Hooks.OperatorHook<T>

java.lang.Object

reactor.core.publisher.Hooks.OperatorHook<T>

Type Parameters:

T - arbitrary sequence type

Enclosing class:

Hooks

public static final class Hooks.OperatorHook<T>
extends java.lang.Object

Filtering and Handling options to apply on a given Publisher

Method Summary

Modifier and Type	Method and Description
Hooks.OperatorHook<T>	doOnEach(java.util.function.Consumer<? super T> onNextCall, java.util.function.Consumer<? super java.lang.Throwable> onErrorCall, java.lang.Runnable onCompleteCall, java.lang.Runnable onAfterTerminateCall) Peek into sequence signals.
Hooks.OperatorHook<T>	doOnLifecycle(java.util.function.Consumer<? super org.reactivestreams.Subscription> onSubscribeCall, java.util.function.LongConsumer onRequestCall, java.lang.Runnable onCancelCall) Peek into lifecycle signals.
Hooks.OperatorHook<T>	ifFlux() Apply hook only if publisher() is Flux
Hooks.OperatorHook<T>	ifMono() Apply hook only if publisher() is Mono
Hooks.OperatorHook<T>	ifName(java.lang.String name) Apply hook only if publisher() if operator name match the type name (case insensitive, without Mono/Flux prefix or Fuseable suffix.
Hooks.OperatorHook<T>	ifNameContains(java.lang.String name) Apply hook only if publisher() if operator name match the type name (case insensitive, without Mono/Flux prefix or Fuseable suffix.
Hooks.OperatorHook<T>	ignore() Discard all Hooks.OperatorHook applied to the current publisher()
Hooks.OperatorHook<T>	log(java.lang.String category, java.util.logging.Level level, SignalType... options) Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation.
Hooks.OperatorHook<T>	operatorStacktrace() Enable operator stack recorder and capture declaration stack.
org.reactivestreams.Publisher<T>	publisher() The current publisher to decorate

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

doOnEach

public final Hooks.OperatorHook<T> doOnEach(java.util.function.Consumer<? super T> onNextCall,
                                            java.util.function.Consumer<? super java.lang.Throwable> onErrorCall,
                                            java.lang.Runnable onCompleteCall,
                                            java.lang.Runnable onAfterTerminateCall)

Peek into sequence signals.

The callbacks are all optional.

Parameters:

onNextCall - A consumer that will observe Subscriber.onNext(Object)

onErrorCall - A consumer that will observe Subscriber.onError(Throwable)}

onCompleteCall - A task that will run on Subscriber.onComplete()

onAfterTerminateCall - A task will run after termination via Subscriber.onComplete() or Subscriber.onError(Throwable)

Returns:

an observing Hooks.OperatorHook

doOnLifecycle

public final Hooks.OperatorHook<T> doOnLifecycle(java.util.function.Consumer<? super org.reactivestreams.Subscription> onSubscribeCall,
                                                 java.util.function.LongConsumer onRequestCall,
                                                 java.lang.Runnable onCancelCall)

Peek into lifecycle signals.

The callbacks are all optional.

Parameters:

onSubscribeCall - A consumer that will observe Subscriber.onSubscribe(Subscription)

onRequestCall - A consumer of long that will observe Subscription.request(long)}

onCancelCall - A task that will run on Subscription.cancel()

Returns:

an observing Hooks.OperatorHook

ignore

public final Hooks.OperatorHook<T> ignore()

Discard all Hooks.OperatorHook applied to the current publisher()

Returns:

an ignoring Hooks.OperatorHook

ifFlux

public final Hooks.OperatorHook<T> ifFlux()

Apply hook only if publisher() is Flux

Returns:

a possibly ignoring Hooks.OperatorHook

ifMono

public final Hooks.OperatorHook<T> ifMono()

Apply hook only if publisher() is Mono

Returns:

a possibly ignoring Hooks.OperatorHook

ifName

public final Hooks.OperatorHook<T> ifName(java.lang.String name)

Apply hook only if publisher() if operator name match the type name (case insensitive, without Mono/Flux prefix or Fuseable suffix.

Returns:

a possibly ignoring Hooks.OperatorHook

ifNameContains

public final Hooks.OperatorHook<T> ifNameContains(java.lang.String name)

Apply hook only if publisher() if operator name match the type name (case insensitive, without Mono/Flux prefix or Fuseable suffix.

Returns:

a possibly ignoring Hooks.OperatorHook

log

public Hooks.OperatorHook<T> log(java.lang.String category,
                                 java.util.logging.Level level,
                                 SignalType... options)

Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation. Default will use the passed Level and java.util.logging. If SLF4J is available, it will be used instead.

Options allow fine grained filtering of the traced signal, for instance to only capture onNext and onError:

     Operators.signalLogger(source, "category", Level.INFO, SignalType.ON_NEXT,
 SignalType.ON_ERROR)

 

Parameters:

category - to be mapped into logger configuration (e.g. org.springframework.reactor).

level - the level to enforce for this tracing Flux

options - a vararg SignalType option to filter log messages

Returns:

a logging Hooks.OperatorHook

operatorStacktrace

public Hooks.OperatorHook<T> operatorStacktrace()

Enable operator stack recorder and capture declaration stack. Errors are observed and enriched with a Suppressed Exception detailing the original stack. Must be called before producers (e.g. Flux.map, Mono.fromCallable) are actually called to intercept the right stack information.

Returns:

a operator stack capture Hooks.OperatorHook

publisher

public org.reactivestreams.Publisher<T> publisher()

The current publisher to decorate

Returns:

The current publisher to decorate