Skip to main content

Service Bus Topic - Messages processing problems

In the last post about Service Bus Topics we discover how we can write code in such a way that migration from Service Bus Queues from Service Bus Topics can be done only changing the configuration file. Today I want to talk a little about what we should be aware where we process messages from topics using Peek and Lock pattern.
As we have already seen, Service Bus Topics allows us to process messages in two ways:
Receive and Delete – when messages are automatically removed after there are received
Peek and Lock – when messages are removed from the topic only after subscription call the Complete() method
We will talk about the last one. When we are using the Peel and Lock pattern, each message after is received from Service Bus is automatically locked and cannot be consumed by other client from the same subscription. If the client is able to process the message with success, he can call the Complete() method. In that moment the message is automatically removed from Service Bus. Is something happen with the message processing, for example an error occurred, the client can call the Abandon() message. In that moment the message is available once again for the given subscription. In the same time, after a message is send to a client of the given subscription, each client have a specific time when he can call Complete() or Abandon method(). If this method is not called, the message will be available one again for the given subscription. The default value is 60 seconds, but can be configured to any value.
In the next example we will try to process a message from the subscription. If an error occurred, in the catch block we will call the Abandon() method:
BrokeredMessage message = topicClient.Receive();
try
{
// process message
message.Complete();
} catch(Exception ex)
{
// log error
message.Abandon();
}
We would saw that the solution is okay and we covered this specials case. We have only on half of the solution. In a case of an error we abandon the message, this is great but what happens next? The message will be unlocked and we will be able to process it again.
We should take care about two other things. The first one is what we are doing when we process a message. For example if we insert some information to database or call another service. In these cases we should have a transactional call. We should be able when calling the Abandon() message to rollback all things that we done.
To be able to make the rollback you can image very complicate scenarios ad there will be cases when an external service will not permit a rollback (for ex. if you call an external service). One simple solution involves the MessageId of each message. This id never changes, even if we call the abandon message for 100 times. Because of this we can store the MessageId in a list and check the id before processing it. In this way we will be able to know if we process the message already. We can image a situation when we have some steps for each message. We can store the step in this list. In this way we will not make some calls to different resources more than one. This type of processing is called “At least once processing”.
The other thing that we need to care about is about the messages that cannot be processed and will throw an error each time. For these cases, BrokeredMessage has a property that tells us how many times the client tried to processes the message. The name of the property is DeliveryCount. I gave a solution in another post for Service Bus Queues. The solution is the same for Service Bus Topics also. http://vunvulearadu.blogspot.hu/2012/08/service-bus-queues-from-windows-azure_1953.html
    BrokeredMessage message = topicClient.Receive();
if(message == null)
{
Thread.Sleep(1000);
continue;
}

try
{
// process our message.
message.Complete()
}
catch(Exception ex)
{
if( message.DeliveryCount > 3 )
{
message.DeadLetter();
}
message.Abandon();
}
In this post we saw what we should handle some specials case situations when working we are receiving and processing message from Service Bus Topics. We should not ignore these cases because we can create duplicate data in our storage system or to process the same messages over and over again.

Comments

Popular posts from this blog

Windows Docker Containers can make WIN32 API calls, use COM and ASP.NET WebForms

After the last post , I received two interesting questions related to Docker and Windows. People were interested if we do Win32 API calls from a Docker container and if there is support for COM. WIN32 Support To test calls to WIN32 API, let’s try to populate SYSTEM_INFO class. [StructLayout(LayoutKind.Sequential)] public struct SYSTEM_INFO { public uint dwOemId; public uint dwPageSize; public uint lpMinimumApplicationAddress; public uint lpMaximumApplicationAddress; public uint dwActiveProcessorMask; public uint dwNumberOfProcessors; public uint dwProcessorType; public uint dwAllocationGranularity; public uint dwProcessorLevel; public uint dwProcessorRevision; } ... [DllImport("kernel32")] static extern void GetSystemInfo(ref SYSTEM_INFO pSI); ... SYSTEM_INFO pSI = new SYSTEM_INFO(

ADO.NET provider with invariant name 'System.Data.SqlClient' could not be loaded

Today blog post will be started with the following error when running DB tests on the CI machine: threw exception: System.InvalidOperationException: The Entity Framework provider type 'System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer' registered in the application config file for the ADO.NET provider with invariant name 'System.Data.SqlClient' could not be loaded. Make sure that the assembly-qualified name is used and that the assembly is available to the running application. See http://go.microsoft.com/fwlink/?LinkId=260882 for more information. at System.Data.Entity.Infrastructure.DependencyResolution.ProviderServicesFactory.GetInstance(String providerTypeName, String providerInvariantName) This error happened only on the Continuous Integration machine. On the devs machines, everything has fine. The classic problem – on my machine it’s working. The CI has the following configuration: TeamCity .NET 4.51 EF 6.0.2 VS2013 It see

Navigating Cloud Strategy after Azure Central US Region Outage

 Looking back, July 19, 2024, was challenging for customers using Microsoft Azure or Windows machines. Two major outages affected customers using CrowdStrike Falcon or Microsoft Azure computation resources in the Central US. These two outages affected many people and put many businesses on pause for a few hours or even days. The overlap of these two issues was a nightmare for travellers. In addition to blue screens in the airport terminals, they could not get additional information from the airport website, airline personnel, or the support line because they were affected by the outage in the Central US region or the CrowdStrike outage.   But what happened in reality? A faulty CrowdStrike update affected Windows computers globally, from airports and healthcare to small businesses, affecting over 8.5m computers. Even if the Falson Sensor software defect was identified and a fix deployed shortly after, the recovery took longer. In parallel with CrowdStrike, Microsoft provided a too