public static void onEachOperator(String key, Function<? super Publisher<Object>, ? extends Publisher<Object>> onEachOperator) {
    """
	Add or replace a named {@link Publisher} operator interceptor for each operator created
	({@link Flux} or {@link Mono}). The passed function is applied to the original
	operator {@link Publisher} and can return a different {@link Publisher},
	on the condition that it generically maintains the same data type as the original.
	Use of the {@link Flux}/{@link Mono} APIs is discouraged as it will recursively
	call this hook, leading to {@link StackOverflowError}.
	<p>
	Note that sub-hooks are cumulative. Invoking this method twice with the same key will
	replace the old sub-hook with that name, but keep the execution order (eg. A-h1, B-h2,
	A-h3 will keep A-B execution order, leading to hooks h3 then h2 being executed).
	Removing a particular key using {@link #resetOnEachOperator(String)} then adding it
	back will result in the execution order changing (the later sub-hook being executed
	last). Can be fully reset via {@link #resetOnEachOperator()}.
	<p>
	This pointcut function cannot make use of {@link Flux}, {@link Mono} or
	{@link ParallelFlux} APIs as it would lead to a recursive call to the hook: the
	operator calls would effectively invoke onEachOperator from onEachOperator.
	
	@param key the key for the sub-hook to add/replace
	@param onEachOperator the sub-hook: a function to intercept each operation call
	(e.g. {@code map (fn)} and {@code map(fn2)} in {@code flux.map(fn).map(fn2).subscribe()})
	
	@see #onEachOperator(Function)
	@see #resetOnEachOperator(String)
	@see #resetOnEachOperator()
	@see #onLastOperator(String, Function)
    """
		Objects.requireNonNull(key, "key");
		Objects.requireNonNull(onEachOperator, "onEachOperator");
		log.debug("Hooking onEachOperator: {}", key);

		synchronized (log) {
			onEachOperatorHooks.put(key, onEachOperator);
			onEachOperatorHook = createOrUpdateOpHook(onEachOperatorHooks.values());
		}
	}
public static void onEachOperator(String key, Function<? super Publisher<Object>, ? extends Publisher<Object>> onEachOperator) {
		Objects.requireNonNull(key, "key");
		Objects.requireNonNull(onEachOperator, "onEachOperator");
		log.debug("Hooking onEachOperator: {}", key);

		synchronized (log) {
			onEachOperatorHooks.put(key, onEachOperator);
			onEachOperatorHook = createOrUpdateOpHook(onEachOperatorHooks.values());
		}
	}
public static void onEachOperator ( String key , Function < ? super Publisher < Object > , ? extends Publisher < Object > > onEachOperator ) { Objects . requireNonNull ( key , "key" ) ; Objects . requireNonNull ( onEachOperator , "onEachOperator" ) ; log . debug ( "Hooking onEachOperator: {}" , key ) ; synchronized ( log ) { onEachOperatorHooks . put ( key , onEachOperator ) ; onEachOperatorHook = createOrUpdateOpHook ( onEachOperatorHooks . values ( ) ) ; } }
Add or replace a named {@link Publisher} operator interceptor for each operator created
({@link Flux} or {@link Mono}). The passed function is applied to the original
operator {@link Publisher} and can return a different {@link Publisher},
on the condition that it generically maintains the same data type as the original.
Use of the {@link Flux}/{@link Mono} APIs is discouraged as it will recursively
call this hook, leading to {@link StackOverflowError}.
<p>
Note that sub-hooks are cumulative. Invoking this method twice with the same key will
replace the old sub-hook with that name, but keep the execution order (eg. A-h1, B-h2,
A-h3 will keep A-B execution order, leading to hooks h3 then h2 being executed).
Removing a particular key using {@link #resetOnEachOperator(String)} then adding it
back will result in the execution order changing (the later sub-hook being executed
last). Can be fully reset via {@link #resetOnEachOperator()}.
<p>
This pointcut function cannot make use of {@link Flux}, {@link Mono} or
{@link ParallelFlux} APIs as it would lead to a recursive call to the hook: the
operator calls would effectively invoke onEachOperator from onEachOperator.

@param key the key for the sub-hook to add/replace
@param onEachOperator the sub-hook: a function to intercept each operation call
(e.g. {@code map (fn)} and {@code map(fn2)} in {@code flux.map(fn).map(fn2).subscribe()})

@see #onEachOperator(Function)
@see #resetOnEachOperator(String)
@see #resetOnEachOperator()
@see #onLastOperator(String, Function)
Add or replace a named { @link Publisher } operator interceptor for each operator created ( { @link Flux } or { @link Mono } ) . The passed function is applied to the original operator { @link Publisher } and can return a different { @link Publisher } on the condition that it generically maintains the same data type as the original . Use of the { @link Flux } / { @link Mono } APIs is discouraged as it will recursively call this hook leading to { @link StackOverflowError } . <p > Note that sub - hooks are cumulative . Invoking this method twice with the same key will replace the old sub - hook with that name but keep the execution order ( eg . A - h1 B - h2 A - h3 will keep A - B execution order leading to hooks h3 then h2 being executed ) . Removing a particular key using { @link #resetOnEachOperator ( String ) } then adding it back will result in the execution order changing ( the later sub - hook being executed last ) . Can be fully reset via { @link #resetOnEachOperator () } . <p > This pointcut function cannot make use of { @link Flux } { @link Mono } or { @link ParallelFlux } APIs as it would lead to a recursive call to the hook : the operator calls would effectively invoke onEachOperator from onEachOperator .