appmap 0.45.0 → 0.45.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0db499c7da4baea3f29fb56214a95e18047a07fc0c132ba559f7f6eb7ef9033a
-  data.tar.gz: 3aabf3bf1a31c39d6844ccf17807a4b7e206783bdf8e373008d3db0d04a854d7
+  metadata.gz: b91b79723565f45d9d59ce341a9944a3a4e1c853bc77c1b176dc7b26ede9df22
+  data.tar.gz: f9be88ae7e83b801f66ada4087a06923ad9fa4d10e498f1c8b07fe0e301552d7
 SHA512:
-  metadata.gz: a38e51f5c932d9a04b566c2664104e08a56af80fd3277c039603eb719336599bc9764781e1d0835c6c7b702e4e0465587fd4537e292df325c0d9efe4a90c1493
-  data.tar.gz: 168e2b8c1605cf7b4f8c4d6a5f373b5add4ce1804c4c494f3cc4e3b29da5a08f4e121889bca36e06e1e29aa4c9943c16b76f7868e9331c3a7e5b33af0817f1a0
+  metadata.gz: e7eda447c67a44ad10226f5b6e9eb51c82995a4b2df970af27b0e2b5304101d419a6b3843ef6f0a983a3f952da2e3ed55f0de327b2856fcf970961c410c19b79
+  data.tar.gz: 839df6608d503e74f663d42673d9cf91866592a1715cee1c828c3de23ae472fdff6025ea9ee767a33e384b2ed51f46a999001d354f3e763deba46a5253eb5661

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.45.1](https://github.com/applandinc/appmap-ruby/compare/v0.45.0...v0.45.1) (2021-05-04)
+
+
+### Bug Fixes
+
+* Optimize instrumentation and load time ([db4a8ce](https://github.com/applandinc/appmap-ruby/commit/db4a8ceed4103a52caafa46626c66f33fbfeac27))
+
 # [0.45.0](https://github.com/applandinc/appmap-ruby/compare/v0.44.0...v0.45.0) (2021-05-03)
 
 

data/README.md

@@ -14,6 +14,7 @@
 - [AppMap Swagger](#appmap-swagger)
 - [Uploading AppMaps](#uploading-appmaps)
 - [Development](#development)
+  - [Internal architecture](#internal-architecture)
   - [Running tests](#running-tests)
   - [Using fixture apps](#using-fixture-apps)
     - [`test/fixtures`](#testfixtures)
@@ -369,6 +370,34 @@ For instructions on uploading, see the documentation of the [AppLand CLI](https:
 # Development
 [![Build Status](https://travis-ci.com/applandinc/appmap-ruby.svg?branch=master)](https://travis-ci.com/applandinc/appmap-ruby)
 
+## Internal architecture
+
+**Configuration**
+
+*appmap.yml* is loaded into an `AppMap::Config`. 
+
+**Hooking**
+
+Once configuration is loaded, `AppMap::Hook` is enabled. "Hooking" refers to the process of replacing a method
+with a "hooked" version of the method. The hooked method checks to see if tracing is enabled. If so, it wraps the original
+method with calls that record the parameters and return value.
+
+**Builtins**
+
+`Hook` begins by iterating over builtin classes and modules defined in the `Config`. Builtins include code
+like `openssl` and `net/http`. This code is not dependent on any external libraries being present, and 
+`appmap` cannot guarantee that it will be loaded before builtins. Therefore, it's necessary to require it and
+hook it by looking up the classes and modules as constants in the `Object` namespace.
+
+**User code and gems**
+
+After hooking builtins, `Hook` attaches a [TracePoint](https://ruby-doc.org/core-2.6/TracePoint.html) to `:begin` events.
+This TracePoint is notified each time a new class or module is being evaluated. When this happens, `Hook` uses the `Config`
+to determine whether any code within the evaluated file is configured for hooking. If so, a `TracePoint` is attached to
+`:end` events. Each `:end` event is fired when a class or module definition is completed. When this happens, the `Hook` enumerates
+the public methods of the class or module, hooking the ones that are targeted by the `Config`. Once the `:end` TracePoint leaves
+the scope of the `:begin`, the `:end` TracePoint is disabled.
+
 ## Running tests
 
 Before running tests, configure `local.appmap` to point to your local `appmap-ruby` directory.

data/lib/appmap/config.rb

@@ -2,7 +2,21 @@
 
 module AppMap
   class Config
+    # Specifies a code +path+ to be mapped.
+    # Options:
+    #
+    # * +gem+ may indicate a gem name that "owns" the path
+    # * +package_name+ can be used to make sure that the code is required so that it can be loaded. This is generally used with
+    #   builtins, or when the path to be required is not automatically required when bundler requires the gem.
+    # * +exclude+ can be used used to exclude sub-paths. Generally not used with +gem+.
+    # * +labels+ is used to apply labels to matching code. This is really only useful when the package will be applied to
+    #   specific functions, via TargetMethods.
+    # * +shallow+ indicates shallow mapping, in which only the entrypoint to a gem is recorded.
     Package = Struct.new(:path, :gem, :package_name, :exclude, :labels, :shallow) do
+      # This is for internal use only.
+      private_methods :gem
+
+      # Specifies the class that will convert code events into event objects.
       attr_writer :handler_class
 
       def handler_class
@@ -18,25 +32,36 @@ module AppMap
       end
 
       class << self
+        # Builds a package for a path, such as `app/models` in a Rails app. Generally corresponds to a `path:` entry
+        # in appmap.yml. Also used for mapping specific methods via TargetMethods.
         def build_from_path(path, shallow: false, package_name: nil, exclude: [], labels: [])
           Package.new(path, nil, package_name, exclude, labels, shallow)
         end
 
-        def build_from_gem(gem, shallow: true, package_name: nil, exclude: [], labels: [])
-          if %w[method_source activesupport].member?(gem)
+        # Builds a package for gem. Generally corresponds to a `gem:` entry in appmap.yml. Also used when mapping
+        # a builtin.
+        def build_from_gem(gem, shallow: true, package_name: nil, exclude: [], labels: [], optional: false, force: false)
+          if !force && %w[method_source activesupport].member?(gem)
             warn "WARNING: #{gem} cannot be AppMapped because it is a dependency of the appmap gem"
             return
           end
-          Package.new(gem_path(gem), gem, package_name, exclude, labels, shallow)
+          path = gem_path(gem, optional)
+          if path
+            Package.new(path, gem, package_name, exclude, labels, shallow)
+          else
+            warn "#{gem} is not available in the bundle" if AppMap::Hook::LOG
+          end
         end
 
         private_class_method :new
 
         protected
 
-        def gem_path(gem)
-          gemspec = Gem.loaded_specs[gem] or raise "Gem #{gem.inspect} not found"
-          gemspec.gem_dir
+        def gem_path(gem, optional)
+          gemspec = Gem.loaded_specs[gem]
+          # This exception will notify a user that their appmap.yml contains non-existent gems.
+          raise "Gem #{gem.inspect} not found" unless gemspec || optional
+          gemspec ? gemspec.gem_dir : nil
         end
       end
 
@@ -57,7 +82,7 @@ module AppMap
       end
     end
 
-    Function = Struct.new(:package, :cls, :labels, :function_names) do
+    Function = Struct.new(:package, :cls, :labels, :function_names) do # :nodoc:
       def to_h
         {
           package: package,
@@ -67,8 +92,9 @@ module AppMap
         }.compact
       end
     end
+    private_constant :Function
 
-    class Hook
+    class TargetMethods # :nodoc:
       attr_reader :method_names, :package
 
       def initialize(method_names, package)
@@ -76,6 +102,10 @@ module AppMap
         @package = package
       end
 
+      def include_method?(method_name)
+        Array(method_names).include?(method_name)
+      end
+
       def to_h
         {
           package: package.name,
@@ -83,55 +113,58 @@ module AppMap
         }
       end
     end
+    private_constant :TargetMethods
 
     OPENSSL_PACKAGES = ->(labels) { Package.build_from_path('openssl', package_name: 'openssl', labels: labels) }
 
     # Methods that should always be hooked, with their containing
     # package and labels that should be applied to them.
     HOOKED_METHODS = {
-      'ActiveSupport::SecurityUtils' => Hook.new(:secure_compare, Package.build_from_path('active_support', labels: %w[crypto.secure_compare])),
-      'ActionView::Renderer' => Hook.new(:render, Package.build_from_path('action_view', labels: %w[mvc.view])),
-      'ActionDispatch::Request::Session' => Hook.new(%i[destroy [] dig values []= clear update delete fetch merge], Package.build_from_path('action_pack', labels: %w[http.session])),
-      'ActionDispatch::Cookies::CookieJar' => Hook.new(%i[[]= clear update delete recycle], Package.build_from_path('action_pack', labels: %w[http.cookie])),
-      'ActionDispatch::Cookies::EncryptedCookieJar' => Hook.new(%i[[]=], Package.build_from_path('action_pack', labels: %w[http.cookie crypto.encrypt])),
-      'CanCan::ControllerAdditions' => Hook.new(%i[authorize! can? cannot?], Package.build_from_path('cancancan', labels: %w[security.authorization])),
-      'CanCan::Ability' => Hook.new(%i[authorize!], Package.build_from_path('cancancan', labels: %w[security.authorization])),
+      'ActionView::Renderer' => TargetMethods.new(:render, Package.build_from_gem('actionview', package_name: 'action_view', labels: %w[mvc.view], optional: true)),
+      'ActionDispatch::Request::Session' => TargetMethods.new(%i[destroy [] dig values []= clear update delete fetch merge], Package.build_from_gem('actionpack', package_name: 'action_dispatch', labels: %w[http.session], optional: true)),
+      'ActionDispatch::Cookies::CookieJar' => TargetMethods.new(%i[[]= clear update delete recycle], Package.build_from_gem('actionpack', package_name: 'action_dispatch', labels: %w[http.cookie], optional: true)),
+      'ActionDispatch::Cookies::EncryptedCookieJar' => TargetMethods.new(%i[[]=], Package.build_from_gem('actionpack', package_name: 'action_dispatch', labels: %w[http.cookie crypto.encrypt], optional: true)),
+      'CanCan::ControllerAdditions' => TargetMethods.new(%i[authorize! can? cannot?], Package.build_from_gem('cancancan', labels: %w[security.authorization], optional: true)),
+      'CanCan::Ability' => TargetMethods.new(%i[authorize!], Package.build_from_gem('cancancan', labels: %w[security.authorization], optional: true)),
       'ActionController::Instrumentation' => [
-        Hook.new(%i[process_action send_file send_data redirect_to], Package.build_from_path('action_view', labels: %w[mvc.controller])),
-        Hook.new(%i[render], Package.build_from_path('action_view', labels: %w[mvc.view])),
+        TargetMethods.new(%i[process_action send_file send_data redirect_to], Package.build_from_gem('actionpack', package_name: 'action_controller', labels: %w[mvc.controller], optional: true)),
+        TargetMethods.new(%i[render], Package.build_from_gem('actionpack', package_name: 'action_controller', labels: %w[mvc.view], optional: true)),
       ]
     }.freeze
 
     BUILTIN_METHODS = {
-      'OpenSSL::PKey::PKey' => Hook.new(:sign, OPENSSL_PACKAGES.(%w[crypto.pkey])),
-      'OpenSSL::X509::Request' => Hook.new(%i[sign verify], OPENSSL_PACKAGES.(%w[crypto.x509])),
-      'OpenSSL::PKCS5' => Hook.new(%i[pbkdf2_hmac_sha1 pbkdf2_hmac], OPENSSL_PACKAGES.(%w[crypto.pkcs5])),
+      'OpenSSL::PKey::PKey' => TargetMethods.new(:sign, OPENSSL_PACKAGES.(%w[crypto.pkey])),
+      'OpenSSL::X509::Request' => TargetMethods.new(%i[sign verify], OPENSSL_PACKAGES.(%w[crypto.x509])),
+      'OpenSSL::PKCS5' => TargetMethods.new(%i[pbkdf2_hmac_sha1 pbkdf2_hmac], OPENSSL_PACKAGES.(%w[crypto.pkcs5])),
       'OpenSSL::Cipher' => [
-        Hook.new(%i[encrypt], OPENSSL_PACKAGES.(%w[crypto.encrypt])),
-        Hook.new(%i[decrypt], OPENSSL_PACKAGES.(%w[crypto.decrypt]))
+        TargetMethods.new(%i[encrypt], OPENSSL_PACKAGES.(%w[crypto.encrypt])),
+        TargetMethods.new(%i[decrypt], OPENSSL_PACKAGES.(%w[crypto.decrypt]))
       ],
       'ActiveSupport::Callbacks::CallbackSequence' => [
-        Hook.new(:invoke_before, Package.build_from_path('active_support', package_name: 'active_support', labels: %w[mvc.before_action])),
-        Hook.new(:invoke_after, Package.build_from_path('active_support', package_name: 'active_support', labels: %w[mvc.after_action])),
+        TargetMethods.new(:invoke_before, Package.build_from_gem('activesupport', force: true, package_name: 'active_support', labels: %w[mvc.before_action])),
+        TargetMethods.new(:invoke_after, Package.build_from_gem('activesupport', force: true, package_name: 'active_support', labels: %w[mvc.after_action])),
       ],
-      'OpenSSL::X509::Certificate' => Hook.new(:sign, OPENSSL_PACKAGES.(%w[crypto.x509])),
-      'Net::HTTP' => Hook.new(:request, Package.build_from_path('net/http', package_name: 'net/http', labels: %w[protocol.http]).tap do |package|
+      'ActiveSupport::SecurityUtils' => TargetMethods.new(:secure_compare, Package.build_from_gem('activesupport', force: true, package_name: 'active_support/security_utils', labels: %w[crypto.secure_compare])),
+      'OpenSSL::X509::Certificate' => TargetMethods.new(:sign, OPENSSL_PACKAGES.(%w[crypto.x509])),
+      'Net::HTTP' => TargetMethods.new(:request, Package.build_from_path('net/http', package_name: 'net/http', labels: %w[protocol.http]).tap do |package|
         package.handler_class = AppMap::Handler::NetHTTP
       end),
-      'Net::SMTP' => Hook.new(:send, Package.build_from_path('net/smtp', package_name: 'net/smtp', labels: %w[protocol.email.smtp])),
-      'Net::POP3' => Hook.new(:mails, Package.build_from_path('net/pop3', package_name: 'net/pop', labels: %w[protocol.email.pop])),
-      'Net::IMAP' => Hook.new(:send_command, Package.build_from_path('net/imap', package_name: 'net/imap', labels: %w[protocol.email.imap])),
-      'Marshal' => Hook.new(%i[dump load], Package.build_from_path('marshal', labels: %w[format.marshal])),
-      'Psych' => Hook.new(%i[dump dump_stream load load_stream parse parse_stream], Package.build_from_path('yaml', package_name: 'psych', labels: %w[format.yaml])),
-      'JSON::Ext::Parser' => Hook.new(:parse, Package.build_from_path('json', package_name: 'json', labels: %w[format.json])),
-      'JSON::Ext::Generator::State' => Hook.new(:generate, Package.build_from_path('json', package_name: 'json', labels: %w[format.json])),
+      'Net::SMTP' => TargetMethods.new(:send, Package.build_from_path('net/smtp', package_name: 'net/smtp', labels: %w[protocol.email.smtp])),
+      'Net::POP3' => TargetMethods.new(:mails, Package.build_from_path('net/pop3', package_name: 'net/pop', labels: %w[protocol.email.pop])),
+      # This is happening: Method send_command not found on Net::IMAP
+      # 'Net::IMAP' => TargetMethods.new(:send_command, Package.build_from_path('net/imap', package_name: 'net/imap', labels: %w[protocol.email.imap])),
+      # 'Marshal' => TargetMethods.new(%i[dump load], Package.build_from_path('marshal', labels: %w[format.marshal])),
+      'Psych' => TargetMethods.new(%i[dump dump_stream load load_stream parse parse_stream], Package.build_from_path('yaml', package_name: 'psych', labels: %w[format.yaml])),
+      'JSON::Ext::Parser' => TargetMethods.new(:parse, Package.build_from_path('json', package_name: 'json', labels: %w[format.json])),
+      'JSON::Ext::Generator::State' => TargetMethods.new(:generate, Package.build_from_path('json', package_name: 'json', labels: %w[format.json])),
     }.freeze
 
-    attr_reader :name, :packages, :exclude, :builtin_methods
+    attr_reader :name, :packages, :exclude, :hooked_methods, :builtin_methods
 
     def initialize(name, packages, exclude: [], functions: [])
       @name = name
       @packages = packages
+      @hook_paths = packages.map(&:path)
       @exclude = exclude
       @builtin_methods = BUILTIN_METHODS
       @functions = functions
@@ -140,7 +173,13 @@ module AppMap
         package_options = {}
         package_options[:labels] = func.labels if func.labels
         @hooked_methods[func.cls] ||= []
-        @hooked_methods[func.cls] << Hook.new(func.function_names, Package.build_from_path(func.package, package_options))
+        @hooked_methods[func.cls] << TargetMethods.new(func.function_names, Package.build_from_path(func.package, package_options))
+      end
+
+      @hooked_methods.each_value do |hooks|
+        Array(hooks).each do |hook|
+          @hook_paths << hook.package.path if hook.package
+        end
       end
     end
 
@@ -191,57 +230,54 @@ module AppMap
       }
     end
 
-    # package_for_method finds the Package, if any, which configures the hook
-    # for a method.
-    def package_for_method(method)
-      package_hooked_by_class(method) || package_hooked_by_source_location(method)
-    end
-
-    def package_hooked_by_class(method)
-      defined_class, _, method_name = ::AppMap::Hook.qualify_method_name(method)
-      return find_package(defined_class, method_name)
+    # Determines if methods defined in a file path should possibly be hooked.
+    def path_enabled?(path)
+      path = AppMap::Util.normalize_path(path)
+      @hook_paths.find { |hook_path| path.index(hook_path) == 0 }
     end
 
-    def package_hooked_by_source_location(method)
-      location = method.source_location
-      location_file, = location
-      return unless location_file
+    # Looks up a class and method in the config, to find the matching Package configuration.
+    # This class is only used after +path_enabled?+ has returned `true`. 
+    LookupPackage = Struct.new(:config, :cls, :method) do
+      def package
+        # Global "excludes" configuration can be used to ignore any class/method.
+        return if config.never_hook?(cls, method)
 
-      location_file = location_file[Dir.pwd.length + 1..-1] if location_file.index(Dir.pwd) == 0
-      packages.select { |pkg| pkg.path }.find do |pkg|
-        (location_file.index(pkg.path) == 0) &&
-          !pkg.exclude.find { |p| location_file.index(p) }
+        package_for_code_object || package_for_location
       end
-    end
-
-    def never_hook?(method)
-      defined_class, separator, method_name = ::AppMap::Hook.qualify_method_name(method)
-      return true if exclude.member?(defined_class) || exclude.member?([ defined_class, separator, method_name ].join)
-    end
 
-    # always_hook? indicates a method that should always be hooked.
-    def always_hook?(defined_class, method_name)
-      !!find_package(defined_class, method_name)
-    end
+      # Hook a method which is specified by class and method name.
+      def package_for_code_object
+        Array(config.hooked_methods[cls.name])
+          .compact
+          .find { |hook| hook.include_method?(method.name) }
+          &.package
+      end
 
-    # included_by_location? indicates a method whose source location matches a method definition that has been
-    # configured for inclusion.
-    def included_by_location?(method)
-      !!package_for_method(method)
+      # Hook a method which is specified by code location (i.e. path).
+      def package_for_location
+        location = method.source_location
+        location_file, = location
+        return unless location_file
+
+        location_file = AppMap::Util.normalize_path(location_file)
+        config
+          .packages
+          .select { |pkg| pkg.path }
+          .find do |pkg|
+            (location_file.index(pkg.path) == 0) &&
+              !pkg.exclude.find { |p| location_file.index(p) }
+          end
+      end
     end
 
-    def find_package(defined_class, method_name)
-      hooks = find_hooks(defined_class)
-      return nil unless hooks
-
-      hook = Array(hooks).find do |hook|
-        Array(hook.method_names).include?(method_name)
-      end
-      hook ? hook.package : nil
+    def lookup_package(cls, method)
+      LookupPackage.new(self, cls, method).package
     end
 
-    def find_hooks(defined_class)
-      Array(@hooked_methods[defined_class] || @builtin_methods[defined_class])
+    def never_hook?(cls, method)
+      _, separator, = ::AppMap::Hook.qualify_method_name(method)
+      return true if exclude.member?(cls.name) || exclude.member?([ cls.name, separator, method.name ].join)
     end
   end
 end

data/lib/appmap/hook.rb

@@ -5,6 +5,7 @@ require 'English'
 module AppMap
   class Hook
     LOG = (ENV['APPMAP_DEBUG'] == 'true' || ENV['DEBUG'] == 'true')
+    LOG_HOOK = (ENV['DEBUG_HOOK'] == 'true')
 
     OBJECT_INSTANCE_METHODS = %i[! != !~ <=> == === =~ __id__ __send__ class clone define_singleton_method display dup enum_for eql? equal? extend freeze frozen? hash inspect instance_eval instance_exec instance_of? instance_variable_defined? instance_variable_get instance_variable_set instance_variables is_a? itself kind_of? method methods nil? object_id private_methods protected_methods public_method public_methods public_send remove_instance_variable respond_to? send singleton_class singleton_method singleton_methods taint tainted? tap then to_enum to_s to_h to_a trust untaint untrust untrusted? yield_self].freeze
     OBJECT_STATIC_METHODS = %i[! != !~ < <= <=> == === =~ > >= __id__ __send__ alias_method allocate ancestors attr attr_accessor attr_reader attr_writer autoload autoload? class class_eval class_exec class_variable_defined? class_variable_get class_variable_set class_variables clone const_defined? const_get const_missing const_set constants define_method define_singleton_method deprecate_constant display dup enum_for eql? equal? extend freeze frozen? hash include include? included_modules inspect instance_eval instance_exec instance_method instance_methods instance_of? instance_variable_defined? instance_variable_get instance_variable_set instance_variables is_a? itself kind_of? method method_defined? methods module_eval module_exec name new nil? object_id prepend private_class_method private_constant private_instance_methods private_method_defined? private_methods protected_instance_methods protected_method_defined? protected_methods public_class_method public_constant public_instance_method public_instance_methods public_method public_method_defined? public_methods public_send remove_class_variable remove_instance_variable remove_method respond_to? send singleton_class singleton_class? singleton_method singleton_methods superclass taint tainted? tap then to_enum to_s trust undef_method untaint untrust untrusted? yield_self].freeze
@@ -35,73 +36,21 @@ module AppMap
 
     def initialize(config)
       @config = config
+      @trace_locations = []
+      # Paths that are known to be non-tracing
+      @notrace_paths = Set.new
     end
 
     # Observe class loading and hook all methods which match the config.
-    def enable &block
+    def enable(&block)
       require 'appmap/hook/method'
 
       hook_builtins
 
-      tp = TracePoint.new(:end) do |trace_point|
-        cls = trace_point.self
+      @trace_begin = TracePoint.new(:class, &method(:trace_class))
+      @trace_end = TracePoint.new(:end, &method(:trace_end))
 
-        instance_methods = cls.public_instance_methods(false) - OBJECT_INSTANCE_METHODS
-        # NoMethodError: private method `singleton_class' called for Rack::MiniProfiler:Class
-        class_methods = begin
-          if cls.respond_to?(:singleton_class)
-            cls.singleton_class.public_instance_methods(false) - instance_methods - OBJECT_STATIC_METHODS
-          else
-            []
-          end
-        rescue NameError
-          []
-        end
-
-        hook = lambda do |hook_cls|
-          lambda do |method_id|
-            # Don't try and trace the AppMap methods or there will be
-            # a stack overflow in the defined hook method.
-            return if (hook_cls&.name || '').split('::')[0] == AppMap.name
-
-            method = begin
-              hook_cls.public_instance_method(method_id)
-            rescue NameError
-              warn "AppMap: Method #{hook_cls} #{method.name} is not accessible" if LOG
-              return
-            end
-
-            warn "AppMap: Examining #{hook_cls} #{method.name}" if LOG
-
-            disasm = RubyVM::InstructionSequence.disasm(method)
-            # Skip methods that have no instruction sequence, as they are obviously trivial.
-            next unless disasm
-
-            next if config.never_hook?(method)
-
-            next unless \
-              config.always_hook?(hook_cls, method.name) ||
-              config.included_by_location?(method)
-
-            package = config.package_for_method(method)
-
-            hook_method = Hook::Method.new(package, hook_cls, method)
-
-            hook_method.activate
-          end
-        end
-
-        instance_methods.each(&hook.(cls))
-        # NoMethodError: private method `singleton_class' called for Rack::MiniProfiler:Class
-        begin
-          class_methods.each(&hook.(cls.singleton_class)) if cls.respond_to?(:singleton_class)
-        rescue NameError
-          # NameError:
-          #   uninitialized constant Faraday::Connection
-        end
-      end
-
-      tp.enable(&block)
+      @trace_begin.enable(&block)
     end
 
     # hook_builtins builds hooks for code that is built in to the Ruby standard library.
@@ -120,25 +69,112 @@ module AppMap
           require hook.package.package_name if hook.package.package_name
           Array(hook.method_names).each do |method_name|
             method_name = method_name.to_sym
+            base_cls = class_from_string.(class_name)
 
-            cls = class_from_string.(class_name)
-            method = \
-              begin
-                cls.instance_method(method_name)
-              rescue NameError
-                cls.method(method_name) rescue nil
-              end
-
-            next if config.never_hook?(method)
+            hook_method = lambda do |entry|
+              cls, method = entry
+              return false if config.never_hook?(cls, method)
 
-            if method
               Hook::Method.new(hook.package, cls, method).activate
+            end
+
+            methods = []
+            methods << [ base_cls, base_cls.public_instance_method(method_name) ] rescue nil
+            if base_cls.respond_to?(:singleton_class)
+              methods << [ base_cls.singleton_class, base_cls.singleton_class.public_instance_method(method_name) ] rescue nil
+            end
+            methods.compact!
+            if methods.empty?
+              warn "Method #{method_name} not found on #{base_cls.name}"
             else
-              warn "Method #{method_name} not found on #{cls.name}"
+              methods.each(&hook_method)
             end
           end
         end
       end
     end
+
+    protected
+
+    def trace_class(trace_point)
+      path = trace_point.path
+
+      return if @notrace_paths.member?(path)
+
+      if config.path_enabled?(path)
+        location = trace_location(trace_point)
+        warn "Entering hook-enabled location #{location}" if Hook::LOG || Hook::LOG_HOOK
+        @trace_locations << location
+        unless @trace_end.enabled?
+          warn "Enabling hooking" if Hook::LOG || Hook::LOG_HOOK
+          @trace_end.enable
+        end
+      else
+        @notrace_paths << path
+      end
+    end
+
+    def trace_location(trace_point)
+      [ trace_point.path, trace_point.lineno ].join(':')
+    end
+
+    def trace_end(trace_point)
+      cls = trace_point.self
+
+      instance_methods = cls.public_instance_methods(false) - OBJECT_INSTANCE_METHODS
+      # NoMethodError: private method `singleton_class' called for Rack::MiniProfiler:Class
+      class_methods = begin
+        if cls.respond_to?(:singleton_class)
+          cls.singleton_class.public_instance_methods(false) - instance_methods - OBJECT_STATIC_METHODS
+        else
+          []
+        end
+      rescue NameError
+        []
+      end
+
+      hook = lambda do |hook_cls|
+        lambda do |method_id|
+          # Don't try and trace the AppMap methods or there will be
+          # a stack overflow in the defined hook method.
+          next if %w[Marshal AppMap ActiveSupport].member?((hook_cls&.name || '').split('::')[0])
+
+          method = begin
+            hook_cls.public_instance_method(method_id)
+          rescue NameError
+            warn "AppMap: Method #{hook_cls} #{method.name} is not accessible" if LOG
+            next
+          end
+
+          warn "AppMap: Examining #{hook_cls} #{method.name}" if LOG
+
+          disasm = RubyVM::InstructionSequence.disasm(method)
+          # Skip methods that have no instruction sequence, as they are obviously trivial.
+          next unless disasm
+
+          package = config.lookup_package(hook_cls, method)
+          next unless package
+
+          Hook::Method.new(package, hook_cls, method).activate
+        end
+      end
+
+      instance_methods.each(&hook.(cls))
+      begin
+        # NoMethodError: private method `singleton_class' called for Rack::MiniProfiler:Class
+        class_methods.each(&hook.(cls.singleton_class)) if cls.respond_to?(:singleton_class)
+      rescue NameError
+        # NameError:
+        #   uninitialized constant Faraday::Connection
+        warn "NameError in #{__FILE__}: #{$!.message}"
+      end
+
+      location = @trace_locations.pop
+      warn "Leaving hook-enabled location #{location}" if Hook::LOG || Hook::LOG_HOOK
+      if @trace_locations.empty?
+        warn "Disabling hooking" if Hook::LOG || Hook::LOG_HOOK
+        @trace_end.disable
+      end
+    end
   end
 end

data/lib/appmap/util.rb

@@ -93,6 +93,14 @@ module AppMap
         matching_headers.blank? ? nil : matching_headers
       end
 
+      def normalize_path(path)
+        if path.index(Dir.pwd) == 0
+          path[Dir.pwd.length + 1..-1]
+        else
+          path
+        end
+      end
+
       # Atomically writes AppMap data to +filename+.
       def write_appmap(filename, appmap)
         require 'fileutils'

data/lib/appmap/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.45.0'
+  VERSION = '0.45.1'
 
   APPMAP_FORMAT_VERSION = '1.5.0'
 end

data/spec/abstract_controller_base_spec.rb

@@ -177,7 +177,7 @@ describe 'Rails' do
             )
   
             expect(appmap['classMap']).to include hash_including(
-              'name' => 'action_view',
+              'name' => 'actionview',
               'children' => include(hash_including(
                 'name' => 'ActionView',
                 'children' => include(hash_including(

data/spec/hook_spec.rb

@@ -60,8 +60,8 @@ describe 'AppMap class Hooking', docker: false do
     config = AppMap::Config.new('hook_spec', [ package ], exclude: %w[ExcludeTest])
     AppMap.configuration = config
 
-    expect(config.never_hook?(ExcludeTest.new.method(:instance_method))).to be_truthy
-    expect(config.never_hook?(ExcludeTest.method(:cls_method))).to be_truthy
+    expect(config.never_hook?(ExcludeTest, ExcludeTest.new.method(:instance_method))).to be_truthy
+    expect(config.never_hook?(ExcludeTest, ExcludeTest.method(:cls_method))).to be_truthy
   end
 
   it "handles an instance method named 'call' without issues" do
@@ -163,7 +163,9 @@ describe 'AppMap class Hooking', docker: false do
     method = hook_cls.instance_method(:say_default)
 
     require 'appmap/hook/method'
-    hook_method = AppMap::Hook::Method.new(config.package_for_method(method), hook_cls, method)
+    package = config.lookup_package(hook_cls, method)
+    expect(package).to be
+    hook_method = AppMap::Hook::Method.new(package, hook_cls, method)
     hook_method.activate
 
     tracer = AppMap.tracing.trace
@@ -861,7 +863,9 @@ describe 'AppMap class Hooking', docker: false do
       _, _, events = test_hook_behavior 'spec/fixtures/hook/compare.rb', nil do
         expect(Compare.compare('string', 'string')).to be_truthy
       end
+
       secure_compare_event = YAML.load(events).find { |evt| evt[:defined_class] == 'ActiveSupport::SecurityUtils' }
+      expect(secure_compare_event).to be_truthy
       secure_compare_event.delete(:lineno)
       secure_compare_event.delete(:path)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appmap
 version: !ruby/object:Gem::Version
-  version: 0.45.0
+  version: 0.45.1
 platform: ruby
 authors:
 - Kevin Gilpin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-03 00:00:00.000000000 Z
+date: 2021-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport