wiretap | desktop app for inspecting mobx | State Container library

send() method returns Mono, so you can invoke the delay* operators that Mono provides. The example above can be changed like this (this example below delays headers and sends an empty response body):

Your question is not clear, but it feels like you want to send a result of one flow to another. Essentially connecting them to a single flow.

The channel() is the best way to do that. The point is that an IntegrationFlow is just a logical container which does not have too much heavy lifting at runtime. The components we need to pay attention are endpoints and channel in between. Even single IntegrationFlow has channels between its handle(), transform(), split() filter() etc. The connection between those endpoint is what important at runtime. And since every single endpoint has its inputChannel to activate, it doesn't mean where and how that endpoint is declared: you still can send a message from any place of your application to that channel. That's a bit of logic behind endpoints and their channel. But I agree that it is much easier to think about business logic as a combination of some unit works, like an IntegrationFlow. So, to connect those units, you really just need to know an input channel where you'd like to send a result of this unit of work.

The wire-tap also could be useful in some scenarios when you want to send the same message at some endpoint to other endpoint and continue in this flow.

So, both your variants are valid, but they may make slight logical difference if it becomes non-linear flow or vise-versa.

See more in docs about flows and wire-taps:

https://docs.spring.io/spring-integration/docs/current/reference/html/dsl.html#java-dsl

https://docs.spring.io/spring-integration/docs/current/reference/html/core.html#channel-wiretap

When all the attempts of the retry are exhausted, the RecoveryCallback is called. See some sample here: How to get HTTP status in advice recovery callback. In that RecoveryCallback you can just return null and send a message to some channel for that storing to DB logic.

Another way is to have extra advice on top of that retry instead of RecoveryCallback. See its docs: https://docs.spring.io/spring-integration/docs/current/reference/html/messaging-endpoints.html#expression-advice. This way when all the attempts are done, the exception is going to be bubbled and caught by that ExpressionEvaluatingRequestHandlerAdvice and its failureChannel. Pay attention to the trapException = true, so the error doesn't go back to the flow. Only to that failureChannel for your DB logic.

You can configure request-level timeout in WebClient.

Scatter gather would be a better approach to pick, you may put delete operation in one node and wrap it up in async scope and as you mentioned other route will read the file contents. This will be much more efficient in comparison to Wiretrap in terms of threads consumption.

And yes, saving content to a variable is not advisable and as you are using mule4, streams are repeatable now i.e you can read a stream more than once. So you can directly access payload in scatter gather.

but this is bad

I don't know what your NPE generates (technically), but the SpanHandler injection and the Brave wrapper are weird, considering the Tracing is from Brave. Then the most likely thing is that in those two lines you are not injecting the necessary dependencies for the creation of Spans well.

I'm not sure what is the question. The logic is definitely whatever we would expect from this advice:

You are not allowed to manually bind anything to the default exchange.

See the management UI - there is no "bind" option.

Nor can you bind the default exchange to another.

You need to publish to the fanout and bind the reply queue to it.