appmap 0.31.0

data/lib/appmap/cucumber.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'appmap/util'
+
+module AppMap
+  module Cucumber
+    ScenarioAttributes = Struct.new(:name, :feature, :feature_group)
+
+    ProviderStruct = Struct.new(:scenario) do
+      def feature_group
+        # e.g. <Cucumber::Core::Ast::Location::Precise: cucumber/api/features/authenticate.feature:1>
+        feature_path.split('/').last.split('.')[0]
+      end
+    end
+
+    # ProviderBefore4 provides scenario name, feature name, and feature group name for Cucumber
+    # versions before 4.0.
+    class ProviderBefore4 < ProviderStruct
+      def attributes
+        ScenarioAttributes.new(scenario.name, scenario.feature.name, feature_group)
+      end
+
+      def feature_path
+        scenario.feature.location.to_s
+      end
+    end
+
+    # Provider4 provides scenario name, feature name, and feature group name for Cucumber
+    # versions 4.0 and later.
+    class Provider4 < ProviderStruct
+      def attributes
+        ScenarioAttributes.new(scenario.name, scenario.name.split(' ')[0..1].join(' '), feature_group)
+      end
+
+      def feature_path
+        scenario.location.file
+      end
+    end
+
+    class << self
+      def write_scenario(scenario, appmap)
+        appmap['metadata'] = update_metadata(scenario, appmap['metadata'])
+        scenario_filename = AppMap::Util.scenario_filename(appmap['metadata']['name'])
+
+        FileUtils.mkdir_p 'tmp/appmap/cucumber'
+        File.write(File.join('tmp/appmap/cucumber', scenario_filename), JSON.generate(appmap))
+      end
+
+      def enabled?
+        ENV['APPMAP'] == 'true'
+      end
+
+      protected
+
+      def cucumber_version
+        Gem.loaded_specs['cucumber']&.version&.to_s
+      end
+
+      def provider(scenario)
+        major, = cucumber_version.split('.').map(&:to_i)
+        if major < 4
+          ProviderBefore4
+        else
+          Provider4
+        end.new(scenario)
+      end
+
+      def update_metadata(scenario, base_metadata)
+        attributes = provider(scenario).attributes
+
+        base_metadata.tap do |m|
+          m['name'] = attributes.name
+          m['feature'] = attributes.feature
+          m['feature_group'] = attributes.feature_group
+          m['labels'] ||= []
+          m['labels'] += (scenario.tags&.map(&:name) || [])
+          m['frameworks'] ||= []
+          m['frameworks'] << {
+            'name' => 'cucumber',
+            'version' => Gem.loaded_specs['cucumber']&.version&.to_s
+          }
+          m['recorder'] = {
+            'name' => 'cucumber'
+          }
+        end
+      end
+    end
+  end
+end

data/lib/appmap/event.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module AppMap
+  module Event
+    @@id_counter = 0
+
+    class << self
+      # reset_id_counter is used by test cases to get consistent event ids.
+      def reset_id_counter
+        @@id_counter = 0
+      end
+
+      def next_id_counter
+        @@id_counter += 1
+      end
+    end
+
+    MethodEventStruct = Struct.new(:id, :event, :defined_class, :method_id, :path, :lineno, :thread_id)
+
+    class MethodEvent < MethodEventStruct
+      LIMIT = 100
+
+      class << self
+        def build_from_invocation(me, event_type, defined_class, method)
+          me.id = AppMap::Event.next_id_counter
+          me.event = event_type
+          me.defined_class = defined_class
+          me.method_id = method.name.to_s
+          path = method.source_location[0]
+          path = path[Dir.pwd.length + 1..-1] if path.index(Dir.pwd) == 0
+          me.path = path
+          me.lineno = method.source_location[1]
+          me.thread_id = Thread.current.object_id
+        end
+
+        # Gets a display string for a value. This is not meant to be a machine deserializable value.
+        def display_string(value)
+          return nil unless value
+
+          last_resort_string = lambda do
+            warn "AppMap encountered an error inspecting a #{value.class.name}: #{$!.message}"
+            '*Error inspecting variable*'
+          end
+
+          value_string = \
+            begin
+              value.to_s
+            rescue NoMethodError
+              begin
+                value.inspect
+              rescue StandardError
+                last_resort_string.call
+              end
+            rescue StandardError
+              last_resort_string.call
+            end
+
+          (value_string||'')[0...LIMIT].encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
+        end
+      end
+
+    end
+
+    class MethodCall < MethodEvent
+      attr_accessor :parameters, :receiver, :static
+
+      class << self
+        def build_from_invocation(mc = MethodCall.new, defined_class, method, receiver, arguments)
+          mc.tap do
+            mc.parameters = method.parameters.map.with_index do |method_param, idx|
+              param_type, param_name = method_param
+              param_name ||= 'arg'
+              value = arguments[idx]
+              {
+                name: param_name,
+                class: value.class.name,
+                object_id: value.__id__,
+                value: display_string(value),
+                kind: param_type
+              }
+            end
+            mc.receiver = {
+              class: receiver.class.name,
+              object_id: receiver.__id__,
+              value: display_string(receiver)
+            }
+            mc.static = receiver.is_a?(Module)
+            MethodEvent.build_from_invocation(mc, :call, defined_class, method)
+          end
+        end
+      end
+
+      def to_h
+        super.tap do |h|
+          h[:static] = static
+          h[:parameters] = parameters
+          h[:receiver] = receiver
+        end
+      end
+
+      alias static? static
+    end
+
+    class MethodReturnIgnoreValue < MethodEvent
+      attr_accessor :parent_id, :elapsed
+
+      class << self
+        def build_from_invocation(mr = MethodReturnIgnoreValue.new, defined_class, method, parent_id, elapsed)
+          mr.tap do |_|
+            mr.parent_id = parent_id
+            mr.elapsed = elapsed
+            MethodEvent.build_from_invocation(mr, :return, defined_class, method)
+          end
+        end
+      end
+
+      def to_h
+        super.tap do |h|
+          h[:parent_id] = parent_id
+          h[:elapsed] = elapsed
+        end
+      end
+    end
+
+    class MethodReturn < MethodReturnIgnoreValue
+      attr_accessor :return_value, :exceptions
+
+      class << self
+        def build_from_invocation(mr = MethodReturn.new, defined_class, method, parent_id, elapsed, return_value, exception)
+          mr.tap do |_|
+            if return_value
+              mr.return_value = {
+                class: return_value.class.name,
+                value: display_string(return_value),
+                object_id: return_value.__id__
+              }
+            end
+            if exception
+              next_exception = exception
+              exceptions = []
+              while next_exception
+                exception_backtrace = next_exception.backtrace_locations.try(:[], 0)
+                exceptions << {
+                  class: next_exception.class.name,
+                  message: next_exception.message,
+                  object_id: next_exception.__id__,
+                  path: exception_backtrace&.path,
+                  lineno: exception_backtrace&.lineno
+                }.compact
+                next_exception = next_exception.cause
+              end
+
+              mr.exceptions = exceptions
+            end
+            MethodReturnIgnoreValue.build_from_invocation(mr, defined_class, method, parent_id, elapsed)
+          end
+        end
+      end
+
+      def to_h
+        super.tap do |h|
+          h[:return_value] = return_value if return_value
+          h[:exceptions] = exceptions if exceptions
+        end
+      end
+    end
+  end
+end

data/lib/appmap/hook.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'English'
+
+module AppMap
+  class Hook
+    LOG = false
+
+    HOOK_DISABLE_KEY = 'AppMap::Hook.disable'
+
+    class << self
+      # Return the class, separator ('.' or '#'), and method name for
+      # the given method.
+      def qualify_method_name(method)
+        if method.owner.singleton_class?
+          # Singleton class names can take two forms:
+          # #<Class:Foo> or
+          # #<Class:#<Bar:0x0123ABC>>. Retrieve the name of
+          # the class from the string.
+          # 
+          # (There really isn't a better way to do this. The
+          # singleton's reference to the class it was created
+          # from is stored in an instance variable named
+          # '__attached__'. It doesn't have the '@' prefix, so
+          # it's internal only, and not accessible from user
+          # code.)
+          class_name = /#<Class:((#<(?<cls>.*?):)|((?<cls>.*?)>))/.match(method.owner.to_s)['cls']
+          [ class_name, '.', method.name ]
+        else
+          [ method.owner.name, '#', method.name ]
+        end
+      end
+    end
+
+    attr_reader :config
+    def initialize(config)
+      @config = config
+    end
+
+    # Observe class loading and hook all methods which match the config.
+    def enable &block
+      before_hook = lambda do |defined_class, method, receiver, args|
+        require 'appmap/event'
+        call_event = AppMap::Event::MethodCall.build_from_invocation(defined_class, method, receiver, args)
+        AppMap.tracing.record_event call_event, defined_class: defined_class, method: method
+        [ call_event, Time.now ]
+      end
+
+      after_hook = lambda do |call_event, defined_class, method, start_time, return_value, exception|
+        require 'appmap/event'
+        elapsed = Time.now - start_time
+        return_event = AppMap::Event::MethodReturn.build_from_invocation \
+                                                     defined_class, method, call_event.id, elapsed, return_value, exception
+        AppMap.tracing.record_event return_event
+      end
+
+      with_disabled_hook = lambda do |&fn|
+        # Don't record functions, such as to_s and inspect, that might be called
+        # by the fn. Otherwise there can be a stack overflow.
+        Thread.current[HOOK_DISABLE_KEY] = true
+        begin
+          fn.call
+        ensure
+          Thread.current[HOOK_DISABLE_KEY] = false
+        end
+      end
+
+      tp = TracePoint.new(:end) do |tp|
+        hook = self
+        cls = tp.self
+
+        instance_methods = cls.public_instance_methods(false)
+        class_methods = cls.singleton_class.public_instance_methods(false) - instance_methods
+
+        hook_method = lambda do |cls|
+          lambda do |method_id|
+            next if method_id.to_s =~ /_hooked_by_appmap$/
+
+            method = cls.public_instance_method(method_id)
+            disasm = RubyVM::InstructionSequence.disasm(method)
+            # Skip methods that have no instruction sequence, as they are obviously trivial.
+            next unless disasm
+
+            defined_class, method_symbol, method_name = Hook.qualify_method_name(method)
+            method_display_name = [defined_class, method_symbol, method_name].join
+
+            # Don't try and trace the AppMap methods or there will be
+            # a stack overflow in the defined hook method.
+            next if /\AAppMap[:\.]/.match?(method_display_name) 
+
+            next unless \
+              config.always_hook?(defined_class, method_name) ||
+              config.included_by_location?(method)
+
+            warn "AppMap: Hooking #{method_display_name}" if LOG
+
+            cls.define_method method_id do |*args, &block|
+              base_method = method.bind(self).to_proc
+
+              hook_disabled = Thread.current[HOOK_DISABLE_KEY]
+              enabled = true if !hook_disabled && AppMap.tracing.enabled?
+              return base_method.call(*args, &block) unless enabled
+
+              call_event, start_time = with_disabled_hook.call do
+                before_hook.call(defined_class, method, self, args)
+              end
+              return_value = nil
+              exception = nil
+              begin
+                return_value = base_method.call(*args, &block)
+              rescue
+                exception = $ERROR_INFO
+                raise
+              ensure
+                with_disabled_hook.call do
+                  after_hook.call(call_event, defined_class, method, start_time, return_value, exception)
+                end
+              end
+            end
+          end
+        end
+
+        instance_methods.each(&hook_method.call(cls))
+        class_methods.each(&hook_method.call(cls.singleton_class))
+      end
+
+      tp.enable(&block)
+    end
+  end
+end

data/lib/appmap/metadata.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module AppMap
+  module Metadata
+    class << self
+      def detect
+        {
+          app: AppMap.configuration.name,
+          language: {
+            name: 'ruby',
+            engine: RUBY_ENGINE,
+            version: RUBY_VERSION
+          },
+          client: {
+            name: 'appmap',
+            url: AppMap::URL,
+            version: AppMap::VERSION
+          }
+        }.tap do |m|
+          if defined?(::Rails) && defined?(::Rails.version)
+            m[:frameworks] ||= []
+            m[:frameworks] << {
+              name: 'rails',
+              version: ::Rails.version
+            }
+          end
+          m[:git] = git_metadata if git_available
+        end
+      end
+
+      protected
+
+      def git_available
+        @git_available = system('git status 2>&1 > /dev/null') if @git_available.nil?
+      end
+
+      def git_metadata
+        git_repo = `git config --get remote.origin.url`.strip
+        git_branch = `git rev-parse --abbrev-ref HEAD`.strip
+        git_sha = `git rev-parse HEAD`.strip
+        git_status = `git status -s`.split("\n").map(&:strip)
+        git_last_annotated_tag = `git describe --abbrev=0 2>/dev/null`.strip
+        git_last_annotated_tag = nil if git_last_annotated_tag.blank?
+        git_last_tag = `git describe --abbrev=0 --tags 2>/dev/null`.strip
+        git_last_tag = nil if git_last_tag.blank?
+        git_commits_since_last_annotated_tag = `git describe`.strip =~ /-(\d+)-(\w+)$/[1] rescue 0 if git_last_annotated_tag
+        git_commits_since_last_tag = `git describe --tags`.strip =~ /-(\d+)-(\w+)$/[1] rescue 0 if git_last_tag
+
+        {
+          repository: git_repo,
+          branch: git_branch,
+          commit: git_sha,
+          status: git_status,
+          git_last_annotated_tag: git_last_annotated_tag,
+          git_last_tag: git_last_tag,
+          git_commits_since_last_annotated_tag: git_commits_since_last_annotated_tag,
+          git_commits_since_last_tag: git_commits_since_last_tag
+        }
+      end
+    end
+  end
+end