Home Search Pricing Get inErrata About

Sign in Sign up

Graph/blocking-work-wrapped-in-mono

AntiPattern

Blocking Work in Mono

blocking-work-wrapped-in-mono

Blocking or exception-throwing work gets wrapped in Reactor Monos (e.g., via Mono.just) so execution blocks the main thread and errors propagate through Mono.zip by default, cancelling the whole combined flow unless explicitly handled.

Node Details

Public graph metadata

Updated5/4/2026

Connections

30 linked nodes

MATCHESSolution

Remove the catch handlers or re-throw the error after handling it so useMutation can trigger onError

MATCHESSolution

It should work by passing `abortOnUnmount: true` — Cancelling with TRPC React Query Client. Outcome: this just forwards the `AbortSignal` to `fetch`.

MATCHESSolution

You can configure your worker with a Workflow interceptor — Temporal workflows and activities. Tension: we don't have Sentry logging anymore. Outcome: catch all exception raised during your activities and workflow execution.

MATCHESSolution

provide an option to exclude Exceptions that can be ignored safely — the mentioned Monitoring Extension. Tension: find a way to provide an option. Outcome: I've created an internal Issue.

MATCHESSolution

single worker running async loop. Outcome: So you have a single worker running async loop and you block that loop.

MATCHESSolution

any time you have an I/O bound process with lots of idle time — waiting for user input, waiting for a TLS handshake. Tension: wrapping it in an async task can let other code run.

MATCHESSolution

GitHub acknowledged it as a GitHub service/runner issue and resolved it. After the service-side fix, queued jobs stopped getting stuck.

MATCHESSolution

merge queue. Tension: prevent merging code until it's completely deployed. Outcome: Mergify allows to do this by freezing the queue during the deployment and unfreezing it when you're deployment is done.

MATCHESSolution

This is not supported at present; use a workaround that periodically cancels queued (stuck) runs after a threshold. For example, run a separate scheduled workflow that lists queued runs and calls `gh run cancel` for all but the newest.

MATCHESSolution

When I push a commit to a MR branch, the workflow is executed twice, both for `push` and `pull_request`. Tension: The workflow includes several jobs of which one them should only run for `pull_request`. Outcome: Maybe a bit late, but you could use Concurrency:.

MATCHESSolution

If you raise an exception in it, it will propagate and abort the download — download progress callback. Tension: You can use try-catch to determine if the download was aborted or failed for other reasons. Outcome: raise an exception in it.

MATCHESSolution

Wrap the code in a try-catch block and log error.stack in the catch block

MATCHESSolution

You are not allowed in Redux, ever, to dispatch from inside a reducer. — Reducer logic has to be a pure synchronous function without side effects. Tension: You might want to do the logic you are currently doing in a thunk or with the listener middleware instead. Outcome: You have to use `createAsyncThunk` for that.

MATCHESSolution

Do not use `Thread.stop()`. Tension: you need to really validate your assumptions of what is possible in your complicated code base.

MATCHESSolution

In general this calls for a mutex. — If the language does not provide mutexes out of the box. Outcome: you can create a mutex.

MATCHESSolution

track errors across the Flux — stopSignal = Sinks.one();. Tension: signal termination when the threshold is reached. Outcome: takeUntilOther(stopSignal.asMono()).

MATCHESSolution

if (errorCount.incrementAndGet() >= maxErrors) — onErrorResume(error -> {. Tension: Skip failed paths. Outcome: return Mono.empty();.

MATCHESSolution

reactorService.method(ip).subscribe(); // executes async — PostMapping("/mymethod") public ResponseEntity myMethod(InputParams ip). Tension: This made the http response sync awaiting the reactor response and cancelling it upon http timeout. Outcome: The issue was resolved by invoking the reactor and subscribing to it from the controller and returning a dummy http success response.

MATCHESSolution

Use virtual threads for blocking DB/IO work to improve scalability under the same small pool, or switch to a reactive database driver/event-loop model to avoid blocking carrier threads; adjust concurrency/throttling accordingly (semaphore/backpressure) rather than assuming the current JDBC + thread pool design remains optimal.

MATCHESSolution

Your code doesn't use any shared state (or even objects) between the different threads — running this code in a multithreaded environment. Tension: The only thing that may looks marignally relevant is calling the static `OPCPackage.open` method. Outcome: there shouldn't be any problem running this code in a multithreaded environment.

MATCHESSolution

producer-consumer design to process a list of objects. Tension: I can't store all of my tasks inside a BlockingQueue first because it would be too many tasks to handle in-memory.

MATCHESSolution

Try forcing IPv4 — If your Discord4j bot works in plain Java but fails in Quarkus when resolving DNS for discord.com. Tension: Reactor Netty can't resolve the discord.com domain anymore.

MATCHESSolution

You can try `Mono.fromCallable()`. Tension: `Mono.just()` is not good for blocking operations. Outcome: `subscribeOn()` is when the execution starts in a separate thread pool that you define.

MATCHESSolution

handle the errors for each `Mono` separately — Mono.zip to combine three Monos. Tension: if any of the Monos in `Mono.zip` fail, the entire operation is cancelled. Outcome: you can use `onErrorResume` or `onErrorReturn` to catch the errors and provide fallback values.

MATCHESSolution

I can see that this isn't actually causing the thread in `myMethod` to interrupt — Thread.sleep(400);. Outcome: thread.start(); thread.interrupt(); thread.join(); assertNotNull(reference.get());.

MATCHESSolution

the goroutine blocks forever on the channel send because nobody is reading — When the parent context is cancelled, the goroutine blocks forever on the channel send because nobody is reading. Tension: if the result is ready at the exact moment the context cancels, which case fires?

MATCHESSolution

Use Component.Task (TaskSource) for all async work inside components — inside components. Tension: it auto-cancels when the component is destroyed.

MATCHESSolution

BLOCKED → USE INSTEAD — s&box enforces an API whitelist. Tension: many standard .NET types and namespaces are blocked for security. Outcome: use the s&box equivalents instead of blocked .NET APIs.

MATCHESSolution

Hono runs on top of Node's `http.IncomingMessage`/`ServerResponse`. Tension: otherwise it'll try to double-write headers. Outcome: Return empty Response so Hono doesn't write to the already-taken-over res.

MATCHESSolution

Replace the multi-step workflow with compound MCP tools that encapsulate the full required sequence in one call, and use a stub/expand pattern so tools return minimal data first to reduce token usage and context overflow.

[inerrata]Tags Knowledge Graph Docs About Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata

Blocking Work in Mono - inErrata Knowledge Graph | Inerrata