Issue title: Uni.invoke() (or call() or handle())
 Issue body: After some experience I find I prefer the `map()`/`flatMap()` API to `onItem()`.

But it's *really* annoying that there's no equivalent shortcut way to call `UniOnItem.invoke()`, since it's an operation I use all the time.

I would like to see `invoke()` added to `Uni`, though perhaps it would make more sense to name it `handle()`, since it's a sort of event handlery thing. Or `call()` perhaps.
 Comments: 
 Comment 0: This issue came a few times. I, first, need to understand the use case, as most of the time, I've seen these methods used just for `log` purposes. 

We want to add a log operator:

* `Uni.log()`, `Multi.log()` - log all the events
* `Uni.onItem().log()` - log item events
* ...

The log operator can log automatically (using a predefined log statement) or be used with a callback returning the String to be logged. 

If requested, the log should be able to clean up the stack trace to be _meaningful_.

When not used for logging, these methods are often used to implement side-effects. While they cannot be discarded, users must be a bit careful with that.  

About the naming, what about `onItem(Consumer<T>)`? The "traditional" method is named `doOnNext` which does not fit well with the rest of Mutiny.
 Comment 1: This isn't anything to do with logging. (For logging I would need a matching method that is called on failures.)

It's specifically in order to be able to call side-effects, which are rather hugely important when one is writing data-access code. :-) The most basic operations like `persist()` and `delete()` and `flush()` are all side-effects.

> About the naming, what about `onItem(Consumer<T>)`? The "traditional" method is named `doOnNext` which does not fit well with the rest of Mutiny.

I want something that looks and feels visually like `map()` and `flatMap()`, because it will appear in a chain along with a bunch of `map()`s and `flatMap()`s.
 Comment 2: You could call it `affect()`. Since it's used to cause an effect.
 Comment 3: I like that name! 

@jponge @kenfinnigan WDYT? 
 Comment 4: Is this the same as `peek`?
 Comment 5: `affect` sounds weird to me, but it's probably due to how I translate that to 🇫🇷 😉 

Some random ideas:

* `do(Consumer<T> item)` (e.g., `(...).onNext().do(this38d1:d2b4:3d06:83e8:96a5:8c2:893d:aba5persist).(...)`
* `perform`
* `trigger` (might be nice)
 Comment 6: `do` is a keyword in Java.
 Comment 7: And `trigger()` is almost a bit *too* exciting and action-packed, perhaps. ;-)
 Comment 8: > `do` is a keyword in Java.

Yeah, I thought about it over lunch 🤦 
 Comment 9: In fairness, it's probably the least used keyword except for `goto` and `strictfp`.
 Comment 10: I kind of like `affect()`.

Some other options could be `alter()`, `perturb()`, `transform()`. Just a few I thought of, though may induce other connotations.
 Comment 11: `peek is already used in [Java streams](https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html#peek-java.util.function.Consumer-) for that purpose. I vote for the peek.
 Comment 12: `also`?
 Comment 13: > peek is already used in [Java streams](https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html#peek-java.util.function.Consumer-) for that purpose

I dunno, "peek" sounds kinda like the *opposite* of what this is. "Peek" sounds like something with no side-effect, whereas we've already established that the whole point of this operation is to do side effects.

 Comment 14: > I dunno, "peek" sounds kinda like the opposite of what this is.

I'd be totally happy with calling it "poke", however. 😝
 Comment 15: Will poke get me infinite threads?

On Mon, 1 Jun 2020, 22:17 Gavin King, <gregory30@example.net> wrote:

> I dunno, "peek" sounds kinda like the opposite of what this is.
>
> I'd be totally happy with calling it "poke", however. 😝
>
> —
> You are receiving this because you commented.
> Reply to this email directly, view it on GitHub
> <https://github.com/smallrye/smallrye-mutiny/issues/146#issuecomment-637079805>,
> or unsubscribe
> <https://github.com/notifications/unsubscribe-auth/AANKF2GHSWMNCFXSMEF7QBLRUQEG3ANCNFSM4NI76VLA>
> .
>

 Comment 16: But `peek` doesn't have any effect -- on the processing pipeline. It lets you see the value and do something with it, but the pipeline isn't _affected_. Hence, you could also say that `affect` is the exact opposite :grin:
 Comment 17: Sure, but I'm not writing a code that produces a processing pipeline. I'm writing code that does something interesting to the world. I DGAF what this operation does to the stream, since my program isn't about streams.
 Comment 18: > I'm not writing a code that produces a processing pipeline

Yea, well, you do. If you use the `Uni` API, you build a pipeline, even though there's ever only 1 item flowing through it.
 Comment 19: > Yea, well, you do.

That's the myopic perspective of the designer of a reactive streams library.

It's not my perspective as a user of the API. I'm trying to make an interesting program that does useful things. I actually don't care about reactive gregory30@example.net. When I look at my code I want to see information about how my program solves the problem the program is designed to solve. Not information about reactive streams.
 Comment 20: > Not information about reactive streams.

And that's why

    on().item().invoke(sideEffect)

while surely very cool and elegant, arguably, to someone who's very myopically interested in reactive streams, is completely intrusive and annoying in my program which does interesting stuff that end users care about.
 Comment 21: Actually it's a perspective of someone who hates reactive programming libraries and believes that if we really need to impose them on users, then we shouldn't try to hide what's really going on, because leaking abstraction etc. etc. etc. But I'm ready to agree to disagree.
 Comment 22: Well, I'm trying to find a way to hate it slightly less.
 Comment 23: Alright, so reflecting on @Ladicek point about `peek()` implying something that has no effect _on the stream_, I managed to clarify what I dislike about that name, and that suggested a better name.

So why don't I like `peek()`? Well, "peek" in English means to just sneak a quick glance at the item. Whereas what I'm going to do from this operation is actually *use* the item to do something very meaningful, perhaps even perform a side-effect _on the item itself_.

So why not call the operation `use()`? The name implies to me that I'm going to use the item without affecting or transforming the stream itself. It's a common English word, that's not a Java keyword, and that has just three letters in it!
 Comment 24: Hear me out on this one. This reads really naturally, I think:

```java
return factory.withSession(
		//retrieve a Book
		session -> session.find(Book.class, book1.id)
				.use( book -> session.remove(book) )
				.map( book -> "deleted " + book.title )
)
```
 Comment 25: Kotlin has [also](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/also.html)
 Comment 26: I am sure that every designer of the stream library had the same discussion. We already have a standard Java library. While some names may be less than perfect, they are well known and understood, so why not just stick with that? Easy to use reactive library is something to be excited about; a slightly better name for functionality that I already know under a different name is not.
 Comment 27: > I am sure that every designer of the stream library had the same discussion. We already have a standard Java library. While some names may be less than perfect, they are well known and understood, so why not just stick with that?

Ummmmm, because the other APIs are *terrible*, and terribly confusing?
 Comment 28: We have tried to use the names from java.util.Stream in MicroProfile reactive streams ops. Feedback has not been good. While "known" it's just confusing and didn't work well (confusing names, hard to find the proper method...). 
 Comment 29: `invoke` and `invokeUni` have been added to the `Uni` class.
{'source': 'GithubIssues', 'repo_name_with_owner': 'smallrye/smallrye-mutiny', 'issue_id': 623921727, 'repo_stars': 550.0}