[SDK] LogRecord attribute limits enforcement

CHANGELOG.md

@@ -90,6 +90,9 @@ Increment the:
 * [CI] iwyu and clang-tidy: use install_thirdparty.sh for third-party
   [#4136](https://github.com/open-telemetry/opentelemetry-cpp/pull/4136)
 
+* [SDK] LogRecord attribute limits enforcement
+  [#4157](https://github.com/open-telemetry/opentelemetry-cpp/pull/4157)
+
 * [CONFIGURATION] File configuration: declarative resource detection types
   [#4148](https://github.com/open-telemetry/opentelemetry-cpp/pull/4148)
 

exporters/otlp/include/opentelemetry/exporters/otlp/otlp_log_recordable.h

@@ -7,6 +7,7 @@
 
 #include "opentelemetry/common/attribute_value.h"
 #include "opentelemetry/sdk/instrumentationscope/instrumentation_scope.h"
+#include "opentelemetry/sdk/logs/log_record_limits.h"
 #include "opentelemetry/sdk/logs/recordable.h"
 #include "opentelemetry/sdk/resource/resource.h"
 #include "opentelemetry/version.h"
@@ -96,6 +97,14 @@ class OtlpLogRecordable final : public opentelemetry::sdk::logs::Recordable
   void SetAttribute(nostd::string_view key,
                     const opentelemetry::common::AttributeValue &value) noexcept override;
 
+  /**
+   * Apply attribute count and value length limits. Must be called before any
+   * SetAttribute call to take effect. The referenced limits object must
+   * outlive this recordable.
+   */
+  void SetLogRecordLimits(
+      const opentelemetry::sdk::logs::LogRecordLimits &limits) noexcept override;
+
   /**
    * Set Resource of this log
    * @param Resource the resource to set
@@ -114,6 +123,7 @@ class OtlpLogRecordable final : public opentelemetry::sdk::logs::Recordable
   const opentelemetry::sdk::resource::Resource *resource_ = nullptr;
   const opentelemetry::sdk::instrumentationscope::InstrumentationScope *instrumentation_scope_ =
       nullptr;
+  const opentelemetry::sdk::logs::LogRecordLimits *limits_ = nullptr;
 };
 
 }  // namespace otlp

exporters/otlp/src/otlp_log_recordable.cc

@@ -2,13 +2,17 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "opentelemetry/exporters/otlp/otlp_log_recordable.h"
+#include <cstddef>
+#include <limits>
+#include <string>
 #include "opentelemetry/common/attribute_value.h"
 #include "opentelemetry/common/timestamp.h"
 #include "opentelemetry/exporters/otlp/otlp_populate_attribute_utils.h"
 #include "opentelemetry/logs/severity.h"
 #include "opentelemetry/nostd/span.h"
 #include "opentelemetry/nostd/string_view.h"
 #include "opentelemetry/sdk/instrumentationscope/instrumentation_scope.h"
+#include "opentelemetry/sdk/logs/log_record_limits.h"
 #include "opentelemetry/sdk/logs/readable_log_record.h"
 #include "opentelemetry/sdk/resource/resource.h"
 #include "opentelemetry/trace/span_id.h"
@@ -18,6 +22,7 @@
 
 // clang-format off
 #include "opentelemetry/exporters/otlp/protobuf_include_prefix.h" // IWYU pragma: keep
+#include "opentelemetry/proto/common/v1/common.pb.h"
 #include "opentelemetry/proto/logs/v1/logs.pb.h"
 #include "opentelemetry/exporters/otlp/protobuf_include_suffix.h" // IWYU pragma: keep
 // clang-format on
@@ -233,10 +238,59 @@ void OtlpLogRecordable::SetTraceFlags(const opentelemetry::trace::TraceFlags &tr
   proto_record_.set_flags(trace_flags.flags());
 }
 
+namespace
+{
+
+void TruncateProtoStringValue(proto::common::v1::AnyValue *value, std::size_t max_length) noexcept
+{
+  if (value == nullptr)
+  {
+    return;
+  }
+  if (value->value_case() == proto::common::v1::AnyValue::kStringValue)
+  {
+    if (value->string_value().size() > max_length)
+    {
+      value->mutable_string_value()->resize(max_length);
+    }
+    return;
+  }
+  if (value->value_case() == proto::common::v1::AnyValue::kArrayValue)
+  {
+    auto *array = value->mutable_array_value();
+    for (int i = 0; i < array->values_size(); ++i)
+    {
+      TruncateProtoStringValue(array->mutable_values(i), max_length);
+    }
+  }
+}
+
+}  // namespace
+
 void OtlpLogRecordable::SetAttribute(opentelemetry::nostd::string_view key,
                                      const opentelemetry::common::AttributeValue &value) noexcept
 {
-  OtlpPopulateAttributeUtils::PopulateAttribute(proto_record_.add_attributes(), key, value, true);
+  if (limits_ != nullptr &&
+      static_cast<std::size_t>(proto_record_.attributes_size()) >= limits_->attribute_count_limit)
+  {
+    proto_record_.set_dropped_attributes_count(proto_record_.dropped_attributes_count() + 1);
+    return;
+  }
+
+  auto *kv = proto_record_.add_attributes();
+  OtlpPopulateAttributeUtils::PopulateAttribute(kv, key, value, true);
+
+  if (limits_ != nullptr &&
+      limits_->attribute_value_length_limit != (std::numeric_limits<std::size_t>::max)())
+  {
+    TruncateProtoStringValue(kv->mutable_value(), limits_->attribute_value_length_limit);
+  }
+}
+
+void OtlpLogRecordable::SetLogRecordLimits(
+    const opentelemetry::sdk::logs::LogRecordLimits &limits) noexcept
+{
+  limits_ = &limits;
 }
 
 void OtlpLogRecordable::SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept

exporters/otlp/test/otlp_log_recordable_test.cc

@@ -19,6 +19,7 @@
 #include "opentelemetry/nostd/string_view.h"
 #include "opentelemetry/nostd/variant.h"
 #include "opentelemetry/sdk/instrumentationscope/instrumentation_scope.h"
+#include "opentelemetry/sdk/logs/log_record_limits.h"
 #include "opentelemetry/sdk/logs/readable_log_record.h"
 #include "opentelemetry/sdk/logs/recordable.h"
 #include "opentelemetry/sdk/resource/resource.h"
@@ -419,6 +420,73 @@ TEST(OtlpLogRecordable, PopulateRequestSameScope)
   EXPECT_EQ(req.resource_logs(0).scope_logs(0).log_records_size(), 2);
   EXPECT_EQ(req.resource_logs(0).scope_logs(0).scope().name(), "lib");
 }
+
+TEST(OtlpLogRecordable, AttributeCountLimitReportsDroppedCount)
+{
+  opentelemetry::sdk::logs::LogRecordLimits limits;
+  limits.attribute_count_limit = 2;
+
+  OtlpLogRecordable rec;
+  rec.SetLogRecordLimits(limits);
+  rec.SetAttribute("a", static_cast<int64_t>(1));
+  rec.SetAttribute("b", static_cast<int64_t>(2));
+  rec.SetAttribute("c", static_cast<int64_t>(3));
+  rec.SetAttribute("d", static_cast<int64_t>(4));
+
+  EXPECT_EQ(rec.log_record().attributes_size(), 2);
+  EXPECT_EQ(rec.log_record().dropped_attributes_count(), 2u);
+}
+
+TEST(OtlpLogRecordable, AttributeValueLengthLimitTruncatesString)
+{
+  opentelemetry::sdk::logs::LogRecordLimits limits;
+  limits.attribute_value_length_limit = 4;
+
+  OtlpLogRecordable rec;
+  rec.SetLogRecordLimits(limits);
+  rec.SetAttribute("k", nostd::string_view("abcdefghij"));
+
+  ASSERT_EQ(rec.log_record().attributes_size(), 1);
+  EXPECT_EQ(rec.log_record().attributes(0).value().string_value(), "abcd");
+  EXPECT_EQ(rec.log_record().dropped_attributes_count(), 0u);
+}
+
+TEST(OtlpLogRecordable, AttributeValueLengthLimitTruncatesArrayElements)
+{
+  opentelemetry::sdk::logs::LogRecordLimits limits;
+  limits.attribute_value_length_limit = 3;
+
+  OtlpLogRecordable rec;
+  rec.SetLogRecordLimits(limits);
+  nostd::string_view values[] = {nostd::string_view("aaaaaa"), nostd::string_view("bb"),
+                                 nostd::string_view("cccc")};
+  rec.SetAttribute("k", nostd::span<const nostd::string_view>(values, 3));
+
+  ASSERT_EQ(rec.log_record().attributes_size(), 1);
+  const auto &array = rec.log_record().attributes(0).value().array_value();
+  ASSERT_EQ(array.values_size(), 3);
+  EXPECT_EQ(array.values(0).string_value(), "aaa");
+  EXPECT_EQ(array.values(1).string_value(), "bb");
+  EXPECT_EQ(array.values(2).string_value(), "ccc");
+}
+
+TEST(OtlpLogRecordable, AttributeValueLengthLimitLeavesNonStringTypesUnchanged)
+{
+  opentelemetry::sdk::logs::LogRecordLimits limits;
+  limits.attribute_value_length_limit = 1;
+
+  OtlpLogRecordable rec;
+  rec.SetLogRecordLimits(limits);
+  rec.SetAttribute("i", static_cast<int64_t>(1234567890));
+  rec.SetAttribute("d", 3.14);
+  rec.SetAttribute("b", true);
+
+  ASSERT_EQ(rec.log_record().attributes_size(), 3);
+  EXPECT_EQ(rec.log_record().attributes(0).value().int_value(), 1234567890);
+  EXPECT_DOUBLE_EQ(rec.log_record().attributes(1).value().double_value(), 3.14);
+  EXPECT_EQ(rec.log_record().attributes(2).value().bool_value(), true);
+}
+
 }  // namespace otlp
 }  // namespace exporter
 OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/logs/log_record_limits.h

@@ -0,0 +1,37 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cstddef>
+#include <limits>
+
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace logs
+{
+
+/**
+ * LogRecordLimits carries the SDK-level attribute limits applied to every
+ * LogRecord emitted through a LoggerProvider. The defaults match the
+ * specification: at most 128 attributes per record, attribute value length
+ * unlimited (no truncation).
+ *
+ * See https://opentelemetry.io/docs/specs/otel/logs/sdk/#logrecord-limits.
+ */
+struct LogRecordLimits
+{
+  static constexpr std::size_t kDefaultAttributeCountLimit = 128;
+  static constexpr std::size_t kDefaultAttributeValueLengthLimit =
+      (std::numeric_limits<std::size_t>::max)();
+
+  std::size_t attribute_count_limit        = kDefaultAttributeCountLimit;
+  std::size_t attribute_value_length_limit = kDefaultAttributeValueLengthLimit;
+};
+
+}  // namespace logs
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/logs/logger_context.h

@@ -9,6 +9,7 @@
 
 #include "logger_config.h"
 #include "opentelemetry/sdk/instrumentationscope/scope_configurator.h"
+#include "opentelemetry/sdk/logs/log_record_limits.h"
 #include "opentelemetry/sdk/logs/processor.h"
 #include "opentelemetry/sdk/resource/resource.h"
 #include "opentelemetry/version.h"
@@ -43,7 +44,8 @@ class LoggerContext
           std::make_unique<instrumentationscope::ScopeConfigurator<LoggerConfig>>(
               instrumentationscope::ScopeConfigurator<LoggerConfig>::Builder(
                   LoggerConfig::Default())
-                  .Build())) noexcept;
+                  .Build()),
+      LogRecordLimits log_record_limits = LogRecordLimits()) noexcept;
 
   /**
    * Attaches a log processor to list of configured processors to this logger context.
@@ -76,6 +78,12 @@ class LoggerContext
   const instrumentationscope::ScopeConfigurator<LoggerConfig> &GetLoggerConfigurator()
       const noexcept;
 
+  /**
+   * Obtain the LogRecord limits applied by this context.
+   * @return The LogRecordLimits for this logger context.
+   */
+  const LogRecordLimits &GetLogRecordLimits() const noexcept;
+
   /**
    * Force all active LogProcessors to flush any buffered logs
    * within the given timeout.
@@ -93,6 +101,8 @@ class LoggerContext
   std::unique_ptr<LogRecordProcessor> processor_;
 
   std::unique_ptr<instrumentationscope::ScopeConfigurator<LoggerConfig>> logger_configurator_;
+
+  LogRecordLimits log_record_limits_;
 };
 }  // namespace logs
 }  // namespace sdk

sdk/include/opentelemetry/sdk/logs/logger_provider_factory.h

@@ -6,6 +6,7 @@
 #include <memory>
 #include <vector>
 
+#include "opentelemetry/sdk/logs/log_record_limits.h"
 #include "opentelemetry/sdk/logs/logger_context.h"
 #include "opentelemetry/sdk/logs/logger_provider.h"
 #include "opentelemetry/sdk/logs/processor.h"
@@ -66,6 +67,15 @@ class OPENTELEMETRY_EXPORT LoggerProviderFactory
       const opentelemetry::sdk::resource::Resource &resource,
       std::unique_ptr<instrumentationscope::ScopeConfigurator<LoggerConfig>> logger_configurator);
 
+  /**
+   * Create a LoggerProvider with explicit LogRecord limits.
+   */
+  static std::unique_ptr<opentelemetry::sdk::logs::LoggerProvider> Create(
+      std::vector<std::unique_ptr<LogRecordProcessor>> &&processors,
+      const opentelemetry::sdk::resource::Resource &resource,
+      std::unique_ptr<instrumentationscope::ScopeConfigurator<LoggerConfig>> logger_configurator,
+      LogRecordLimits log_record_limits);
+
   /**
    * Create a LoggerProvider.
    */

sdk/include/opentelemetry/sdk/logs/multi_recordable.h

@@ -13,6 +13,7 @@
 #include "opentelemetry/common/timestamp.h"
 #include "opentelemetry/logs/log_record.h"
 #include "opentelemetry/nostd/string_view.h"
+#include "opentelemetry/sdk/logs/log_record_limits.h"
 #include "opentelemetry/sdk/logs/processor.h"
 #include "opentelemetry/sdk/logs/recordable.h"
 #include "opentelemetry/sdk/resource/resource.h"
@@ -107,6 +108,12 @@ class MultiRecordable final : public Recordable
   void SetInstrumentationScope(const opentelemetry::sdk::instrumentationscope::InstrumentationScope
                                    &instrumentation_scope) noexcept override;
 
+  /**
+   * Propagate attribute limits to every wrapped recordable. Must be called
+   * before any SetAttribute call.
+   */
+  void SetLogRecordLimits(const LogRecordLimits &limits) noexcept override;
+
 private:
   std::unordered_map<std::size_t, std::unique_ptr<Recordable>> recordables_;
 };

sdk/include/opentelemetry/sdk/logs/read_write_log_record.h

@@ -14,6 +14,7 @@
 #include "opentelemetry/logs/severity.h"
 #include "opentelemetry/nostd/string_view.h"
 #include "opentelemetry/sdk/common/attribute_utils.h"
+#include "opentelemetry/sdk/logs/log_record_limits.h"
 #include "opentelemetry/sdk/logs/readable_log_record.h"
 #include "opentelemetry/trace/span_id.h"
 #include "opentelemetry/trace/trace_flags.h"
@@ -153,13 +154,26 @@ class ReadWriteLogRecord final : public ReadableLogRecord
   void SetAttribute(nostd::string_view key,
                     const opentelemetry::common::AttributeValue &value) noexcept override;
 
+  /**
+   * Apply attribute count and value length limits. Must be called before any
+   * SetAttribute call to take effect. The referenced limits object must
+   * outlive this recordable.
+   */
+  void SetLogRecordLimits(const LogRecordLimits &limits) noexcept override;
+
   /**
    * Get attributes of this log.
    * @return the body field of this log
    */
   const std::unordered_map<std::string, opentelemetry::sdk::common::OwnedAttributeValue> &
   GetAttributes() const noexcept override;
 
+  /**
+   * Get the number of attributes dropped because the attribute count limit
+   * was reached. Truncated string values are not counted as dropped.
+   */
+  uint32_t GetDroppedAttributesCount() const noexcept override;
+
   /**
    * Get resource of this log
    * @return the resource of this log
@@ -200,6 +214,9 @@ class ReadWriteLogRecord final : public ReadableLogRecord
   int64_t event_id_{0};
   std::string event_name_;
 
+  const LogRecordLimits *limits_{nullptr};
+  uint32_t dropped_attributes_count_{0};
+
   // We do not pay for trace state when not necessary
   struct TraceState
   {

sdk/include/opentelemetry/sdk/logs/readable_log_record.h

@@ -114,6 +114,14 @@ class ReadableLogRecord : public Recordable
   virtual const std::unordered_map<std::string, opentelemetry::sdk::common::OwnedAttributeValue> &
   GetAttributes() const noexcept = 0;
 
+  /**
+   * Get the number of attributes dropped because the attribute count limit
+   * was reached. The default implementation reports zero so existing
+   * recordables that do not enforce limits compile without changes.
+   * @return the number of dropped attributes
+   */
+  virtual uint32_t GetDroppedAttributesCount() const noexcept { return 0; }
+
   /**
    * Get resource of this log
    * @return the resource of this log