docs: @PostConstruct
      void init() {
          if (CollectionUtils.isNotEmpty(reactiveInstrumenters)) {
              oldCompletableHook =
                      RxJavaPlugins.getOnCompletableAssembly();
              oldMaybeHook = RxJavaPlugins.getOnMaybeAssembly();
              oldSingleHook = RxJavaPlugins.getOnSingleAssembly();
              oldObservableHook =
                      RxJavaPlugins.getOnObservableAssembly();
              oldFlowableHook =
                      RxJavaPlugins.getOnFlowableAssembly();
              oldConnectableFlowableHook =
                      RxJavaPlugins.getOnConnectableFlowableAssembly();
              oldConnectableObservableHook =
                      RxJavaPlugins.getOnConnectableObservableAssembly();
              oldParallelFlowableHook =
                      RxJavaPlugins.getOnParallelAssembly();
  
              RxJavaPlugins.setOnCompletableAssembly(completable -> {
                  final Completable wrapped = RxInstrumentedWrappers.wrap(completable, reactiveInstrumenters);
                  if (oldCompletableHook != null) {
                      return oldCompletableHook.apply(wrapped);
                  }
                  return wrapped;
              });
  
              RxJavaPlugins.setOnMaybeAssembly(maybe -> {
                  final Maybe wrapped = RxInstrumentedWrappers.wrap(maybe, reactiveInstrumenters);
                  if (oldMaybeHook != null) {
                      return oldMaybeHook.apply(wrapped);
                  }
                  return wrapped;
              });
  
              RxJavaPlugins.setOnSingleAssembly(single -> {
                  final Single wrapped = RxInstrumentedWrappers.wrap(single, reactiveInstrumenters);
                  if (oldSingleHook != null) {
                      return oldSingleHook.apply(wrapped);
                  }
                  return wrapped;
              });
  
              RxJavaPlugins.setOnObservableAssembly(observable -> {
                  final Observable wrapped = RxInstrumentedWrappers.wrap(observable, reactiveInstrumenters);
                  if (oldObservableHook != null) {
                      return oldObservableHook.apply(wrapped);
                  }
                  return wrapped;
              });
  
              RxJavaPlugins.setOnFlowableAssembly(flowable -> {
                  final Flowable wrapped = RxInstrumentedWrappers.wrap(flowable, reactiveInstrumenters);
                  if (oldFlowableHook != null) {
                      return oldFlowableHook.apply(wrapped);
                  }
                  return wrapped;
              });
  
              RxJavaPlugins.setOnConnectableFlowableAssembly(
                      connectableFlowable -> {
                          final ConnectableFlowable wrapped = RxInstrumentedWrappers.wrap(connectableFlowable, reactiveInstrumenters);
                          if (oldConnectableFlowableHook != null) {
                              return oldConnectableFlowableHook.apply(wrapped);
                          }
                          return wrapped;
                      });
  
              RxJavaPlugins.setOnConnectableObservableAssembly(connectableObservable -> {
                  final ConnectableObservable wrapped = RxInstrumentedWrappers.wrap(connectableObservable, reactiveInstrumenters);
                  if (oldConnectableObservableHook != null) {
                      return oldConnectableObservableHook.apply(connectableObservable);
                  }
                  return wrapped;
              });
  
              RxJavaPlugins.setOnParallelAssembly(parallelFlowable -> {
                  final ParallelFlowable wrapped = RxInstrumentedWrappers.wrap(parallelFlowable, reactiveInstrumenters);
                  if (oldParallelFlowableHook != null) {
                      return oldParallelFlowableHook.apply(wrapped);
                  }
                  return wrapped;
              });
  
          }
  
          if (CollectionUtils.isNotEmpty(instrumenters)) {
              Function<? super Runnable, ? extends Runnable> existing = RxJavaPlugins.getScheduleHandler();
              if (existing != null && !(existing instanceof RxJava2Instrumentation)) {
                  RxJavaPlugins.setScheduleHandler(runnable -> this.apply(existing.apply(runnable)));
              } else {
                  RxJavaPlugins.setScheduleHandler(this);
              }
          }
      }