I'm migrating an in-process Azure Function to the isolated worker model in C# on .NET 10 and Functions v4. The function starts a long-running operation using a fire-and-forget pattern such as `_ = Task.Run(() => FunctionX);` and then immediately returns. I use `ILogger` with configuration in `appsettings.json`. Logging works before the background operation starts, but messages written inside `FunctionX` stop appearing as soon as the main function returns. This did not happen with the in-process model. What is the recommended way to run this work and preserve reliable logging?
3 Answers
Don’t use fire-and-forget work inside an Azure Function. Once the invocation returns, the worker can consider the execution complete, shut down, recycle, or lose the process before the background task finishes. The task can also lose invocation-related services and logging context. Make the function `async` and await the operation instead: `await FunctionX();`. If the work is too long for one invocation, move it to a durable design instead of trying to keep it running in the background.
The isolated worker model isn’t intended to guarantee completion of detached tasks after the trigger method returns. Registering `ILogger` and configuring `appsettings.json` can be correct while logs are still lost because the process ends or the task is interrupted. If you only need parallelism for short operations, start the task and await it with `Task.WhenAll`; don’t use `Task.Run` as a background-job mechanism. For anything that must reliably finish, persist the work and process it through a durable trigger.
For long-running processing, have the initial function place a message on a storage queue, Service Bus queue, or another durable trigger, then let a separate function process that message. Configure retries, poison-message handling, and an appropriate visibility or lock timeout. Durable Functions are another good option when the process has multiple steps, needs checkpoints, or must survive restarts. In both cases, the processing function should await its work so the platform knows whether it completed successfully.
That makes sense. The work can run for a long time, so I’ll look at moving it behind a queue or using Durable Functions rather than returning before it completes.