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(other: Publisher<*>): Mono<Void>

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

block

open fun block(): @Nullable Void?

open fun block(timeout: Duration): @Nullable Void?

blockOptional

open fun blockOptional(): Optional<Void>

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

cache

fun cache(): Mono<Void>

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

fun cache(ttl: Duration, timer: Scheduler): Mono<Void>

fun cache(ttlForValue: Function<in Void, Duration>, ttlForError: Function<Throwable, Duration>, ttlForEmpty: Supplier<Duration>): Mono<Void>

fun cache(ttlForValue: Function<in Void, Duration>, ttlForError: Function<Throwable, Duration>, ttlForEmpty: Supplier<Duration>, timer: Scheduler): Mono<Void>

cacheInvalidateIf

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

cacheInvalidateWhen

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

fun cacheInvalidateWhen(invalidationTriggerGenerator: Function<in Void, Mono<Void>>, onInvalidate: Consumer<in Void>): Mono<Void>

cancelOn

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

cast

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

checkpoint

fun checkpoint(): Mono<Void>

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

fun checkpoint(description: @Nullable String?, forceStackTrace: Boolean): Mono<Void>

concatWith

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

contextCapture

fun contextCapture(): Mono<Void>

contextWrite

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

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

defaultIfEmpty

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

delayElement

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

fun delayElement(delay: Duration, timer: Scheduler): Mono<Void>

delaySubscription

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

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

fun delaySubscription(delay: Duration, timer: Scheduler): Mono<Void>

delayUntil

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

dematerialize

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

doAfterTerminate

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

doFinally

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

doFirst

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

doOnCancel

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

doOnDiscard

fun <R : Any> doOnDiscard(type: Class<R>, discardHook: Consumer<in R>): Mono<Void>

doOnEach

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

doOnError

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

fun <E : Throwable> doOnError(exceptionType: Class<E>, onError: Consumer<in E>): Mono<Void>

fun doOnError(predicate: Predicate<in Throwable>, onError: Consumer<in Throwable>): Mono<Void>

doOnNext

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

doOnRequest

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

doOnSubscribe

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

doOnSuccess

fun doOnSuccess(onSuccess: Consumer<in @Nullable Void?>): Mono<Void>

doOnTerminate

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

elapsed

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

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

expand

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

fun expand(expander: Function<in Void, out Publisher<out Void>>, capacityHint: Int): Flux<Void>

expandDeep

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

fun expandDeep(expander: Function<in Void, out Publisher<out Void>>, capacityHint: Int): Flux<Void>

filter

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

filterWhen

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

flatMap

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

flatMapIterable

fun <R : Any> flatMapIterable(mapper: Function<in Void, out Iterable<out R>>): Flux<R>

flatMapMany

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

fun <R : Any> flatMapMany(mapperOnNext: Function<in Void, out Publisher<out R>>, mapperOnError: Function<in Throwable, out Publisher<out R>>, mapperOnComplete: Supplier<out Publisher<out R>>): Flux<R>

flux

fun flux(): Flux<Void>

handle

fun <R : Any> handle(handler: 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(category: @Nullable String?): Mono<Void>

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

fun log(category: @Nullable String?, level: Level, vararg options: SignalType): Mono<Void>

fun log(category: @Nullable String?, level: Level, showOperatorLine: Boolean, vararg options: SignalType): Mono<Void>

fun log(logger: Logger, level: Level, showOperatorLine: Boolean, vararg options: SignalType): Mono<Void>

map

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

mapNotNull

fun <R : Any> mapNotNull(mapper: Function<in Void, out @Nullable R?>): Mono<R>

materialize

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

mergeWith

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

metrics

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

name

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

ofType

fun ofType(clazz: Class): Mono

onErrorComplete

fun onErrorComplete(): Mono<Void>

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

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

onErrorContinue

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

fun <E : Throwable> onErrorContinue(type: Class<E>, errorConsumer: BiConsumer<Throwable, Any>): Mono<Void>

fun <E : Throwable> onErrorContinue(errorPredicate: Predicate<E>, errorConsumer: BiConsumer<Throwable, Any>): Mono<Void>

onErrorMap

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

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

fun onErrorMap(predicate: Predicate<in Throwable>, mapper: Function<in Throwable, out Throwable>): Mono<Void>

onErrorResume

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

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

fun onErrorResume(predicate: Predicate<in Throwable>, fallback: Function<in Throwable, out Mono<out Void>>): Mono<Void>

onErrorReturn

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

fun <E : Throwable> onErrorReturn(type: Class<E>, fallbackValue: Void): Mono<Void>

fun onErrorReturn(predicate: Predicate<in Throwable>, fallbackValue: Void): Mono<Void>

onErrorStop

fun onErrorStop(): Mono<Void>

onTerminateDetach

fun onTerminateDetach(): Mono<Void>

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

publish

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

publishOn

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

repeat

fun repeat(): Flux<Void>

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

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

fun repeat(numRepeat: Long, predicate: BooleanSupplier): Flux<Void>

repeatWhen

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

repeatWhenEmpty

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

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

retry

fun retry(): Mono<Void>

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

retryWhen

fun retryWhen(retrySpec: 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(actual: Subscriber<in Void>)

fun subscribe(): Disposable

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

fun subscribe(consumer: @Nullable Consumer<in Void>?, errorConsumer: Consumer<in Throwable>): Disposable

fun subscribe(consumer: @Nullable Consumer<in Void>?, errorConsumer: @Nullable Consumer<in Throwable>?, completeConsumer: @Nullable Runnable?): Disposable

fun subscribe(consumer: @Nullable Consumer<in Void>?, errorConsumer: @Nullable Consumer<in Throwable>?, completeConsumer: @Nullable Runnable?, subscriptionConsumer: @Nullable Consumer<in Subscription>?): Disposable

fun subscribe(consumer: @Nullable Consumer<in Void>?, errorConsumer: @Nullable Consumer<in Throwable>?, completeConsumer: @Nullable Runnable?, initialContext: @Nullable Context?): Disposable

subscribeOn