SQS Timeouts not firing when using async ReceiveMessageAsync

[jakejscott]

Timeout exceptions are not being thrown when I configure the SQS client with a 10 second timeout, and a long polling time of 20 seconds. Here is the sample code:

using System;
using System.Net;
using System.Threading.Tasks;
using Amazon;
using Amazon.Runtime;
using Amazon.SQS;
using Amazon.SQS.Model;

namespace ConsoleApp1
{
    public class Program
    {
        static void Main(string[] args)
        {
            TaskScheduler.UnobservedTaskException += (sender, eventArgs) =>
            {
                Console.Error.WriteLine("UnobservedTaskException event");
            };

            try
            {
                Task.Run(async () =>
                {
                    var accessKey = Environment.GetEnvironmentVariable("MY_AWS_ACCESSKEY");
                    var secretKey = Environment.GetEnvironmentVariable("MY_AWS_SECRETKEY");
                    var queueUrl = Environment.GetEnvironmentVariable("MY_QUEUEURL");

                    var credentials = new BasicAWSCredentials(accessKey, secretKey);

                    AWSConfigs.LoggingConfig.LogMetrics = true;
                    AWSConfigs.LoggingConfig.LogResponses = ResponseLoggingOption.Always;
                    AWSConfigs.LoggingConfig.LogTo = LoggingOptions.Console;
                    AWSConfigs.LoggingConfig.LogMetricsFormat = LogMetricsFormatOption.Standard;

                    var clientConfig = new AmazonSQSConfig
                    {
                        RegionEndpoint = RegionEndpoint.APSoutheast2,
                        Timeout = TimeSpan.FromSeconds(10),                 // Default value is 100 seconds
                        ReadWriteTimeout = TimeSpan.FromSeconds(30),        // Default value is 300 seconds
                        MaxErrorRetry = 0,                                  // Default value is 4 retries
                        ThrottleRetries = false                             // Default value is true
                    };

                    IAmazonSQS sqs = new AmazonSQSClient(credentials, clientConfig);

                    var request = new ReceiveMessageRequest
                    {
                        QueueUrl = queueUrl,
                        MaxNumberOfMessages = 1,
                        WaitTimeSeconds = 20,
                    };

                    Console.WriteLine("Polling SQS...");
                    ReceiveMessageResponse response = await sqs.ReceiveMessageAsync(request);

                    if (response.HttpStatusCode == HttpStatusCode.OK)
                    {
                        Console.WriteLine("Response OK");
                    }
                    else
                    {
                        Console.WriteLine("Response Failed");
                    }
                })
                .GetAwaiter().GetResult();

                
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }

            Console.WriteLine("Done");
            Console.ReadLine();
        }
    }
}

[jakejscott]

How this came about: I was testing long polling and disconnecting myself from the internet... and something bad happened.....no timeouts. I would have expected the code to throw after some amount of time but it doesn't. It just sits there forever if I don't reconnect to the internet. When I use the normal sync APIs timeouts are thrown as you would expect.

[jakejscott]

I'm using the following version of the librarys

<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="AWSSDK.Core" version="3.3.10.3" targetFramework="net452" />
  <package id="AWSSDK.SQS" version="3.3.1.11" targetFramework="net452" />
</packages>
```
I'm also using .NET Framework 4.5.2

[gokarnm]

You would have to pass a CancellationToken with an appropriate timeout value to the ReceiveMessageAsync method explicitly. On .NET 4.5 we use HttpWebRequest as the underlying HTTP Client, and its Timeout property is only used for synchronous calls. We'll consider having the SDK create a cancellation token instead in future.

    var cts = new CancellationTokenSource();
    cts.CancelAfter(TimeSpan.FromSeconds(10));
    var token = cts.Token;
    ReceiveMessageResponse response = await sqs.ReceiveMessageAsync(request, token);

[jakejscott]

Yeah I came to the same conclusion, and added some code to catch the OperationCanceledException and then compare the exceptions CancellationToken to the source so that you know if was a timeout:

var recieveTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(30));

ReceiveMessageResponse response;
try
{
    var request = new ReceiveMessageRequest
    {
        QueueUrl = queueUrl,
        MaxNumberOfMessages = 1,
        WaitTimeSeconds = 20,
    };
    response = await sqs.ReceiveMessageAsync(request, recieveTimeout.Token);
}
catch (OperationCanceledException opEx)
{
    if (opEx.CancellationToken == recieveTimeout.Token)
    {
        log.Warning("Timeout receiving messages.");
    }
    else
    {
        throw;
    }
}

I think there needs to be some documentation added about using CancellationTokenSource for all async code.

[PavelSafronov]

We've updated the ClientConfig documentation to clarify the applicability of the timeout fields. Thanks for bringing this up. Closing this issue.