datadog-ci 1.34.0 → 1.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2adf2fb252fdff7c6d0e1e73c2b6ade74c53bc5e8a238d447793da6833837c0
-  data.tar.gz: a49b2d09ae48bb2dc90c9846c6aae128a05d75353a2e7dc9df248960f165f556
+  metadata.gz: f1aa81f9987d876f143abe3a9b7721e1a5b35178c5c854dcdaf79b872c5a0c9e
+  data.tar.gz: 261ea8b1b233ac66c0ba7b417018fe477afb05a274ed6607b6bf3c235c58c3ff
 SHA512:
-  metadata.gz: 75d99396decbd20bb93cc2e061295be1e55c033b41980216bc0bb9229fd36269e7ad8bd5ad1104203ca10a32bed668aa65f41d01ddd5c8ebef34d206397a7c25
-  data.tar.gz: 3a0efeaaad0042cd836c51a7232a0348b377acf959bc6e10670e01ed5d7ea863caf60853142cb7e2d563da1c64ef1dadee5c3735a69bf482dfdb7b611239767d
+  metadata.gz: 05aed65898a6b065f99e6a9fd2aab34023fd3ac77aaacc4146d39d8a1e6653ad5cb6d970afc5e6d590a4ddf6eec3f54704089a5ea49d7bf2f614d27d1572ed91
+  data.tar.gz: f89daf423afed1bd0ac7c227a28c4a980b92916fcf03a078a9278eb880e059c9fb40f8dc3b0887645e8a806f2e879e70bf23eaaa7500cd3e6e6e2d4b518a449f

data/CHANGELOG.md

@@ -1,5 +1,7 @@
 ## [Unreleased]
 
+## [1.35.0] - 2026-07-23
+
 ## [1.34.0] - 2026-06-25
 
 ### Added
@@ -665,7 +667,8 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 
 - Ruby versions < 2.7 no longer supported ([#8][])
 
-[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.34.0...main
+[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.35.0...main
+[1.35.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.34.0...v1.35.0
 [1.34.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.33.0...v1.34.0
 [1.33.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.32.0...v1.33.0
 [1.32.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.31.0...v1.32.0

data/lib/datadog/ci/contrib/minitest/helpers.rb

@@ -81,11 +81,14 @@ module Datadog
           end
 
           def self.extract_runnable_source_location(klass, method_name)
-            source_location = extract_source_location_from_class(klass)
-            if source_location.nil? || source_location.empty?
-              return klass.instance_method(method_name).source_location
+            method_source_location = extract_source_location_from_method(klass, method_name)
+            klass_source_location = extract_source_location_from_class(klass)
+
+            if defined?(::Minitest::Spec) && klass&.ancestors&.include?(::Minitest::Spec)
+              method_source_location || klass_source_location
+            else
+              klass_source_location || method_source_location
             end
-            source_location
           end
 
           def self.skip_test_suite(test_suite)
@@ -102,9 +105,21 @@ module Datadog
           end
 
           def self.extract_source_location_from_class(klass)
-            return [] if klass.nil? || klass.name.nil?
+            return nil if klass.nil? || klass.name.nil?
+
+            empty_source_location_to_nil(SourceCode::ConstantResolver.safely_get_const_source_location(klass.name))
+          end
 
-            SourceCode::ConstantResolver.safely_get_const_source_location(klass.name) || []
+          def self.extract_source_location_from_method(klass, method_name)
+            return nil if klass.nil?
+            return nil if method_name.nil? || method_name.empty?
+
+            empty_source_location_to_nil(klass.instance_method(method_name).source_location)
+          end
+
+          def self.empty_source_location_to_nil(source_location)
+            return nil if source_location.nil? || source_location.empty?
+            source_location
           end
         end
       end

data/lib/datadog/ci/contrib/rspec/anonymous_example_name.rb

@@ -0,0 +1,515 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module Contrib
+      module RSpec
+        module AnonymousExampleName
+          ISEQ_SIMPLE_DATA_FORMAT = "YARVInstructionSequence/SimpleDataFormat"
+
+          SELF_VALUE = :__datadog_rspec_self__
+          EMPTY_ARGUMENTS = [].freeze
+          MINIMUM_RUBY_VERSION = Gem::Version.new("3.2")
+
+          EXPECTATION_METHODS = {
+            to: "is expected to",
+            not_to: "is expected not to",
+            to_not: "is expected not to"
+          }.freeze
+          SHOULD_METHODS = {
+            should: "is expected to",
+            should_not: "is expected not to"
+          }.freeze
+          OPERATOR_METHODS = %i[== != === =~ !~ < <= > >= + - * / %].each_with_object({}) { |method_name, methods|
+            methods[method_name] = true
+          }.freeze
+          MATCHER_CHAIN_METHODS = %i[
+            and
+            at_least
+            at_most
+            by
+            by_at_least
+            by_at_most
+            exactly
+            from
+            of
+            once
+            or
+            times
+            to
+            twice
+            with
+            within
+          ].each_with_object({}) { |method_name, methods|
+            methods[method_name] = true
+          }.freeze
+          PRETTY_MATCHER_PREFIXES = %w[be_ have_ raise_ respond_ yield_ start_ end_].freeze
+          PRETTY_MATCHER_METHODS = %i[
+            be
+            change
+            contain_exactly
+            eq
+            eql
+            equal
+            exist
+            include
+            match
+            output
+            raise_error
+            satisfy
+            throw_symbol
+          ].each_with_object({}) { |method_name, methods|
+            methods[method_name] = true
+          }.freeze
+          MAX_RENDERED_VALUE_LENGTH = 80
+          MAX_RENDERED_NAME_LENGTH = 180
+
+          def self.supported?
+            return false unless defined?(RubyVM::InstructionSequence)
+            return false unless RUBY_ENGINE == "ruby"
+
+            Gem::Version.new(RUBY_VERSION) >= MINIMUM_RUBY_VERSION
+          end
+
+          def self.call(target)
+            return nil if target.nil?
+            return nil unless supported?
+
+            iseq = iseq_for(target)
+            return nil unless iseq
+
+            rendered_name = render_iseq(iseq)
+            trim(rendered_name, MAX_RENDERED_NAME_LENGTH) if rendered_name
+          rescue => e
+            warn_anonymous_example_name_error(e)
+            nil
+          end
+
+          def self.iseq_for(target)
+            return target if target.is_a?(RubyVM::InstructionSequence)
+
+            RubyVM::InstructionSequence.of(target)
+          end
+          private_class_method :iseq_for
+
+          def self.render_iseq(iseq)
+            body = iseq.to_a[13]
+            return nil unless body.is_a?(Array)
+
+            # Most anonymous RSpec examples end with `<expectation>.to <matcher>`.
+            # Render only that known shape by walking backwards from the final matcher call:
+            # it avoids simulating unrelated subject code, so dynamic values do not
+            # leak into the name and dangerous user code is not evaluated.
+            expectation_call_index = final_expectation_call_index(body)
+            return nil unless expectation_call_index
+
+            call_data = body[expectation_call_index][1]
+            return nil unless call_data[:orig_argc].to_i == 1
+
+            matcher_expression = render_expression_ending_at(body, expectation_call_index - 1)
+            return nil unless matcher_expression
+
+            method_name = call_data[:mid]
+            return nil if EXPECTATION_METHODS.key?(method_name) && !expectation_receiver_at?(body, matcher_expression[1])
+
+            name_prefix = EXPECTATION_METHODS[method_name] || SHOULD_METHODS[method_name]
+            "#{name_prefix} #{matcher_expression[0]}"
+          end
+          private_class_method :render_iseq
+
+          def self.final_expectation_call_index(body)
+            index = body.length - 1
+
+            while index >= 0
+              entry = body[index]
+
+              if entry.is_a?(Array)
+                call_data = entry[1]
+                if call_data.is_a?(Hash)
+                  method_name = call_data[:mid]
+                  return index if EXPECTATION_METHODS.key?(method_name) || SHOULD_METHODS.key?(method_name)
+                end
+              end
+
+              index -= 1
+            end
+
+            nil
+          end
+          private_class_method :final_expectation_call_index
+
+          def self.expectation_receiver_at?(body, index)
+            index = previous_instruction_index(body, index)
+            return false unless index
+
+            instruction = body[index]
+            call_data = instruction[1]
+            return false unless call_data.is_a?(Hash)
+
+            method_name = call_data[:mid]
+            method_name == :expect || method_name == :is_expected
+          end
+          private_class_method :expectation_receiver_at?
+
+          # Render the expression that produced the stack value at `index`.
+          #
+          # YARV bytecode is stack-based: matcher arguments are pushed before the
+          # final `to`/`not_to` call consumes them. We walk backwards from the
+          # producer instruction, render only shapes we understand, and return the
+          # previous instruction index so callers can continue rendering earlier
+          # stack values without evaluating user code.
+          def self.render_expression_ending_at(body, index)
+            return nil unless index
+
+            index = previous_instruction_index(body, index)
+            return nil unless index
+
+            instruction = body[index]
+            opcode = instruction[0]
+
+            case opcode
+            when :putself
+              [SELF_VALUE, index - 1]
+            when :putnil
+              ["nil", index - 1]
+            when :putobject, :putchilledstring, :putstring
+              [render_literal(instruction[1]), index - 1]
+            when :duparray
+              [render_array_literal(instruction[1]), index - 1]
+            when :duphash
+              [render_hash_literal(instruction[1]), index - 1]
+            when :newarray
+              render_new_array_expression(body, index)
+            when :newhash
+              render_new_hash_expression(body, index)
+            when :opt_getconstant_path
+              [render_constant_path(instruction[1]), index - 1]
+            when :pop
+              render_optimized_new_expression(body, index)
+            when :send, :opt_send_without_block, :opt_plus, :opt_minus, :opt_mult, :opt_div,
+              :opt_mod, :opt_eq, :opt_neq, :opt_lt, :opt_le, :opt_gt, :opt_ge
+              render_send_expression(body, index, instruction)
+            else
+              render_special_expression(index, instruction)
+            end
+          end
+          private_class_method :render_expression_ending_at
+
+          # `newarray` consumes N already-pushed stack values. Render those values
+          # backwards, then restore source order so matcher names read like Ruby.
+          def self.render_new_array_expression(body, index)
+            expression = render_expression_list_ending_at(body, index - 1, body[index][1].to_i)
+            return nil unless expression
+
+            [render_array_literal(expression[0]), expression[1]]
+          end
+          private_class_method :render_new_array_expression
+
+          # `newhash` consumes alternating key/value stack entries. We render the
+          # pairs instead of inspecting a runtime Hash, keeping generated names
+          # deterministic even when the original values are local variables.
+          def self.render_new_hash_expression(body, index)
+            expression = render_expression_list_ending_at(body, index - 1, body[index][1].to_i)
+            return nil unless expression
+
+            values = expression[0]
+            pairs = values.each_slice(2).map { |key, value| "#{key} => #{value}" }
+            ["{#{pairs.join(", ")}}", expression[1]]
+          end
+          private_class_method :render_new_hash_expression
+
+          def self.render_optimized_new_expression(body, index)
+            # Ruby 4 compiles zero-argument `Class.new` with `opt_new` followed by
+            # constructor bookkeeping and a final `pop`. Collapse that whole shape
+            # back to the receiver class so `Object.new` renders as stable `Object`.
+            swap_index = previous_instruction_index(body, index - 1)
+            return nil unless swap_index
+            return nil unless body[swap_index][0] == :swap
+
+            receiver_index = optimized_new_receiver_index(body, swap_index - 1)
+            return nil unless receiver_index
+
+            receiver_expression = render_expression_ending_at(body, receiver_index)
+            return nil unless receiver_expression
+
+            [render_send(receiver_expression[0], :new, EMPTY_ARGUMENTS, nil), receiver_expression[1]]
+          end
+          private_class_method :render_optimized_new_expression
+
+          # Ruby 4's optimized constructor bytecode places the receiver before
+          # `putnil`, `swap`, and `opt_new`. Find that receiver so the outer `pop`
+          # handler can render `Object.new` as the stable class name `Object`.
+          def self.optimized_new_receiver_index(body, index)
+            while index >= 0
+              entry = body[index]
+
+              if entry.is_a?(Array) && entry[0] == :opt_new
+                call_data = entry[1]
+                if call_data.is_a?(Hash) && call_data[:mid] == :new && call_data[:orig_argc].to_i.zero?
+                  swap_index = previous_instruction_index(body, index - 1)
+                  return nil unless swap_index
+                  return nil unless body[swap_index][0] == :swap
+
+                  nil_index = previous_instruction_index(body, swap_index - 1)
+                  return nil unless nil_index
+                  return nil unless body[nil_index][0] == :putnil
+
+                  return previous_instruction_index(body, nil_index - 1)
+                end
+              end
+
+              index -= 1
+            end
+
+            nil
+          end
+          private_class_method :optimized_new_receiver_index
+
+          # Method calls consume arguments first and the receiver last. Render that
+          # stack shape backwards, then format the send as matcher-style text when
+          # it belongs to RSpec's expectation DSL.
+          def self.render_send_expression(body, index, instruction)
+            call_data = instruction[1]
+            return nil unless call_data.is_a?(Hash)
+
+            arguments_expression = render_expression_list_ending_at(body, index - 1, call_data[:orig_argc].to_i)
+            return nil unless arguments_expression
+
+            arguments = arguments_expression[0]
+            receiver_end_index = arguments_expression[1]
+
+            receiver_index = previous_instruction_index(body, receiver_end_index)
+            return nil unless receiver_index
+
+            receiver_instruction = body[receiver_index]
+            if receiver_instruction[0] == :putself
+              receiver = SELF_VALUE
+              previous_index = receiver_index - 1
+            else
+              receiver_expression = render_expression_ending_at(body, receiver_index)
+              return nil unless receiver_expression
+
+              receiver = receiver_expression[0]
+              previous_index = receiver_expression[1]
+            end
+
+            block_iseq = instruction[2] if iseq_array?(instruction[2])
+            rendered_send = render_send(receiver, call_data[:mid], arguments, block_iseq)
+
+            [rendered_send, previous_index]
+          end
+          private_class_method :render_send_expression
+
+          # Render `count` adjacent stack expressions ending at `index`.
+          # Arguments appear on the stack left-to-right, but because we scan from
+          # the end, each rendered value is written back into its original slot.
+          def self.render_expression_list_ending_at(body, index, count)
+            return [EMPTY_ARGUMENTS, index] if count <= 0
+
+            arguments = Array.new(count)
+            argument_index = count - 1
+
+            while argument_index >= 0
+              expression = render_expression_ending_at(body, index)
+              return nil unless expression
+
+              arguments[argument_index] = expression[0]
+              index = expression[1]
+              argument_index -= 1
+            end
+
+            [arguments, index]
+          end
+          private_class_method :render_expression_list_ending_at
+
+          # Instruction sequence bodies also contain labels and events. Only array
+          # entries are executable instructions for the subset we render here.
+          def self.previous_instruction_index(body, index)
+            while index >= 0
+              return index if body[index].is_a?(Array)
+
+              index -= 1
+            end
+
+            nil
+          end
+          private_class_method :previous_instruction_index
+
+          # Handle compact Ruby opcodes that are common in tiny matcher arguments.
+          # Locals are intentionally rendered as `local`; reading their runtime
+          # values would make names unstable and could execute user code.
+          def self.render_special_expression(index, instruction)
+            opcode = instruction[0].to_s
+
+            if opcode.start_with?("putobject_INT2FIX_")
+              [opcode.delete_prefix("putobject_INT2FIX_").delete_suffix("_"), index - 1]
+            elsif opcode.start_with?("getlocal")
+              ["local", index - 1]
+            end
+          end
+          private_class_method :render_special_expression
+
+          # Convert a rendered send into the text users expect from an RSpec
+          # generated description. For constructor calls on constants, keep only
+          # the class name so `Object.new` does not introduce object identity.
+          def self.render_send(receiver, method_name, arguments, block_iseq)
+            if receiver == SELF_VALUE && arguments.empty? && !block_iseq
+              return render_method_name(receiver, method_name, arguments, block_iseq)
+            end
+
+            return receiver if method_name == :new && arguments.empty? && constant_name?(receiver)
+
+            render_method_call(receiver, method_name, arguments, block_iseq)
+          end
+          private_class_method :render_send
+
+          # Format non-trivial sends. Matcher calls and matcher chains use RSpec's
+          # human-readable style (`include "x"`, `change by 1`); ordinary nested
+          # sends keep Ruby-ish receiver syntax (`local.to_s`) for clarity.
+          def self.render_method_call(receiver, method_name, arguments, block_iseq)
+            matcher_chain = MATCHER_CHAIN_METHODS.key?(method_name)
+            method_text = render_method_name(receiver, method_name, arguments, block_iseq)
+            argument_text = arguments.join(", ")
+            receiver_text = (receiver == SELF_VALUE) ? "self" : receiver.to_s
+
+            if OPERATOR_METHODS.key?(method_name)
+              return "#{receiver_text} #{method_name} #{argument_text}".strip
+            end
+
+            if receiver == SELF_VALUE
+              return argument_text.empty? ? method_text : "#{method_text} #{argument_text}"
+            end
+
+            if matcher_chain
+              return argument_text.empty? ? "#{receiver} #{method_text}" : "#{receiver} #{method_text} #{argument_text}"
+            end
+
+            argument_suffix = argument_text.empty? ? "" : "(#{argument_text})"
+            "#{receiver_text}.#{method_name}#{argument_suffix}"
+          end
+          private_class_method :render_method_call
+
+          # RSpec generated descriptions turn matcher-like method names into prose
+          # only when the send is part of matcher DSL text. Keep ordinary nested
+          # Ruby calls (`local.to_s`) untouched.
+          def self.render_method_name(receiver, method_name, arguments, block_iseq)
+            method_text = method_name.to_s
+            return method_text unless humanize_method_name?(receiver, method_name, method_text, arguments, block_iseq)
+
+            method_text.tr("_", " ")
+          end
+          private_class_method :render_method_name
+
+          def self.humanize_method_name?(receiver, method_name, method_text, arguments, block_iseq)
+            return false unless receiver == SELF_VALUE || MATCHER_CHAIN_METHODS.key?(method_name) || block_iseq
+
+            pretty_matcher_method?(method_name, method_text) || !arguments.empty? || block_iseq
+          end
+          private_class_method :humanize_method_name?
+
+          # RSpec turns many matcher method names into words in generated example
+          # descriptions. Mirror that only for known matcher methods/prefixes.
+          def self.pretty_matcher_method?(method_name, method_text)
+            PRETTY_MATCHER_METHODS.key?(method_name) ||
+              PRETTY_MATCHER_PREFIXES.any? { |prefix| method_text.start_with?(prefix) }
+          end
+          private_class_method :pretty_matcher_method?
+
+          # Literal operands are embedded in bytecode and safe to read. For any
+          # object-like value, use the class name instead of `inspect` so memory
+          # addresses cannot leak into test identities.
+          def self.render_literal(value)
+            rendered_value =
+              case value
+              when nil
+                "nil"
+              when true
+                "true"
+              when false
+                "false"
+              when Symbol
+                value.inspect
+              when String
+                value.inspect
+              when Numeric
+                value.to_s
+              when Regexp
+                value.inspect
+              when Array
+                render_array_literal(value)
+              when Hash
+                render_hash_literal(value)
+              else
+                value.class.name || "value"
+              end
+
+            trim(rendered_value, MAX_RENDERED_VALUE_LENGTH)
+          end
+          private_class_method :render_literal
+
+          # Keep array literals readable while recursively applying the same stable
+          # rendering rules to their elements.
+          def self.render_array_literal(value)
+            return "[]" unless value.is_a?(Array)
+
+            "[#{value.map { |element| render_literal(element) }.join(", ")}]"
+          end
+          private_class_method :render_array_literal
+
+          # Sort hash keys so equivalent literal hashes render consistently across
+          # Ruby versions and construction paths.
+          def self.render_hash_literal(value)
+            return "{}" unless value.is_a?(Hash)
+
+            pairs = value.keys.sort_by(&:to_s).map do |key|
+              "#{render_literal(key)} => #{render_literal(value[key])}"
+            end
+
+            "{#{pairs.join(", ")}}"
+          end
+          private_class_method :render_hash_literal
+
+          # `opt_getconstant_path` stores constants as path parts. Join them into a
+          # Ruby-looking constant name without resolving the constant at runtime.
+          def self.render_constant_path(value)
+            return "constant" unless value.is_a?(Array)
+
+            value.compact.join("::")
+          end
+          private_class_method :render_constant_path
+
+          # Used when collapsing zero-argument constructor calls; only collapse
+          # real constant paths, not arbitrary receiver text.
+          def self.constant_name?(value)
+            value.is_a?(String) && value.match?(/\A[A-Z]\w*(?:::[A-Z]\w*)*\z/)
+          end
+          private_class_method :constant_name?
+
+          # Block matchers carry the block body as an embedded instruction
+          # sequence. Its presence changes matcher wording, but rendering the
+          # block body would risk pulling subject code into the name.
+          def self.iseq_array?(value)
+            value.is_a?(Array) && value[0] == ISEQ_SIMPLE_DATA_FORMAT
+          end
+          private_class_method :iseq_array?
+
+          # Bound rendered values and names so unusually large literals do not
+          # create oversized span names.
+          def self.trim(value, max_length)
+            return value if value.length <= max_length
+
+            "#{value[0, max_length - 3]}..."
+          end
+          private_class_method :trim
+
+          def self.warn_anonymous_example_name_error(error)
+            Datadog.logger.warn { "Unable to compute RSpec anonymous example name: #{error.class}: #{error.message}" }
+
+            nil
+          end
+          private_class_method :warn_anonymous_example_name_error
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/contrib/rspec/example.rb

@@ -7,6 +7,7 @@ require_relative "../../source_code/path_filter"
 require_relative "../../utils/bundle"
 require_relative "../../utils/test_run"
 require_relative "../instrumentation"
+require_relative "anonymous_example_name"
 require_relative "ext"
 
 module Datadog
@@ -110,11 +111,7 @@ module Datadog
             def datadog_test_name
               return @datadog_test_name if defined?(@datadog_test_name)
 
-              test_name = full_description.strip
-              if metadata[:description].empty?
-                # for unnamed it blocks this appends something like "example at ./spec/some_spec.rb:10"
-                test_name << " #{description}"
-              end
+              test_name = datadog_unnamed_example? ? datadog_unnamed_example_name : full_description.strip
 
               # remove example group description from test name to avoid duplication
               test_name = test_name.sub(datadog_test_suite_description, "").strip
@@ -266,6 +263,27 @@ module Datadog
               end
             end
 
+            # ============================================
+            # Test name helpers
+            # ============================================
+
+            def datadog_unnamed_example?
+              # @type var description_args: Array[untyped]
+              description_args = Array(metadata[:description_args])
+              description_args.empty? || description_args.all? { |description_arg| description_arg.to_s.strip.empty? }
+            end
+
+            def datadog_unnamed_example_name
+              example_name = AnonymousExampleName.call(datadog_anonymous_example_block)
+              example_name ||= "anonymous example"
+
+              "#{metadata[:example_group][:full_description]} #{example_name}"
+            end
+
+            def datadog_anonymous_example_block
+              metadata[:block] || @example_block
+            end
+
             # ============================================
             # Source location resolution
             # ============================================

data/lib/datadog/ci/contrib/simplecov/result_extractor.rb

@@ -22,7 +22,15 @@ module Datadog
                 ::SimpleCov::ResultAdapter.call(::Coverage.peek_result)
               )
 
-              ::SimpleCov::Result.new(add_not_loaded_files(result))
+              # SimpleCov 1.0 changed add_not_loaded_files to return a
+              # [coverage, not_loaded_files] tuple instead of a coverage hash.
+              processed = add_not_loaded_files(result)
+              if processed.is_a?(::Array)
+                coverage, not_loaded_files = processed
+                ::SimpleCov::Result.new(coverage, not_loaded_files: not_loaded_files)
+              else
+                ::SimpleCov::Result.new(processed)
+              end
             end
 
             def datadog_configuration

data/lib/datadog/ci/test_discovery/component.rb

@@ -4,6 +4,7 @@ require "fileutils"
 require "json"
 require_relative "../ext/test"
 require_relative "../ext/test_discovery"
+require_relative "../utils/test_name"
 
 module Datadog
   module CI
@@ -76,6 +77,9 @@ module Datadog
         end
 
         def record_test(name:, suite:, module_name:, parameters:, source_file:)
+          name = name.nil? ? nil : Utils::TestName.normalize(name)
+          suite = suite.nil? ? nil : Utils::TestName.normalize(suite)
+
           test_info = {
             "name" => name,
             "suite" => suite,

data/lib/datadog/ci/test_tracing/component.rb

@@ -16,6 +16,7 @@ require_relative "../ext/test"
 require_relative "../git/local_repository"
 require_relative "../utils/file_storage"
 require_relative "../utils/stateful"
+require_relative "../utils/test_name"
 
 require_relative "../worker"
 
@@ -109,6 +110,7 @@ module Datadog
         def start_test_suite(test_suite_name, service: nil, tags: {})
           return skip_tracing unless test_suite_level_visibility_enabled
 
+          test_suite_name = Utils::TestName.normalize(test_suite_name)
           context = @local_test_suites_mode ? @context : maybe_remote_context
 
           test_suite = context.start_test_suite(test_suite_name, service: service, tags: tags)
@@ -117,6 +119,9 @@ module Datadog
         end
 
         def trace_test(test_name, test_suite_name, service: nil, tags: {}, &block)
+          test_name = Utils::TestName.normalize(test_name)
+          test_suite_name = Utils::TestName.normalize(test_suite_name)
+
           test_suite = active_test_suite(test_suite_name)
           tags[Ext::Test::TAG_SUITE] ||= test_suite_name
 
@@ -165,6 +170,8 @@ module Datadog
           # we return the single active test suite because most of the time there is only one test suite running
           return single_active_test_suite if test_suite_name.nil?
 
+          test_suite_name = Utils::TestName.normalize(test_suite_name)
+
           # when fetching test_suite to use as test's context, try local context instance first
           local_test_suite = @context.active_test_suite(test_suite_name)
           return local_test_suite if local_test_suite
@@ -194,6 +201,7 @@ module Datadog
         end
 
         def deactivate_test_suite(test_suite_name)
+          test_suite_name = Utils::TestName.normalize(test_suite_name)
           test_suite = active_test_suite(test_suite_name)
           on_test_suite_finished(test_suite) if test_suite
 

data/lib/datadog/ci/test_tracing/deprecated_total_coverage_metric.rb

@@ -12,7 +12,7 @@ module Datadog
             return
           end
 
-          unless ::SimpleCov.running
+          unless simplecov_running?
             Datadog.logger.debug("SimpleCov is not running, skipping code coverage extraction")
             return
           end
@@ -30,6 +30,16 @@ module Datadog
 
           test_session.set_tag(Ext::Test::TAG_CODE_COVERAGE_LINES_PCT, result.covered_percent)
         end
+
+        # SimpleCov 1.0 removed the `running` accessor and relies on Ruby's
+        # Coverage.running? instead.
+        def self.simplecov_running?
+          return ::SimpleCov.running if ::SimpleCov.respond_to?(:running)
+          return false unless defined?(::Coverage)
+
+          ::Coverage.running?
+        end
+        private_class_method :simplecov_running?
       end
     end
   end

data/lib/datadog/ci/utils/test_name.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module Utils
+      module TestName
+        MONTH = "(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)"
+        WEEKDAY = "(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)"
+        CONSTANT_NAME = "[A-Z]\\w*(?:::[A-Z]\\w*)*"
+
+        DATE_INSPECT_PATTERN = /#<Date(?::[^>\n]*)?>/.freeze
+        TIME_INSPECT_PATTERN = /#<(?:DateTime|Time)(?::[^>\n]*)?>/.freeze
+        CLASS_INSPECT_PATTERN = /#<Class:(#{CONSTANT_NAME}|0x[0-9a-fA-F]+)(?:\s[^>\n]*)?>/.freeze
+        NAMED_OBJECT_INSPECT_PATTERN = /#<(#{CONSTANT_NAME})(?::[^>\n]*)?>/.freeze
+        OBJECT_INSPECT_PATTERN = /#<[^>\n]+>/.freeze
+        ACTIVE_RECORD_CLASS_INSPECT_PATTERN = /
+          \b(#{CONSTANT_NAME})
+          (?:
+            \s\(call\s'\1\.connection'\sto\ establish\ a\ connection\)
+            |
+            \(
+              (?:\.\.\.\s*)?[a-z_][a-z0-9_]*:\s[^,)\n]*
+              (?:
+                ,\s(?:\.\.\.\s*)?[a-z_][a-z0-9_]*:\s[^,)\n]*
+              )*
+            \)
+          )
+        /x.freeze
+
+        TIME_PATTERN = /
+          \b
+          (?:
+            \d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?
+            (?:\s?(?:Z|UTC|[A-Z]{2,5}|[+-]\d{2}:?\d{2}))?
+            |
+            #{WEEKDAY},?\s+\d{1,2}\s+#{MONTH}\s+\d{4}\s+\d{2}:\d{2}:\d{2}(?:\.\d+)?
+            (?:\s+(?:UTC|[A-Z]{2,5}|[+-]\d{2}:?\d{2}))?
+          )
+          \b
+        /x.freeze
+        DATE_PATTERN = /
+          \b
+          (?:
+            \d{4}-\d{2}-\d{2}
+            |
+            #{WEEKDAY},?\s+\d{1,2}\s+#{MONTH}\s+\d{4}
+          )
+          \b
+        /x.freeze
+        RANGE_PATTERN = /
+          (^|[^\w.])
+          (?:-?\d+(?:\.\d+)?|DATE|TIME|:[a-zA-Z_]\w*|"[^"]*"|'[^']*')
+          \s*\.{2,3}\s*
+          (?:-?\d+(?:\.\d+)?|DATE|TIME|:[a-zA-Z_]\w*|"[^"]*"|'[^']*')
+          (?=$|[^\w.])
+        /x.freeze
+
+        def self.normalize(name)
+          return name unless name.is_a?(String)
+          return name if name.empty?
+
+          normalized = name.gsub(DATE_INSPECT_PATTERN, "DATE")
+          normalized.gsub!(TIME_INSPECT_PATTERN, "TIME")
+          normalized.gsub!(CLASS_INSPECT_PATTERN) do
+            class_name = Regexp.last_match(1).to_s
+            class_name.start_with?("0x") ? "CLASS" : "CLASS:#{class_name}"
+          end
+          normalized.gsub!(NAMED_OBJECT_INSPECT_PATTERN) { "OBJECT:#{Regexp.last_match(1)}" }
+          normalized.gsub!(OBJECT_INSPECT_PATTERN, "OBJECT")
+          normalized.gsub!(ACTIVE_RECORD_CLASS_INSPECT_PATTERN) { Regexp.last_match(1).to_s }
+          normalized.gsub!(ARRAY_PATTERN) { |value| array_literal?(value) ? "ARRAY" : value }
+          normalized.gsub!(HASH_PATTERN) { |value| hash_literal?(value) ? "HASH" : value }
+          normalized.gsub!(TIME_PATTERN, "TIME")
+          normalized.gsub!(DATE_PATTERN, "DATE")
+          normalized.gsub!(RANGE_PATTERN) { "#{Regexp.last_match(1)}RANGE" }
+
+          normalized
+        rescue => e
+          warn_normalization_error(e)
+          name
+        end
+
+        ARRAY_PATTERN = /\[[^\[\]\n]{0,300}\]/.freeze
+        HASH_PATTERN = /\{[^{}\n]{0,300}\}/.freeze
+
+        def self.array_literal?(value)
+          content = value[1, value.length - 2].to_s.strip
+          return true if content.empty?
+
+          content.include?(",") || content.match?(/\A(?:"|'|:|-?\d|true\b|false\b|nil\b|#<|\[|\{)/)
+        end
+        private_class_method :array_literal?
+
+        def self.hash_literal?(value)
+          content = value[1, value.length - 2].to_s.strip
+          return true if content.empty?
+
+          content.include?("=>") ||
+            content.match?(/(?:\A|,)\s*(?:"[^"]+"|'[^']+'|:[a-zA-Z_]\w*|[a-zA-Z_]\w*)\s*:/)
+        end
+        private_class_method :hash_literal?
+
+        def self.warn_normalization_error(error)
+          Datadog.logger.warn { "Unable to normalize test name: #{error.class}: #{error.message}" }
+
+          nil
+        end
+        private_class_method :warn_normalization_error
+      end
+    end
+  end
+end

data/lib/datadog/ci/version.rb

@@ -4,7 +4,7 @@ module Datadog
   module CI
     module VERSION
       MAJOR = 1
-      MINOR = 34
+      MINOR = 35
       PATCH = 0
       PRE = nil
       BUILD = nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datadog-ci
 version: !ruby/object:Gem::Version
-  version: 1.34.0
+  version: 1.35.0
 platform: ruby
 authors:
 - Datadog, Inc.
@@ -151,6 +151,7 @@ files:
 - lib/datadog/ci/contrib/parallel_tests/integration.rb
 - lib/datadog/ci/contrib/parallel_tests/patcher.rb
 - lib/datadog/ci/contrib/patcher.rb
+- lib/datadog/ci/contrib/rspec/anonymous_example_name.rb
 - lib/datadog/ci/contrib/rspec/configuration/settings.rb
 - lib/datadog/ci/contrib/rspec/documentation_formatter.rb
 - lib/datadog/ci/contrib/rspec/example.rb
@@ -322,6 +323,7 @@ files:
 - lib/datadog/ci/utils/runtime_tags_overrides.rb
 - lib/datadog/ci/utils/stateful.rb
 - lib/datadog/ci/utils/telemetry.rb
+- lib/datadog/ci/utils/test_name.rb
 - lib/datadog/ci/utils/test_run.rb
 - lib/datadog/ci/version.rb
 - lib/datadog/ci/worker.rb