[SDK] Span limits configuration

CHANGELOG.md

@@ -27,6 +27,11 @@ Increment the:
 * [CMAKE] Fix and test WITH_API_ONLY option
   [#4201](https://github.com/open-telemetry/opentelemetry-cpp/pull/4201)
 
+* [SDK] Span limits can now be configured through the TracerProvider interface
+        and declaritive configuration. When set, limits are enforced by the
+        SpanData and OtlpRecordables recordables used by the standard exporters
+  [#4232](https://github.com/open-telemetry/opentelemetry-cpp/pull/4232)
+
 * [API] Fix `TraceState::IsValidKey()` to comply with the W3C Trace Context
   Level 2, where keys containing `@` and keys with more than 241 characters
   before `@` or more than 14 characters after `@` are now accepted.

exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h

@@ -35,7 +35,11 @@ struct OPENTELEMETRY_EXPORT OtlpGrpcExporterOptions : public OtlpGrpcClientOptio
   OtlpGrpcExporterOptions &operator=(OtlpGrpcExporterOptions &&)      = default;
   ~OtlpGrpcExporterOptions() override;
 
-  /** Collection Limits. No limit by default. */
+  /** Collection Limits. No limit by default.
+   * @deprecated Configure span limits via TracerProviderFactory::Create(), SpanLimitsConfiguration,
+   * or the YAML `tracer_provider.limits` node instead. These fields will be
+   * removed in a future release.
+   */
   std::uint32_t max_attributes           = (std::numeric_limits<std::uint32_t>::max)();
   std::uint32_t max_events               = (std::numeric_limits<std::uint32_t>::max)();
   std::uint32_t max_links                = (std::numeric_limits<std::uint32_t>::max)();

exporters/otlp/include/opentelemetry/exporters/otlp/otlp_http_exporter_options.h

@@ -127,7 +127,11 @@ struct OPENTELEMETRY_EXPORT OtlpHttpExporterOptions
   /** The backoff will be multiplied by this value after each retry attempt. */
   float retry_policy_backoff_multiplier{};
 
-  /** Collection Limits. No limit by default. */
+  /** Collection Limits. No limit by default.
+   * @deprecated Configure span limits via TracerProviderFactory::Create(), SpanLimitsConfiguration,
+   * or the YAML `tracer_provider.limits` node instead. These fields will be
+   * removed in a future release.
+   */
   std::uint32_t max_attributes           = (std::numeric_limits<std::uint32_t>::max)();
   std::uint32_t max_events               = (std::numeric_limits<std::uint32_t>::max)();
   std::uint32_t max_links                = (std::numeric_limits<std::uint32_t>::max)();

exporters/otlp/include/opentelemetry/exporters/otlp/otlp_recordable.h

@@ -23,6 +23,7 @@
 #include "opentelemetry/sdk/instrumentationscope/instrumentation_scope.h"
 #include "opentelemetry/sdk/resource/resource.h"
 #include "opentelemetry/sdk/trace/recordable.h"
+#include "opentelemetry/sdk/trace/span_limits.h"
 #include "opentelemetry/trace/span_context.h"
 #include "opentelemetry/trace/span_id.h"
 #include "opentelemetry/trace/span_metadata.h"
@@ -37,17 +38,25 @@ namespace otlp
 class OtlpRecordable final : public opentelemetry::sdk::trace::Recordable
 {
 public:
+  /**
+   * Construct with optional span limits parameters.
+   *
+   * @deprecated Configure span limits via TracerProviderFactory::Create(), SpanLimitsConfiguration,
+   * or the YAML `tracer_provider.limits` node instead. These optional span limit params will be
+   * removed in a future release.
+   */
   explicit OtlpRecordable(
       std::uint32_t max_attributes           = (std::numeric_limits<std::uint32_t>::max)(),
       std::uint32_t max_events               = (std::numeric_limits<std::uint32_t>::max)(),
       std::uint32_t max_links                = (std::numeric_limits<std::uint32_t>::max)(),
       std::uint32_t max_attributes_per_event = (std::numeric_limits<std::uint32_t>::max)(),
       std::uint32_t max_attributes_per_link  = (std::numeric_limits<std::uint32_t>::max)())
-      : max_attributes_(max_attributes),
-        max_events_(max_events),
-        max_links_(max_links),
-        max_attributes_per_event_(max_attributes_per_event),
-        max_attributes_per_link_(max_attributes_per_link)
+      : span_limits_{max_attributes,
+                     (std::numeric_limits<std::size_t>::max)(),
+                     max_events,
+                     max_links,
+                     max_attributes_per_event,
+                     max_attributes_per_link}
   {}
 
   proto::trace::v1::Span &span() noexcept { return span_; }
@@ -92,6 +101,17 @@ class OtlpRecordable final : public opentelemetry::sdk::trace::Recordable
 
   void SetDuration(std::chrono::nanoseconds duration) noexcept override;
 
+  /**
+   * Set span limits.
+   *
+   * Until the deprecated OTLP exporter option values are removed, the effective limit for each
+   * field is the minimum (most restrictive) of the deprecated otlp exporter option values (passed
+   * to the constructor) and the values set by calling this method.
+   *
+   * @param limits The span limits to set.
+   */
+  void SetSpanLimits(const opentelemetry::sdk::trace::SpanLimits &limits) noexcept override;
+
   void SetInstrumentationScope(const opentelemetry::sdk::instrumentationscope::InstrumentationScope
                                    &instrumentation_scope) noexcept override;
 
@@ -100,11 +120,8 @@ class OtlpRecordable final : public opentelemetry::sdk::trace::Recordable
   const opentelemetry::sdk::resource::Resource *resource_ = nullptr;
   const opentelemetry::sdk::instrumentationscope::InstrumentationScope *instrumentation_scope_ =
       nullptr;
-  std::uint32_t max_attributes_;
-  std::uint32_t max_events_;
-  std::uint32_t max_links_;
-  std::uint32_t max_attributes_per_event_;
-  std::uint32_t max_attributes_per_link_;
+  opentelemetry::sdk::trace::SpanLimits span_limits_{
+      opentelemetry::sdk::trace::SpanLimits::NoLimits()};
 };
 }  // namespace otlp
 }  // namespace exporter

exporters/otlp/src/otlp_recordable.cc

@@ -1,8 +1,9 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
-#include <stdint.h>
+#include <algorithm>
 #include <chrono>
+#include <cstdint>
 #include <string>
 
 #include "opentelemetry/common/attribute_value.h"
@@ -15,6 +16,7 @@
 #include "opentelemetry/nostd/string_view.h"
 #include "opentelemetry/sdk/instrumentationscope/instrumentation_scope.h"
 #include "opentelemetry/sdk/resource/resource.h"
+#include "opentelemetry/sdk/trace/span_limits.h"
 #include "opentelemetry/trace/span_context.h"
 #include "opentelemetry/trace/span_id.h"
 #include "opentelemetry/trace/span_metadata.h"
@@ -114,24 +116,40 @@ void OtlpRecordable::SetResource(const sdk::resource::Resource &resource) noexce
   resource_ = &resource;
 }
 
+void OtlpRecordable::SetSpanLimits(const opentelemetry::sdk::trace::SpanLimits &limits) noexcept
+{
+  // Update the span limits to be the minimum of the current limits and the new limits
+  // The initial limits are set on construction from the deprecated span limits otlp options.
+  // TODO: replace with a simple copy once the deprecated options are removed.
+  span_limits_ = {
+      (std::min)(span_limits_.attribute_count_limit, limits.attribute_count_limit),
+      (std::min)(span_limits_.attribute_value_length_limit, limits.attribute_value_length_limit),
+      (std::min)(span_limits_.event_count_limit, limits.event_count_limit),
+      (std::min)(span_limits_.link_count_limit, limits.link_count_limit),
+      (std::min)(span_limits_.event_attribute_count_limit, limits.event_attribute_count_limit),
+      (std::min)(span_limits_.link_attribute_count_limit, limits.link_attribute_count_limit),
+  };
+}
+
 void OtlpRecordable::SetAttribute(nostd::string_view key,
                                   const common::AttributeValue &value) noexcept
 {
-  if (static_cast<uint32_t>(span_.attributes_size()) >= max_attributes_)
+  if (static_cast<std::uint32_t>(span_.attributes_size()) >= span_limits_.attribute_count_limit)
   {
     span_.set_dropped_attributes_count(span_.dropped_attributes_count() + 1);
     return;
   }
 
   auto *attribute = span_.add_attributes();
-  OtlpPopulateAttributeUtils::PopulateAttribute(attribute, key, value, false);
+  OtlpPopulateAttributeUtils::PopulateAttribute(attribute, key, value, false,
+                                                span_limits_.attribute_value_length_limit);
 }
 
 void OtlpRecordable::AddEvent(nostd::string_view name,
                               common::SystemTimestamp timestamp,
                               const common::KeyValueIterable &attributes) noexcept
 {
-  if (static_cast<uint32_t>(span_.events_size()) >= max_events_)
+  if (static_cast<std::uint32_t>(span_.events_size()) >= span_limits_.event_count_limit)
   {
     span_.set_dropped_events_count(span_.dropped_events_count() + 1);
     return;
@@ -142,20 +160,22 @@ void OtlpRecordable::AddEvent(nostd::string_view name,
   event->set_time_unix_nano(timestamp.time_since_epoch().count());
 
   attributes.ForEachKeyValue([&](nostd::string_view key, common::AttributeValue value) noexcept {
-    if (static_cast<uint32_t>(event->attributes_size()) >= max_attributes_per_event_)
+    if (static_cast<std::uint32_t>(event->attributes_size()) >=
+        span_limits_.event_attribute_count_limit)
     {
       event->set_dropped_attributes_count(event->dropped_attributes_count() + 1);
       return true;
     }
-    OtlpPopulateAttributeUtils::PopulateAttribute(event->add_attributes(), key, value, false);
+    OtlpPopulateAttributeUtils::PopulateAttribute(event->add_attributes(), key, value, false,
+                                                  span_limits_.attribute_value_length_limit);
     return true;
   });
 }
 
 void OtlpRecordable::AddLink(const trace::SpanContext &span_context,
                              const common::KeyValueIterable &attributes) noexcept
 {
-  if (static_cast<uint32_t>(span_.links_size()) >= max_links_)
+  if (static_cast<std::uint32_t>(span_.links_size()) >= span_limits_.link_count_limit)
   {
     span_.set_dropped_links_count(span_.dropped_links_count() + 1);
     return;
@@ -167,12 +187,14 @@ void OtlpRecordable::AddLink(const trace::SpanContext &span_context,
                     trace::SpanId::kSize);
   link->set_trace_state(span_context.trace_state()->ToHeader());
   attributes.ForEachKeyValue([&](nostd::string_view key, common::AttributeValue value) noexcept {
-    if (static_cast<uint32_t>(link->attributes_size()) >= max_attributes_per_link_)
+    if (static_cast<std::uint32_t>(link->attributes_size()) >=
+        span_limits_.link_attribute_count_limit)
     {
       link->set_dropped_attributes_count(link->dropped_attributes_count() + 1);
       return true;
     }
-    OtlpPopulateAttributeUtils::PopulateAttribute(link->add_attributes(), key, value, false);
+    OtlpPopulateAttributeUtils::PopulateAttribute(link->add_attributes(), key, value, false,
+                                                  span_limits_.attribute_value_length_limit);
     return true;
   });
 }