[CHORE] Hold the status helper to its own precondition, and take the log level with the handler

Three small ones.

IsAcknowledgedStatus() is noexcept and reached straight for get(), leaving the type check
to whoever called it. The one caller does check, so nothing is wrong today, but the two
ways a later one could get it wrong are not symmetrical: a string throws, and out of a
noexcept function that is std::terminate rather than a wrong answer, while a float does
not throw at all, it truncates, so 200.5 would have answered for 200. The check is now
where the assumption is.

The asynchronous cases saved and restored the log handler but not the log level. The
level is process wide, another case in the same binary can lower it, and a failure the
runtime filtered out looks exactly like one the parser never reported, so they would have
stopped discriminating without saying so. This is not hypothetical in this file: the
debug case added earlier passed for that reason until the level went in beside the
handler.

The header now says what it does not do. A repeated key is folded before the document
reaches this, so a body carrying both "errors": true and "errors": false arrives as
whichever one the parser kept, and nothing here can tell the other was sent. Deciding an
outcome from the documented fields is what this is for; standing up to a responder that
is trying to be believed is not.

Signed-off-by: thc1006 <84045975+thc1006@users.noreply.github.com>

Author: thc1006

exporters/elasticsearch/include/opentelemetry/exporters/elasticsearch/detail/es_bulk_response.h

@@ -47,9 +47,21 @@ inline bool IsAppliedStatus(nlohmann::json::number_integer_t value) noexcept
   return 200 == value || 201 == value;
 }
 
-/** Whether an acknowledged operation status is one that applied the operation. */
+/**
+ * Whether an acknowledged operation status is one that applied the operation.
+ *
+ * The type check is here rather than left to the caller, although the one caller does it too.
+ * This is noexcept, and get() on a value that is not a number throws, so a caller that forgot
+ * would not get a wrong answer, it would get std::terminate. A float does not throw: it
+ * truncates, so 200.5 would answer for 200.
+ */
 inline bool IsAcknowledgedStatus(const nlohmann::json &status) noexcept
 {
+  if (!status.is_number_integer())
+  {
+    return false;
+  }
+
   if (status.is_number_unsigned())
   {
     return IsAppliedStatus(status.get<nlohmann::json::number_unsigned_t>());
@@ -64,6 +76,11 @@ inline bool IsAcknowledgedStatus(const nlohmann::json &status) noexcept
  * Callers include noexcept response handlers, so nothing may escape. Anything that stops the body
  * being inspected counts as a failed export.
  *
+ * This reads the fields the bulk response documents to decide an outcome. It is not a check
+ * against a responder that is trying to be believed: a repeated key, for one, is folded before
+ * this sees the document, so a body carrying both "errors": true and "errors": false arrives as
+ * whichever one the parser kept, and nothing here can tell that the other was ever sent.
+ *
  * @param status_code the response status, which the caller passes rather than this reading the
  *        body alone: "errors" describes item outcomes and cannot override a transport error
  * @param body the raw response body

exporters/elasticsearch/test/es_log_record_exporter_test.cc

@@ -668,13 +668,25 @@ class ElasticsearchLogsExporterAsyncTests : public ::testing::Test
     handler_          = nostd::shared_ptr<opentelemetry::sdk::common::internal_log::LogHandler>(
         new CapturingLogHandler());
     opentelemetry::sdk::common::internal_log::GlobalLogHandler::SetLogHandler(handler_);
+
+    // The level as well as the handler. It is process wide and another case in this binary can
+    // lower it, and a failure filtered out at runtime looks exactly like one the parser never
+    // reported, so these cases would stop discriminating without saying so.
+    previous_level_ = opentelemetry::sdk::common::internal_log::GlobalLogHandler::GetLogLevel();
+    opentelemetry::sdk::common::internal_log::GlobalLogHandler::SetLogLevel(
+        opentelemetry::sdk::common::internal_log::LogLevel::Error);
+    restore_level_ = true;
 #endif
   }
 
   void TearDown() override
   {
     // Put back what was found, rather than a fresh default that would displace a handler another
     // case in this binary had installed.
+    if (restore_level_)
+    {
+      opentelemetry::sdk::common::internal_log::GlobalLogHandler::SetLogLevel(previous_level_);
+    }
     if (handler_)
     {
       opentelemetry::sdk::common::internal_log::GlobalLogHandler::SetLogHandler(previous_handler_);
@@ -697,6 +709,9 @@ class ElasticsearchLogsExporterAsyncTests : public ::testing::Test
 
   nostd::shared_ptr<opentelemetry::sdk::common::internal_log::LogHandler> handler_;
   nostd::shared_ptr<opentelemetry::sdk::common::internal_log::LogHandler> previous_handler_;
+  opentelemetry::sdk::common::internal_log::LogLevel previous_level_ =
+      opentelemetry::sdk::common::internal_log::LogLevel::Warning;
+  bool restore_level_ = false;
 };
 
 class ElasticsearchLogsExporterDebugLoggingTests : public ::testing::Test