Setting Timeouts on HTTP Requests

When making HTTP requests to external services, there's always a chance the server will be slow to respond or unavailable. We don't want our application to hang indefinitely waiting for a response.

The cpr library allows setting timeouts on requests to mitigate this:

1#include <cpr/cpr.h>
2#include <iostream>
3#include <chrono>
4
5int main() {
6  // Request times out after 1 second
7  cpr::Timeout timeout{std::chrono::seconds{1}};
8
9  // A url that will take 2 seconds to respond
10  cpr::Url URL{"http://www.httpbin.org/delay/2"};
11
12  cpr::Response r = cpr::Get(URL, timeout);
13  if (r.error) {
14    std::cout << r.error.message;
15  }
16}

1Operation timed out after 1013 milliseconds with 0 bytes received

Here we create a cpr::Timeout object representing 1 seconds. This is passed to cpr::Get. We can detect timeouts and handle them appropriately, perhaps by retrying the request or showing an error message to the user.

The cpr::Timeout constructor takes any std::chrono::duration, so we can easily specify the timeout in seconds, milliseconds, etc:

1cpr::Timeout t1{std::chrono::seconds{5}};
2cpr::Timeout t2{std::chrono::milliseconds{500}};

We can also set connection and low-speed limits:

1#include <cpr/cpr.h>
2#include <iostream>
3#include <chrono>
4
5int main() {
6  // A url that will take 4 seconds to respond
7  cpr::Url URL{"http://www.httpbin.org/delay/4"};
8
9  // Abort if not connected within 3 seconds
10  cpr::ConnectTimeout ctimeout{
11    std::chrono::seconds{3}};
12
13  // Abort if transfer speed < 1 byte/sec
14  // for 3 seconds
15  cpr::LowSpeed ls{1, 3};
16
17  cpr::Response r = cpr::Get(URL, ctimeout, ls);
18  if (r.error) {
19    std::cout << r.error.message;
20  }
21}

1Operation too slow. Less than 1 bytes/sec transferred the last 3 seconds

cpr::ConnectTimeout limits how long to wait to establish the initial TCP connection.

cpr::LowSpeed aborts if the transfer speed is below a threshold for a given duration. This prevents "stalling" even after the connection is established.

By tweaking these policies we can fine-tune the behavior of our HTTP clients and avoid slowdowns due to unresponsive servers.