contrast-agent 3.10.1 → 3.12.2

data/lib/contrast/utils/object_share.rb

@@ -9,9 +9,6 @@ module Contrast
     # duplication.
     class ObjectShare
       # Strings
-      AND =           '&'
-      OR =            '||'
-      PIPE =          '|'
       ASTERISK =      '*'
       BACK_SLASH =    '\\'
       EMPTY_STRING =  ''
@@ -27,8 +24,7 @@ module Contrast
       NEW_LINE =      "\n"
       NIL_STRING =    'nil'
       PERIOD =        '.'
-      PLUS_SIGN =     '+'
-      POUND_SIGN = HASH_CHAR = '#'
+      POUND_SIGN =    '#'
       QUESTION_MARK = '?'
       RETURN =        "\r"
       SEMICOLON =     ';'
@@ -39,35 +35,17 @@ module Contrast
       DOUBLE_UNDERSCORE = '__'
       AT =            '@'
       LEFT_ANGLE =    '<'
-      RIGHT_ANGLE =   '>'
-      LEFT_BRACKET =   '['
-      RIGHT_BRACKET =  ']'
-      LEFT_PAREN =     '('
-      RIGHT_PAREN =    ')'
       COLON_SLASH_SLASH = '://'
-      TICK =           '`'
-      BACK_TICK =      '`'
-      LEFT_CURLY =     '{'
-      RIGHT_CURLY =    '}'
       DOLLAR_SIGN =    '$'
       CARROT =         '^'
-      PERCENT =        '%'
-      LETTER_Q =       'Q'
-      OR_STRING =      'or'
 
-      DOUBLE_QUOTE_ESCAPED = '&quot;'
-
-      READ_FLAG =     'r'
       WRITE_FLAG =    'w'
-      READ_WRITE_FLAG = 'rw'
 
       PARENT_PATH =   '..'
 
       RUBY = 'Ruby'
       CACHE = 'cache'
-      GEM_SUFFIX = '.gem'
 
-      CONTRAST_METHOD_START = 'cs__'
       CONTRAST_PATCHED_METHOD_START = 'cs__patched_'
       CONTRAST_MODULE_START = 'Contrast::'
       ANONYMOUS_CLASS_MARKER = '#<'
@@ -75,13 +53,11 @@ module Contrast
 
       EMPTY_ARRAY = [].freeze
       EMPTY_HASH = {}.freeze
-      EMPTY_TRIPLE = [EMPTY_STRING, EMPTY_STRING, EMPTY_STRING].freeze
 
       # RegExps
       DIGIT_REGEXP =       /[[:digit:]]/.freeze
       WHITE_SPACE_REGEXP = /\s/.freeze
       NOT_WHITE_SPACE_REGEXP = /[^\s]/.freeze
-      WINDOWS_REGEXP = /cygwin|mswin|mingw|bccwin|wince|emx/.freeze
 
       # Messages
       OVERRIDE_MESSAGE = 'A security filter prevented original response from being returned.'
@@ -93,10 +69,7 @@ module Contrast
       CLASS = 'Class'
       MODULE = 'Module'
 
-      BRACKET_INTERPOLATION_START = '#{'
-
       OBJECT_KEY = 'O'
-      PARAMETER_KEY = 'P'
       RETURN_KEY = 'R'
       UNKNOWN = 'unknown'
 

data/lib/contrast/utils/os.rb

@@ -8,32 +8,8 @@ module Contrast
     # Utility memozies to avoid multiple lookups.
     module OS
       class << self
-        def windows?
-          @_windows = !(/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM).nil? if @_windows.nil?
-          @_windows
-        end
-
-        def mac?
-          @_mac ||= !(/darwin/ =~ RUBY_PLATFORM).nil? if @_mac.nil?
-          @_mac
-        end
-
-        def unix?
-          @unix ||= !windows? if @_unix.nil?
-          @unix
-        end
-
-        def linux?
-          @_linux ||= unix? && !OS.mac? if @_linux.nil?
-          @_linux
-        end
-
         def running?
-          process = if Contrast::Utils::OS.windows?
-                      `tasklist /fi "imagename eq contrast-service.exe"`
-                    else
-                      `ps aux | grep contrast-servic[e]`
-                    end
+          process = `ps aux | grep contrast-servic[e]`
           process != ''
         end
 

data/lib/contrast/utils/service_response_util.rb

@@ -1,108 +1,84 @@
 # Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+cs__scoped_require 'contrast/logger/log'
+cs__scoped_require 'contrast/agent/reaction_processor'
+cs__scoped_require 'contrast/components/interface'
+cs__scoped_require 'contrast/utils/assess/sampling_util'
+
 module Contrast
   module Utils
     # Utility class for processing responses from the Contrast Service. Specifically, this class
     # processes Server and Application settings and updates the Settings component.
     module ServiceResponseUtil
       include Contrast::Components::Interface
-      access_component :contrast_service, :logging, :settings, :analysis
+      access_component :agent, :analysis, :logging, :settings
 
       class << self
-        # TODO: RUBY-119
+        # Return true if the agent has processed a response from the service
+        def update_received?
+          @_last_update.nil?
+        end
+
         def process_response response
-          fs = Contrast::Agent::FeatureState.instance
-          fs.last_update = response&.sent_ms
+          @_last_update = response&.sent_ms
+
           server_features = process_server_response(response)
           app_settings = process_application_response(response)
 
           # ReactionProcessor is a design pattern from TeamServer.
           # Right now, there's one potential reaction, which is disabling the agent
           Contrast::Agent::ReactionProcessor.process(response&.application_settings)
-          # Determine new accumulator state
-          if (new_accum = response&.accumulator_settings)
-            SETTINGS.accumulator_settings.replace(new_accum)
-          end
 
-          fs.logger_manager.update(server_features&.log_file, server_features&.log_level)
+          Contrast::Logger::Log.instance.update(server_features&.log_file, server_features&.log_level)
           update_features(server_features, app_settings)
-          logger.debug("Agent modes: P-#{ fs.protect_enabled? ? 'ENABLED' : 'DISABLED' }, A-#{ fs.assess_enabled? ? 'ENABLED' : 'DISABLED' }")
+          logger.trace(
+              'Agent settings updated in response to Service',
+              protect_on: PROTECT.enabled?,
+              assess_on: ASSESS.enabled?)
         end
 
         private
 
         # Given some protobuf messages, update settings.
         # This is the bridge between Contrast Service <-> Settings.
-        LOG_SERVER_SETTINGS_UPDATE = 'Agent: Received updated server features'
-        LOG_UPDATE_PROTECT         = 'Updating Protect state'
-        LOG_UPDATE_ASSESS          = 'Updating Assess state'
         def process_server_response response
           server_features = response&.server_features
           return unless server_features
 
-          logger.debug(LOG_SERVER_SETTINGS_UPDATE)
-          # 'defend' is legacy for 'protect' in the dtm.
-          protect = server_features.defend
-          assess = server_features.assess
-
-          protect_enable = !!protect.enabled
-          assess_enable =  !!assess.enabled
+          logger.trace('Agent: Received updated server features')
 
-          # protect
-          begin
-            logger.debug(LOG_UPDATE_PROTECT)
-            SETTINGS.protect_state[:enabled] = protect_enable
-          end
-
-          # assess
-          begin
-            logger.debug(LOG_UPDATE_ASSESS)
-            SETTINGS.assess_state[:enabled] = assess_enable
-            SETTINGS.assess_state[:sampling_settings] = assess.sampling
-          end
+          SETTINGS.update_from_server_features(server_features)
 
           server_features
         end
 
-        MODE_WHITELIST = %i[NO_ACTION BLOCK_AT_PERIMETER MONITOR BLOCK].cs__freeze
-        LOG_APP_SETTINGS_UPDATE = 'Agent: Received updated application settings'
         def process_application_response response
           app_settings = response&.application_settings
           return unless app_settings
 
-          logger.debug(LOG_APP_SETTINGS_UPDATE)
-          exclusion_matchers = app_settings.exclusions.map { |exc| Contrast::Agent::ExclusionMatcher.new(exc) }
-          protection_rules = app_settings.protection_rules.map { |pr, _hash| [pr.id, pr.mode] }
-          protection_rules.select! { |(_id, mode)| MODE_WHITELIST.include? mode }
-          modes_by_id = protection_rules.to_h
-          SETTINGS.application_state.merge!(
-              modes_by_id: modes_by_id,
-              exclusion_matchers: exclusion_matchers,
-              disabled_assess_rules: app_settings.disabled_assess_rules,
-              session_id: app_settings.session_id)
+          logger.debug('Agent: Received updated application settings')
+
+          SETTINGS.update_from_application_settings(app_settings)
 
           app_settings
         end
 
-        # This is can also go into settings/c.service, but it
-        # requires protobuf decorators to be pretty and decomposed.
-        LOG_INFO_RULE_SETTINGS = 'Current rule settings:'
+        # This can't go in the Settings component because protect and assess depend on settings
+        # I don't think it should go into contrast_service because that only handles connection specific data
         def update_features server_features, app_settings
-          if !!(server_features || app_settings)
-            logger.debug_with_time('Rebuilding rule modes') do
-              SETTINGS.build_protect_rules if PROTECT.enabled?
-              SETTINGS.build_assess_rules  if ASSESS.enabled?
-
-              logger.info(LOG_INFO_RULE_SETTINGS)
-              PROTECT.rules.each { |k, v| logger.info(".. protect: #{ k } (#{ v.mode })") }
-              ASSESS.rules.each { |k, v| logger.info(".. assess:  #{ k } (#{ v.enabled? })") }
-            end
-          end
+          return unless !!(server_features || app_settings)
+          return unless AGENT.enabled?
+
+          logger.trace_with_time('Rebuilding rule modes') do
+            SETTINGS.build_protect_rules if PROTECT.enabled?
+            SETTINGS.build_assess_rules  if ASSESS.enabled?
+            AGENT.reset_ruleset
 
-          # This is for assess
-          # PERF, we could avoid here with dirty-tracking.
-          Contrast::Utils::Assess::SamplingUtil.instance.update
+            logger.info('Current rule settings:')
+            PROTECT.rules.each { |k, v| logger.info('Protect Rule mode set', rule: k, mode: v.mode) }
+            ASSESS.rules.each { |k, v| logger.info('Assess Rule mode set', rule: k, mode: v.enabled?) }
+          end
         end
       end
     end

data/lib/contrast/utils/service_sender_util.rb

@@ -13,11 +13,9 @@ module Contrast
     # to SpeedRacer.
     module ServiceSenderUtil
       include Contrast::Components::Interface
-      access_component :contrast_service, :logging, :analysis, :agent
+      access_component :analysis, :app_context, :logging, :settings
 
       class << self
-        attr_reader :assess_messages, :ready_messages_queue
-
         # Push the given DTM into a queue to be sent to the Service.
         #
         # @param event [Contrast::Api::Dtm] One of the DTMs valid for the event field of
@@ -25,33 +23,49 @@ module Contrast
         def push_to_ready_queue event
           return unless event
 
-          # Since a message may try to be pushed before sending_thread starts up, we need to initialize
-          # the queue on first message sent
-          @ready_messages_queue ||= Queue.new
+          prep_queue
           ready_messages_queue.push event
-          logger.debug("Enqueued the #{ event.cs__class.name } event #{ event.__id__ }.") # TODO: RUBY-794 make Type & ID structured for parsing)
+          logger.debug('Enqueued event',
+                       event_id: event.__id__,
+                       event_type: event.cs__class.name,
+                       queue: ready_messages_queue.__id__,
+                       length: ready_messages_queue.length)
+        end
+
+        # Bypass the queue and send the message directly to SpeedRacer. This is the only way
+        # to receive the response object back from SpeedRacer. An invoking method that needs
+        # to process the response object with custom logic should use this method.
+        #
+        # @param event [Contrast::Api::Dtm] One of the DTMs valid for the event
+        #   field of Contrast::Api::Dtm::Message
+        # @return [Array<Contrast::Api::Dtm::AttackResult>] the response from SpeedRacer
+        def send_event_immediately event
+          client.send_to_speedracer(event) if event
         end
 
         def sending_thread
-          # in case we got here before a message attempted to be sent, let's make sure these are initialized
-          @ready_messages_queue ||= Queue.new
-          @assess_messages ||= []
+          return @_sender_thread if @_sender_thread
 
+          # in case we got here before a message attempted to be sent, let's make sure these are initialized
           @_sender_thread ||= Contrast::Agent::Thread.new do
             loop do
-              check_assess_queue if assess_messages # don't bother checking if assess queue is already cleared
+              check_assess_queue
               # if ready messages queue is empty, calling thread is suspended until a message is pushed onto queue
               event = ready_messages_queue.pop
               begin
-                logger.debug("Dequeued the #{ event.cs__class.name } event #{ event.__id__ }.") # TODO: RUBY-794 make Type & ID structured for parsing)
-                response = Contrast::Agent::FeatureState.instance.client.send_to_speedracer event
+                logger.debug('Dequeued event',
+                             event_id: event.__id__,
+                             event_type: event.cs__class.name,
+                             queue: ready_messages_queue.__id__,
+                             length: ready_messages_queue.length)
+                response = client.send_to_speedracer(event)
                 Contrast::Utils::ServiceResponseUtil.process_response(response) if response
               rescue StandardError => e
-                logger.error(e, 'Could not send message to service from service sender thread.')
+                logger.error('Could not send message to service from service sender thread.', e)
               end
             end
           end
-          logger.debug(nil, 'Started background sending thread.')
+          logger.debug('Started background sending thread.')
         end
         alias_method :start, :sending_thread
 
@@ -60,17 +74,64 @@ module Contrast
         end
 
         def add_to_assess_messages msg
-          # This list holds messages containing assess findings. We currently
-          # do not know if the agent is running in assess, so until we do then
-          # we must keep the messages stored here.
-          @assess_messages ||= []
-          assess_messages << msg
+          assess_messages! << msg
+        end
+
+        # Return true if the agent has connected with the service
+        def connection_established?
+          client.connection_established?
         end
 
         private
 
+        # TODO: RUBY-920
+        # If we've been forked, then we need to make sure the sender is set and
+        # alive. This is a temporary workaround to address issues in Passenger
+        # around forking and will be addressed next sprint.
+        def prep_queue
+          return if @_sender_thread&.alive?
+
+          @_sender_thread = nil
+          start
+        end
+
+        def ready_messages_queue
+          @_ready_messages_queue ||= begin
+                                       tmp = Queue.new
+                                       logger.debug('Creating new ready_messages_queue.',
+                                                    queue: tmp.__id__,
+                                                    length: tmp.length)
+                                       tmp
+                                     end
+        end
+
+        def assess_messages!
+          unless @_assess_messages
+            logger.debug('Creating new assess messages queue by force.')
+            @_assess_messages = nil
+          end
+          assess_messages
+        end
+
+        # This list holds messages containing assess findings. We may not
+        # know if the agent is running in assess, so until we do then we
+        # must keep the messages stored here. Once we do know, we'll set this
+        # to `false` and rely on the standard ready_messages_queue
+        def assess_messages
+          if @_assess_messages.nil?
+            logger.debug('Creating new assess messages queue.')
+            @_assess_messages = []
+          end
+          @_assess_messages
+        end
+
+        def client
+          @_client ||= Contrast::Agent::SocketClient.new
+        end
+
         def check_assess_queue
-          return unless AGENT.ready?
+          return unless assess_messages
+          return unless APP_CONTEXT.ready?
 
           if ASSESS.enabled?
             assess_messages.each do |msg|
@@ -78,7 +139,7 @@ module Contrast
               ready_messages_queue.push msg # this message is ready to be sent to SR
             end
           end
-          @assess_messages = nil # clear out queue, we no longer need it
+          @_assess_messages = false # clear out queue, we no longer need it
         end
 
         # When we queued up findings, we didn't have access to a configuration
@@ -97,7 +158,7 @@ module Contrast
           end
 
           msg.findings.each do |finding|
-            finding.session_id = Contrast::Agent::FeatureState.instance.current_session_id
+            finding.session_id = SETTINGS.session_id
           end
         end
       end

data/lib/contrast/utils/sinatra_helper.rb

@@ -33,12 +33,6 @@ module Contrast
         end
       end
 
-      def self.settings_instance
-        @_settings_instance ||= begin
-                                  app_class&.settings
-                                end
-      end
-
       def self.view_directory
         @_view_directory ||= begin
           app_class&.settings&.views

data/lib/contrast/utils/stack_trace_utils.rb

@@ -3,207 +3,111 @@
 
 cs__scoped_require 'contrast/utils/object_share'
 cs__scoped_require 'contrast/api'
+cs__scoped_require 'contrast/utils/cache'
 
 module Contrast
   module Utils
     # Utilities for converting ruby stack trace into DTMs
     class StackTraceUtils
-      CONTRAST_MARKER = 'contrast/extensions/ruby_core'
-      MONKEYPATCH_MARKER = 'cs__'
-
-      # TODO: RUBY-532
-      CLASSNAME_CACHE = Contrast::Utils::Cache.new
-
       # need lib here to separate from specs
-      AGENT_CLASS_MARKERS = %w[
-        /lib/contrast/
-      ].cs__freeze
-
-      def self.custom_code_context?
-        stack = Kernel.caller(0, 15)
-        i = 0
-        while i < stack.length
-          stack_element = stack[i]
-          if stack_element.include?('contrast')
-            # Noop
-          elsif stack_element.include?('gems')
-            return false
-          else
-            return true
+      AGENT_CLASS_MARKER = '/lib/contrast/'
+
+      class << self
+        # Determine if this method is being invoked by application code or not
+        # based on the immediate caller of the code after Contrast.
+        #
+        # @return [Boolean] true if this code is called with application
+        #   (non-gem) code in the caller
+        def custom_code_context?
+          root_dir = Contrast::Agent.framework_manager.app_root
+
+          stack = Kernel.caller(0, 15)
+          i = 0
+          while i < stack.length
+            stack_element = stack[i]
+            i += 1
+            next if stack_element.include?('/contrast/')
+
+            return stack_element.start_with?(root_dir)
           end
-          i += 1
         end
-      end
-
-      def self.build(
-          skip: 0,
-          depth: 10,
-          ignore: false,
-          ignore_strings: AGENT_CLASS_MARKERS,
-          class_lookup: false,
-          rasp_element: true)
-
-        stack = caller(skip.to_i, depth.to_i)
-        return [] unless stack
-
-        stack = reject_caller_entries(stack, ignore_strings) if ignore
-        stack.map! do |entry|
-          element = rasp_or_assess(rasp_element)
-          element = fill_element(element, entry, class_lookup)
-          element
-        end
-        stack.compact!
-        stack
-      end
 
-      def self.reject_caller_entries stack, ignore_strings
-        return stack unless ignore_strings&.any?
-
-        stack.reject do |entry|
-          ignore_strings.any? { |marker| entry.include?(marker) } ||
-              entry.include?(MONKEYPATCH_MARKER)
+        # Call and translate a caller_locations array to an array of
+        # StackTraceElement for TeamServer to display, excluding any Contrast
+        # code found.
+        #
+        # @return [Array<Contrast::Api::Dtm::StackTraceElement]
+        def build_protect_stack_array
+          stack = caller(2, 20)
+          return [] unless stack
+
+          stack = reject_caller_entries(stack)
+          i = 0
+          stack.map! do |entry|
+            element = Contrast::Api::Dtm::StackTraceElement.new
+            element = fill_protect_element(element, entry, i)
+            i += 1
+            element
+          end
+          stack.compact!
+          stack
         end
-      end
 
-      def self.rasp_or_assess rasp_element
-        if rasp_element
-          Contrast::Api::Dtm::StackTraceElement.new
-        else
-          Contrast::Api::Dtm::TraceStack.new
+        # Translate a caller array to an array of TraceStacks for TeamServer to
+        # display, excluding any Contrast code found.
+        #
+        # @param stack [Array<String>] the output of Kernel.caller
+        # @return [Array<Contrast::Api::Dtm::TraceStack]
+        def build_assess_stack_array stack
+          converted = []
+          return converted unless stack
+
+          i = 0
+          while i < stack.length
+            caller_location = stack[i]
+            i += 1
+            next if caller_location.include?(AGENT_CLASS_MARKER)
+
+            # To play nice with the way that TeamServer is rendering these
+            # values, we only populate the file_name field with exactly what we
+            # want them to display
+            element = Contrast::Api::Dtm::TraceStack.new
+            element.file_name = caller_location
+            converted << element
+          end
+          converted
         end
-      end
 
-      def self.to_dtm_stack stack_locations: nil, rasp_element: true
-        return [] unless stack_locations
+        private
 
-        stack_locations = reject_locations(stack_locations)
-        stack_locations.map! do |caller_location|
-          element = rasp_or_assess(rasp_element)
-          element = fill_loc_element(element, caller_location)
-          element
-        end
-        stack_locations.compact!
-        stack_locations
-      end
-
-      def self.reject_locations stack_locations
-        stack_locations.reject do |entry|
-          class_path = entry.path
-          method = entry.label
-          AGENT_CLASS_MARKERS.any? { |marker| class_path.include?(marker) } ||
-              method.include?(MONKEYPATCH_MARKER)
+        def reject_caller_entries stack
+          stack.reject do |entry|
+            entry = entry.to_s
+            entry.include?(AGENT_CLASS_MARKER)
+          end
         end
-      end
 
-      # "/.rvm/rubies/ruby-1.9.3-p551/lib/ruby/1.9.1/irb/workspace.rb:80:in `eval'"
-      def self.fill_element element, str, class_lookup
-        return element if str.nil? || str.strip.empty?
-
-        path, line, method = str.split(':')
-        element.line_number = line.to_i
-        file_name = filename_from_path(path)
-        element.file_name = Contrast::Utils::StringUtils.force_utf8(file_name)
-        declaring_class = best_classname(path, element.file_name) if class_lookup
-        element.declaring_class = Contrast::Utils::StringUtils.force_utf8(declaring_class)
-        method_name = find_method_name(method)
-        element.method_name = Contrast::Utils::StringUtils.force_utf8(method_name)
-        element
-      rescue StandardError
-        # NOOP
-        nil
-      end
-
-      def self.best_classname path, file
-        name = first_class(path)
-        name || look_like_classname(file)
-      end
-
-      # "/.rvm/rubies/ruby-1.9.3-p551/lib/ruby/1.9.1/irb/workspace.rb:80:in `eval'"
-      def self.fill_loc_element element, caller_location
-        return element unless caller_location
-
-        lineno = caller_location.lineno
-        element.line_number = lineno.to_i
-        path = caller_location.path
-        path = Contrast::Utils::StringUtils.force_utf8(path)
-        file_name = filename_from_path(path)
-        element.file_name = Contrast::Utils::StringUtils.force_utf8(file_name)
-        element.declaring_class = path
-        label = caller_location.label
-        element.method_name = Contrast::Utils::StringUtils.force_utf8(label)
-        element
-      rescue StandardError
-        # NOOP
-        nil
-      end
+        # In Contrast UI - there are many ways to render the stacktraces. For
+        # Protect, there are two ways we're concerned about, one for the first
+        # element and then all others.
+        # 1 for protect first frame - We need the method specifically for this rendering
+        # 1 for protect Nth frames
+        def fill_protect_element element, caller_location, index
+          return element unless caller_location
+
+          if index.zero?
+            element.method_name = caller_location.split('`')[-1].delete_suffix!('\'')
+            element.file_name = caller_location.split(':')[0]
+          else
+            element.file_name = caller_location
+          end
 
-      def self.filename_from_path path
-        file_idx = path.rindex(Contrast::Utils::ObjectShare::SLASH)
-        if file_idx
-          txt_idx = file_idx + 1
-          path[txt_idx, path.length - txt_idx]
-        else
-          path
+          element
+        rescue StandardError
+          # NOOP
+          nil
         end
       end
-
-      # Bit of a HACK: Given a path to a file, assume that the first line in the
-      # form `class Name` is the class that was loaded. True most of the time.
-      #
-      # Using regexp here is expensive b/c it creates a ton of new Strings. We're
-      # trying to avoid that, so our guess is a little more clumsy, but should
-      # still work.
-      #
-      # Note: Might need to tune end marker to include /n
-      # based on: /\s*class\s+([_[:alpha:]][_[:alnum:]]*)/m
-      CLASS_MARKER = ' class '
-      CLASS_END_MARKER = Contrast::Utils::ObjectShare::NEW_LINE
-      def self.first_class path
-        return nil if path.nil? || path.empty?
-
-        name = CLASSNAME_CACHE[path]
-        return name if name
-
-        text = File.read(path)
-        name = parse_string(text, CLASS_MARKER, CLASS_END_MARKER)
-        CLASSNAME_CACHE[path] = name if name
-        name
-      end
-
-      RB_MARKER = '.rb'
-      # Convert a file to look like a classname
-      # If the file ends w/ '.rb', trim that off
-      # If the file doesn't start with a capital letter,
-      # capitalize it
-      def self.look_like_classname file
-        file = file.to_s
-        file[0].capitalize + (file.end_with?(RB_MARKER) ? file.slice(1..-4) : file.slice(1..-1))
-      end
-
-      # Using regexp here is expensive b/c it creates a ton of new Strings. We're
-      # trying to avoid that, so our guess is a little more clumsy, but should
-      # still work.
-      #
-      # Note: Might need to tune end marker to include /n
-      # based on: /[`]([^']*)[']/
-      METHOD_MARKER = Contrast::Utils::ObjectShare::TICK
-      METHOD_END_MARKER = Contrast::Utils::ObjectShare::COMMA
-      def self.find_method_name method
-        parse_string(method, METHOD_MARKER, METHOD_END_MARKER)
-      end
-
-      def self.parse_string string, start_marker, end_marker
-        return nil unless string
-
-        start_idx = string.index(start_marker)
-        return nil unless start_idx
-
-        start_idx += start_marker.length # account for marker length
-        end_idx = string.index(end_marker, start_idx)
-        end_idx ||= string.length
-        len = end_idx - start_idx
-        string[start_idx, len]
-      end
     end
   end
 end