[EXPORTER] Cancel instead of finish the ES session on export timeout

FinishSession() waits for the in-flight transfer to complete, which
defeats the purpose of the response deadline for HTTP clients (e.g.
curl) whose worker thread blocks on the transfer itself. Cancel the
session instead when the deadline expires.

Addresses review feedback from open-telemetry#4530 (review)

Author: om7057

exporters/elasticsearch/test/es_log_record_exporter_test.cc

@@ -140,8 +140,19 @@ class SilentSession final : public http_client::Session
   void SendRequest(std::shared_ptr<http_client::EventHandler>) noexcept override {}
 
   bool IsSessionActive() noexcept override { return true; }
-  bool CancelSession() noexcept override { return true; }
-  bool FinishSession() noexcept override { return true; }
+  bool CancelSession() noexcept override
+  {
+    cancel_called_ = true;
+    return true;
+  }
+  bool FinishSession() noexcept override
+  {
+    finish_called_ = true;
+    return true;
+  }
+
+  bool cancel_called_ = false;
+  bool finish_called_ = false;
 };
 
 class SilentHttpClient final : public http_client::HttpClient
@@ -150,12 +161,15 @@ class SilentHttpClient final : public http_client::HttpClient
   std::shared_ptr<http_client::Session> CreateSession(
       opentelemetry::nostd::string_view) noexcept override
   {
-    return std::make_shared<SilentSession>();
+    session_ = std::make_shared<SilentSession>();
+    return session_;
   }
 
   bool CancelAllSessions() noexcept override { return true; }
   bool FinishAllSessions() noexcept override { return true; }
   void SetMaxSessionsPerConnection(std::size_t) noexcept override {}
+
+  std::shared_ptr<SilentSession> session_;
 };
 #endif  // !ENABLE_ASYNC_EXPORT
 
@@ -220,6 +234,29 @@ TEST(ElasticsearchLogsExporterTests, ExportReturnsOnTimeoutWhenClientNeverRespon
 
   EXPECT_EQ(result, opentelemetry::sdk::common::ExportResult::kFailure);
 }
+
+// Regression test: on a timed-out export, Export() used to call session->FinishSession()
+// regardless of the outcome. A real HTTP client (e.g. curl) blocks its FinishSession() on
+// the in-flight transfer completing, which is exactly the hang the deadline exists to avoid,
+// so the timeout path must cancel the session instead of finishing it.
+TEST(ElasticsearchLogsExporterTests, ExportCancelsSessionOnTimeoutInsteadOfFinishing)
+{
+  logs_exporter::ElasticsearchExporterOptions options("localhost", 9200, "logs",
+                                                      /*response_timeout=*/1);
+  auto http_client = std::make_shared<SilentHttpClient>();
+  auto exporter    = std::unique_ptr<sdklogs::LogRecordExporter>(
+      new logs_exporter::ElasticsearchLogRecordExporter(options, http_client));
+
+  auto record = exporter->MakeRecordable();
+  record->SetBody("this export should cancel its session, not finish it");
+
+  auto result = exporter->Export(nostd::span<std::unique_ptr<sdklogs::Recordable>>(&record, 1));
+
+  ASSERT_EQ(result, opentelemetry::sdk::common::ExportResult::kFailure);
+  ASSERT_NE(http_client->session_, nullptr);
+  EXPECT_TRUE(http_client->session_->cancel_called_);
+  EXPECT_FALSE(http_client->session_->finish_called_);
+}
 #endif  // !ENABLE_ASYNC_EXPORT
 
 // Attempt to write a log to an invalid host/port, test that the Export() returns failure