code: @SuppressWarnings("unchecked")
      public static <T> T contextualize(final OperationalContextRetriver retriver, final T instance, Class<?> interfaze,
          final Class<?>... contextPropagatingInterfaces) {
          return (T) Proxy.newProxyInstance(instance.getClass().getClassLoader(), new Class<?>[] {interfaze},
              new InvocationHandler() {
                  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                      OperationalContext context = retriver.retrieve();
                      context.activate();
                      try {
                          Object result = method.invoke(instance, args);
                          Class<?> type = method.getReturnType();
                          if (result != null && type != null && type.isInterface() && Arrays.asList(
                              contextPropagatingInterfaces).contains(type)) {
                              return contextualize(retriver, result, type, contextPropagatingInterfaces);
                          } else {
                              return result;
                          }
                      } catch (InvocationTargetException e) {
                          throw e.getTargetException();
                      } finally {
                          context.deactivate();
                      }
                  }
              });
      }
docs: Contextualizes operation with contexts given by {@link OperationalContext} which is given by provided
  {@link OperationalContextRetriver}
  
  @param retriever                    the context retriever
  @param instance                     the instance to wrap (must comply with given interface)
  @param interfaze                    the interface of return object
  @param contextPropagatingInterfaces when a return type of any invocation is one of these interfaces, the given result will be call contextually as well