Hooks.OperatorHook (Reactor Core 3.1.0.M1)

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 Object
```
Filtering and Handling options to apply on a given Publisher

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Hooks.OperatorHook<T>`	`doOnEach(Consumer<? super T> onNextCall, Consumer<? super Throwable> onErrorCall, Runnable onCompleteCall, Runnable onAfterTerminateCall)` Peek into sequence signals.
`Hooks.OperatorHook<T>`	`doOnLifecycle(Consumer<? super Subscription> onSubscribeCall, LongConsumer onRequestCall, 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(String... names)` Apply hook only if one of the provided names matches the operator underlying type name (case insensitive, without Mono/Flux prefix or Fuseable suffix).
`Hooks.OperatorHook<T>`	`ifNameContains(String... names)` Apply hook only if one of the provided names is contained in the operator's underlying type name (case insensitive, without Mono/Flux prefix or Fuseable suffix).
`Hooks.OperatorHook<T>`	`ifParallelFlux()` Apply hook only if `publisher()` is `ParallelFlux`
`Hooks.OperatorHook<T>`	`ignore()` Discard all `Hooks.OperatorHook` applied to the current `publisher()`
`Hooks.OperatorHook<T>`	`log(String category, boolean showOperatorLine, SignalType... options)` Observe Reactive Streams signals matching the passed filter `options` and log them at INFO level.
`Hooks.OperatorHook<T>`	`log(String category, Level level, boolean showOperatorLine, SignalType... options)` Observe Reactive Streams signals matching the passed filter `options` and log them at the provided level.
`Hooks.OperatorHook<T>`	`log(String category, Level level, SignalType... options)` Observe Reactive Streams signals matching the passed filter `options`and log them at the provided level.
`Hooks.OperatorHook<T>`	`log(String category, SignalType... options)` Observe Reactive Streams signals matching the passed filter `options` and log them at INFO level.
`Hooks.OperatorHook<T>`	`operatorStacktrace()` Enable operator stack recorder that captures a declaration stack whenever an operator is instantiated.
`Publisher<T>`	`publisher()` The publisher being decorated

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(Consumer<? super T> onNextCall,
                                            Consumer<? super Throwable> onErrorCall,
                                            Runnable onCompleteCall,
                                            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(Consumer<? super Subscription> onSubscribeCall,
                                                 LongConsumer onRequestCall,
                                                 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
  - ifParallelFlux
```
public final Hooks.OperatorHook<T> ifParallelFlux()
```
    Apply hook only if publisher() is ParallelFlux
    
    Returns:
    
    a possibly ignoring Hooks.OperatorHook
  - ifName
```
public final Hooks.OperatorHook<T> ifName(String... names)
```
    Apply hook only if one of the provided names matches the operator underlying type name (case insensitive, without Mono/Flux prefix or Fuseable suffix).
    
    Parameters:
    
    names - a list of possible names that would match if equal
    
    Returns:
    
    a possibly ignoring Hooks.OperatorHook
  - ifNameContains
```
public final Hooks.OperatorHook<T> ifNameContains(String... names)
```
    Apply hook only if one of the provided names is contained in the operator's underlying type name (case insensitive, without Mono/Flux prefix or Fuseable suffix).
    
    Parameters:
    
    names - a list of possible names that would match if contained
    
    Returns:
    
    a possibly ignoring Hooks.OperatorHook
  - log
```
public Hooks.OperatorHook<T> log(String category,
                                 SignalType... options)
```
    Observe Reactive Streams signals matching the passed filter options and log them at INFO level.
    Logging it done through Logger so the default logging framework is java.util.logging, but 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). If category is null, empty or ends with "." like "reactor.", a generated operator suffix will complete, e.g. "reactor.Flux.Map".
    
    options - a vararg SignalType option to filter log messages
    
    Returns:
    
    a logging Hooks.OperatorHook
  - log
```
public Hooks.OperatorHook<T> log(String category,
                                 boolean showOperatorLine,
                                 SignalType... options)
```
    Observe Reactive Streams signals matching the passed filter options and log them at INFO level.
    Logging it done through Logger so the default logging framework is java.util.logging, but 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). If category is null, empty or ends with "." like "reactor.", a generated operator suffix will complete, e.g. "reactor.Flux.Map".
    
    showOperatorLine - capture the current stack to display operator class/line number.
    
    options - a vararg SignalType option to filter log messages
    
    Returns:
    
    a logging Hooks.OperatorHook
  - log
```
public Hooks.OperatorHook<T> log(String category,
                                 Level level,
                                 SignalType... options)
```
    Observe Reactive Streams signals matching the passed filter optionsand log them at the provided level.
    Logging it done through Logger so the default logging framework is java.util.logging, but 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). If category is null, empty or ends with "." like "reactor.", a generated operator suffix will complete, e.g. "reactor.Flux.Map".
    
    level - the level to enforce for this tracing Flux
    
    options - a vararg SignalType option to filter log messages
    
    Returns:
    
    a logging Hooks.OperatorHook
  - log
```
public Hooks.OperatorHook<T> log(String category,
                                 Level level,
                                 boolean showOperatorLine,
                                 SignalType... options)
```
    Observe Reactive Streams signals matching the passed filter options and log them at the provided level.
    Logging it done through Logger so the default logging framework is java.util.logging, but 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). If category is null, empty or ends with "." like "reactor.", a generated operator suffix will complete, e.g. "reactor.Flux.Map".
    
    level - the level to enforce for this tracing Flux
    
    showOperatorLine - capture the current stack to display operator class/line number.
    
    options - a vararg SignalType option to filter log messages
    
    Returns:
    
    a logging Hooks.OperatorHook
  - operatorStacktrace
```
public Hooks.OperatorHook<T> operatorStacktrace()
```
    Enable operator stack recorder that captures a declaration stack whenever an operator is instantiated. When errors are observed later on, they will be enriched with a Suppressed Exception detailing the original assembly line 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 capturing Hooks.OperatorHook
  - publisher
```
public Publisher<T> publisher()
```
    The publisher being decorated
    
    Returns:
    
    The publisher being decorated

Class Hooks.OperatorHook<T>

Method Summary

Methods inherited from class java.lang.Object

Method Detail

doOnEach

doOnLifecycle

ignore

ifFlux

ifMono

ifParallelFlux

ifName

ifNameContains

log

log

log

log

operatorStacktrace

publisher