appmap 0.44.0 → 0.47.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02dfa68caaa5e5413c68ae06e89664a676624c9dbb301e2ebbc2a7ae26359afd
-  data.tar.gz: af97e3fb4bb428a238b854ef30969f232c48d4f3a59956865a4cc95788ac35e8
+  metadata.gz: 12dbe41efff7d8fd40a884be376ff1579d961371b780eddf18d4724e7ce5997f
+  data.tar.gz: fb038cfbcc6c2432b780d4555b8948729fd65a2943a4bc1200c7d6943a62f5a8
 SHA512:
-  metadata.gz: 9a0f2454acf5d10c48aaf1abb6e4b23d674acbbfe495770a25ff83093c38dd81cf0bb1c85dfbae4691773586ace8500c3f9b879b31749c4142851f460ed1a87c
-  data.tar.gz: a2860fb0258b96d95e5ca98f7d13b382c86b635ce1c2d97084c1f651a55973d2ffe31e360695fdec963292081e527b96876c6b42976a90573b9201e14032d1f5
+  metadata.gz: 07a9ec31b08915e1d630a90200393d88db2b85b49b8dc21ffa595e598fa57ff8ed3afa463e3e9dc2ae9485d5dff399eb1724c6aa38cbcceeb0d3c6c0757d0f70
+  data.tar.gz: 3c6e629772604730b6acc14409c98694624cbfcbbc14a661182b6bb5388664b15a918c3e82ca5b55dd1daf6ca142741d0380a3e88c152f5bafcd57cb9b38dd6c

data/.releaserc.yml

@@ -0,0 +1,11 @@
+plugins:
+  - '@semantic-release/commit-analyzer'
+  - '@semantic-release/release-notes-generator'
+  - '@semantic-release/changelog'
+  - 'semantic-release-rubygem'
+  - - '@semantic-release/git'
+    - assets:
+        - CHANGELOG.md
+        - appmap.gemspec
+        - lib/appmap/version.rb
+  - '@semantic-release/github'

data/.travis.yml

@@ -16,23 +16,39 @@ before_script:
 
 cache:
   bundler: true
-  directories:
-    - $HOME/docker
-
-# https://stackoverflow.com/a/41975912
-before_cache:
-  # Save tagged docker images
-  - >
-    mkdir -p $HOME/docker && docker images -a --filter='dangling=false' --format '{{.Repository}}:{{.Tag}} {{.ID}}'
-    | xargs -n 2 -t sh -c 'test -e $HOME/docker/$1.tar.gz || docker save $0 | gzip -2 > $HOME/docker/$1.tar.gz'
 
 before_install:
-  # Load cached docker images
-  - if [[ -d $HOME/docker ]]; then ls $HOME/docker/*.tar.gz | xargs -I {file} sh -c "zcat {file} | docker load"; fi
+  # 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:
   include:
   - stage: test
     script:
     - mkdir tmp
-    - bundle exec rake test
+    - GEM_ALTERNATIVE_NAME='' bundle exec rake test
+
+    
+before_deploy:
+  - |
+    nvm install --lts \
+      && nvm use --lts \
+      && npm i -g \
+        semantic-release \
+        @semantic-release/git \
+        @semantic-release/changelog \
+        semantic-release-rubygem
+
+deploy:
+  - provider: script
+    script: ./release.sh
+    on:
+      branch: master

data/CHANGELOG.md

@@ -1,3 +1,45 @@
+## [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)
+
+
+### Bug Fixes
+
+* Properly name status_code in HTTP server response ([556e87c](https://github.com/applandinc/appmap-ruby/commit/556e87c9a7bf214f6b8714add4f77448fd223d33))
+
+
+### Features
+
+* Record http_client_request and http_client_response ([1db32ae](https://github.com/applandinc/appmap-ruby/commit/1db32ae0d26a7f1400b6b814d25b13368f06c158))
+* Update AppMap format version to 1.5.0 ([061705e](https://github.com/applandinc/appmap-ruby/commit/061705e4619cb881e8edd022ef835183e399e127))
+* **build:** add deployment via `semantic-release` with automatic publication to rubygems ([9f183de](https://github.com/applandinc/appmap-ruby/commit/9f183de13f405900000c3da979c3a8a5b6e34a24))
+
 # v0.44.0
 
 * Support recording and labeling of indivudal functions via `functions:` section in *appmap.yml*.

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)
@@ -325,25 +325,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.
-
-6. Open the AppLand browser extension and push `Stop`. The recording will be transferred to the AppLand website and opened in your browser.
+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)
 
-## 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 +369,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/README_CI.md

@@ -0,0 +1,29 @@
+# Configuration variables:
+
+* `GH_TOKEN`: used by `semantic-release` to push changes to Github and manage releases
+* `GEM_HOST_API_KEY`: rubygems API key
+* `GEM_ALTERNATIVE_NAME` (optional): used for testing of CI flows, 
+to avoid publication of test releases under official package name
+* `DOCKERHUB\_USERNAME`, `DOCKERHUB_PASSWORD`: optional dockerhub credentials, 
+to avoid throttling of dockerhub anonymous pulls
+
+Note: for security reasons, it's better to use dedicated (not personal) 
+Dockerhub account, 
+and also use [access tokens](https://docs.docker.com/docker-hub/access-tokens/) 
+instead of primary password
+
+# Release command
+
+`./release.sh` 
+
+Bash wrapper script is used merely as a launcher of `semantic-release` 
+with extra logic to explicitly determine git url from `TRAVIS_REPO_SLUG` \
+variable if its defined (otherwise git url is taken from `package.json`, 
+which breaks CI on forked repos).
+
+# CI flow
+
+1. Test happens using current version number specified in `lib/appmap/version.rb`, then `release.sh` launches `semantic-release` to do the rest
+2. The version number is increased (including modicication of `version.rb`)
+3. Gem is published under new version number
+4. Github release is created with the new version number

data/Rakefile

@@ -37,7 +37,8 @@ end
   
 def build_base_image(ruby_version)
   run_cmd "docker build" \
-         " --build-arg RUBY_VERSION=#{ruby_version} --build-arg GEM_VERSION=#{GEM_VERSION}" \
+         " --build-arg RUBY_VERSION=#{ruby_version}"    \
+         " --build-arg GEM_VERSION=#{GEM_VERSION}"      \
          " -t appmap:#{GEM_VERSION} -f Dockerfile.appmap ."
 end
   
@@ -46,7 +47,7 @@ def build_app_image(app, ruby_version)
     run_cmd( {"RUBY_VERSION" => ruby_version, "GEM_VERSION" => GEM_VERSION},
       " docker-compose build" \
       " --build-arg RUBY_VERSION=#{ruby_version}" \
-      " --build-arg GEM_VERSION=#{GEM_VERSION}")
+      " --build-arg GEM_VERSION=#{GEM_VERSION}"  ) 
   end
 end
 
@@ -138,3 +139,4 @@ task spec: %i[spec:all]
 task test: %i[spec:all minitest]
 
 task default: :test
+

data/appmap.gemspec

@@ -4,8 +4,12 @@ lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'appmap/version'
 
+
+
 Gem::Specification.new do |spec|
-  spec.name          = 'appmap'
+  # ability to parameterize gem name is added intentionally, 
+  # to support the possibility of unofficial releases, e.g. during CI tests
+  spec.name          = (ENV['GEM_ALTERNATIVE_NAME'].to_s.empty? ? 'appmap' : ENV["GEM_ALTERNATIVE_NAME"] )
   spec.version       = AppMap::VERSION
   spec.authors       = ['Kevin Gilpin']
   spec.email         = ['kgilpin@gmail.com']

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,32 @@
 # 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
+        require 'appmap/handler/function'
+        @handler_class || AppMap::Handler::Function
+      end
+
       # Indicates that only the entry points to a package will be recorded.
       # Once the code has entered a package, subsequent calls within the package will not be
       # recorded unless the code leaves the package and re-enters it.
@@ -11,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
 
@@ -42,6 +77,7 @@ module AppMap
           path: path,
           package_name: package_name,
           gem: gem,
+          handler_class: handler_class.name,
           exclude: exclude.blank? ? nil : exclude,
           labels: labels.blank? ? nil : labels,
           shallow: shallow
@@ -49,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,
@@ -59,78 +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])),
-      '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])),
+      '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' => 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
 
@@ -181,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)
+    # 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_class(method)
-      defined_class, _, method_name = ::AppMap::Hook.qualify_method_name(method)
-      return find_package(defined_class, method_name)
-    end
+    # 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)
 
-    def package_hooked_by_source_location(method)
-      location = method.source_location
-      location_file, = location
-      return unless location_file
-
-      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
+      # 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
 
-    # 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 code location (i.e. path).
+      def package_for_location
+        location = method.source_location
+        location_file, = location
+        return unless location_file
 
-    # 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)
+        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