datadog 2.32.0 → 2.34.0

data/lib/datadog/core/environment/process.rb

@@ -10,18 +10,17 @@ module Datadog
       #
       # @api private
       module Process
-        # This method returns a key/value part of serialized tags in the format of k1:v1,k2:v2,k3:v3
-        # @return [String] comma-separated normalized key:value pairs
+        # Returns a comma-separated string of normalized key:value pairs.
+        # Includes svc.user or svc.auto based on whether the service was explicitly configured.
+        # @return [String]
         def self.serialized
-          return @serialized if defined?(@serialized)
-
-          @serialized = tags.join(',').freeze
+          tags.join(',').freeze
         end
 
-        # This method returns an array in the format ["k1:v1","k2:v2","k3:v3"]
-        # @return [Array<String>] array of normalized key:value pairs
+        # Returns an array of normalized key:value pair strings.
+        # Includes svc.user or svc.auto based on whether the service was explicitly configured.
+        # @return [Array<String>]
         def self.tags
-          return @tags if defined?(@tags)
           tags = []
 
           workdir = TagNormalizer.normalize_process_value(entrypoint_workdir.to_s)
@@ -35,17 +34,44 @@ module Datadog
 
           tags << "#{Environment::Ext::TAG_ENTRYPOINT_TYPE}:#{TagNormalizer.normalize(entrypoint_type, remove_digit_start_char: false)}"
 
-          rails_application_name = TagNormalizer.normalize_process_value(@rails_application_name.to_s)
-          tags << "#{Environment::Ext::TAG_RAILS_APPLICATION}:#{rails_application_name}" unless rails_application_name.empty?
+          rails_name = TagNormalizer.normalize_process_value(@rails_application_name.to_s)
+          tags << "#{Environment::Ext::TAG_RAILS_APPLICATION}:#{rails_name}" unless rails_name.empty?
+
+          if defined?(@service_user_configured)
+            if @service_user_configured
+              tags << "#{Environment::Ext::TAG_SVC_USER}:true"
+            else
+              svc = TagNormalizer.normalize_process_value(@service_name.to_s)
+              tags << "#{Environment::Ext::TAG_SVC_AUTO}:#{svc}" unless svc.empty?
+            end
+          end
+
+          tags.freeze
+        end
+
+        # Called via after_set on option :service in settings.rb whenever the service value changes.
+        # @param name [String] the service name
+        # @param user_configured [Boolean] whether the service was explicitly set by the user
+        # @return [void]
+        def self.set_service(name, user_configured:)
+          @service_name = name
+          @service_user_configured = user_configured
+        end
 
-          @tags = tags.freeze
+        # Sets the rails application name from other places in code
+        # @param name [String] the rails application name
+        # @return [void]
+        def self.rails_application_name=(name)
+          @rails_application_name = name
         end
 
         # Returns the last segment of the working directory of the process
         # Example: /app/myapp -> myapp
         # @return [String] the last segment of the working directory
         def self.entrypoint_workdir
-          File.basename(Dir.pwd)
+          return @entrypoint_workdir if defined?(@entrypoint_workdir)
+
+          @entrypoint_workdir = File.basename(Dir.pwd)
         end
 
         # Returns the entrypoint type of the process
@@ -55,10 +81,10 @@ module Datadog
           Environment::Ext::PROCESS_TYPE
         end
 
-        # Returns the last segment of the base directory of the process
+        # Returns the basename of the script being run
         # Example 1: /bin/mybin -> mybin
-        # Example 2: ruby /test/myapp.rb -> myapp
-        # @return [String] the last segment of base directory of the script
+        # Example 2: ruby /test/myapp.rb -> myapp.rb
+        # @return [String] the basename of the script
         #
         # @note Determining true entrypoint name is rather complicated. This method
         # is the initial implementation but it does not produce optimal output in all cases.
@@ -66,12 +92,14 @@ module Datadog
         # as their entrypoint name.
         # We might improve the behavior in the future if there is customer demand for it.
         def self.entrypoint_name
-          File.basename($0)
+          return @entrypoint_name if defined?(@entrypoint_name)
+
+          @entrypoint_name = File.basename($0)
         end
 
-        # Returns the last segment of the base directory of the process
+        # Returns the last segment of the directory containing the script
         # Example 1: /bin/mybin -> bin
-        # Example 2: ruby /test/myapp.js -> test
+        # Example 2: ruby /test/myapp.rb -> test
         # @return [String] the last segment of the base directory of the script
         #
         # @note As with entrypoint name, determining true entrypoint directory is complicated.
@@ -80,16 +108,9 @@ module Datadog
         # the entrypoint basedir is `bin` which is not very helpful.
         # We might improve this in the future if there is customer demand.
         def self.entrypoint_basedir
-          File.basename(File.expand_path(File.dirname($0)))
-        end
+          return @entrypoint_basedir if defined?(@entrypoint_basedir)
 
-        # Sets the rails application name from other places in code
-        # @param name [String] the rails application name
-        # @return [void]
-        def self.rails_application_name=(name)
-          @rails_application_name = name
-          remove_instance_variable(:@tags) if instance_variable_defined?(:@tags)
-          remove_instance_variable(:@serialized) if instance_variable_defined?(:@serialized)
+          @entrypoint_basedir = File.basename(File.expand_path(File.dirname($0)))
         end
 
         private_class_method :entrypoint_workdir, :entrypoint_type, :entrypoint_name, :entrypoint_basedir

data/lib/datadog/core/environment/socket.rb

@@ -18,6 +18,19 @@ module Datadog
 
           @hostname ||= ::Socket.gethostname.freeze
         end
+
+        # Returns the resolved hostname when `report_hostname` is enabled:
+        # the configured DD_HOSTNAME if set, otherwise the system hostname.
+        # Returns nil when `report_hostname` is disabled or no hostname is available.
+        def resolved_hostname(settings)
+          return nil unless settings.tracing.report_hostname
+
+          configured = settings.hostname
+          return configured if configured && !configured.empty?
+
+          resolved_hostname = hostname
+          resolved_hostname if resolved_hostname && !resolved_hostname.empty?
+        end
       end
     end
   end

data/lib/datadog/core/remote/client/capabilities.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
-require_relative '../../utils/base64'
+require_relative '../../utils/base64_codec'
 require_relative '../../../appsec/remote'
 require_relative '../../../tracing/remote'
+require_relative '../../../di/remote'
+require_relative '../../../symbol_database/remote'
 require_relative '../../../open_feature/remote'
 
 module Datadog
@@ -37,6 +39,13 @@ module Datadog
               register_capabilities(Datadog::DI::Remote.capabilities)
               register_products(Datadog::DI::Remote.products)
               register_receivers(Datadog::DI::Remote.receivers(@telemetry))
+
+              # Symbol Database
+              if settings.respond_to?(:symbol_database) && settings.symbol_database.enabled
+                register_capabilities(Datadog::SymbolDatabase::Remote.capabilities)
+                register_products(Datadog::SymbolDatabase::Remote.products)
+                register_receivers(Datadog::SymbolDatabase::Remote.receivers(@telemetry))
+              end
             end
 
             if settings.respond_to?(:open_feature) && settings.open_feature.enabled
@@ -68,7 +77,7 @@ module Datadog
             cap_to_hexs = capabilities.reduce(:|).to_s(16).tap { |s| s.size.odd? && s.prepend('0') }.scan(/\h\h/)
             binary = cap_to_hexs.each_with_object([]) { |hex, acc| acc << hex }.map { |e| e.to_i(16) }.pack('C*')
 
-            Datadog::Core::Utils::Base64.strict_encode64(binary)
+            Datadog::Core::Utils::Base64Codec.strict_encode64(binary)
           end
         end
       end

data/lib/datadog/core/remote/transport/http/config.rb

@@ -4,7 +4,7 @@ require 'json'
 
 require_relative '../../../transport/http/api/endpoint'
 require_relative '../../../transport/http/response'
-require_relative '../../../utils/base64'
+require_relative '../../../utils/base64_codec'
 require_relative '../../../utils/truncation'
 
 module Datadog
@@ -35,7 +35,7 @@ module Datadog
 
                 # TODO: these fallbacks should be improved
                 roots = payload[:roots] || []
-                targets = payload[:targets] || Datadog::Core::Utils::Base64.strict_encode64('{}')
+                targets = payload[:targets] || Datadog::Core::Utils::Base64Codec.strict_encode64('{}')
                 target_files = payload[:target_files] || []
                 client_configs = payload[:client_configs] || []
 
@@ -45,7 +45,7 @@ module Datadog
                   raise TypeError.new(String, root) unless root.is_a?(String)
 
                   decoded = begin
-                    Datadog::Core::Utils::Base64.strict_decode64(root) # TODO: unprocessed, don't symbolize_names
+                    Datadog::Core::Utils::Base64Codec.strict_decode64(root) # TODO: unprocessed, don't symbolize_names
                   rescue ArgumentError
                     raise DecodeError.new(:roots, root)
                   end
@@ -65,7 +65,7 @@ module Datadog
 
                 @targets = begin
                   decoded = begin
-                    Datadog::Core::Utils::Base64.strict_decode64(targets)
+                    Datadog::Core::Utils::Base64Codec.strict_decode64(targets)
                   rescue ArgumentError
                     raise DecodeError.new(:targets, targets)
                   end
@@ -93,7 +93,7 @@ module Datadog
                   raise TypeError.new(String, raw) unless raw.is_a?(String)
 
                   content = begin
-                    Datadog::Core::Utils::Base64.strict_decode64(raw)
+                    Datadog::Core::Utils::Base64Codec.strict_decode64(raw)
                   rescue ArgumentError
                     raise DecodeError.new(:target_files, raw)
                   end

data/lib/datadog/core/telemetry/request.rb

@@ -10,8 +10,6 @@ module Datadog
       # Module defining methods for collecting metadata for telemetry
       module Request
         class << self
-          using Core::Utils::Hash::Refinement
-
           def build_payload(event, seq_id, debug: false)
             hash = {
               api_version: 'v2',

data/lib/datadog/core/transport/response.rb

@@ -70,7 +70,7 @@ module Datadog
         end
 
         def to_s
-          "#{super}, error_type:#{error.class} error:#{error}"
+          "#{self.class}, error_type:#{error.class} error:#{error}"
         end
 
         def inspect

data/lib/datadog/core/utils/{base64.rb → base64_codec.rb}

@@ -3,8 +3,9 @@
 module Datadog
   module Core
     module Utils
-      # Helper methods for encoding and decoding base64
-      module Base64
+      # Base64 encoding/decoding without using the `base64` gem,
+      # which is no longer a default gem since Ruby 3.4.
+      module Base64Codec
         def self.encode64(bin)
           [bin].pack('m')
         end

data/lib/datadog/core/utils/hash.rb

@@ -3,30 +3,7 @@
 module Datadog
   module Core
     module Utils
-      # Refinements for {Hash}.
       module Hash
-        # This refinement ensures modern rubies are allowed to use newer,
-        # simpler, and more performant APIs.
-        module Refinement
-          # Introduced in Ruby 2.4
-          unless ::Hash.method_defined?(:compact)
-            refine ::Hash do
-              def compact
-                reject { |_k, v| v.nil? }
-              end
-            end
-          end
-
-          # Introduced in Ruby 2.4
-          unless ::Hash.method_defined?(:compact!)
-            refine ::Hash do
-              def compact!
-                reject! { |_k, v| v.nil? }
-              end
-            end
-          end
-        end
-
         # A minimal {Hash} wrapper that provides case-insensitive access
         # to hash keys, without the overhead of copying the original hash.
         #

data/lib/datadog/core/utils/spawn_monkey_patch.rb

@@ -3,32 +3,62 @@
 module Datadog
   module Core
     module Utils
+      # Applies the Process.spawn wrapper used to merge additional environment variables
+      # into child processes.
       module SpawnMonkeyPatch
-        # @param lineage_envs_provider [#call] returns a Hash of env vars to merge into the child process
-        def self.apply!(lineage_envs_provider:)
-          @lineage_envs_provider = lineage_envs_provider
+        # @param env_provider [#call] returns a Hash of env vars to merge into the child process
+        def self.apply!(env_provider:)
+          @env_provider = env_provider
+
+          # Idempotent: tests, reloads, or repeated Components init must not stack prepends.
+          return if ::Process.singleton_class.ancestors.include?(ProcessSpawnPatch)
+
           ::Process.singleton_class.prepend(ProcessSpawnPatch)
-          true
         end
 
+        # Prepends `Process.spawn` to merge `env_provider` output into the child's environment hash.
         module ProcessSpawnPatch
-          def spawn(*args, **opts)
-            args.replace(SpawnMonkeyPatch.inject_lineage_envs(args))
-            super
+          # The One and Only Correct Delegation Pattern
+          if RUBY_VERSION >= '3'
+            def spawn(*args, **kwargs) # steep:ignore DifferentMethodParameterKind
+              super(*SpawnMonkeyPatch.inject_envs(args), **kwargs)
+            end
+          else
+            def spawn(*args)
+              super(*SpawnMonkeyPatch.inject_envs(args))
+            end
+            ruby2_keywords :spawn if respond_to?(:ruby2_keywords, true)
           end
         end
 
-        # Process.spawn(env?, cmd, ...): env is optional first arg (Hash). When present, merge
-        # runtime_ids into it; when absent, prepend full ENV + runtime_ids so the child inherits both.
-        def self.inject_lineage_envs(args)
-          runtime_ids = @lineage_envs_provider.call
-          env_provided = Hash === args.first
+        # Merge the env vars from `env_provider` with the optional env `Hash` from {Process.spawn}.
+        #
+        # `env` is the first argument when it is a {Hash}; see MRI `spawn([env, ] *args, options)`:
+        # https://docs.ruby-lang.org/en/master/Process.html#method-c-spawn
+        #
+        # When there is **no** leading env Hash, MRI inherits the parent's `ENV`; we prepend only the
+        # `env_provider` hash so spawned children see parent env plus injections.
+        #
+        # When callers pass `unsetenv_others: true`, MRI only forwards the explicitly passed env Hash;
+        # replacing a missing hash with DATADOG_ENV.to_h would wrongly carry over parent variables.
+        # Prepending only the provider hash preserves `unsetenv_others` semantics.
+        #
+        # See https://docs.ruby-lang.org/en/master/Process.html#module-Process-label-Environment+Variables+-28-3Aunsetenv_others-29
+        #
+        # NOTE: `::Hash` (not bare `Hash`) is required because this module is nested under
+        # `Datadog::Core::Utils`, and `Datadog::Core::Utils::Hash` exists.
+        # Bare `Hash` resolves to that module via Module.nesting, making `Hash === some_hash`
+        # silently return `false`. See https://github.com/DataDog/dd-trace-rb/issues/5621.
+        def self.inject_envs(args)
+          provided_env = @env_provider.call
 
-          base_env = env_provided ? args.first : DATADOG_ENV.to_h
-          env = base_env.merge(runtime_ids)
-          rest = env_provided ? args.drop(1) : args
+          if ::Hash === args.first
+            args[0] = args.first.merge(provided_env)
+          else
+            args.unshift(provided_env)
+          end
 
-          [env, *rest]
+          args
         end
       end
     end

data/lib/datadog/data_streams/pathway_context.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'stringio'
-require_relative '../core/utils/base64'
+require_relative '../core/utils/base64_codec'
 
 module Datadog
   module DataStreams
@@ -34,7 +34,7 @@ module Datadog
       end
 
       def encode_b64
-        Core::Utils::Base64.strict_encode64(encode)
+        Core::Utils::Base64Codec.strict_encode64(encode)
       end
 
       # Decode pathway context from base64 encoded string
@@ -42,7 +42,7 @@ module Datadog
         return nil unless encoded_ctx && !encoded_ctx.empty?
 
         begin
-          binary_data = Core::Utils::Base64.strict_decode64(encoded_ctx)
+          binary_data = Core::Utils::Base64Codec.strict_decode64(encoded_ctx)
           decode(binary_data)
         rescue ArgumentError => e
           # Invalid base64 encoding - may indicate version mismatch or corruption

data/lib/datadog/di/code_tracker.rb

@@ -249,23 +249,34 @@ module Datadog
           exact = registry[suffix]
           return [suffix, exact] if exact
 
-          suffix = suffix.dup
-          loop do
-            inexact = []
-            registry.each do |path, iseq|
-              if Utils.path_matches_suffix?(path, suffix)
-                inexact << [path, iseq]
+          # Normalize Windows-style backslash separators (DEBUG-5111) upfront
+          # so the suffix-shortening loop's "/+" regex can strip leading
+          # components on probes whose sourceFile uses backslashes.
+          suffix = Utils.normalize_windows_separators(suffix)
+
+          # Per the design comment in utils.rb, attempt case-sensitive
+          # matching first (steps 5-6) and only fall back to case-insensitive
+          # matching (steps 7-8) when no case-sensitive match is found.
+          [false, true].each do |case_insensitive|
+            working_suffix = suffix.dup
+            loop do
+              inexact = []
+              registry.each do |path, iseq|
+                if Utils.path_matches_suffix?(path, working_suffix, case_insensitive: case_insensitive)
+                  inexact << [path, iseq]
+                end
               end
+              if inexact.length > 1
+                raise Error::MultiplePathsMatch, "Multiple paths matched requested suffix"
+              end
+              if inexact.any?
+                return inexact.first
+              end
+              break unless working_suffix.include?('/')
+              working_suffix.sub!(%r{.*/+}, '')
             end
-            if inexact.length > 1
-              raise Error::MultiplePathsMatch, "Multiple paths matched requested suffix"
-            end
-            if inexact.any?
-              return inexact.first
-            end
-            return nil unless suffix.include?('/')
-            suffix.sub!(%r{.*/+}, '')
           end
+          nil
         end
       end
 
@@ -365,15 +376,25 @@ module Datadog
         # Exact match.
         return suffix if paths.include?(suffix)
 
-        # Suffix match.
-        suffix = suffix.dup
-        loop do
-          matches = paths.select { |p| Utils.path_matches_suffix?(p, suffix) }
-          raise Error::MultiplePathsMatch, "Multiple paths matched requested suffix" if matches.length > 1
-          return matches.first if matches.any?
-          return nil unless suffix.include?('/')
-          suffix.sub!(%r{.*/+}, '')
+        # Normalize Windows-style backslash separators (DEBUG-5111) upfront
+        # so the suffix-shortening loop's "/+" regex can strip leading
+        # components on probes whose sourceFile uses backslashes.
+        suffix = Utils.normalize_windows_separators(suffix)
+
+        # Suffix match. Per the design comment in utils.rb, attempt
+        # case-sensitive matching first (steps 5-6) and only fall back to
+        # case-insensitive (steps 7-8) when no case-sensitive match is found.
+        [false, true].each do |case_insensitive|
+          working_suffix = suffix.dup
+          loop do
+            matches = paths.select { |p| Utils.path_matches_suffix?(p, working_suffix, case_insensitive: case_insensitive) }
+            raise Error::MultiplePathsMatch, "Multiple paths matched requested suffix" if matches.length > 1
+            return matches.first if matches.any?
+            break unless working_suffix.include?('/')
+            working_suffix.sub!(%r{.*/+}, '')
+          end
         end
+        nil
       end
     end
   end

data/lib/datadog/di/contrib/active_record.rb

@@ -23,7 +23,11 @@ Datadog::DI::Serializer.register(
   #
   # +depth+ is the remaining depth for serializing collections and objects.
   # It should always be an integer.
-  # Reduce it by 1 when invoking +serialize_value+ on the contents of +value+.
+  # Pass it through to +serialize_value+ when the structure you produce
+  # represents +value+ directly (a transparent wrapper); +serialize_value+
+  # decrements depth itself when it recurses into Array/Hash/object entries.
+  # Decrement +depth+ only if your wrapper introduces real additional
+  # nesting levels in the output.
   # This serializer could also potentially do its own depth limiting.
   #
   # Steep: steep thinks all of the arguments are nil here
@@ -33,5 +37,5 @@ Datadog::DI::Serializer.register(
     attributes: value.attributes,
     new_record: value.new_record?,
   }
-  serializer.serialize_value(value_to_serialize, depth: depth - 1, type: value.class)
+  serializer.serialize_value(value_to_serialize, depth: depth, type: value.class)
 end

data/lib/datadog/di/instrumenter.rb

@@ -106,7 +106,7 @@ module Datadog
         serializer = self.serializer
         method_name = probe.method_name
         loc = begin
-          cls.instance_method(method_name).source_location
+          cls.instance_method(method_name).source_location # steep:ignore ArgumentTypeMismatch
         rescue NameError
           # The target method is not defined.
           # This could be because it will be explicitly defined later
@@ -618,12 +618,32 @@ module Datadog
       def raise_if_probe_in_loaded_features(probe, line_no, code_tracker)
         return unless probe.file
 
-        # Find the loaded path matching the probe file.
+        # Find the loaded path matching the probe file. Case-sensitive
+        # matching is attempted first, with case-insensitive matching as a
+        # fallback (see the design comment in utils.rb, steps 5-8). Leading
+        # directory components are stripped so probes whose sourceFile carries
+        # a source-repo prefix that does not exist on disk still resolve to
+        # the loaded file — matching the behavior of
+        # CodeTracker#iseqs_for_path_suffix.
         loaded_path = if $LOADED_FEATURES.include?(probe.file)
           probe.file
         else
           # Expensive suffix check.
-          $LOADED_FEATURES.find { |path| Utils.path_matches_suffix?(path, probe.file) }
+          suffix = Utils.normalize_windows_separators(probe.file)
+          found = nil #: ::String?
+          [false, true].each do |case_insensitive|
+            working_suffix = suffix.dup
+            loop do
+              found = $LOADED_FEATURES.find do |path|
+                Utils.path_matches_suffix?(path, working_suffix, case_insensitive: case_insensitive)
+              end
+              break if found
+              break unless working_suffix.include?('/')
+              working_suffix.sub!(%r{.*/+}, '')
+            end
+            break if found
+          end
+          found
         end
 
         return unless loaded_path
@@ -648,7 +668,7 @@ module Datadog
 
       # TODO test that this resolves qualified names e.g. A::B
       def symbolize_class_name(cls_name)
-        Object.const_get(cls_name)
+        Object.const_get(cls_name) # steep:ignore ArgumentTypeMismatch
       rescue NameError => exc
         raise Error::DITargetNotDefined, "Class not defined: #{cls_name}: #{exc.class}: #{exc.message}"
       end

data/lib/datadog/di/probe_notification_builder.rb

@@ -369,7 +369,7 @@ module Datadog
         rescue => exc
           evaluation_errors << {
             message: "#{exc.class}: #{exc.message}",
-            expr: segment.dsl_expr,
+            expr: segment.dsl_expr, # steep:ignore NoMethod
           }
           '[evaluation error]'
         end.join

data/lib/datadog/di/remote.rb

@@ -42,14 +42,14 @@ module Datadog
               changes.each do |change|
                 case change.type
                 when :insert
-                  add_probe(change.content, component)
+                  add_probe(change.content, component) # steep:ignore NoMethod
                 when :update
                   # We do not implement updates at the moment, remove the
                   # probe and reinstall.
-                  remove_probe(change.content, component)
-                  add_probe(change.content, component)
+                  remove_probe(change.content, component) # steep:ignore NoMethod
+                  add_probe(change.content, component) # steep:ignore NoMethod
                 when :delete
-                  remove_probe(change.previous, component)
+                  remove_probe(change.previous, component) # steep:ignore NoMethod
                 else
                   # This really should never happen since we generate the
                   # change types in the library.

data/lib/datadog/di/serializer.rb

@@ -255,7 +255,7 @@ module Datadog
 
             serialized.update(value: value)
           when Array
-            if depth < 0
+            if depth <= 0
               serialized.update(notCapturedReason: "depth")
             else
               max = settings.dynamic_instrumentation.max_capture_collection_size
@@ -271,7 +271,7 @@ module Datadog
               serialized.update(elements: entries)
             end
           when Hash
-            if depth < 0
+            if depth <= 0
               serialized.update(notCapturedReason: "depth")
             else
               max = settings.dynamic_instrumentation.max_capture_collection_size
@@ -288,7 +288,7 @@ module Datadog
               serialized.update(entries: entries)
             end
           else
-            if depth < 0
+            if depth <= 0
               serialized.update(notCapturedReason: "depth")
             else
               fields = {}
@@ -369,7 +369,7 @@ module Datadog
         when String
           serialize_string_or_symbol_for_message(value)
         when Symbol
-          ':' + serialize_string_or_symbol_for_message(value)
+          ':' + serialize_string_or_symbol_for_message(value) # steep:ignore ArgumentTypeMismatch
         when Array
           return '...' if depth <= 0
 
@@ -482,7 +482,7 @@ module Datadog
             if max % 2 == 0
               upper += 1
             end
-            value[0...max / 2 - 1] + '...' + value[upper...length]
+            value[0...max / 2 - 1] + '...' + value[upper...length] # steep:ignore NoMethod
           end
         else
           value