Merge pull request #108 from open-telemetry/main

merged from upstream

Author: malkia

exporters/elasticsearch/src/es_log_record_exporter.cc

@@ -63,7 +63,7 @@ class ResponseHandler : public http_client::EventHandler
       {
         log_message = BuildResponseLogMessage(response, body_);
 
-        OTEL_INTERNAL_LOG_ERROR("ES Log Exporter] Export failed, " << log_message);
+        OTEL_INTERNAL_LOG_ERROR("[ES Log Exporter] Export failed, " << log_message);
       }
 
       if (console_debug_)

exporters/elasticsearch/src/es_log_recordable.cc

@@ -1,14 +1,41 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
+#include <chrono>
+#include <ctime>
+#include <nlohmann/json.hpp>
+#include <string>
+
 #include "opentelemetry/exporters/elasticsearch/es_log_recordable.h"
 #include "opentelemetry/logs/severity.h"
+#include "opentelemetry/nostd/variant.h"
 #include "opentelemetry/sdk/instrumentationscope/instrumentation_scope.h"
 #include "opentelemetry/sdk/resource/resource.h"
 #include "opentelemetry/trace/span_id.h"
 #include "opentelemetry/trace/trace_flags.h"
 #include "opentelemetry/trace/trace_id.h"
 
+namespace nlohmann
+{
+template <>
+struct adl_serializer<opentelemetry::sdk::common::OwnedAttributeValue>
+{
+  static void to_json(json &j, const opentelemetry::sdk::common::OwnedAttributeValue &v)
+  {
+    opentelemetry::nostd::visit([&j](const auto &value) { j = value; }, v);
+  }
+};
+
+template <>
+struct adl_serializer<opentelemetry::common::AttributeValue>
+{
+  static void to_json(json &j, const opentelemetry::common::AttributeValue &v)
+  {
+    opentelemetry::nostd::visit([&j](const auto &value) { j = value; }, v);
+  }
+};
+}  // namespace nlohmann
+
 OPENTELEMETRY_BEGIN_NAMESPACE
 namespace exporter
 {
@@ -18,146 +45,13 @@ void ElasticSearchRecordable::WriteValue(
     const opentelemetry::sdk::common::OwnedAttributeValue &value,
     const std::string &name)
 {
-  namespace common = opentelemetry::sdk::common;
-  switch (value.index())
-  {
-    case common::kTypeBool:
-      json_[name] = opentelemetry::nostd::get<bool>(value) ? true : false;
-      return;
-    case common::kTypeInt:
-      json_[name] = opentelemetry::nostd::get<int>(value);
-      return;
-    case common::kTypeInt64:
-      json_[name] = opentelemetry::nostd::get<int64_t>(value);
-      return;
-    case common::kTypeUInt:
-      json_[name] = opentelemetry::nostd::get<unsigned int>(value);
-      return;
-    case common::kTypeUInt64:
-      json_[name] = opentelemetry::nostd::get<uint64_t>(value);
-      return;
-    case common::kTypeDouble:
-      json_[name] = opentelemetry::nostd::get<double>(value);
-      return;
-    case common::kTypeString:
-      json_[name] = opentelemetry::nostd::get<std::string>(value).data();
-      return;
-    default:
-      return;
-  }
+  json_[name] = value;
 }
 
 void ElasticSearchRecordable::WriteValue(const opentelemetry::common::AttributeValue &value,
                                          const std::string &name)
 {
-
-  // Assert size of variant to ensure that this method gets updated if the variant
-  // definition changes
-
-  if (nostd::holds_alternative<bool>(value))
-  {
-    json_[name] = opentelemetry::nostd::get<bool>(value) ? true : false;
-  }
-  else if (nostd::holds_alternative<int>(value))
-  {
-    json_[name] = opentelemetry::nostd::get<int>(value);
-  }
-  else if (nostd::holds_alternative<int64_t>(value))
-  {
-    json_[name] = opentelemetry::nostd::get<int64_t>(value);
-  }
-  else if (nostd::holds_alternative<unsigned int>(value))
-  {
-    json_[name] = opentelemetry::nostd::get<unsigned int>(value);
-  }
-  else if (nostd::holds_alternative<uint64_t>(value))
-  {
-    json_[name] = opentelemetry::nostd::get<uint64_t>(value);
-  }
-  else if (nostd::holds_alternative<double>(value))
-  {
-    json_[name] = opentelemetry::nostd::get<double>(value);
-  }
-  else if (nostd::holds_alternative<const char *>(value))
-  {
-    json_[name] = std::string(nostd::get<const char *>(value));
-  }
-  else if (nostd::holds_alternative<nostd::string_view>(value))
-  {
-    json_[name] = static_cast<std::string>(opentelemetry::nostd::get<nostd::string_view>(value));
-  }
-  else if (nostd::holds_alternative<nostd::span<const uint8_t>>(value))
-  {
-    nlohmann::json array_value = nlohmann::json::array();
-    for (const auto &val : nostd::get<nostd::span<const uint8_t>>(value))
-    {
-      array_value.push_back(val);
-    }
-    json_[name] = array_value;
-  }
-  else if (nostd::holds_alternative<nostd::span<const bool>>(value))
-  {
-    nlohmann::json array_value = nlohmann::json::array();
-    for (const auto &val : nostd::get<nostd::span<const bool>>(value))
-    {
-      array_value.push_back(val);
-    }
-    json_[name] = array_value;
-  }
-  else if (nostd::holds_alternative<nostd::span<const int>>(value))
-  {
-    nlohmann::json array_value = nlohmann::json::array();
-    for (const auto &val : nostd::get<nostd::span<const int>>(value))
-    {
-      array_value.push_back(val);
-    }
-    json_[name] = array_value;
-  }
-  else if (nostd::holds_alternative<nostd::span<const int64_t>>(value))
-  {
-    nlohmann::json array_value = nlohmann::json::array();
-    for (const auto &val : nostd::get<nostd::span<const int64_t>>(value))
-    {
-      array_value.push_back(val);
-    }
-    json_[name] = array_value;
-  }
-  else if (nostd::holds_alternative<nostd::span<const unsigned int>>(value))
-  {
-    nlohmann::json array_value = nlohmann::json::array();
-    for (const auto &val : nostd::get<nostd::span<const unsigned int>>(value))
-    {
-      array_value.push_back(val);
-    }
-    json_[name] = array_value;
-  }
-  else if (nostd::holds_alternative<nostd::span<const uint64_t>>(value))
-  {
-    nlohmann::json array_value = nlohmann::json::array();
-    for (const auto &val : nostd::get<nostd::span<const uint64_t>>(value))
-    {
-      array_value.push_back(val);
-    }
-    json_[name] = array_value;
-  }
-  else if (nostd::holds_alternative<nostd::span<const double>>(value))
-  {
-    nlohmann::json array_value = nlohmann::json::array();
-    for (const auto &val : nostd::get<nostd::span<const double>>(value))
-    {
-      array_value.push_back(val);
-    }
-    json_[name] = array_value;
-  }
-  else if (nostd::holds_alternative<nostd::span<const nostd::string_view>>(value))
-  {
-    nlohmann::json array_value = nlohmann::json::array();
-    for (const auto &val : nostd::get<nostd::span<const nostd::string_view>>(value))
-    {
-      array_value.push_back(static_cast<std::string>(val));
-    }
-    json_[name] = array_value;
-  }
+  json_[name] = value;
 }
 
 ElasticSearchRecordable::ElasticSearchRecordable() noexcept : sdk::logs::Recordable()
@@ -180,27 +74,19 @@ void ElasticSearchRecordable::SetTimestamp(
 #if __cplusplus >= 202002L
   const std::string dateStr = std::format("{:%FT%T%Ez}", timePoint);
 #else
-  const static int dateToSecondsSize = 19;
-  const static int millisecondsSize  = 8;
-  const static int timeZoneSize      = 1;
-  const static int dateSize          = dateToSecondsSize + millisecondsSize + timeZoneSize;
-
   std::time_t time = std::chrono::system_clock::to_time_t(timePoint);
   std::tm tm       = *std::gmtime(&time);
-
-  char bufferDate[dateSize];  // example: 2024-10-18T07:26:00.123456Z
-  std::strftime(bufferDate, sizeof(bufferDate), "%Y-%m-%dT%H:%M:%S", &tm);
   auto microseconds =
       std::chrono::duration_cast<std::chrono::microseconds>(timePoint.time_since_epoch()) %
       std::chrono::seconds(1);
 
-  char bufferMilliseconds[millisecondsSize];
-  std::snprintf(bufferMilliseconds, sizeof(bufferMilliseconds), ".%06ld",
+  // `sizeof()` includes the null terminator
+  constexpr auto dateSize = sizeof("YYYY-MM-DDTHH:MM:SS.uuuuuuZ");
+  char bufferDate[dateSize];
+  auto offset = std::strftime(bufferDate, sizeof(bufferDate), "%Y-%m-%dT%H:%M:%S", &tm);
+  std::snprintf(bufferDate + offset, sizeof(bufferDate) - offset, ".%06ldZ",
                 static_cast<long>(microseconds.count()));
 
-  std::strcat(bufferDate, bufferMilliseconds);
-  std::strcat(bufferDate, "Z");
-
   const std::string dateStr(bufferDate);
 #endif
 
@@ -221,9 +107,8 @@ void ElasticSearchRecordable::SetSeverity(opentelemetry::logs::Severity severity
   std::uint32_t severity_index = static_cast<std::uint32_t>(severity);
   if (severity_index >= std::extent<decltype(opentelemetry::logs::SeverityNumToText)>::value)
   {
-    std::stringstream sout;
-    sout << "Invalid severity(" << severity_index << ")";
-    severityField = sout.str();
+    severityField =
+        std::string("Invalid severity(").append(std::to_string(severity_index)).append(")");
   }
   else
   {
@@ -240,7 +125,7 @@ void ElasticSearchRecordable::SetTraceId(const opentelemetry::trace::TraceId &tr
 {
   if (trace_id.IsValid())
   {
-    char trace_buf[32];
+    char trace_buf[opentelemetry::trace::TraceId::kSize * 2];
     trace_id.ToLowerBase16(trace_buf);
     json_["traceid"] = std::string(trace_buf, sizeof(trace_buf));
   }
@@ -254,7 +139,7 @@ void ElasticSearchRecordable::SetSpanId(const opentelemetry::trace::SpanId &span
 {
   if (span_id.IsValid())
   {
-    char span_buf[16];
+    char span_buf[opentelemetry::trace::SpanId::kSize * 2];
     span_id.ToLowerBase16(span_buf);
     json_["spanid"] = std::string(span_buf, sizeof(span_buf));
   }
@@ -282,7 +167,7 @@ void ElasticSearchRecordable::SetAttribute(
 void ElasticSearchRecordable::SetResource(
     const opentelemetry::sdk::resource::Resource &resource) noexcept
 {
-  for (auto &attribute : resource.GetAttributes())
+  for (const auto &attribute : resource.GetAttributes())
   {
     WriteValue(attribute.second, attribute.first);
   }

opentracing-shim/include/opentelemetry/opentracingshim/propagation.h

@@ -29,7 +29,8 @@ class CarrierWriterShim : public opentelemetry::context::propagation::TextMapCar
 
   virtual void Set(nostd::string_view key, nostd::string_view value) noexcept override
   {
-    writer_.Set(key.data(), value.data());
+    writer_.Set(opentracing::string_view{key.data(), key.size()},
+                opentracing::string_view{value.data(), value.size()});
   }
 
 private:
@@ -46,17 +47,17 @@ class CarrierReaderShim : public opentelemetry::context::propagation::TextMapCar
     nostd::string_view value;
 
     // First try carrier.LookupKey since that can potentially be the fastest approach.
-    if (auto result = reader_.LookupKey(key.data()))
+    if (auto result = reader_.LookupKey(opentracing::string_view{key.data(), key.size()}))
     {
-      value = result.value().data();
+      value = nostd::string_view{result.value().data(), result.value().size()};
     }
     else  // Fall back to iterating through all of the keys.
     {
       reader_.ForeachKey([key, &value](opentracing::string_view k,
                                        opentracing::string_view v) -> opentracing::expected<void> {
-        if (k == key.data())
+        if (key == nostd::string_view{k.data(), k.size()})
         {
-          value = v.data();
+          value = nostd::string_view{v.data(), v.size()};
           // Found key, so bail out of the loop with a success error code.
           return opentracing::make_unexpected(std::error_code{});
         }
@@ -77,8 +78,9 @@ class CarrierReaderShim : public opentelemetry::context::propagation::TextMapCar
     return reader_
         .ForeachKey([&callback](opentracing::string_view key,
                                 opentracing::string_view) -> opentracing::expected<void> {
-          return callback(key.data()) ? opentracing::make_expected()
-                                      : opentracing::make_unexpected(std::error_code{});
+          return callback(nostd::string_view{key.data(), key.size()})
+                     ? opentracing::make_expected()
+                     : opentracing::make_unexpected(std::error_code{});
         })
         .has_value();
   }

opentracing-shim/include/opentelemetry/opentracingshim/shim_utils.h

@@ -29,7 +29,10 @@ static inline opentelemetry::common::AttributeValue attributeFromValue(
     AttributeValue operator()(int64_t v) { return v; }
     AttributeValue operator()(uint64_t v) { return v; }
     AttributeValue operator()(const std::string &v) { return nostd::string_view{v}; }
-    AttributeValue operator()(opentracing::string_view v) { return nostd::string_view{v.data()}; }
+    AttributeValue operator()(opentracing::string_view v)
+    {
+      return nostd::string_view{v.data(), v.size()};
+    }
     AttributeValue operator()(std::nullptr_t) { return nostd::string_view{}; }
     AttributeValue operator()(const char *v) { return v; }
     AttributeValue operator()(opentracing::util::recursive_wrapper<opentracing::Values>)
@@ -54,7 +57,7 @@ static inline std::string stringFromValue(const opentracing::Value &value)
     std::string operator()(int64_t v) { return std::to_string(v); }
     std::string operator()(uint64_t v) { return std::to_string(v); }
     std::string operator()(const std::string &v) { return v; }
-    std::string operator()(opentracing::string_view v) { return std::string{v.data()}; }
+    std::string operator()(opentracing::string_view v) { return std::string{v.data(), v.size()}; }
     std::string operator()(std::nullptr_t) { return std::string{}; }
     std::string operator()(const char *v) { return std::string{v}; }
     std::string operator()(opentracing::util::recursive_wrapper<opentracing::Values>)

opentracing-shim/src/span_context_shim.cc

@@ -23,7 +23,7 @@ bool SpanContextShim::BaggageItem(nostd::string_view key, std::string &value) co
 void SpanContextShim::ForeachBaggageItem(VisitBaggageItem f) const
 {
   baggage_->GetAllEntries([&f](nostd::string_view key, nostd::string_view value) {
-    return f(key.data(), value.data());
+    return f(std::string{key.data(), key.size()}, std::string{value.data(), value.size()});
   });
 }
 

opentracing-shim/src/span_shim.cc

@@ -45,7 +45,7 @@ void SpanShim::FinishWithOptions(const opentracing::FinishSpanOptions &finish_sp
 
 void SpanShim::SetOperationName(opentracing::string_view name) noexcept
 {
-  span_->UpdateName(name.data());
+  span_->UpdateName(nostd::string_view{name.data(), name.size()});
 }
 
 void SpanShim::SetTag(opentracing::string_view key, const opentracing::Value &value) noexcept
@@ -57,7 +57,8 @@ void SpanShim::SetTag(opentracing::string_view key, const opentracing::Value &va
   }
   else
   {
-    span_->SetAttribute(key.data(), utils::attributeFromValue(value));
+    auto key_view = nostd::string_view{key.data(), key.size()};
+    span_->SetAttribute(key_view, utils::attributeFromValue(value));
   }
 }
 
@@ -68,9 +69,11 @@ void SpanShim::SetBaggageItem(opentracing::string_view restricted_key,
   // Baggage key/value pair, and sets it as the current instance for this Span Shim.
   if (restricted_key.empty() || value.empty())
     return;
+  auto restricted_key_view = nostd::string_view{restricted_key.data(), restricted_key.size()};
+  auto value_view          = nostd::string_view{value.data(), value.size()};
   // This operation MUST be safe to be called concurrently.
   const std::lock_guard<decltype(context_lock_)> guard(context_lock_);
-  context_ = context_.newWithKeyValue(restricted_key.data(), value.data());
+  context_ = context_.newWithKeyValue(restricted_key_view, value_view);
 }
 
 std::string SpanShim::BaggageItem(opentracing::string_view restricted_key) const noexcept
@@ -82,7 +85,8 @@ std::string SpanShim::BaggageItem(opentracing::string_view restricted_key) const
   // This operation MUST be safe to be called concurrently.
   const std::lock_guard<decltype(context_lock_)> guard(context_lock_);
   std::string value;
-  return context_.BaggageItem(restricted_key.data(), value) ? value : "";
+  auto restricted_key_view = nostd::string_view{restricted_key.data(), restricted_key.size()};
+  return context_.BaggageItem(restricted_key_view, value) ? value : "";
 }
 
 void SpanShim::Log(std::initializer_list<EventEntry> fields) noexcept
@@ -128,7 +132,7 @@ void SpanShim::logImpl(nostd::span<const EventEntry> fields,
 
   for (const auto &entry : fields)
   {
-    nostd::string_view key = entry.first.data();
+    nostd::string_view key{entry.first.data(), entry.first.size()};
     // ... including mapping of the following key/value pairs:
     if (is_error)
     {