Merge branch 'main' into fix/4625-narrow-ext-headers

Author: ParthibanRajasekaran

.bazelversion

@@ -1 +1 @@
-8.8.0
+8.8.1

.github/workflows/codeql-analysis.yml

@@ -57,7 +57,7 @@ jobs:
       run: |
         sudo -E ./ci/install_thirdparty.sh --install-dir /usr/local --tags-file third_party_release --packages "ryml"
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+      uses: github/codeql-action/init@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
       with:
         languages: cpp
         config: |
@@ -72,4 +72,4 @@ jobs:
               "${GITHUB_WORKSPACE}"
         cmake --build . --parallel
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+      uses: github/codeql-action/analyze@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2

CHANGELOG.md

@@ -92,6 +92,12 @@ Increment the:
 
 * [BUG] Do not queue a curl session closed by the Retry-After cap
   [#4632](https://github.com/open-telemetry/opentelemetry-cpp/pull/4632)
+* [BUG] Fix a data race on the curl operation's last result code
+  [#4618](https://github.com/open-telemetry/opentelemetry-cpp/pull/4618)
+
+* [BUG] Do not busy-spin the curl background thread while a retry is queued
+  at shutdown
+  [#4637](https://github.com/open-telemetry/opentelemetry-cpp/pull/4637)
 
 ## [1.29.0] 2026-09-13
 

api/include/opentelemetry/common/spin_lock_mutex.h

@@ -35,15 +35,7 @@ constexpr int SPINLOCK_SLEEP_MS        = 1;
  * 2. A loop where the current thread yields control after checking the lock.
  * 3. Issuing a thread-sleep call before starting back in phase 1.
  *
- * This is meant to give a good balance of perofrmance and CPU consumption in
- * practice.
- *
- * This mutex uses an incremental back-off strategy with the following phases:
- * 1. A tight spin-lock loop (pending: using hardware PAUSE/YIELD instructions)
- * 2. A loop where the current thread yields control after checking the lock.
- * 3. Issuing a thread-sleep call before starting back in phase 1.
- *
- * This is meant to give a good balance of perofrmance and CPU consumption in
+ * This is meant to give a good balance of performance and CPU consumption in
  * practice.
  *
  * This class implements the `BasicLockable` specification:
@@ -119,7 +111,7 @@ class SpinLockMutex
       {
         return;
       }
-      // Sleep and then start the whole process again. (goal ~1000ns)
+      // Sleep and then start the whole process again. (goal ~1ms)
       std::this_thread::sleep_for(std::chrono::milliseconds(SPINLOCK_SLEEP_MS));
     }
     return;

ext/src/http/client/curl/http_client_curl.cc

@@ -635,6 +635,8 @@ bool HttpClient::MaybeSpawnBackgroundThread()
             if (self->doRetrySessions(true))
             {
               still_running = 1;
+              // With wait_for zero, as during shutdown, poll here until a queued retry is due.
+              need_wait_more = true;
             }
 
             // If there is no pending jobs, we can stop the background thread.

ext/src/http/client/curl/http_operation_curl.cc

@@ -508,8 +508,8 @@ HttpOperation::~HttpOperation()
       {
         if (HttpOperationAccessor::GetThreadId(*async_data_) != std::this_thread::get_id())
         {
-          async_data_->result_future.wait();
-          last_curl_result_ = async_data_->result_future.get();
+          // PerformCurlMessage() stores this, then calls the Cleanup() that sets the promise.
+          static_cast<void>(async_data_->result_future.get());
         }
       }
       break;
@@ -533,8 +533,8 @@ void HttpOperation::Finish()
     // We should not wait in callback from Cleanup()
     if (HttpOperationAccessor::GetThreadId(*async_data_) != std::this_thread::get_id())
     {
-      async_data_->result_future.wait();
-      last_curl_result_ = async_data_->result_future.get();
+      // PerformCurlMessage() stores this, then calls the Cleanup() that sets the promise.
+      static_cast<void>(async_data_->result_future.get());
     }
   }
 }

ext/test/http/curl_http_test.cc

@@ -6,7 +6,13 @@
 #include "gtest/gtest.h"
 
 #ifdef ENABLE_OTLP_RETRY_PREVIEW
+#  include <ratio>
 #  include "gmock/gmock.h"
+#  ifdef _WIN32
+#    include <windows.h>
+#  else
+#    include <ctime>
+#  endif
 #endif  // ENABLE_OTLP_RETRY_PREVIEW
 
 #ifdef ENABLE_OTLP_COMPRESSION_PREVIEW
@@ -770,6 +776,64 @@ TEST_F(BasicCurlHttpTests, RetryAfterBeyondMaxBackoffDoesNotDelayShutdown)
                                return received.uri == "/retry-after/";
                              }));
 }
+
+// CPU time of the whole process. std::clock() measures wall time on Windows.
+std::chrono::microseconds ProcessCpuTime()
+{
+#  ifdef _WIN32
+  FILETIME created{}, exited{}, kernel{}, user{};
+  GetProcessTimes(GetCurrentProcess(), &created, &exited, &kernel, &user);
+  // FILETIME counts 100 ns ticks.
+  const auto ticks = [](const FILETIME &time) {
+    return (static_cast<std::uint64_t>(time.dwHighDateTime) << 32) | time.dwLowDateTime;
+  };
+  return std::chrono::microseconds{static_cast<std::int64_t>((ticks(kernel) + ticks(user)) / 10)};
+#  else
+  return std::chrono::microseconds{
+      static_cast<std::int64_t>(static_cast<double>(std::clock()) * 1000000 / CLOCKS_PER_SEC)};
+#  endif
+}
+
+// During shutdown the IO loop used to skip its poll while a retry waited out its backoff.
+TEST_F(BasicCurlHttpTests, ShutdownDoesNotSpinWhileARetryIsQueued)
+{
+  received_requests_.clear();
+  curl::HttpClient http_client;
+  // Three waits: the first can still sleep on a poll the loop asked for before the join.
+  const http_client::RetryPolicy retry_policy = {4, std::chrono::duration<float>{0.25f},
+                                                 std::chrono::duration<float>{5.0f}, 2.0f};
+
+  auto session = http_client.CreateSession("http://127.0.0.1:19000");
+  auto request = session->CreateRequest();
+  request->SetMethod(http_client::Method::Post);
+  request->SetUri("retry/");
+  request->SetRetryPolicy(retry_policy);
+  auto handler = std::make_shared<RetryEventHandler>();
+  session->SendRequest(handler);
+  ASSERT_TRUE(waitForRequests(30, 1));
+
+  const auto cpu_before = ProcessCpuTime();
+  const auto started_at = std::chrono::steady_clock::now();
+  http_client.WaitBackgroundThreadExit();
+  const auto joined_in = std::chrono::steady_clock::now() - started_at;
+  const auto cpu_used  = ProcessCpuTime() - cpu_before;
+
+  session->FinishSession();
+  ASSERT_TRUE(handler->got_response_.load(std::memory_order_acquire));
+
+  std::unique_lock<std::mutex> lock_requests(mtx_requests);
+  EXPECT_EQ(4, std::count_if(received_requests_.begin(), received_requests_.end(),
+                             [](const HTTP_SERVER_NS::HttpRequest &received) {
+                               return received.uri == "/retry/";
+                             }));
+
+#  ifdef __APPLE__
+  GTEST_SKIP() << "The test server's kqueue reactor spins while a connection is open";
+#  endif
+  EXPECT_TRUE(cpu_used * 2 < joined_in)
+      << "join ms: " << std::chrono::duration_cast<std::chrono::milliseconds>(joined_in).count()
+      << ", CPU ms: " << std::chrono::duration_cast<std::chrono::milliseconds>(cpu_used).count();
+}
 #endif  // ENABLE_OTLP_RETRY_PREVIEW
 
 // A cancel that arrives once the server has answered used to deliver Cancelled and the response,