opentelemetry-sdk 0.2.0

data/lib/opentelemetry/sdk/trace/multi_span_processor.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      # Implementation of the SpanProcessor duck type that simply forwards all
+      # received events to a list of SpanProcessors.
+      class MultiSpanProcessor
+        # Creates a new {MultiSpanProcessor}.
+        #
+        # @param [Enumerable<SpanProcessor>] span_processors a collection of
+        #   SpanProcessors.
+        # @return [MultiSpanProcessor]
+        def initialize(span_processors)
+          @span_processors = span_processors.to_a.freeze
+        end
+
+        # Called when a {Span} is started, if the {Span#recording?}
+        # returns true.
+        #
+        # This method is called synchronously on the execution thread, should
+        # not throw or block the execution thread.
+        #
+        # @param [Span] span the {Span} that just started.
+        def on_start(span)
+          @span_processors.each { |processor| processor.on_start(span) }
+        end
+
+        # Called when a {Span} is ended, if the {Span#recording?}
+        # returns true.
+        #
+        # This method is called synchronously on the execution thread, should
+        # not throw or block the execution thread.
+        #
+        # @param [Span] span the {Span} that just ended.
+        def on_finish(span)
+          @span_processors.each { |processor| processor.on_finish(span) }
+        end
+
+        # Called when {TracerFactory#shutdown} is called.
+        def shutdown
+          @span_processors.each(&:shutdown)
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/sdk/trace/noop_span_processor.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'singleton'
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      # NoopSpanProcessor is a singleton implementation of the duck type
+      # SpanProcessor that provides synchronous no-op hooks for when a
+      # {Span} is started or when a {Span} is ended.
+      class NoopSpanProcessor
+        include Singleton
+
+        # Called when a {Span} is started, if the {Span#recording?}
+        # returns true.
+        #
+        # This method is called synchronously on the execution thread, should
+        # not throw or block the execution thread.
+        #
+        # @param [Span] span the {Span} that just started.
+        def on_start(span); end
+
+        # Called when a {Span} is ended, if the {Span#recording?}
+        # returns true.
+        #
+        # This method is called synchronously on the execution thread, should
+        # not throw or block the execution thread.
+        #
+        # @param [Span] span the {Span} that just ended.
+        def on_finish(span); end
+
+        # Called when {TracerFactory#shutdown} is called.
+        def shutdown; end
+      end
+    end
+  end
+end

data/lib/opentelemetry/sdk/trace/samplers.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'opentelemetry/sdk/trace/samplers/decision'
+require 'opentelemetry/sdk/trace/samplers/result'
+require 'opentelemetry/sdk/trace/samplers/probability_sampler'
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      # The Samplers module contains the sampling logic for OpenTelemetry. The
+      # reference implementation provides a {ProbabilitySampler}, {ALWAYS_ON},
+      # {ALWAYS_OFF}, and {ALWAYS_PARENT}.
+      #
+      # Custom samplers can be provided by SDK users. The required interface is
+      # a callable with the signature:
+      #
+      #   (trace_id:, span_id:, parent_context:, hint:, links:, name:, kind:, attributes:) -> Result
+      #
+      # Where:
+      #
+      # @param [String] trace_id The trace_id of the {Span} to be created.
+      # @param [String] span_id The span_id of the {Span} to be created.
+      # @param [OpenTelemetry::Trace::SpanContext] parent_context The
+      #   {OpenTelemetry::Trace::SpanContext} of a parent span, typically
+      #   extracted from the wire. Can be nil for a root span.
+      # @param [Symbol] hint A {OpenTelemetry::Trace::SamplingHint} about
+      #   whether the {Span} should be sampled and/or record events.
+      # @param [Enumerable<Link>] links A collection of links to be associated
+      #   with the {Span} to be created. Can be nil.
+      # @param [String] name Name of the {Span} to be created.
+      # @param [Symbol] kind The {OpenTelemetry::Trace::SpanKind} of the {Span}
+      #   to be created. Can be nil.
+      # @param [Hash<String, Object>] attributes Attributes to be attached
+      #   to the {Span} to be created. Can be nil.
+      # @return [Result] The sampling result.
+      module Samplers
+        RECORD_AND_SAMPLED = Result.new(decision: Decision::RECORD_AND_SAMPLED)
+        NOT_RECORD = Result.new(decision: Decision::NOT_RECORD)
+        RECORD = Result.new(decision: Decision::RECORD)
+        SAMPLING_HINTS = [Decision::NOT_RECORD, Decision::RECORD, Decision::RECORD_AND_SAMPLED].freeze
+        APPLY_PROBABILITY_TO_SYMBOLS = %i[root_spans root_spans_and_remote_parent all_spans].freeze
+
+        private_constant(:RECORD_AND_SAMPLED, :NOT_RECORD, :RECORD, :SAMPLING_HINTS, :APPLY_PROBABILITY_TO_SYMBOLS)
+
+        # rubocop:disable Lint/UnusedBlockArgument
+
+        # Ignores all values in hint and returns a {Result} with
+        # {Decision::RECORD_AND_SAMPLED}.
+        ALWAYS_ON = ->(trace_id:, span_id:, parent_context:, hint:, links:, name:, kind:, attributes:) { RECORD_AND_SAMPLED }
+
+        # Ignores all values in hint and returns a {Result} with
+        # {Decision::NOT_RECORD}.
+        ALWAYS_OFF = ->(trace_id:, span_id:, parent_context:, hint:, links:, name:, kind:, attributes:) { NOT_RECORD }
+
+        # Ignores all values in hint and returns a {Result} with
+        # {Decision::RECORD_AND_SAMPLED} if the parent context is sampled or
+        # {Decision::NOT_RECORD} otherwise, or if there is no parent context.
+        # rubocop:disable Style/Lambda
+        ALWAYS_PARENT = ->(trace_id:, span_id:, parent_context:, hint:, links:, name:, kind:, attributes:) do
+          if parent_context&.trace_flags&.sampled?
+            RECORD_AND_SAMPLED
+          else
+            NOT_RECORD
+          end
+        end
+        # rubocop:enable Style/Lambda
+        # rubocop:enable Lint/UnusedBlockArgument
+
+        # Returns a new sampler. The probability of sampling a trace is equal
+        # to that of the specified probability.
+        #
+        # @param [Numeric] probability The desired probability of sampling.
+        #   Must be within [0.0, 1.0].
+        # @param [optional Enumerable<Symbol>] ignore_hints Sampling hints to
+        #   ignore. Defaults to ignore {OpenTelemetry::Trace::SamplingHint::RECORD}.
+        # @param [optional Boolean] ignore_parent Whether to ignore parent
+        #   sampling. Defaults to not ignore parent sampling.
+        # @param [optional Symbol] apply_probability_to Whether to apply
+        #   probability sampling to root spans, root spans and remote parents,
+        #   or all spans. Allowed values include :root_spans, :root_spans_and_remote_parent,
+        #   and :all_spans. Defaults to :root_spans_and_remote_parent.
+        # @raise [ArgumentError] if probability is out of range
+        # @raise [ArgumentError] if ignore_hints contains invalid hints
+        # @raise [ArgumentError] if apply_probability_to is not one of the allowed symbols
+        def self.probability(probability,
+                             ignore_hints: [OpenTelemetry::Trace::SamplingHint::RECORD],
+                             ignore_parent: false,
+                             apply_probability_to: :root_spans_and_remote_parent)
+          raise ArgumentError, 'probability must be in range [0.0, 1.0]' unless (0.0..1.0).include?(probability)
+          raise ArgumentError, 'ignore_hints' unless (ignore_hints.to_a - SAMPLING_HINTS).empty?
+          raise ArgumentError, 'apply_probability_to' unless APPLY_PROBABILITY_TO_SYMBOLS.include?(apply_probability_to)
+
+          ProbabilitySampler.new(probability,
+                                 ignore_hints: ignore_hints.to_a,
+                                 ignore_parent: ignore_parent,
+                                 apply_to_remote_parent: apply_probability_to != :root_spans,
+                                 apply_to_all_spans: apply_probability_to == :all_spans)
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/sdk/trace/samplers/decision.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      module Samplers
+        # The Decision module contains a set of constants to be used in the
+        # decision part of a sampling {Result}.
+        module Decision
+          # Decision to not record events and not sample.
+          NOT_RECORD = OpenTelemetry::Trace::SamplingHint::NOT_RECORD
+
+          # Decision to record events and not sample.
+          RECORD = OpenTelemetry::Trace::SamplingHint::RECORD
+
+          # Decision to record events and sample.
+          RECORD_AND_SAMPLED = OpenTelemetry::Trace::SamplingHint::RECORD_AND_SAMPLED
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/sdk/trace/samplers/probability_sampler.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      module Samplers
+        # @api private
+        #
+        # Implements sampling based on a probability.
+        class ProbabilitySampler
+          HINT_RECORD_AND_SAMPLED = OpenTelemetry::Trace::SamplingHint::RECORD_AND_SAMPLED
+          HINT_RECORD = OpenTelemetry::Trace::SamplingHint::RECORD
+
+          private_constant(:HINT_RECORD_AND_SAMPLED, :HINT_RECORD)
+
+          def initialize(probability, ignore_hints:, ignore_parent:, apply_to_remote_parent:, apply_to_all_spans:)
+            @probability = probability
+            @id_upper_bound = format('%016x', (probability * (2**64 - 1)).ceil)
+            @ignored_hints = ignore_hints
+            @use_parent_sampled_flag = !ignore_parent
+            @apply_to_remote_parent = apply_to_remote_parent
+            @apply_to_all_spans = apply_to_all_spans
+          end
+
+          # @api private
+          #
+          # Callable interface for probability sampler. See {Samplers}.
+          def call(trace_id:, span_id:, parent_context:, hint:, links:, name:, kind:, attributes:)
+            # Ignored for sampling decision: links, name, kind, attributes.
+
+            hint = nil if @ignored_hints.include?(hint)
+
+            sampled = sample?(hint, trace_id, parent_context)
+            recording = hint == HINT_RECORD || sampled
+
+            if sampled && recording
+              RECORD_AND_SAMPLED
+            elsif recording
+              RECORD
+            else
+              NOT_RECORD
+            end
+          end
+
+          private
+
+          def sample?(hint, trace_id, parent_context)
+            if parent_context.nil?
+              hint == HINT_RECORD_AND_SAMPLED || sample_trace_id?(trace_id)
+            else
+              parent_sampled?(parent_context) || hint == HINT_RECORD_AND_SAMPLED || sample_trace_id_for_child?(parent_context, trace_id)
+            end
+          end
+
+          def parent_sampled?(parent_context)
+            @use_parent_sampled_flag && parent_context.trace_flags.sampled?
+          end
+
+          def sample_trace_id_for_child?(parent_context, trace_id)
+            (@apply_to_all_spans || (@apply_to_remote_parent && parent_context.remote?)) && sample_trace_id?(trace_id)
+          end
+
+          def sample_trace_id?(trace_id)
+            @probability == 1.0 || trace_id[16, 16] < @id_upper_bound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/sdk/trace/samplers/result.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      module Samplers
+        # The Result class represents an arbitrary sampling result. It has
+        # boolean values for the sampling decision and whether to record
+        # events, and a collection of attributes to be attached to a sampled
+        # root span.
+        class Result
+          EMPTY_HASH = {}.freeze
+          DECISIONS = [Decision::RECORD, Decision::NOT_RECORD, Decision::RECORD_AND_SAMPLED].freeze
+          private_constant(:EMPTY_HASH, :DECISIONS)
+
+          # Returns a frozen hash of attributes to be attached span.
+          #
+          # @return [Hash<String, Object>]
+          attr_reader :attributes
+
+          # Returns a new sampling result with the specified decision and
+          # attributes.
+          #
+          # @param [Symbol] decision Whether or not a span should be sampled
+          #   and/or record events.
+          # @param [optional Hash<String, Object>] attributes A frozen or freezable hash
+          #   containing attributes to be attached to the span.
+          def initialize(decision:, attributes: nil)
+            @decision = decision
+            @attributes = attributes.freeze || EMPTY_HASH
+          end
+
+          # Returns true if this span should be sampled.
+          #
+          # @return [Boolean] sampling decision
+          def sampled?
+            @decision == Decision::RECORD_AND_SAMPLED
+          end
+
+          # Returns true if this span should record events, attributes, status, etc.
+          #
+          # @return [Boolean] recording decision
+          def recording?
+            @decision != Decision::NOT_RECORD
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      # Implementation of {OpenTelemetry::Trace::Span} that records trace events.
+      #
+      # This implementation includes reader methods intended to allow access to
+      # internal state by SpanProcessors (see {NoopSpanProcessor} for the interface).
+      # Instrumentation should use the API provided by {OpenTelemetry::Trace::Span}
+      # and should consider {Span} to be write-only.
+      #
+      # rubocop:disable Metrics/ClassLength
+      class Span < OpenTelemetry::Trace::Span
+        # The following readers are intended for the use of SpanProcessors and
+        # should not be considered part of the public interface for instrumentation.
+        attr_reader :name, :status, :kind, :parent_span_id, :start_timestamp, :end_timestamp, :links, :library_resource
+
+        # Return a frozen copy of the current attributes. This is intended for
+        # use of SpanProcesses and should not be considered part of the public
+        # interface for instrumentation.
+        #
+        # @return [Hash<String, Object>] may be nil.
+        def attributes
+          # Don't bother synchronizing. Access by SpanProcessors is expected to
+          # be serialized.
+          @attributes&.clone.freeze
+        end
+
+        # Return a frozen copy of the current events. This is intended for use
+        # of SpanProcessors and should not be considered part of the public
+        # interface for instrumentation.
+        #
+        # @return [Array<Event>] may be nil.
+        def events
+          # Don't bother synchronizing. Access by SpanProcessors is expected to
+          # be serialized.
+          @events&.clone.freeze
+        end
+
+        # Return the flag whether this span is recording events
+        #
+        # @return [Boolean] true if this Span is active and recording information
+        #   like events with the #add_event operation and attributes using
+        #   #set_attribute.
+        def recording?
+          true
+        end
+
+        # Set attribute
+        #
+        # Note that the OpenTelemetry project
+        # {https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/data-semantic-conventions.md
+        # documents} certain "standard attributes" that have prescribed semantic
+        # meanings.
+        #
+        # @param [String] key
+        # @param [String, Boolean, Numeric] value
+        #
+        # @return [self] returns itself
+        def set_attribute(key, value)
+          super
+          @mutex.synchronize do
+            if @ended
+              OpenTelemetry.logger.warn('Calling set_attribute on an ended Span.')
+            else
+              @attributes ||= {}
+              @attributes[key] = value
+              trim_span_attributes(@attributes)
+              @total_recorded_attributes += 1
+            end
+          end
+          self
+        end
+
+        # Add an Event to a {Span}. This can be accomplished eagerly or lazily.
+        # Lazy evaluation is useful when the event attributes are expensive to
+        # build and where the cost can be avoided for an unsampled {Span}.
+        #
+        # Eager example:
+        #
+        #   span.add_event(name: 'event', attributes: {'eager' => true})
+        #
+        # Lazy example:
+        #
+        #   span.add_event { OpenTelemetry::Trace::Event.new(name: 'event', attributes: {'eager' => false}) }
+        #
+        # Note that the OpenTelemetry project
+        # {https://github.com/open-telemetry/opentelemetry-specification/blob/master/semantic-conventions.md
+        # documents} certain "standard event names and keys" which have
+        # prescribed semantic meanings.
+        #
+        # @param [optional String] name Optional name of the event. This is
+        #   required if a block is not given.
+        # @param [optional Hash<String, Object>] attributes One or more key:value
+        #   pairs, where the keys must be strings and the values may be string,
+        #   boolean or numeric type. This argument should only be used when
+        #   passing in a name.
+        # @param [optional Time] timestamp Optional timestamp for the event.
+        #   This argument should only be used when passing in a name.
+        #
+        # @return [self] returns itself
+        def add_event(name: nil, attributes: nil, timestamp: nil)
+          super
+          event = block_given? ? yield : OpenTelemetry::Trace::Event.new(name: name, attributes: attributes, timestamp: timestamp || Time.now)
+          @mutex.synchronize do
+            if @ended
+              OpenTelemetry.logger.warn('Calling add_event on an ended Span.')
+            else
+              @events ||= []
+              @events = append_event(@events, event)
+              @total_recorded_events += 1
+            end
+          end
+          self
+        end
+
+        # Sets the Status to the Span
+        #
+        # If used, this will override the default Span status. Default is OK.
+        #
+        # Only the value of the last call will be recorded, and implementations
+        # are free to ignore previous calls.
+        #
+        # @param [Status] status The new status, which overrides the default Span
+        #   status, which is OK.
+        #
+        # @return [void]
+        def status=(status)
+          super
+          @mutex.synchronize do
+            if @ended
+              OpenTelemetry.logger.warn('Calling status= on an ended Span.')
+            else
+              @status = status
+            end
+          end
+        end
+
+        # Updates the Span name
+        #
+        # Upon this update, any sampling behavior based on Span name will depend
+        # on the implementation.
+        #
+        # @param [String] new_name The new operation name, which supersedes
+        #   whatever was passed in when the Span was started
+        #
+        # @return [void]
+        def name=(new_name)
+          super
+          @mutex.synchronize do
+            if @ended
+              OpenTelemetry.logger.warn('Calling name= on an ended Span.')
+            else
+              @name = new_name
+            end
+          end
+        end
+
+        # Finishes the Span
+        #
+        # Implementations MUST ignore all subsequent calls to {#finish} (there
+        # might be exceptions when Tracer is streaming event and has no mutable
+        # state associated with the Span).
+        #
+        # Call to {#finish} MUST not have any effects on child spans. Those may
+        # still be running and can be ended later.
+        #
+        # This API MUST be non-blocking*.
+        #
+        # (*) not actually non-blocking. In particular, it synchronizes on an
+        # internal mutex, which will typically be uncontended, and
+        # {Export::BatchSpanProcessor} will also synchronize on a mutex, if that
+        # processor is used.
+        #
+        # @param [Time] end_timestamp optional end timestamp for the span.
+        #
+        # @return [self] returns itself
+        def finish(end_timestamp: nil)
+          @mutex.synchronize do
+            if @ended
+              OpenTelemetry.logger.warn('Calling finish on an ended Span.')
+              return self
+            end
+            @end_timestamp = end_timestamp || Time.now
+            @attributes.freeze
+            @events.freeze
+            @ended = true
+          end
+          @span_processor.on_finish(self)
+          self
+        end
+
+        # @api private
+        #
+        # Returns a SpanData containing a snapshot of the Span fields. It is
+        # assumed that the Span has been finished, and that no further
+        # modifications will be made to the Span.
+        #
+        # This method should be called *only* from a SpanProcessor prior to
+        # calling the SpanExporter.
+        #
+        # @return [SpanData]
+        def to_span_data
+          SpanData.new(
+            @name,
+            @kind,
+            @status,
+            @parent_span_id,
+            @child_count,
+            @total_recorded_attributes,
+            @total_recorded_events,
+            @total_recorded_links,
+            @start_timestamp,
+            @end_timestamp,
+            @attributes,
+            @links,
+            @events,
+            @library_resource,
+            context.span_id,
+            context.trace_id,
+            context.trace_flags
+          )
+        end
+
+        # @api private
+        def initialize(context, name, kind, parent_span_id, trace_config, span_processor, attributes, links, start_timestamp, library_resource) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          super(span_context: context)
+          @mutex = Mutex.new
+          @name = name
+          @kind = kind
+          @parent_span_id = parent_span_id.freeze || OpenTelemetry::Trace::INVALID_SPAN_ID
+          @trace_config = trace_config
+          @span_processor = span_processor
+          @library_resource = library_resource
+          @ended = false
+          @status = nil
+          @child_count = 0
+          @total_recorded_events = 0
+          @total_recorded_links = links&.size || 0
+          @total_recorded_attributes = attributes&.size || 0
+          @start_timestamp = start_timestamp
+          @end_timestamp = nil
+          @attributes = attributes.nil? ? nil : Hash[attributes] # We need a mutable copy of attributes.
+          trim_span_attributes(@attributes)
+          @events = nil
+          @links = trim_links(links, trace_config.max_links_count, trace_config.max_attributes_per_link)
+          @span_processor.on_start(self)
+        end
+
+        # TODO: Java implementation overrides finalize to log if a span isn't finished.
+
+        private
+
+        def trim_span_attributes(attrs)
+          return if attrs.nil?
+
+          excess = attrs.size - @trace_config.max_attributes_count
+          # TODO: with Ruby 2.5, replace with the more efficient
+          # attrs.shift(excess) if excess.positive?
+          excess.times { attrs.shift } if excess.positive?
+          nil
+        end
+
+        def trim_links(links, max_links_count, max_attributes_per_link) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          # Fast path (likely) common cases.
+          return nil if links.nil?
+
+          if links.size <= max_links_count &&
+             links.all? { |link| link.attributes.size <= max_attributes_per_link && Internal.valid_attributes?(link.attributes) }
+            return links.frozen? ? links : links.clone.freeze
+          end
+
+          # Slow path: trim attributes for each Link.
+          links.last(max_links_count).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 - max_attributes_per_link
+            excess.times { attrs.shift } if excess.positive?
+            OpenTelemetry::Trace::Link.new(link.context, attrs)
+          end.freeze
+        end
+
+        def append_event(events, event) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          max_events_count = @trace_config.max_events_count
+          max_attributes_per_event = @trace_config.max_attributes_per_event
+
+          # Fast path (likely) common case.
+          if events.size < max_events_count &&
+             event.attributes.size <= max_attributes_per_event &&
+             Internal.valid_attributes?(event.attributes)
+            return events << event
+          end
+
+          # Slow path.
+          excess = events.size + 1 - max_events_count
+          events.shift(excess) if excess.positive?
+
+          excess = event.attributes.size - max_attributes_per_event
+          if excess.positive? || !Internal.valid_attributes?(event.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 - max_attributes_per_event
+            excess.times { attrs.shift } if excess.positive?
+            event = OpenTelemetry::Trace::Event.new(name: event.name, attributes: attrs, timestamp: event.timestamp)
+          end
+          events << event
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end