Serverless Throttling?

Hi. I have written a method using the guidance at https://learn.microsoft.com/en-us/azure/cosmos-db/nosql/tutorial-dotnet-bulk-import. To shorten the code I have removed most logging. It looks something like this (questions follow):

public async Task<List<SomeObject>> UpdateAll(List<SomeObject> SomeObjectList,
    CancellationToken cancellationToken = default)
{
    int successfulRequests = 0;
    int failedRequests = 0;
    var concurrentTasks = new List<Task>();

    // Patterns for using Task.WhenAll
    // https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task.whenall?view=net-8.0
    // https://learn.microsoft.com/en-us/azure/cosmos-db/nosql/tutorial-dotnet-bulk-import
    if (SomeObjectList != null && SomeObjectList.Count > 0)
    {
        foreach (var item in SomeObjectList)
        {
            var updatedSomeObject = _mapper.Map<SomeObjectDocument>(item);
            concurrentTasks.Add(_container
                .ReplaceItemAsync<SomeObjectDocument>(updatedSomeObject,
                updatedSomeObject.Id, new PartitionKey(updatedSomeObject.Id),
                options, cancellationToken)
                    .ContinueWith(itemResponse =>
                    {
                        if (!itemResponse.IsCompletedSuccessfully)
                        {
                            AggregateException innerExceptions = itemResponse.Exception.Flatten();
                            if (innerExceptions.InnerExceptions.FirstOrDefault(innerEx => innerEx is CosmosException)
                                is CosmosException cosmosException)
                            {
                                Interlocked.Increment(ref failedRequests);
                                _logger.LogError(cosmosException, "SomeObjectRepository:UpdateAll - CosmosException while updating" +
                                    " object with id: '{id}', error details: {error}", updatedSomeObject.Id, cosmosException.ToString());
                                Console.WriteLine($"SomeObjectRepository:UpdateAll - CosmosException while updating" +
                                    $" object with id: '{updatedSomeObject.Id}', error details: {cosmosException.ToString()}");
                            }
                            else
                            {
                                Interlocked.Increment(ref failedRequests);
                                _logger.LogError(innerExceptions, "SomeObjectRepository:UpdateAll - Unexpected exception while updating" +
                                    " object with id: '{id}', error details: {error}", updatedSomeObject.Id, innerExceptions.ToString());
                                Console.WriteLine($"SomeObjectRepository:UpdateAll - CosmosException while updating" +
                                    $" object with id: '{updatedSomeObject.Id}', error details: {innerExceptions.ToString()}");
                            }
                        }
                        else
                        {
                            Interlocked.Increment(ref successfulRequests);
                        }
                    }, cancellationToken, TaskContinuationOptions.None, TaskScheduler.Default));
        }

        Task completedTask = Task.WhenAll(concurrentTasks);

        try
        {
            await completedTask;
        }
        catch (Exception ex)
        {
            // All error messages are logged in the ContinueWith.
            // Log a warning here so we aren't eating the exception.
            loging...
        }

        if (completedTask.Status == TaskStatus.Faulted)
        {
            logging...
        }
    }

    return SomeObjectList;
}

Additional Notes:

• Cosmos DB is serverless.
• This class runs in an isolated process Azure Function using .NET8.
• The code works when updating a smaller number of documents, but throws 429 exceptions on large updates. This is likely expected since Cosmos DB is serverless and supports 5,000 RU/sec.
• I have tried throttling requests by using SemaphoreSlim, ConcurrentExclusiveSchedulerPair limited to one concurrent process, and others.

Questions:

• _logger is private class property created by an injected ILoggerFactory. The logging statements in the ContinueWith do not appear in AppInsights. The Console.WriteLine statements do appear. Should the logger work in a ContinueWith?
• Should I be using something other than TaskContinueOptions.None?
• I could not find a Cosmos DB RU rate limiter, did I miss something?
• The documentation states that 429 errors have automatic retry and will often complete. How do I trap what eventually completed and what did not?
• Code like this is used in many repositories. Do I have to write custom code to determine the average RU/write depending on the repository, then send tasks in batches that will not exceed 5,000 RU/sec?

Thanks!

Mike