Given a `Flux` or a `Mono` from project reactor is a there a way to get the Flux or Mono to print out what the operator chain looks like. For example given the code below.

```
Fulx flux = Flux.just("a","b","c")
              .map( v -> v.toUpperCase())
              .log();

```

Is there some way to get the flux to print out a list of all the operators that are chained inside in the processing pipeline? Some nice ascii formatted text or a marble diagram? 

printTheFlux(flux) should make a nice printout that show the structure of all the operators from the example above. I am not expecting to produce the code in the lambda's just a way to see what operators are chained together.
['https://Stackoverflow.com/questions/48375282', 'https://Stackoverflow.com', 'https://Stackoverflow.com/users/438319/']
There is partial building blocks for doing this with the `Scannable` interface:

```
public String textRepresentation(Flux<?> flux) {
    Scannable sc = Scannable.from(flux);
    //scan the last operator in the chain and ask if it knows its parents
    List<String> names = sc.parents().map(Scannable::operatorName)
                                     .collect(Collectors.toList());
    //as it traverses the chain from bottom to top, we need to reverse the order
    Collections.reverse(names);
    //need to also add the last operator
    names.add(sc.operatorName());
    return names.toString();
}

@Test
public void textRepresentationTest() {
    Flux flux = Flux.just("a","b","c")
                    .map( v -> v.toUpperCase())
                    .log();

    System.out.println(textRepresentation(flux));
}

```

Prints

```
[map, log]

```

Not all operators fully support it though (as you can see, the `just` source doesn't for instance).
Nice suggestion!

However, waiting for it, we can just have something like :

```
    Disposable flux = Flux.just("a", "b", "c")
            .map(String::toUpperCase)
            .doOnNext(FluxUtil::print)
            .subscribe();

```

Where `FluxUtil::print` is just a static method that you can write with different ways.

Here is the complete code works for me:

```
public class FluxUtil {

    private static String s = "";

    public static void main(String[] args) {

        Disposable flux = Flux.just("a", "b", "c")
                .map(String::toUpperCase)
                .doOnNext(FluxUtil::print)
                .subscribe();
    }

    private static Object print(Object o) {

        s = !s.isEmpty() ? s.concat("->") : s;
        s = s.concat(o.toString());
        System.out.println(s);
        return o;
    }
}

```