appmap 0.26.1 → 0.32.0

data/lib/appmap/hook.rb

@@ -4,149 +4,77 @@ require 'English'
 
 module AppMap
   class Hook
-    LOG = false
-
-    Package = Struct.new(:path, :exclude) do
-      def to_h
-        {
-          path: path,
-          exclude: exclude.blank? ? nil : exclude
-        }.compact
+    LOG = (ENV['DEBUG'] == 'true')
+
+    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
 
-    Config = Struct.new(:name, :packages) do
-      class << self
-        # Loads configuration data from a file, specified by the file name.
-        def load_from_file(config_file_name)
-          require 'yaml'
-          load YAML.safe_load(::File.read(config_file_name))
-        end
+    attr_reader :config
+    def initialize(config)
+      @config = config
+    end
 
-        # Loads configuration from a Hash.
-        def load(config_data)
-          packages = (config_data['packages'] || []).map do |package|
-            Package.new(package['path'], package['exclude'] || [])
-          end
-          Config.new config_data['name'], packages
-        end
-      end
+    # Observe class loading and hook all methods which match the config.
+    def enable &block
+      require 'appmap/hook/method'
 
-      def initialize(name, packages = [])
-        super name, packages || []
-      end
+      tp = TracePoint.new(:end) do |trace_point|
+        cls = trace_point.self
 
-      def to_h
-        {
-          name: name,
-          packages: packages.map(&:to_h)
-        }
-      end
-    end
+        instance_methods = cls.public_instance_methods(false)
+        class_methods = cls.singleton_class.public_instance_methods(false) - instance_methods
 
-    HOOK_DISABLE_KEY = 'AppMap::Hook.disable'
+        hook = lambda do |hook_cls|
+          lambda do |method_id|
+            next if method_id.to_s =~ /_hooked_by_appmap$/
 
-    class << self
-      # Observe class loading and hook all methods which match the config.
-      def hook(config = AppMap.configure)
-        package_include_paths = config.packages.map(&:path)
-        package_exclude_paths = config.packages.map do |pkg|
-          pkg.exclude.map do |exclude|
-            File.join(pkg.path, exclude)
-          end
-        end.flatten
+            method = hook_cls.public_instance_method(method_id)
+            hook_method = Hook::Method.new(hook_cls, method)
 
-        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
+            warn "AppMap: Examining #{hook_method.method_display_name}" if LOG
 
-        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
+            disasm = RubyVM::InstructionSequence.disasm(method)
+            # Skip methods that have no instruction sequence, as they are obviously trivial.
+            next unless disasm
 
-        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 oveflow.
-          Thread.current[HOOK_DISABLE_KEY] = true
-          begin
-            fn.call
-          ensure
-            Thread.current[HOOK_DISABLE_KEY] = false
-          end
-        end
+            # Don't try and trace the AppMap methods or there will be
+            # a stack overflow in the defined hook method.
+            next if /\AAppMap[:\.]/.match?(hook_method.method_display_name)
 
-        TracePoint.trace(:end) do |tp|
-          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)
-              location = method.source_location
-              location_file, = location
-              next unless location_file
-
-              location_file = location_file[Dir.pwd.length + 1..-1] if location_file.index(Dir.pwd) == 0
-              match = package_include_paths.find { |p| location_file.index(p) == 0 }
-              match &&= !package_exclude_paths.find { |p| location_file.index(p) }
-              next unless match
-
-              disasm = RubyVM::InstructionSequence.disasm(method)
-              # Skip methods that have no instruction sequence, as they are obviously trivial.
-              next unless disasm
-
-              defined_class, method_symbol = \
-                if method.owner.singleton_class?
-                  # Singleton class name is like: #<Class:<(.*)>>
-                  class_name = method.owner.to_s['#<Class:<'.length-1..-2]
-                  [ class_name, '.' ]
-                else
-                  [ method.owner.name, '#' ]
-                end
-
-              warn "AppMap: Hooking #{defined_class}#{method_symbol}#{method.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
+            next unless \
+              config.always_hook?(hook_method.defined_class, method.name) ||
+              config.included_by_location?(method)
 
-          instance_methods.each(&hook_method.call(cls))
-          class_methods.each(&hook_method.call(cls.singleton_class))
+            hook_method.activate
+          end
         end
+
+        instance_methods.each(&hook.(cls))
+        class_methods.each(&hook.(cls.singleton_class))
       end
+
+      tp.enable(&block)
     end
   end
 end

data/lib/appmap/hook/method.rb

@@ -0,0 +1,78 @@
+module AppMap
+  class Hook
+    class Method
+      attr_reader :hook_class, :hook_method, :defined_class, :method_display_name
+
+      HOOK_DISABLE_KEY = 'AppMap::Hook.disable'
+      private_constant :HOOK_DISABLE_KEY
+
+      def initialize(hook_class, hook_method)
+        @hook_class = hook_class
+        @hook_method = hook_method
+        @defined_class, method_symbol = Hook.qualify_method_name(@hook_method)
+        @method_display_name = [@defined_class, method_symbol, @hook_method.name].join
+      end
+
+      def activate
+        warn "AppMap: Hooking #{method_display_name}" if Hook::LOG
+
+        hook_method = self.hook_method
+        before_hook = self.method(:before_hook)
+        after_hook = self.method(:after_hook)
+        with_disabled_hook = self.method(:with_disabled_hook)
+
+        hook_class.define_method hook_method.name do |*args, &block|
+          instance_method = hook_method.bind(self).to_proc
+
+          hook_disabled = Thread.current[HOOK_DISABLE_KEY]
+          enabled = true if !hook_disabled && AppMap.tracing.enabled?
+          return instance_method.call(*args, &block) unless enabled
+
+          call_event, start_time = with_disabled_hook.() do
+            before_hook.(self, args)
+          end
+          return_value = nil
+          exception = nil
+          begin
+            return_value = instance_method.(*args, &block)
+          rescue
+            exception = $ERROR_INFO
+            raise
+          ensure
+            with_disabled_hook.() do
+              after_hook.(call_event, start_time, return_value, exception)
+            end
+          end
+        end
+      end
+
+      protected
+
+      def before_hook(receiver, args)
+        require 'appmap/event'
+        call_event = AppMap::Event::MethodCall.build_from_invocation(defined_class, hook_method, receiver, args)
+        AppMap.tracing.record_event call_event, defined_class: defined_class, method: hook_method
+        [ call_event, Time.now ]
+      end
+
+      def after_hook(call_event, start_time, return_value, exception)
+        require 'appmap/event'
+        elapsed = Time.now - start_time
+        return_event = \
+          AppMap::Event::MethodReturn.build_from_invocation call_event.id, elapsed, return_value, exception
+        AppMap.tracing.record_event return_event
+      end
+
+      def with_disabled_hook(&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
+    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

data/lib/appmap/middleware/remote_recording.rb

@@ -5,12 +5,9 @@ module AppMap
     # RemoteRecording adds `/_appmap/record` routes to control recordings via HTTP requests
     class RemoteRecording
       def initialize(app)
-        require 'appmap/command/record'
         require 'json'
 
         @app = app
-        @config = AppMap.configure
-        AppMap::Hook.hook(@config)
       end
 
       def event_loop
@@ -63,15 +60,14 @@ module AppMap
         @events.delete_if(&is_control_command_event)
         @events.delete_if(&is_return_from_control_command_event)
 
-        require 'appmap/command/record'
-        metadata = AppMap::Command::Record.detect_metadata
+        metadata = AppMap.detect_metadata
         metadata[:recorder] = {
           name: 'remote_recording'
         }
 
         response = JSON.generate \
           version: AppMap::APPMAP_FORMAT_VERSION,
-          classMap: AppMap.class_map(@config, tracer.event_methods),
+          classMap: AppMap.class_map(tracer.event_methods),
           metadata: metadata,
           events: @events
 

data/lib/appmap/minitest.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'appmap/util'
+
+module AppMap
+  # Integration of AppMap with Minitest. When enabled with APPMAP=true, the AppMap tracer will
+  # be activated around each test.
+  module Minitest
+    APPMAP_OUTPUT_DIR = 'tmp/appmap/minitest'
+    LOG = false
+
+    def self.metadata
+      AppMap.detect_metadata
+    end
+
+    Recording = Struct.new(:test) do
+      def initialize(test)
+        super
+
+        warn "Starting recording of test #{test.class}.#{test.name}" if AppMap::Minitest::LOG
+        @trace = AppMap.tracing.trace
+      end
+
+      def finish
+        warn "Finishing recording of test #{test.class}.#{test.name}" if AppMap::Minitest::LOG
+
+        events = []
+        AppMap.tracing.delete @trace
+
+        events << @trace.next_event.to_h while @trace.event?
+
+        AppMap::Minitest.add_event_methods @trace.event_methods
+
+        class_map = AppMap.class_map(@trace.event_methods)
+
+        feature_group = test.class.name.underscore.split('_')[0...-1].join('_').capitalize
+        feature_name = test.name.split('_')[1..-1].join(' ')
+        scenario_name = [ feature_group, feature_name ].join(' ')
+
+        AppMap::Minitest.save scenario_name,
+                              class_map,
+                              events: events,
+                              feature_name: feature_name,
+                              feature_group_name: feature_group
+      end
+    end
+
+    @recordings_by_test = {}
+    @event_methods = Set.new
+
+    class << self
+      def init
+        warn 'Configuring AppMap recorder for Minitest'
+
+        FileUtils.mkdir_p APPMAP_OUTPUT_DIR
+      end
+
+      def begin_test(test)
+        @recordings_by_test[test.object_id] = Recording.new(test)
+      end
+
+      def end_test(test)
+        recording = @recordings_by_test.delete(test.object_id)
+        return warn "No recording found for #{test}" unless recording
+
+        recording.finish
+      end
+
+      def config
+        @config or raise "AppMap is not configured"
+      end
+
+      def add_event_methods(event_methods)
+        @event_methods += event_methods
+      end
+
+      def save(example_name, class_map, events: nil, feature_name: nil, feature_group_name: nil, labels: nil)
+        metadata = AppMap::Minitest.metadata.tap do |m|
+          m[:name] = example_name
+          m[:app] = AppMap.configuration.name
+          m[:feature] = feature_name if feature_name
+          m[:feature_group] = feature_group_name if feature_group_name
+          m[:frameworks] ||= []
+          m[:frameworks] << {
+            name: 'minitest',
+            version: Gem.loaded_specs['minitest']&.version&.to_s
+          }
+          m[:recorder] = {
+            name: 'minitest'
+          }
+        end
+
+        appmap = {
+          version: AppMap::APPMAP_FORMAT_VERSION,
+          metadata: metadata,
+          classMap: class_map,
+          events: events
+        }.compact
+        fname = AppMap::Util.scenario_filename(example_name)
+
+        File.write(File.join(APPMAP_OUTPUT_DIR, fname), JSON.generate(appmap))
+      end
+
+      def print_inventory
+        class_map = AppMap.class_map(@event_methods)
+        save 'Inventory', class_map, labels: %w[inventory]
+      end
+
+      def enabled?
+        ENV['APPMAP'] == 'true'
+      end
+
+      def run
+        init
+        at_exit do
+          print_inventory
+        end
+      end
+    end
+  end
+end
+
+if AppMap::Minitest.enabled?
+  require 'appmap'
+  require 'minitest/test'
+
+  class ::Minitest::Test
+    alias run_without_hook run
+
+    def run
+      AppMap::Minitest.begin_test self
+      begin
+        run_without_hook
+      ensure
+        AppMap::Minitest.end_test self
+      end
+    end
+  end
+
+  AppMap::Minitest.run
+end