fix!: span limits env vars (#879)

Author: fbogsany

sdk/lib/opentelemetry/sdk/trace/span.rb

@@ -296,7 +296,7 @@ def initialize(context, parent_context, name, kind, parent_span_id, span_limits,
           @attributes = attributes.nil? ? nil : Hash[attributes] # We need a mutable copy of attributes.
           trim_span_attributes(@attributes)
           @events = nil
-          @links = trim_links(links, span_limits.link_count_limit, span_limits.attribute_per_link_count_limit)
+          @links = trim_links(links, span_limits.link_count_limit, span_limits.link_attribute_count_limit)
           @span_processors.each { |processor| processor.on_start(self, parent_context) }
         end
 
@@ -327,33 +327,33 @@ def truncate_attribute_values(attrs)
           attrs
         end
 
-        def trim_links(links, link_count_limit, attribute_per_link_count_limit) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def trim_links(links, link_count_limit, link_attribute_count_limit) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           # Fast path (likely) common cases.
           return nil if links.nil?
 
           if links.size <= link_count_limit &&
-             links.all? { |link| link.attributes.size <= attribute_per_link_count_limit && Internal.valid_attributes?(name, 'link', link.attributes) }
+             links.all? { |link| link.attributes.size <= link_attribute_count_limit && Internal.valid_attributes?(name, 'link', link.attributes) }
             return links.frozen? ? links : links.clone.freeze
           end
 
           # Slow path: trim attributes for each Link.
           links.last(link_count_limit).map! do |link|
             attrs = Hash[link.attributes] # link.attributes is frozen, so we need an unfrozen copy to adjust.
             attrs.keep_if { |key, value| Internal.valid_key?(key) && Internal.valid_value?(value) }
-            excess = attrs.size - attribute_per_link_count_limit
+            excess = attrs.size - link_attribute_count_limit
             excess.times { attrs.shift } if excess.positive?
             OpenTelemetry::Trace::Link.new(link.span_context, attrs)
           end.freeze
         end
 
         def append_event(events, event) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           event_count_limit = @span_limits.event_count_limit
-          attribute_per_event_count_limit = @span_limits.attribute_per_event_count_limit
+          event_attribute_count_limit = @span_limits.event_attribute_count_limit
           valid_attributes = Internal.valid_attributes?(name, 'event', event.attributes)
 
           # Fast path (likely) common case.
           if events.size < event_count_limit &&
-             event.attributes.size <= attribute_per_event_count_limit &&
+             event.attributes.size <= event_attribute_count_limit &&
              valid_attributes
             return events << event
           end
@@ -362,11 +362,11 @@ def append_event(events, event) # rubocop:disable Metrics/AbcSize, Metrics/Cyclo
           excess = events.size + 1 - event_count_limit
           events.shift(excess) if excess.positive?
 
-          excess = event.attributes.size - attribute_per_event_count_limit
+          excess = event.attributes.size - event_attribute_count_limit
           if excess.positive? || !valid_attributes
             attrs = Hash[event.attributes] # event.attributes is frozen, so we need an unfrozen copy to adjust.
             attrs.keep_if { |key, value| Internal.valid_key?(key) && Internal.valid_value?(value) }
-            excess = attrs.size - attribute_per_event_count_limit
+            excess = attrs.size - event_attribute_count_limit
             excess.times { attrs.shift } if excess.positive?
             event = Event.new(event.name, attrs.freeze, event.timestamp)
           end

sdk/lib/opentelemetry/sdk/trace/span_limits.rb

@@ -22,10 +22,10 @@ class SpanLimits
         attr_reader :link_count_limit
 
         # The global default max number of attributes per {OpenTelemetry::SDK::Trace::Event}.
-        attr_reader :attribute_per_event_count_limit
+        attr_reader :event_attribute_count_limit
 
         # The global default max number of attributes per {OpenTelemetry::Trace::Link}.
-        attr_reader :attribute_per_link_count_limit
+        attr_reader :link_attribute_count_limit
 
         # Returns a {SpanLimits} with the desired values.
         #
@@ -35,21 +35,21 @@ def initialize(attribute_count_limit: Integer(ENV.fetch('OTEL_SPAN_ATTRIBUTE_COU
                        attribute_length_limit: ENV['OTEL_RUBY_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT'],
                        event_count_limit: Integer(ENV.fetch('OTEL_SPAN_EVENT_COUNT_LIMIT', 128)),
                        link_count_limit: Integer(ENV.fetch('OTEL_SPAN_LINK_COUNT_LIMIT', 128)),
-                       attribute_per_event_count_limit: attribute_count_limit,
-                       attribute_per_link_count_limit: attribute_count_limit)
+                       event_attribute_count_limit: Integer(ENV.fetch('OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT', 128)),
+                       link_attribute_count_limit: Integer(ENV.fetch('OTEL_LINK_ATTRIBUTE_COUNT_LIMIT', 128)))
           raise ArgumentError, 'attribute_count_limit must be positive' unless attribute_count_limit.positive?
           raise ArgumentError, 'attribute_length_limit must not be less than 32' unless attribute_length_limit.nil? || Integer(attribute_length_limit) >= 32
           raise ArgumentError, 'event_count_limit must be positive' unless event_count_limit.positive?
           raise ArgumentError, 'link_count_limit must be positive' unless link_count_limit.positive?
-          raise ArgumentError, 'attribute_per_event_count_limit must be positive' unless attribute_per_event_count_limit.positive?
-          raise ArgumentError, 'attribute_per_link_count_limit must be positive' unless attribute_per_link_count_limit.positive?
+          raise ArgumentError, 'event_attribute_count_limit must be positive' unless event_attribute_count_limit.positive?
+          raise ArgumentError, 'link_attribute_count_limit must be positive' unless link_attribute_count_limit.positive?
 
           @attribute_count_limit = attribute_count_limit
           @attribute_length_limit = attribute_length_limit.nil? ? nil : Integer(attribute_length_limit)
           @event_count_limit = event_count_limit
           @link_count_limit = link_count_limit
-          @attribute_per_event_count_limit = attribute_per_event_count_limit
-          @attribute_per_link_count_limit = attribute_per_link_count_limit
+          @event_attribute_count_limit = event_attribute_count_limit
+          @link_attribute_count_limit = link_attribute_count_limit
         end
 
         # The default {SpanLimits}.

sdk/test/opentelemetry/sdk/trace/span_limits_test.rb

@@ -15,23 +15,25 @@
       _(config.attribute_count_limit).must_equal 128
       _(config.event_count_limit).must_equal 128
       _(config.link_count_limit).must_equal 128
-      _(config.attribute_per_event_count_limit).must_equal 128
-      _(config.attribute_per_link_count_limit).must_equal 128
+      _(config.event_attribute_count_limit).must_equal 128
+      _(config.link_attribute_count_limit).must_equal 128
     end
 
     it 'reflects environment variables' do
       with_env('OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT' => '1',
                'OTEL_SPAN_EVENT_COUNT_LIMIT' => '2',
                'OTEL_SPAN_LINK_COUNT_LIMIT' => '3',
                'OTEL_RUBY_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT' => '32',
+               'OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT' => '5',
+               'OTEL_LINK_ATTRIBUTE_COUNT_LIMIT' => '6',
                'OTEL_TRACES_SAMPLER' => 'always_on') do
         config = subject.new
         _(config.attribute_count_limit).must_equal 1
         _(config.event_count_limit).must_equal 2
         _(config.link_count_limit).must_equal 3
         _(config.attribute_length_limit).must_equal 32
-        _(config.attribute_per_event_count_limit).must_equal 1
-        _(config.attribute_per_link_count_limit).must_equal 1
+        _(config.event_attribute_count_limit).must_equal 5
+        _(config.link_attribute_count_limit).must_equal 6
       end
     end
 
@@ -40,18 +42,20 @@
                'OTEL_SPAN_EVENT_COUNT_LIMIT' => '2',
                'OTEL_SPAN_LINK_COUNT_LIMIT' => '3',
                'OTEL_RUBY_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT' => '4',
+               'OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT' => '5',
+               'OTEL_LINK_ATTRIBUTE_COUNT_LIMIT' => '6',
                'OTEL_TRACES_SAMPLER' => 'always_on') do
         config = subject.new(attribute_count_limit: 10,
                              event_count_limit: 11,
                              link_count_limit: 12,
-                             attribute_per_event_count_limit: 13,
-                             attribute_per_link_count_limit: 14,
+                             event_attribute_count_limit: 13,
+                             link_attribute_count_limit: 14,
                              attribute_length_limit: 32)
         _(config.attribute_count_limit).must_equal 10
         _(config.event_count_limit).must_equal 11
         _(config.link_count_limit).must_equal 12
-        _(config.attribute_per_event_count_limit).must_equal 13
-        _(config.attribute_per_link_count_limit).must_equal 14
+        _(config.event_attribute_count_limit).must_equal 13
+        _(config.link_attribute_count_limit).must_equal 14
         _(config.attribute_length_limit).must_equal 32
       end
     end

sdk/test/opentelemetry/sdk/trace/span_test.rb

@@ -19,8 +19,8 @@
       attribute_count_limit: 1,
       event_count_limit: 1,
       link_count_limit: 1,
-      attribute_per_event_count_limit: 1,
-      attribute_per_link_count_limit: 1,
+      event_attribute_count_limit: 1,
+      link_attribute_count_limit: 1,
       attribute_length_limit: 32
     )
   end
@@ -250,7 +250,7 @@
       SpanLimits.new(
         attribute_count_limit: 10,
         event_count_limit: 5,
-        attribute_per_event_count_limit: 10
+        event_attribute_count_limit: 10
       )
     end
 

sdk/test/opentelemetry/sdk/trace/tracer_test.rb

@@ -130,7 +130,7 @@
     end
 
     it 'trims link attributes' do
-      tracer_provider.span_limits = SpanLimits.new(attribute_per_link_count_limit: 1)
+      tracer_provider.span_limits = SpanLimits.new(link_attribute_count_limit: 1)
       link = OpenTelemetry::Trace::Link.new(OpenTelemetry::Trace::SpanContext.new, '1' => 1, '2' => 2)
       span = tracer.start_root_span('root', links: [link])
       _(span.links.first.attributes.size).must_equal(1)
@@ -285,7 +285,7 @@
     end
 
     it 'trims link attributes' do
-      tracer_provider.span_limits = SpanLimits.new(attribute_per_link_count_limit: 1)
+      tracer_provider.span_limits = SpanLimits.new(link_attribute_count_limit: 1)
       link = OpenTelemetry::Trace::Link.new(OpenTelemetry::Trace::SpanContext.new, '1' => 1, '2' => 2)
       span = tracer.start_span('op', with_parent: context, links: [link])
       _(span.links.first.attributes.size).must_equal(1)