libcurl C++: long delay in response from server - c++

Question

I have a libcurl program running on Ubuntu 20.04.1 LTS that downloads a webpage's data when it detects that the webpage's HTTPS status code changes from 503 to 200. When the code changes, it means the site owners have uploaded new info to the page.
I used to be able to detect the change from 503 to 200 in around 150-200 milliseconds consistently for months.
Since around mid-July 2021 however (and without changing the libcurl program's code whatsoever), when the site changes from 503 to 200 I do not get a response for anywhere between 7 to 18 seconds to tell me the code has changed.
Note: I have spoken to other users who have confirmed that they are still recieving the updated data in sub 200 milliseconds, as well as the site owners who described everything as working as normally.
Current output/ attempts to solve:
Uninstalled and reinstalled libcurl with sudo apt-get install libcurl4-openssl-dev
I decided to use Wireshark, the output of which can be seen here [use code 173967 if required/ happy to do so]. The scheduled change of the status code is usually at/after 1633012200. The libcurl sending IP is seen as 192.168.0.29 and the destination is 13.224.247.34, but I cannot ascertain if the information is indeed being delivered on time and my application is causing the bottleneck, or if there is a genuine network issue.
Employed debugging print statements. One statement prints "sent" when the response code request is sent, and the other prints "received" with the returned response code and an EPOCH timestamp.
On the countdown to the website's scheduled change from 503 to 200, in the terminal I see the expected output of sent -> received -> EPOCH timestamp. When the website's scheduled change from 503 to 200 occurs, all I see in the terminal is sent, followed by a 7 to 18 second delay before an output of received 200 -> timestamp.
Tested the same code with the same URL on three separate servers with different IP addresses but with the same OS, which all produced the same delayed result although some slightly less slow than others.
An example of print statement output:
/*
listening...
sent
response
503
1632925797111
sent
response
503
1632925797227
sent
response
503
1632925797336
sent
<---- Program hangs here for approx. 7-18 seconds before printing 200 and timestamp*/
Current code:
#include <iomanip>
#include <vector>
#include <iostream>
#include <string>
#include <chrono>
#include <future>
#include <algorithm>
#include <cstring>
#include <curl/curl.h>
// Function for writing callback
size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
std::vector<char> *response = reinterpret_cast<std::vector<char> *>(userdata);
response->insert(response->end(), ptr, ptr+nmemb);
return nmemb;
}
// Handle requests to URL
long request(CURL *curl, const std::string &url) {
std::vector<char> response;
long response_code;
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "");
curl_easy_setopt(curl, CURLOPT_COOKIE, "");
auto res = curl_easy_perform(curl);
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
if (response_code == 200) {
// do something
}
return response_code;
}
int main() {
curl_global_init(CURL_GLOBAL_ALL);
CURL *curl = curl_easy_init();
std::string value1;
std::cout << std::endl << "Press 1 to start listening..." << std::endl;
std::cin >> value1;
if (value1 == "1") {
std::cout << std::endl << "listening..." << std::endl;
while (true) {
std::cout << "sent" << std::endl;
long response_code = request(curl, "https://someurl.xyz");
std::cout << "response" << std::endl;
if (response_code == 200) {
std::int64_t epoch_2 = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
std::cout << "code 200 detected at : " << epoch_2 << std::endl;
break; // Page updated
}
else {
std::cout << response_code << std::endl;
std::int64_t epoch_3 = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
std::cout << epoch_3 << std::endl;
}
}
}
curl_easy_cleanup(curl);
curl_global_cleanup();
return 0;
}
Summary question:
Q1. Given that other users are not experiencing this and I have ran this same test on different servers with different IP addresses, does anyone know what could be causing the delay of my program detecting the status code change? As previously stated, this program worked as expected with little to no delay before July 2021.
This issue has been ongoing for over three months. If anyone has any ideas, or could possibly point me in a direction to diagnose this, I would be highly appreciative.