appmap 0.45.0 → 0.48.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0db499c7da4baea3f29fb56214a95e18047a07fc0c132ba559f7f6eb7ef9033a
-  data.tar.gz: 3aabf3bf1a31c39d6844ccf17807a4b7e206783bdf8e373008d3db0d04a854d7
+  metadata.gz: 6ce9ca4faa9074d177861610ff47bec4e7b02191e870759a12d1ed9207e9f79a
+  data.tar.gz: 6b0157f28774b1d46fdea527c8076846253780040628f3879ec8c18af8c4a60d
 SHA512:
-  metadata.gz: a38e51f5c932d9a04b566c2664104e08a56af80fd3277c039603eb719336599bc9764781e1d0835c6c7b702e4e0465587fd4537e292df325c0d9efe4a90c1493
-  data.tar.gz: 168e2b8c1605cf7b4f8c4d6a5f373b5add4ce1804c4c494f3cc4e3b29da5a08f4e121889bca36e06e1e29aa4c9943c16b76f7868e9331c3a7e5b33af0817f1a0
+  metadata.gz: e9d67de222d734c8b650c2c8bb8cef70b371908561dd8df43410f370071cdd1c24b9cc8d4919ccfda59745afefccc29e8af30444f25136aac685384ec079e0ba
+  data.tar.gz: 387a7a074b9c56ae423825e0beea405909066528c40ff6d6ce3789843193c6e0c73cafabefd8e091dc9961dd5e2c112f311538e8afdc5bbaf37ca187be2f1606

data/.travis.yml

@@ -17,6 +17,16 @@ before_script:
 cache:
   bundler: true
 
+before_install:
+  # see https://blog.travis-ci.com/docker-rate-limits 
+  # and also https://www.docker.com/blog/what-you-need-to-know-about-upcoming-docker-hub-rate-limiting/
+  # if we do not use authorized account, 
+  # the pulls-per-IP quota is shared with other Travis users
+  - >
+    if [ ! -z "$DOCKERHUB_PASSWORD" ] && [ ! -z "$DOCKERHUB_USERNAME" ]; then
+      echo "$DOCKERHUB_PASSWORD" | docker login -u "$DOCKERHUB_USERNAME" --password-stdin  ;
+    fi
+
  
 # GEM_ALTERNATIVE_NAME only needed for deployment 
 jobs:

data/CHANGELOG.md

@@ -1,3 +1,39 @@
+# [0.48.0](https://github.com/applandinc/appmap-ruby/compare/v0.47.1...v0.48.0) (2021-05-19)
+
+
+### Features
+
+* Hook the code only when APPMAP=true ([dd9e383](https://github.com/applandinc/appmap-ruby/commit/dd9e383024d1d9205a617d46bd64b90820035533))
+* Remove server process recording from doc and tests ([383ba0a](https://github.com/applandinc/appmap-ruby/commit/383ba0ad444922a0a85409477d11bc7ed06a9160))
+
+## [0.47.1](https://github.com/applandinc/appmap-ruby/compare/v0.47.0...v0.47.1) (2021-05-13)
+
+
+### Bug Fixes
+
+* Add the proper template function hooks for Rails 6.0.7 ([175f489](https://github.com/applandinc/appmap-ruby/commit/175f489acbaed77ad52a18d805e4b6eeae1abfdb))
+
+# [0.47.0](https://github.com/applandinc/appmap-ruby/compare/v0.46.0...v0.47.0) (2021-05-13)
+
+
+### Features
+
+* Emit swagger-style normalized paths instead of Rails-style ones ([5a93cd7](https://github.com/applandinc/appmap-ruby/commit/5a93cd7096ca195146a84a6733c7d502dbcd0272))
+
+# [0.46.0](https://github.com/applandinc/appmap-ruby/compare/v0.45.1...v0.46.0) (2021-05-12)
+
+
+### Features
+
+* Record view template rendering events and template paths ([973b258](https://github.com/applandinc/appmap-ruby/commit/973b2581b6e2d4e15a1b93331e4e95a88678faae))
+
+## [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

@@ -9,11 +9,11 @@
   - [Minitest](#minitest)
   - [Cucumber](#cucumber)
   - [Remote recording](#remote-recording)
-  - [Server process recording](#server-process-recording)
 - [AppMap for VSCode](#appmap-for-vscode)
 - [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)
@@ -83,22 +83,6 @@ If you are using Ruby on Rails, require the railtie after Rails is loaded.
 require 'appmap/railtie' if defined?(AppMap).
 ```
 
-**application.rb**
-
-Add this line to *application.rb*, to enable server recording with `APPMAP_RECORD=true`:
-
-```ruby
-module MyApp
-  class Application < Rails::Application
-    ...
-  
-    config.appmap.enabled = true if ENV['APPMAP_RECORD']
-    
-    ...
-  end
-end
-```
-
 # Configuration
 
 When you run your program, the `appmap` gem reads configuration settings from `appmap.yml`. Here's a sample configuration
@@ -325,25 +309,25 @@ if defined?(AppMap)
 end
 ```
 
-2. Download and unpack the [AppLand browser extension](https://github.com/applandinc/appland-browser-extension). Install into Chrome using `chrome://extensions/`. Turn on "Developer Mode" and then load the extension using the "Load unpacked" button.
+2. (optional) Download and unpack the [AppLand browser extension](https://github.com/applandinc/appland-browser-extension). Install into Chrome using `chrome://extensions/`. Turn on "Developer Mode" and then load the extension using the "Load unpacked" button.
 
-3. Start your Rails application server. For example:
+3. Start your Rails application server, with `APPMAP_RECORD=true`. For example:
 
 ```sh-session
-$ bundle exec rails server
+$ APPMAP_RECORD=true bundle exec rails server
 ```
 
-4. Open the AppLand browser extension and push `Start`.
+4. Start the recording
 
-5. Use your app. For example, perform a login flow, or run through a manual UI test.
+Option 1: Open the AppLand browser extension and push `Start`.
+Option 2: `curl -XPOST localhost:3000/_appmap/record` (be sure and get the port number right)
 
-6. Open the AppLand browser extension and push `Stop`. The recording will be transferred to the AppLand website and opened in your browser.
-
-## Server process recording
+5. Use your app. For example, perform a login flow, or run through a manual UI test.
 
-Run your Rails server with `APPMAP_RECORD=true`. When the server exits, an *appmap.json* file will be written to the project directory. This is a great way to start the server, interact with your app as a user (or through it's API), and then view an AppMap of everything that happened.
+6. Finish the recording.
 
-Be sure and set `WEB_CONCURRENCY=1`, if you are using a webserver that can run multiple processes. You only want there to be one process while you are recording, otherwise they will both try and write *appmap.json* and one of them will clobber the other.
+Option 1: Open the AppLand browser extension and push `Stop`. The recording will be transferred to the AppLand website and opened in your browser.
+Option 2: `curl -XDELETE localhost:3000/_appmap/record > recording.appmap.json` - Saves the recording as a local file.
 
 
 # AppMap for VSCode
@@ -369,6 +353,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.rb

@@ -9,7 +9,6 @@ end
 
 require 'appmap/version'
 require 'appmap/hook'
-require 'appmap/handler/net_http'
 require 'appmap/config'
 require 'appmap/trace'
 require 'appmap/class_map'
@@ -99,4 +98,4 @@ module AppMap
 end
 
 require 'appmap/railtie' if defined?(::Rails::Railtie)
-AppMap.initialize unless ENV['APPMAP_INITIALIZE'] == 'false'
+AppMap.initialize if ENV['APPMAP'] == 'true'

data/lib/appmap/class_map.rb

@@ -82,16 +82,13 @@ module AppMap
       protected
 
       def add_function(root, method)
-        package = method.package
-        static = method.static
-
         object_infos = [
           {
-            name: package.name,
+            name: method.package,
             type: 'package'
           }
         ]
-        object_infos += method.defined_class.split('::').map do |name|
+        object_infos += method.class_name.split('::').map do |name|
           {
             name: name,
             type: 'class'
@@ -100,7 +97,7 @@ module AppMap
         function_info = {
           name: method.name,
           type: 'function',
-          static: static
+          static: method.static
         }
         location = method.source_location
 
@@ -108,20 +105,15 @@ module AppMap
           if location
             location_file, lineno = location
             location_file = location_file[Dir.pwd.length + 1..-1] if location_file.index(Dir.pwd) == 0
-            [ location_file, lineno ].join(':')
+            [ location_file, lineno ].compact.join(':')
           else
-            [ method.defined_class, static ? '.' : '#', method.name ].join
+            [ method.class_name, method.static ? '.' : '#', method.name ].join
           end
 
-        comment = begin
-          method.comment
-        rescue MethodSource::SourceNotFoundError
-          nil
-        end
-
+        comment = method.comment
         function_info[:comment] = comment unless comment.blank?
 
-        function_info[:labels] = parse_labels(comment) + (package.labels || [])
+        function_info[:labels] = parse_labels(comment) + (method.labels || [])
         object_infos << function_info
 
         parent = root

data/lib/appmap/config.rb

@@ -1,8 +1,25 @@
 # frozen_string_literal: true
 
+require 'appmap/handler/net_http'
+require 'appmap/handler/rails/template'
+
 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 +35,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 +85,33 @@ module AppMap
       end
     end
 
-    Function = Struct.new(:package, :cls, :labels, :function_names) do
+    # Identifies specific methods within a package which should be hooked.
+    class TargetMethods # :nodoc:
+      attr_reader :method_names, :package
+
+      def initialize(method_names, package)
+        @method_names = method_names
+        @package = package
+      end
+
+      def include_method?(method_name)
+        Array(method_names).include?(method_name)
+      end
+
+      def to_h
+        {
+          package: package.name,
+          method_names: method_names
+        }
+      end
+    end
+    private_constant :TargetMethods
+
+    # Function represents a specific function configured for hooking by the +functions+
+    # entry in appmap.yml. When the Config is initialized, each Function is converted into
+    # a Package and TargetMethods. It's called a Function rather than a Method, because Function
+    # is the AppMap terminology.
+    Function = Struct.new(:package, :cls, :labels, :function_names) do # :nodoc:
       def to_h
         {
           package: package,
@@ -67,80 +121,127 @@ module AppMap
         }.compact
       end
     end
+    private_constant :Function
 
-    class Hook
-      attr_reader :method_names, :package
+    ClassTargetMethods = Struct.new(:cls, :target_methods) # :nodoc:
+    private_constant :ClassTargetMethods
 
-      def initialize(method_names, package)
-        @method_names = method_names
-        @package = package
+    MethodHook = Struct.new(:cls, :method_names, :labels) # :nodoc:
+    private_constant :MethodHook
+    
+    class << self
+      def package_hooks(gem_name, methods, handler_class: nil, package_name: nil)
+        Array(methods).map do |method|
+          package = Package.build_from_gem(gem_name, package_name: package_name, labels: method.labels, shallow: false, optional: true)
+          next unless package
+
+          package.handler_class = handler_class if handler_class
+          ClassTargetMethods.new(method.cls, TargetMethods.new(Array(method.method_names), package))
+        end.compact
       end
 
-      def to_h
-        {
-          package: package.name,
-          method_names: method_names
-        }
+      def method_hook(cls, method_names, labels)
+        MethodHook.new(cls, method_names, labels)
       end
     end
 
-    OPENSSL_PACKAGES = ->(labels) { Package.build_from_path('openssl', package_name: 'openssl', labels: labels) }
+    # Hook well-known functions. When a function configured here is available in the bundle, it will be hooked with the
+    # predefined labels specified here. If any of these hooks are not desired, they can be disabled in the +exclude+ section
+    # of appmap.yml.
+    METHOD_HOOKS = [
+      package_hooks('actionview',
+        [
+          method_hook('ActionView::Renderer', :render, %w[mvc.view]),
+          method_hook('ActionView::TemplateRenderer', :render, %w[mvc.view]),
+          method_hook('ActionView::PartialRenderer', :render, %w[mvc.view])
+        ],
+        handler_class: AppMap::Handler::Rails::Template::RenderHandler,
+        package_name: 'action_view'
+      ),
+      package_hooks('actionview',
+        [
+          method_hook('ActionView::Resolver', %i[find_all find_all_anywhere], %w[mvc.template.resolver])
+        ],
+        handler_class: AppMap::Handler::Rails::Template::ResolverHandler,
+        package_name: 'action_view'
+      ),
+      package_hooks('actionpack',
+        [
+          method_hook('ActionDispatch::Request::Session', %i[destroy [] dig values []= clear update delete fetch merge], %w[http.session]),
+          method_hook('ActionDispatch::Cookies::CookieJar', %i[[]= clear update delete recycle], %w[http.session]),
+          method_hook('ActionDispatch::Cookies::EncryptedCookieJar', %i[[]= clear update delete recycle], %w[http.cookie crypto.encrypt])
+        ],
+        package_name: 'action_dispatch'
+      ),
+      package_hooks('cancancan',
+        [
+          method_hook('CanCan::ControllerAdditions', %i[authorize! can? cannot?], %w[security.authorization]),
+          method_hook('CanCan::Ability', %i[authorize?], %w[security.authorization])
+        ]
+      ),
+      package_hooks('actionpack',
+        [
+          method_hook('ActionController::Instrumentation', %i[process_action send_file send_data redirect_to], %w[mvc.controller])
+        ],
+        package_name: 'action_controller'
+      )
+    ].flatten.freeze
 
-    # 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])),
-      '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])),
-      ]
-    }.freeze
+    OPENSSL_PACKAGES = ->(labels) { Package.build_from_path('openssl', package_name: 'openssl', labels: labels) }
 
-    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])),
+    # Hook functions which are builtin to Ruby. Because they are builtins, they may be loaded before appmap.
+    # Therefore, we can't rely on TracePoint to report the loading of this code.
+    BUILTIN_HOOKS = {
+      '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_hooks
 
     def initialize(name, packages, exclude: [], functions: [])
       @name = name
       @packages = packages
+      @hook_paths = Set.new(packages.map(&:path))
       @exclude = exclude
-      @builtin_methods = BUILTIN_METHODS
+      @builtin_hooks = BUILTIN_HOOKS
       @functions = functions
-      @hooked_methods = HOOKED_METHODS.dup
+
+      @hooked_methods = METHOD_HOOKS.each_with_object(Hash.new { |h,k| h[k] = [] }) do |cls_target_methods, hooked_methods|
+        hooked_methods[cls_target_methods.cls] << cls_target_methods.target_methods
+      end
+
       functions.each do |func|
         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
+        end
       end
     end
 
@@ -191,57 +292,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