Azure Function App Service Bus Topic 在设置一些 PrefetchCount 限制和锁定错误时触发随机错误

Question

Below code I have for one of the Azure Function Service Bus topic trigger, where I am receiving the service bus messages in batch and each message I am putting into one Task.

I have below service bus settings as well,

"serviceBus": {
  "prefetchCount": 0,
  "messageHandlerOptions": {
    "autoComplete": false,
    "maxConcurrentCalls": 32,
    "maxAutoRenewDuration": "00:05:00"
  }
}

Things working as expected, but 2 issues I am seeing randomly,

1. When I am putting prefetchCount = 4 (example) I am getting warning like,

WRN] Prefetch count for receiver with Identifier ingestion-topic/Subscriptions/ingestion-sub-80c010ae-2078-4bdf-b7e2-c51672e668d6 is less than the max messages requested. When using prefetch, it isn't possible to receive more than the prefetch count in any single Receive call: PrefetchCount: 10; MaxMessages: 1000

Question - What this mean? and what's the perfect settings above different settings?

2. Plus randomly I m seeing below error, however messages are not dead-letters, what this error meaning and what could be potential fix here?

function: RunAsync The lock supplied is invalid. Either the lock expired, or the message has already been removed from the queue

3. Can I set PrefetchCount = 0.

Thanks and appreciate

[FunctionName(nameof(RunAsync))]
    public async Task RunAsync([ServiceBusTrigger("%InputTopic%", "%InputSubscription%", Connection = "ServiceBusConnection", AutoCompleteMessages = false)]
    ServiceBusReceivedMessage[] messages, ServiceBusMessageActions messageActions)
    {
        _logger.LogInformation($"Number of orders: {messages.Length}");

        var taskList = new List<Task<Tuple<bool, ServiceBusReceivedMessage>>>();

        foreach (var message in messages)
        {
            try
            {
                var order = message.Body.ToObjectFromJson<Order>();
                //process each messages in parallel with dedicated task
                taskList.Add(Task.Run(() => _messageProcessor.Process(order.ArticleNumber, message)));
                //If the code execution makes it here, then you are good to go
                await messageActions.CompleteMessageAsync(message);
            }
            catch (TimeoutException toex)
            {
                //Wait a couple of seconds
                //Let's assume the retry fails again, so we want abandon it
                //This will put the message back into the queue and increment DeliveryCount by 1
                _logger.LogInformation($"A transient exception happened: {toex.Message}");
                await messageActions.AbandonMessageAsync(message);
            }
            catch (FormatException fex)
            {
                if (message.DeliveryCount > 10)
                {
                    _logger.LogInformation($"Sending message; {message.MessageId} to DLQ");
                    await messageActions.DeadLetterMessageAsync(message, fex.Message + " sending to DLQ");
                }
                else
                {
                    _logger.LogInformation($"An format exception happened: {fex.Message}, DeliveryCount: {message.DeliveryCount}");
                    await messageActions.AbandonMessageAsync(message);
                }
            }
            catch (Exception ex)
            {
                _logger.LogInformation($"An exception happened: {ex.Message}");
                //Comment out this CompleteAsync and the message will get processed when Lock Duration is breached
                await messageActions.CompleteMessageAsync(message);
            }
        }

        //get responses for all the task
        var responses = await Task.WhenAll(taskList);

        //make decision to complete or DeadLetter 
        foreach (var (flag, message) in responses)
        {
            switch (flag)
            {
                case false:
                    _logger.LogError("Error processing message");
                    break;
                default:
                    var order = message.Body.ToObjectFromJson<Order>();
                    _logger.LogInformation($"OrderID: {order.Id}, ArticleNumber: {order.ArticleNumber}, Amount: {order.Amount}, Customer First Name: {order.Customer.FirstName}, Customer Last Name: {order.Customer.LastName}");
                    break;
            }
        }
    }

Answer 1

• you can set PrefetchCount to 0 it is and optional parameter. It is available if you want high speed and want message to be ready after the maximum number of messages are already fetch.

• That is why you are getting the warning because it seems that the number of messages available is less that the max count and you are setting up the prefetch count on top of it.

• Regarding the error try to setup retry policy so that every time something fails the function will try to retry the task again. This is done by setting up a parameter called maximum retry coun t.

Reference:

prefetch azure service bus messages.

Retry policy for function.