appmap 0.42.0 → 0.45.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50826fcf91733d3bb29aad0b6c77af2516ad08aa87557c3675d4be896f7790db
-  data.tar.gz: 4e5ee3f431b68a69de5ff6b080eeae861f3f7de6fe952ea1e71b5c30d4777bc1
+  metadata.gz: b91b79723565f45d9d59ce341a9944a3a4e1c853bc77c1b176dc7b26ede9df22
+  data.tar.gz: f9be88ae7e83b801f66ada4087a06923ad9fa4d10e498f1c8b07fe0e301552d7
 SHA512:
-  metadata.gz: fcd01c7d1a3d70c29e33d8890e8f1ea8d7dc5cd2fbca7724618fcc76190c2d0217b89ba69e4de5003eb80147d44c15335cfdff60e67cdaf3eeaa18655fdf2b4f
-  data.tar.gz: 32c714968c8669f3a9dceb20543a0f09856948f4b4d6b8584ad06d6347cf10f28a4d0386e4f3af1aaccb1709ec2a88fefe88da88104ffbe18dfd0fd81fb5cb95
+  metadata.gz: e7eda447c67a44ad10226f5b6e9eb51c82995a4b2df970af27b0e2b5304101d419a6b3843ef6f0a983a3f952da2e3ed55f0de327b2856fcf970961c410c19b79
+  data.tar.gz: 839df6608d503e74f663d42673d9cf91866592a1715cee1c828c3de23ae472fdff6025ea9ee767a33e384b2ed51f46a999001d354f3e763deba46a5253eb5661

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

@@ -13,11 +13,32 @@ services:
 # necessary.
 before_script:
   - unset RAILS_ENV
-  
+
+cache:
+  bundler: true
+
+ 
+# 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.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*.
+* Remove deprecated `exe/appmap`.
+* Add `test_status` and `exception` fields to AppMap metadata.
+* Write AppMap file atomically, by writing to a temp file first and then moving it into place.
+* Remove printing of `Inventory.json` file.
+* Remove source code from `classMap`.
+
+# v0.43.0
+
+* Record `name` and `class` of each entry in Hash-like parameters, messages, and return values.
+* Record client-sent headers in HTTP server request and response.
+* Record HTTP server request `mime_type`.
+* Record HTTP server request `authorization`.
+
+# v0.42.1
+
+* Add missing require `set`.
+* Check `cls.respond_to?(:singleton_class)`, since it oddly, may not.
+
 # v0.42.0
 
 * Remove `feature_group` and `feature` metadata from minitest and RSpec AppMaps.

data/README.md

@@ -11,8 +11,10 @@
   - [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)
@@ -109,6 +111,9 @@ name: my_project
 packages:
 - path: app/controllers
 - path: app/models
+  # Exclude sub-paths within the package path
+  exclude:
+  - concerns/accessor
 - path: app/jobs
 - path: app/helpers
 # Include the gems that you want to see in the dependency maps.
@@ -117,15 +122,22 @@ packages:
 - gem: devise
 - gem: aws-sdk
 - gem: will_paginate
+# Global exclusion of a class name
 exclude:
 - MyClass
 - MyClass#my_instance_method
 - MyClass.my_class_method
+functions:
+- packages: myapp
+  class: ControllerHelper
+  function: logged_in_user
+  labels: [ authentication ]
 ```
 
 * **name** Provides the project name (required)
 * **packages** A list of source code directories which should be recorded.
 * **exclude** A list of classes and/or methods to definitively exclude from recording.
+* **functions** A list of specific functions, scoped by package and class, to record.
 
 **packages**
 
@@ -144,6 +156,11 @@ Each entry in the `packages` list is a YAML object which has the following keys:
 
 Optional list of fully qualified class and method names. Separate class and method names with period (`.`) for class methods and hash (`#`) for instance methods.
 
+**functions**
+
+Optional list of `class, function` pairs. The `package` name is used to place the function within the class map, and does not have to match
+the folder or gem name. The primary use of `functions` is to apply specific labels to functions whose source code is not accessible (e.g., it's in a Gem).
+For functions which are part of the application code, use `@label` or `@labels` in code comments to apply labels.
 
 # Labels
 
@@ -329,9 +346,20 @@ Run your Rails server with `APPMAP_RECORD=true`. When the server exits, an *appm
 
 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.
 
+
 # AppMap for VSCode
 
-The [AppMap extension for VSCode](https://marketplace.visualstudio.com/items?itemName=appland.appmap) is a great way to onboard developers to new code, and troubleshoot hard-to-understand bugs with visuals.
+The [AppMap extension for VSCode](https://marketplace.visualstudio.com/items?itemName=appland.appmap) helps you navigate your code more efficiently with interactive, accurate software architecture diagrams right in your IDE. In less than two minutes you can go from installing the AppMap extension to exploring maps of your code's architecture. AppMap helps you:
+
+* Onboard to code architecture, with no extra work for the team
+* Conduct code and design reviews using live and accurate data
+* Troubleshoot hard-to-understand bugs using a "top-down" approach.
+
+Each interactive diagram links directly to the source code, and the information is easy to share.
+
+# AppMap Swagger
+
+[appmap_swagger](https://github.com/applandinc/appmap_swagger-ruby) is a tool to generate Swagger files from AppMap data. With `appmap_swagger`, you can add Swagger to your Ruby or Ruby on Rails project, with no need to write or modify code. Use the Swagger UI to interact with your web services API as you build it, and use diffs of Swagger to perform code review of web service changes.
 
 # Uploading AppMaps
 
@@ -342,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.
@@ -369,7 +425,7 @@ The fixture apps in `test/fixtures` are plain Ruby projects that exercise the ba
 
 ### `spec/fixtures`
 
-The fixture apps in `spec/fixtures` are simple Rack, Rails4, and Rails5 apps.
+The fixture apps in `spec/fixtures` are simple Rack, Rails5, and Rails6 apps.
 You can use them to interactively develop and test the recording features of the `appmap` gem.
 These fixture apps are more sophisticated than `test/fixtures`, because they include additional 
 resources such as a PostgreSQL database.
@@ -395,11 +451,15 @@ $ docker-compose run --rm app ./create_app
 Now you can start a development container.
 
 ```sh-session
-$ docker-compose run --rm -v $PWD/../../..:/src/appmap-ruby app bash
+$ docker-compose run --rm -v $PWD:/app -v $PWD/../../..:/src/appmap-ruby app bash
 Starting rails_users_app_pg_1 ... done
-root@6fab5f89125f:/app# cd /src/app
+root@6fab5f89125f:/app# cd /src/appmap-ruby
+root@6fab5f89125f:/src/appmap-ruby# rm ext/appmap/*.so ext/appmap/*.o
+root@6fab5f89125f:/src/appmap-ruby# bundle
+root@6fab5f89125f:/src/appmap-ruby# bundle exec rake compile
+root@6fab5f89125f:/src/appmap-ruby# cd /src/app
 root@6fab5f89125f:/src/app# bundle config local.appmap /src/appmap-ruby
-root@6fab5f89125f:/src/app# bundle update appmap
+root@6fab5f89125f:/src/app# bundle
 ```
 
 At this point, the bundle is built with the `appmap` gem located  in `/src/appmap`, which is volume-mounted from the host.
@@ -414,4 +474,3 @@ Configuring AppMap from path appmap.yml
 Finished in 0.07357 seconds (files took 2.1 seconds to load)
 4 examples, 0 failures
 ```
-

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']
@@ -20,8 +24,6 @@ Gem::Specification.new do |spec|
 ")
   spec.extensions << "ext/appmap/extconf.rb"
 
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
   spec.add_dependency 'activesupport'

data/lib/appmap.rb

@@ -9,6 +9,7 @@ end
 
 require 'appmap/version'
 require 'appmap/hook'
+require 'appmap/handler/net_http'
 require 'appmap/config'
 require 'appmap/trace'
 require 'appmap/class_map'
@@ -43,6 +44,7 @@ module AppMap
     # Call this function before the program code is loaded by the Ruby VM, otherwise
     # the load events won't be seen and the hooks won't activate.
     def initialize(config_file_path = 'appmap.yml')
+      raise "AppMap configuration file #{config_file_path} does not exist" unless ::File.exists?(config_file_path)
       warn "Configuring AppMap from path #{config_file_path}"
       Config.load_from_file(config_file_path).tap do |configuration|
         self.configuration = configuration
@@ -50,11 +52,6 @@ module AppMap
       end
     end
 
-    # Whether to include source and comments in all class maps.
-    def include_source?
-      ENV['APPMAP_SOURCE'] == 'true'
-    end
-
     # Used to start tracing, stop tracing, and record events.
     def tracing
       @tracing ||= Trace::Tracing.new
@@ -88,8 +85,8 @@ module AppMap
     end
 
     # Builds a class map from a config and a list of Ruby methods.
-    def class_map(methods, options = {})
-      ClassMap.build_from_methods(methods, options)
+    def class_map(methods)
+      ClassMap.build_from_methods(methods)
     end
 
     # Returns default metadata detected from the Ruby system and from the

data/lib/appmap/class_map.rb

@@ -71,17 +71,17 @@ module AppMap
     end
 
     class << self
-      def build_from_methods(methods, options = {})
+      def build_from_methods(methods)
         root = Types::Root.new
         methods.each do |method|
-          add_function root, method, options
+          add_function root, method
         end
         root.children.map(&:to_h)
       end
 
       protected
 
-      def add_function(root, method, include_source: true)
+      def add_function(root, method)
         package = method.package
         static = method.static
 
@@ -113,16 +113,13 @@ module AppMap
             [ method.defined_class, static ? '.' : '#', method.name ].join
           end
 
-        source, comment = begin
-          [ method.source, method.comment ]
+        comment = begin
+          method.comment
         rescue MethodSource::SourceNotFoundError
-          [ nil, nil, ]
+          nil
         end
 
-        if include_source
-          function_info[:source] = source unless source.blank?
-          function_info[:comment] = comment unless comment.blank?
-        end
+        function_info[:comment] = comment unless comment.blank?
 
         function_info[:labels] = parse_labels(comment) + (package.labels || [])
         object_infos << function_info

data/lib/appmap/command/record.rb

@@ -27,7 +27,7 @@ module AppMap
           event_thread.join
           yield AppMap::APPMAP_FORMAT_VERSION,
                 AppMap.detect_metadata,
-                AppMap.class_map(tracer.event_methods, include_source: AppMap.include_source?),
+                AppMap.class_map(tracer.event_methods),
                 events
         end
 

data/lib/appmap/config.rb

@@ -2,7 +2,28 @@
 
 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 +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
 
@@ -42,6 +74,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,44 +82,105 @@ module AppMap
       end
     end
 
-    Hook = Struct.new(:method_names, :package) do
+    Function = Struct.new(:package, :cls, :labels, :function_names) do # :nodoc:
+      def to_h
+        {
+          package: package,
+          class: cls,
+          labels: labels,
+          functions: function_names.map(&:to_sym)
+        }.compact
+      end
+    end
+    private_constant :Function
+
+    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
 
-    OPENSSL_PACKAGES = Package.build_from_path('openssl', package_name: 'openssl', labels: %w[security crypto])
+    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[provider.secure_compare])),
-      'ActionView::Renderer' => Hook.new(:render, Package.build_from_path('action_view', labels: %w[mvc.view])),
-      'ActionDispatch::Cookies::CookieJar' => Hook.new(%i[[]= clear update delete recycle], Package.build_from_path('action_pack', labels: %w[provider.http.cookie])),
-      'ActionDispatch::Cookies::EncryptedCookieJar' => Hook.new(%i[[]=], Package.build_from_path('action_pack', labels: %w[provider.http.cookie crypto])),
-      'CanCan::ControllerAdditions' => Hook.new(%i[authorize! can? cannot?], Package.build_from_path('cancancan', labels: %w[provider.authorization])),
-      'CanCan::Ability' => Hook.new(%i[authorize!], Package.build_from_path('cancancan', labels: %w[provider.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' => [
+        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),
-      'OpenSSL::X509::Request' => Hook.new(%i[sign verify], OPENSSL_PACKAGES),
-      'OpenSSL::PKCS5' => Hook.new(%i[pbkdf2_hmac_sha1 pbkdf2_hmac], OPENSSL_PACKAGES),
-      'OpenSSL::Cipher' => Hook.new(%i[encrypt decrypt final], OPENSSL_PACKAGES),
-      'OpenSSL::X509::Certificate' => Hook.new(:sign, OPENSSL_PACKAGES),
-      'Net::HTTP' => Hook.new(:request, Package.build_from_path('net/http', package_name: 'net/http', labels: %w[protocol.http io])),
-      'Net::SMTP' => Hook.new(:send, Package.build_from_path('net/smtp', package_name: 'net/smtp', labels: %w[protocol.smtp protocol.email io])),
-      'Net::POP3' => Hook.new(:mails, Package.build_from_path('net/pop3', package_name: 'net/pop', labels: %w[protocol.pop protocol.email io])),
-      'Net::IMAP' => Hook.new(:send_command, Package.build_from_path('net/imap', package_name: 'net/imap', labels: %w[protocol.imap protocol.email io])),
-      'Marshal' => Hook.new(%i[dump load], Package.build_from_path('marshal', labels: %w[format.marshal provider.serialization])),
-      '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 provider.serialization])),
-      'JSON::Ext::Parser' => Hook.new(:parse, Package.build_from_path('json', package_name: 'json', labels: %w[format.json provider.serialization])),
-      'JSON::Ext::Generator::State' => Hook.new(:generate, Package.build_from_path('json', package_name: 'json', labels: %w[format.json provider.serialization])),
+      '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' => [
+        TargetMethods.new(%i[encrypt], OPENSSL_PACKAGES.(%w[crypto.encrypt])),
+        TargetMethods.new(%i[decrypt], OPENSSL_PACKAGES.(%w[crypto.decrypt]))
+      ],
+      'ActiveSupport::Callbacks::CallbackSequence' => [
+        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])),
+      ],
+      '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
+    attr_reader :name, :packages, :exclude, :hooked_methods, :builtin_methods
 
-    def initialize(name, packages = [], exclude = [])
+    def initialize(name, packages, exclude: [], functions: [])
       @name = name
       @packages = packages
+      @hook_paths = packages.map(&:path)
       @exclude = exclude
+      @builtin_methods = BUILTIN_METHODS
+      @functions = functions
+      @hooked_methods = HOOKED_METHODS.dup
+      functions.each do |func|
+        package_options = {}
+        package_options[:labels] = func.labels if func.labels
+        @hooked_methods[func.cls] ||= []
+        @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
 
     class << self
@@ -98,6 +192,16 @@ module AppMap
 
       # Loads configuration from a Hash.
       def load(config_data)
+        functions = (config_data['functions'] || []).map do |function_data|
+          package = function_data['package']
+          cls = function_data['class']
+          functions = function_data['function'] || function_data['functions']
+          raise 'AppMap class configuration should specify package, class and function(s)' unless package && cls && functions
+          functions = Array(functions).map(&:to_sym)
+          labels = function_data['label'] || function_data['labels']
+          labels = Array(labels).map(&:to_s) if labels
+          Function.new(package, cls, labels, functions)
+        end
         packages = (config_data['packages'] || []).map do |package|
           gem = package['gem']
           path = package['path']
@@ -112,7 +216,8 @@ module AppMap
             Package.build_from_path(path, exclude: package['exclude'] || [], shallow: package['shallow'])
           end
         end.compact
-        Config.new config_data['name'], packages, config_data['exclude'] || []
+        exclude = config_data['exclude'] || []
+        Config.new config_data['name'], packages, exclude: exclude, functions: functions
       end
     end
 
@@ -120,58 +225,59 @@ module AppMap
       {
         name: name,
         packages: packages.map(&:to_h),
+        functions: @functions.map(&:to_h),
         exclude: exclude
       }
     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)
-      hook = find_hook(defined_class)
-      return nil unless hook
-
-      Array(hook.method_names).include?(method_name) ? hook.package : nil
+    def lookup_package(cls, method)
+      LookupPackage.new(self, cls, method).package
     end
 
-    def find_hook(defined_class)
-      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