wow-opentelemetry/me.ahoo.wow.opentelemetry/ExchangeTraceMono

ExchangeTraceMono

class ExchangeTraceMono<T : MessageExchange<*, *>>(parentContext: Context, instrumenter: Instrumenter<T, Unit>, request: T, source: Mono<Void>) : Mono<Void>

Constructors

ExchangeTraceMono

constructor(parentContext: Context, instrumenter: Instrumenter<T, Unit>, request: T, source: Mono<Void>)

Functions

and

fun and(p0: Publisher<*>): Mono<Void>

fun as(p0: Function<in Mono<Void>, P>): P

block

@Nullable

open fun block(): Void

@Nullable

open fun block(p0: Duration): Void

blockOptional

open fun blockOptional(): Optional<Void>

open fun blockOptional(p0: Duration): Optional<Void>

cache

fun cache(): Mono<Void>

fun cache(p0: Duration): Mono<Void>

fun cache(p0: Duration, p1: Scheduler): Mono<Void>

fun cache(p0: Function<in Void, Duration>, p1: Function<Throwable, Duration>, p2: Supplier<Duration>): Mono<Void>

fun cache(p0: Function<in Void, Duration>, p1: Function<Throwable, Duration>, p2: Supplier<Duration>, p3: Scheduler): Mono<Void>

cacheInvalidateIf

fun cacheInvalidateIf(p0: Predicate<in Void>): Mono<Void>

cacheInvalidateWhen

fun cacheInvalidateWhen(p0: Function<in Void, Mono<Void>>): Mono<Void>

fun cacheInvalidateWhen(p0: Function<in Void, Mono<Void>>, p1: Consumer<in Void>): Mono<Void>

cancelOn

fun cancelOn(p0: Scheduler): Mono<Void>

cast

fun <E : Any> cast(p0: Class<E>): Mono<E>

checkpoint

fun checkpoint(): Mono<Void>

fun checkpoint(p0: String): Mono<Void>

fun checkpoint(@Nullable p0: String, p1: Boolean): Mono<Void>

concatWith

fun concatWith(p0: Publisher<out Void>): Flux<Void>

contextCapture

fun contextCapture(): Mono<Void>

contextWrite

fun contextWrite(p0: Function<Context, Context>): Mono<Void>

fun contextWrite(p0: ContextView): Mono<Void>

defaultIfEmpty

fun defaultIfEmpty(p0: Void): Mono<Void>

delayElement

fun delayElement(p0: Duration): Mono<Void>

fun delayElement(p0: Duration, p1: Scheduler): Mono<Void>

delaySubscription

fun delaySubscription(p0: Duration): Mono<Void>

fun delaySubscription(p0: Publisher): Mono<Void>

fun delaySubscription(p0: Duration, p1: Scheduler): Mono<Void>

delayUntil

fun delayUntil(p0: Function<in Void, out Publisher<*>>): Mono<Void>

dematerialize

fun <X : Any> dematerialize(): Mono<X>

doAfterTerminate

fun doAfterTerminate(p0: Runnable): Mono<Void>

doFinally

fun doFinally(p0: Consumer<SignalType>): Mono<Void>

doFirst

fun doFirst(p0: Runnable): Mono<Void>

doOnCancel

fun doOnCancel(p0: Runnable): Mono<Void>

doOnDiscard

fun <R : Any> doOnDiscard(p0: Class<R>, p1: Consumer<in R>): Mono<Void>

doOnEach

fun doOnEach(p0: Consumer<in Signal<Void>>): Mono<Void>

doOnError

fun doOnError(p0: Consumer<in Throwable>): Mono<Void>

fun <E : Throwable> doOnError(p0: Class<E>, p1: Consumer<in E>): Mono<Void>

fun doOnError(p0: Predicate<in Throwable>, p1: Consumer<in Throwable>): Mono<Void>

doOnNext

fun doOnNext(p0: Consumer<in Void>): Mono<Void>

doOnRequest

fun doOnRequest(p0: LongConsumer): Mono<Void>

doOnSubscribe

fun doOnSubscribe(p0: Consumer<in Subscription>): Mono<Void>

doOnSuccess

fun doOnSuccess(p0: Consumer<in Void>): Mono<Void>

doOnTerminate

fun doOnTerminate(p0: Runnable): Mono<Void>

elapsed

fun elapsed(): Mono<Tuple2<Long, Void>>

fun elapsed(p0: Scheduler): Mono<Tuple2<Long, Void>>

expand

fun expand(p0: Function<in Void, out Publisher<out Void>>): Flux<Void>

fun expand(p0: Function<in Void, out Publisher<out Void>>, p1: Int): Flux<Void>

expandDeep

fun expandDeep(p0: Function<in Void, out Publisher<out Void>>): Flux<Void>

fun expandDeep(p0: Function<in Void, out Publisher<out Void>>, p1: Int): Flux<Void>

filter

fun filter(p0: Predicate<in Void>): Mono<Void>

filterWhen

fun filterWhen(p0: Function<in Void, out Publisher<Boolean>>): Mono<Void>

flatMap

fun <R : Any> flatMap(p0: Function<in Void, out Mono<out R>>): Mono<R>

flatMapIterable

fun <R : Any> flatMapIterable(p0: Function<in Void, out MutableIterable<R>>): Flux<R>

flatMapMany

fun <R : Any> flatMapMany(p0: Function<in Void, out Publisher<out R>>): Flux<R>

fun <R : Any> flatMapMany(p0: Function<in Void, out Publisher<out R>>, p1: Function<in Throwable, out Publisher<out R>>, p2: Supplier<out Publisher<out R>>): Flux<R>

flux

fun flux(): Flux<Void>

handle

fun <R : Any> handle(p0: BiConsumer<in Void, SynchronousSink<R>>): Mono<R>

hasElement

fun hasElement(): Mono<Boolean>

hide

fun hide(): Mono<Void>

ignoreElement

fun ignoreElement(): Mono<Void>

log

fun log(): Mono<Void>

fun log(@Nullable p0: String): Mono<Void>

fun log(p0: Logger): Mono<Void>

fun log(@Nullable p0: String, p1: Level, vararg p2: SignalType): Mono<Void>

fun log(@Nullable p0: String, p1: Level, p2: Boolean, vararg p3: SignalType): Mono<Void>

fun log(p0: Logger, p1: Level, p2: Boolean, vararg p3: SignalType): Mono<Void>

map

fun <R : Any> map(p0: Function<in Void, out R>): Mono<R>

mapNotNull

fun <R : Any> mapNotNull(p0: Function<in Void, out R>): Mono<R>

materialize

fun materialize(): Mono<Signal<Void>>

mergeWith

fun mergeWith(p0: Publisher<out Void>): Flux<Void>

metrics

fun ~~metrics~~(): Mono<Void>

name

fun name(p0: String): Mono<Void>

ofType

fun ofType(p0: Class): Mono

onErrorComplete

fun onErrorComplete(): Mono<Void>

fun onErrorComplete(p0: Class<out Throwable>): Mono<Void>

fun onErrorComplete(p0: Predicate<in Throwable>): Mono<Void>

onErrorContinue

fun onErrorContinue(p0: BiConsumer<Throwable, Any>): Mono<Void>

fun <E : Throwable> onErrorContinue(p0: Class<E>, p1: BiConsumer<Throwable, Any>): Mono<Void>

fun <E : Throwable> onErrorContinue(p0: Predicate<E>, p1: BiConsumer<Throwable, Any>): Mono<Void>

onErrorMap

fun onErrorMap(p0: Function<in Throwable, out Throwable>): Mono<Void>

fun <E : Throwable> onErrorMap(p0: Class<E>, p1: Function<in E, out Throwable>): Mono<Void>

fun onErrorMap(p0: Predicate<in Throwable>, p1: Function<in Throwable, out Throwable>): Mono<Void>

onErrorResume

fun onErrorResume(p0: Function<in Throwable, out Mono<out Void>>): Mono<Void>

fun <E : Throwable> onErrorResume(p0: Class<E>, p1: Function<in E, out Mono<out Void>>): Mono<Void>

fun onErrorResume(p0: Predicate<in Throwable>, p1: Function<in Throwable, out Mono<out Void>>): Mono<Void>

onErrorReturn

fun onErrorReturn(p0: Void): Mono<Void>

fun <E : Throwable> onErrorReturn(p0: Class<E>, p1: Void): Mono<Void>

fun onErrorReturn(p0: Predicate<in Throwable>, p1: Void): Mono<Void>

onErrorStop

fun onErrorStop(): Mono<Void>

onTerminateDetach

fun onTerminateDetach(): Mono<Void>

fun or(p0: Mono<out Void>): Mono<Void>

publish

fun <R : Any> publish(p0: Function<in Mono<Void>, out Mono<out R>>): Mono<R>

publishOn

fun publishOn(p0: Scheduler): Mono<Void>

repeat

fun repeat(): Flux<Void>

fun repeat(p0: BooleanSupplier): Flux<Void>

fun repeat(p0: Long): Flux<Void>

fun repeat(p0: Long, p1: BooleanSupplier): Flux<Void>

repeatWhen

fun repeatWhen(p0: Function<Flux<Long>, out Publisher<*>>): Flux<Void>

repeatWhenEmpty

fun repeatWhenEmpty(p0: Function<Flux<Long>, out Publisher<*>>): Mono<Void>

fun repeatWhenEmpty(p0: Int, p1: Function<Flux<Long>, out Publisher<*>>): Mono<Void>

retry

fun retry(): Mono<Void>

fun retry(p0: Long): Mono<Void>

retryWhen

fun retryWhen(p0: Retry): Mono<Void>

fun share(): Mono<Void>

single

fun single(): Mono<Void>

singleOptional

fun singleOptional(): Mono<Optional<Void>>

open override fun subscribe(actual: CoreSubscriber<in Void>)

fun subscribe(): Disposable

fun subscribe(p0: Consumer<in Void>): Disposable

override fun subscribe(p0: Subscriber<in Void>)

fun subscribe(@Nullable p0: Consumer<in Void>, p1: Consumer<in Throwable>): Disposable

fun subscribe(@Nullable p0: Consumer<in Void>, @Nullable p1: Consumer<in Throwable>, @Nullable p2: Runnable): Disposable

fun subscribe(@Nullable p0: Consumer<in Void>, @Nullable p1: Consumer<in Throwable>, @Nullable p2: Runnable, @Nullable p3: Consumer<in Subscription>): Disposable