appmap 0.67.1 → 0.68.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66a5dd9600679b05f4789e2531ca6151bc46fa5e95a7458d401f67b3b94861e7
-  data.tar.gz: 89380ec4d7ebfabe615a187a1d0a10ad107d06df4e5bc50c987b62a3f27c4edf
+  metadata.gz: 4d54229f9f87639b89c9388722e8e9ee30e327a39f9e4effe40739033229de5f
+  data.tar.gz: 2a87b31d06444d8091f78ec00e0751b900f2068ee87003c945b3b6da3e58602d
 SHA512:
-  metadata.gz: 89b13f75e8fbe46e5ddf9a5ec817eaebfd0356d124f2a117e74c24a44d07a8d89f9b0e5afcacbe9ea1277f34979955f30d441c5325ce8aa954bfeda08ce2f03f
-  data.tar.gz: 27c0ba4946df49d998aa6cfa5cfae8cbcc10bed6ec0590ac06c106e99d828f03bfb675b4a67317b1abd1b87ba1c0016699f44470585c0954d431198ee34b6b44
+  metadata.gz: 3a6efa5f3fbac309a6df73405f281deaaf4a577de3d22466e04e2a8587af59dc418e99c032387f5cf00d604da2d43cedfaa745f63589ae39f8edba685f9ab5b9
+  data.tar.gz: 390d01607fcf6ae24852758a50f4f174b90c4d59f5b008c77c60108540a9d58c65917a36242ce495430fc7bfe38bdd58a4be050d106ebbb4c7ad6a3ea7d2104e

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# [0.68.0](https://github.com/applandinc/appmap-ruby/compare/v0.67.1...v0.68.0) (2021-11-05)
+
+
+### Bug Fixes
+
+* Require weakref ([2f94f80](https://github.com/applandinc/appmap-ruby/commit/2f94f808bd3327aa3fc7fd8e6a3428a5da3a29bb))
+
+
+### Features
+
+* Externalize config of hooks ([8080222](https://github.com/applandinc/appmap-ruby/commit/8080222ce5b61d9824eaf20410d7b9b94b679890))
+* Support loading hook config via path env vars ([4856483](https://github.com/applandinc/appmap-ruby/commit/48564837784f8b0e87c4286ad3e2f6cb2d272dcf))
+
 ## [0.67.1](https://github.com/applandinc/appmap-ruby/compare/v0.67.0...v0.67.1) (2021-11-02)
 
 

data/lib/appmap/builtin_hooks/json.yml

@@ -0,0 +1,4 @@
+- method: JSON::Ext::Parser#parse
+  label: format.json.parse
+- method: JSON::Ext::Generator::State#generate
+  label: format.json.generate

data/lib/appmap/builtin_hooks/net/http.yml

@@ -0,0 +1,3 @@
+- method: Net::HTTP#request
+  label: protocol.http
+  handler_class: AppMap::Handler::NetHTTP

data/lib/appmap/builtin_hooks/openssl.yml

@@ -0,0 +1,16 @@
+- method: OpenSSL::PKey::PKey#sign
+  label: crypto.pkey
+- methods:
+  - OpenSSL::X509::Request#sign
+  - OpenSSL::X509::Request#verify
+  label: crypto.x509
+- method: OpenSSL::X509::Certificate#sign
+  label: crypto.x509
+- methods:
+  - OpenSSL::PKCS5#pbkdf2_hmac
+  - OpenSSL::PKCS5#pbkdf2_hmac_sha1
+  label: crypto.pkcs5
+- method: OpenSSL::Cipher#encrypt
+  label: crypto.encrypt
+- method: OpenSSL::Cipher#decrypt
+  label: crypto.decrypt

data/lib/appmap/builtin_hooks/yaml.yml

@@ -0,0 +1,10 @@
+- methods:
+  - Psych#load
+  - Psych#load_stream
+  - Psych#parse
+  - Psych#parse_stream
+  label: format.yaml.parse
+- methods:
+  - Psych#dump
+  - Psych#dump_stream
+  label: format.yaml.generate

data/lib/appmap/config.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'pathname'
 require 'set'
 require 'yaml'
 require 'appmap/util'
@@ -11,17 +12,20 @@ require 'appmap/depends/configuration'
 
 module AppMap
   class Config
-    # Specifies a code +path+ to be mapped.
+    # Specifies a logical code package be mapped.
+    # This can be a project source folder, a Gem, or a builtin.
+    #
     # Options:
     #
+    # * +path+ indicates a relative path to a code folder.
     # * +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
+    # * +require_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
+    Package = Struct.new(:name, :path, :gem, :require_name, :exclude, :labels, :shallow, :builtin) do
       # This is for internal use only.
       private_methods :gem
 
@@ -43,20 +47,24 @@ module AppMap
       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)
+        def build_from_path(path, shallow: false, require_name: nil, exclude: [], labels: [])
+          Package.new(path, path, nil, require_name, exclude, labels, shallow)
+        end
+
+        def build_from_builtin(path, shallow: false, require_name: nil, exclude: [], labels: [])
+          Package.new(path, path, nil, require_name, exclude, labels, shallow, true)
         end
 
         # 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)
+        def build_from_gem(gem, shallow: true, require_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
           path = gem_path(gem, optional)
           if path
-            Package.new(path, gem, package_name, exclude, labels, shallow)
+            Package.new(gem, path, gem, require_name, exclude, labels, shallow)
           else
             AppMap::Util.startup_message "#{gem} is not available in the bundle"
           end
@@ -74,19 +82,16 @@ module AppMap
         end
       end
 
-      def name
-        gem || path
-      end
-
       def to_h
         {
+          name: name,
           path: path,
-          package_name: package_name,
           gem: gem,
-          handler_class: handler_class.name,
+          require_name: require_name,
+          handler_class: handler_class ? handler_class.name : nil,
           exclude: Util.blank?(exclude) ? nil : exclude,
           labels: Util.blank?(labels) ? nil : labels,
-          shallow: shallow
+          shallow: shallow.nil? ? nil : shallow,
         }.compact
       end
     end
@@ -96,12 +101,12 @@ module AppMap
       attr_reader :method_names, :package
 
       def initialize(method_names, package)
-        @method_names = method_names
+        @method_names = Array(method_names).map(&:to_sym)
         @package = package
       end
 
       def include_method?(method_name)
-        Array(method_names).include?(method_name)
+        method_names.include?(method_name.to_sym)
       end
 
       def to_h
@@ -110,6 +115,8 @@ module AppMap
           method_names: method_names
         }
       end
+
+      alias as_json to_h
     end
     private_constant :TargetMethods
 
@@ -117,11 +124,11 @@ module AppMap
     # 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, :builtin, :package_name) do # :nodoc:
+    Function = Struct.new(:package, :cls, :labels, :function_names, :builtin, :require_name) do # :nodoc:
       def to_h
         {
           package: package,
-          package_name: package_name,
+          require_name: require_name,
           class: cls,
           labels: labels,
           functions: function_names.map(&:to_sym),
@@ -138,9 +145,15 @@ module AppMap
     private_constant :MethodHook
     
     class << self
-      def package_hooks(gem_name, methods, handler_class: nil, package_name: nil)
+      def package_hooks(methods, path: nil, gem: nil, force: false, builtin: false, handler_class: nil, require_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)
+          package = if builtin
+            Package.build_from_builtin(path, require_name: require_name, labels: method.labels, shallow: false)
+          elsif gem
+            Package.build_from_gem(gem, require_name: require_name, labels: method.labels, shallow: false, force: force, optional: true)
+          elsif path
+            Package.build_from_path(path, require_name: require_name, labels: method.labels, shallow: false)
+          end
           next unless package
 
           package.handler_class = handler_class if handler_class
@@ -151,87 +164,107 @@ module AppMap
       def method_hook(cls, method_names, labels)
         MethodHook.new(cls, method_names, labels)
       end
+
+      def declare_hook(hook_decl)
+        hook_decl = YAML.load(hook_decl) if hook_decl.is_a?(String)
+        
+        methods_decl = hook_decl['methods'] || hook_decl['method']
+        methods_decl = Array(methods_decl) unless methods_decl.is_a?(Hash)
+        labels_decl = Array(hook_decl['labels'] || hook_decl['label'])
+
+        methods = methods_decl.map do |name|
+          class_name, method_name, static = name.include?('.') ? name.split('.', 2) + [ true ] : name.split('#', 2) + [ false ]
+          method_hook class_name, [ method_name ], labels_decl
+        end
+
+        require_name = hook_decl['require_name']
+        gem_name = hook_decl['gem']
+        path = hook_decl['path']
+        builtin = hook_decl['builtin']
+
+        options = {
+          builtin: builtin,
+          gem: gem_name,
+          path: path,
+          require_name: require_name || gem_name || path,
+          force: hook_decl['force']
+        }.compact
+
+        handler_class = hook_decl['handler_class']
+        options[:handler_class] = Util::class_from_string(handler_class) if handler_class
+        
+        package_hooks(methods, **options)
+      end
+
+      def declare_hook_deprecated(hook_decl)
+        function_name = hook_decl['name']
+        package, cls, functions = []
+        if function_name
+          package, cls, _, function = Util.parse_function_name(function_name)
+          functions = Array(function)
+        else
+          package = hook_decl['package']
+          cls = hook_decl['class']
+          functions = hook_decl['function'] || hook_decl['functions']
+          raise %q(AppMap config 'function' element should specify 'package', 'class' and 'function' or 'functions') unless package && cls && functions
+        end
+
+        functions = Array(functions).map(&:to_sym)
+        labels = hook_decl['label'] || hook_decl['labels']
+        req = hook_decl['require']
+        builtin = hook_decl['builtin']
+
+        package_options = {}
+        package_options[:labels] = Array(labels).map(&:to_s) if labels if labels
+        package_options[:require_name] = req
+        package_options[:require_name] ||= package if builtin
+        tm = TargetMethods.new(functions, Package.build_from_path(package, **package_options))
+        ClassTargetMethods.new(cls, tm)
+      end
+
+      def builtin_hooks_path
+        [ [ __dir__, 'builtin_hooks' ].join('/') ] + ( ENV['APPMAP_BUILTIN_HOOKS_PATH'] || '').split(/[;:]/)
+      end
+
+      def gem_hooks_path
+        [ [ __dir__, 'gem_hooks' ].join('/') ] + ( ENV['APPMAP_GEM_HOOKS_PATH'] || '').split(/[;:]/)
+      end
+
+      def load_hooks
+        loader = lambda do |dir, &block|
+          basename = dir.split('/').compact.join('/')
+          [].tap do |hooks|
+            Dir.glob(Pathname.new(dir).join('**').join('*.yml').to_s).each do |yaml_file|
+              path = yaml_file[basename.length + 1...-4]
+              YAML.load(File.read(yaml_file)).map do |config|
+                block.call path, config
+                config
+              end.each do |config|
+                hooks << declare_hook(config)
+              end
+            end
+          end.compact
+        end
+
+        builtin_hooks = builtin_hooks_path.map do |path|
+          loader.(path) do |path, config|
+            config['path'] = path
+            config['builtin'] = true
+          end
+        end
+
+        gem_hooks = gem_hooks_path.map do |path|
+          loader.(path) do |path, config|
+            config['gem'] = path
+            config['builtin'] = false
+          end
+        end
+
+        (builtin_hooks + gem_hooks).flatten
+      end
     end
 
-    # 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[[] dig values fetch], %w[http.session.read]),
-          method_hook('ActionDispatch::Request::Session', %i[destroy []= clear update delete merge], %w[http.session.write]),
-          method_hook('ActionDispatch::Cookies::CookieJar', %i[[] fetch], %w[http.session.read]),
-          method_hook('ActionDispatch::Cookies::CookieJar', %i[[]= clear update delete recycle], %w[http.session.write]),
-          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
-
-    OPENSSL_PACKAGES = ->(labels) { Package.build_from_path('openssl', package_name: 'openssl', labels: labels) }
-
-    # 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' => [
-        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[load load_stream parse parse_stream], Package.build_from_path('yaml', package_name: 'psych', labels: %w[format.yaml.parse])),
-        TargetMethods.new(%i[dump dump_stream], Package.build_from_path('yaml', package_name: 'psych', labels: %w[format.yaml.generate])),
-      ],
-      'JSON::Ext::Parser' => TargetMethods.new(:parse, Package.build_from_path('json', package_name: 'json', labels: %w[format.json.parse])),
-      'JSON::Ext::Generator::State' => TargetMethods.new(:generate, Package.build_from_path('json', package_name: 'json', labels: %w[format.json.generate])),
-    }.freeze
-
-    attr_reader :name, :appmap_dir, :packages, :exclude, :swagger_config, :depends_config, :hooked_methods, :builtin_hooks
+    attr_reader :name, :appmap_dir, :packages, :exclude, :swagger_config, :depends_config, :gem_hooks, :builtin_hooks
 
     def initialize(name,
       packages: [],
@@ -246,31 +279,22 @@ module AppMap
       @depends_config = depends_config
       @hook_paths = Set.new(packages.map(&:path))
       @exclude = exclude
-      @builtin_hooks = BUILTIN_HOOKS.dup
       @functions = functions
 
-      @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
-        package_options[:package_name] = func.package_name
-        package_options[:package_name] ||= func.package if func.builtin
-        hook = TargetMethods.new(func.function_names, Package.build_from_path(func.package, **package_options))
-        if func.builtin
-          @builtin_hooks[func.cls] ||= []
-          @builtin_hooks[func.cls] << hook
+      @builtin_hooks = Hash.new { |h,k| h[k] = [] }
+      @gem_hooks = Hash.new { |h,k| h[k] = [] }
+      
+      (functions + self.class.load_hooks).each_with_object(Hash.new { |h,k| h[k] = [] }) do |cls_target_methods, gem_hooks|
+        hooks = if cls_target_methods.target_methods.package.builtin
+          @builtin_hooks
         else
-          @hooked_methods[func.cls] << hook
+          @gem_hooks
         end
+        hooks[cls_target_methods.cls] << cls_target_methods.target_methods
       end
 
-      @hooked_methods.each_value do |hooks|
-        Array(hooks).each do |hook|
-          @hook_paths << hook.package.path
-        end
+      @gem_hooks.each_value do |hooks|
+        @hook_paths += Array(hooks).map { |hook| hook.package.path }.compact
       end
     end
 
@@ -334,23 +358,14 @@ module AppMap
         }.compact
 
         if config_data['functions']
-          config_params[:functions] = config_data['functions'].map do |function_data|
-            function_name = function_data['name']
-            package, cls, functions = []
-            if function_name
-              package, cls, _, function = Util.parse_function_name(function_name)
-              functions = Array(function)
+          config_params[:functions] = config_data['functions'].map do |hook_decl|
+            if hook_decl['name'] || hook_decl['package']
+              declare_hook_deprecated(hook_decl)
             else
-              package = function_data['package']
-              cls = function_data['class']
-              functions = function_data['function'] || function_data['functions']
-              raise %q(AppMap config 'function' element should specify 'package', 'class' and 'function' or 'functions') unless package && cls && functions
+              # Support the same syntax within the 'functions' that's used for externalized
+              # hook config.
+              declare_hook(hook_decl)
             end
-
-            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, function_data['builtin'], function_data['require'])
           end
         end
 
@@ -366,7 +381,11 @@ module AppMap
                 shallow = package['shallow']
                 # shallow is true by default for gems
                 shallow = true if shallow.nil?
-                Package.build_from_gem(gem, package_name: package['package'], exclude: package['exclude'] || [], shallow: shallow)
+
+                require_name = \
+                  package['package'] || #deprecated
+                  package['require_name']
+                Package.build_from_gem(gem, require_name: require_name, exclude: package['exclude'] || [], shallow: shallow)
               else
                 Package.build_from_path(path, exclude: package['exclude'] || [], shallow: package['shallow'])
               end
@@ -417,8 +436,8 @@ module AppMap
 
       # Hook a method which is specified by class and method name.
       def package_for_code_object
-        Array(config.hooked_methods[cls.name])
-          .compact
+        class_name = cls.to_s.index('#<Class:') == 0 ? cls.to_s['#<Class:'.length...-1] : cls.name
+        Array(config.gem_hooks[class_name])
           .find { |hook| hook.include_method?(method.name) }
           &.package
       end

data/lib/appmap/event.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'weakref'
+
 module AppMap
   module Event
     @@id_counter = 0

data/lib/appmap/gem_hooks/actionpack.yml

@@ -0,0 +1,40 @@
+- methods:
+  - ActionDispatch::Request::Session#[]
+  - ActionDispatch::Request::Session#dig
+  - ActionDispatch::Request::Session#values
+  - ActionDispatch::Request::Session#fetch
+  - ActionDispatch::Cookies::CookieJar#[]
+  - ActionDispatch::Cookies::CookieJar#fetch
+  label: http.session.read
+  require_name: action_dispatch
+- methods:
+  - ActionDispatch::Request::Session#destroy
+  - ActionDispatch::Request::Session#[]=
+  - ActionDispatch::Request::Session#clear
+  - ActionDispatch::Request::Session#update
+  - ActionDispatch::Request::Session#delete
+  - ActionDispatch::Request::Session#merge
+  - ActionDispatch::Cookies::CookieJar#[]=
+  - ActionDispatch::Cookies::CookieJar#clear
+  - ActionDispatch::Cookies::CookieJar#update
+  - ActionDispatch::Cookies::CookieJar#delete
+  - ActionDispatch::Cookies::CookieJar#recycle!
+  label: http.session.write
+  require_name: action_dispatch
+- methods:
+  - ActionDispatch::Cookies::EncryptedCookieJar#[]=
+  - ActionDispatch::Cookies::EncryptedCookieJar#clear
+  - ActionDispatch::Cookies::EncryptedCookieJar#update
+  - ActionDispatch::Cookies::EncryptedCookieJar#delete
+  - ActionDispatch::Cookies::EncryptedCookieJar#recycle
+  labels:
+  - http.cookie
+  - crypto.encrypt
+  require_name: action_dispatch
+- methods:
+  - ActionController::Instrumentation#process_action
+  - ActionController::Instrumentation#send_file
+  - ActionController::Instrumentation#send_data
+  - ActionController::Instrumentation#redirect_to
+  label: mvc.controller
+  require_name: action_controller

data/lib/appmap/gem_hooks/actionview.yml

@@ -0,0 +1,13 @@
+- methods:
+  - ActionView::Renderer#render
+  - ActionView::TemplateRenderer#render
+  - ActionView::PartialRenderer#render
+  label: mvc.view
+  handler_class: AppMap::Handler::Rails::Template::RenderHandler
+  require_name: action_view
+- methods:
+  - ActionView::Resolver#find_all
+  - ActionView::Resolver#find_all_anywhere
+  label: mvc.template.resolver
+  handler_class: AppMap::Handler::Rails::Template::ResolverHandler
+  require_name: action_view

data/lib/appmap/gem_hooks/activesupport.yml

@@ -0,0 +1,12 @@
+- method: ActiveSupport::Callbacks::CallbackSequence#invoke_before
+  label: mvc.before_action
+  require_name: active_support
+  force: true
+- method: ActiveSupport::Callbacks::CallbackSequence#invoke_after
+  label: mvc.after_action
+  require_name: active_support
+  force: true
+- method: ActiveSupport::SecurityUtils#secure_compare
+  label: crypto.secure_compare
+  require_name: active_support/security_utils
+  force: true

data/lib/appmap/gem_hooks/cancancan.yml

@@ -0,0 +1,6 @@
+- methods:
+  - CanCan::ControllerAdditions#authorize!
+  - CanCan::ControllerAdditions#can?
+  - CanCan::ControllerAdditions#cannot?
+  - CanCan::Ability#authorize?
+  label: security.authorization

data/lib/appmap/hook.rb

@@ -15,10 +15,23 @@ module AppMap
     @method_arity = ::Method.instance_method(:arity)
 
     class << self
-      def lock_builtins
-        return if @builtins_hooked
+      def hook_builtins?
+        Mutex.new.synchronize do
+          @hook_builtins = true if @hook_builtins.nil?
 
-        @builtins_hooked = true
+          return false unless @hook_builtins
+
+          @hook_builtins = false
+          true
+        end
+      end
+
+      def already_hooked?(method)
+        # After a method is defined, the statement "module_function <the-method>" can convert that method
+        # into a module (class) method. The method is hooked first when it's defined, then AppMap will attempt to
+        # hook it again when it's redefined as a module method. So we check the method source location - if it's 
+        # part of the AppMap source tree, we ignore it.
+        method.source_location && method.source_location[0].index(__dir__) == 0
       end
 
       # Return the class, separator ('.' or '#'), and method name for
@@ -79,42 +92,43 @@ module AppMap
     # hook_builtins builds hooks for code that is built in to the Ruby standard library.
     # No TracePoint events are emitted for builtins, so a separate hooking mechanism is needed. 
     def hook_builtins
-      return unless self.class.lock_builtins
+      return unless self.class.hook_builtins?
 
-      class_from_string = lambda do |fq_class|
-        fq_class.split('::').inject(Object) do |mod, class_name|
-          mod.const_get(class_name)
-        end
-      end
+      hook_loaded_code = lambda do |hooks_by_class, builtin|
+        hooks_by_class.each do |class_name, hooks|
+          Array(hooks).each do |hook|
+            require hook.package.require_name if builtin && hook.package.require_name && hook.package.require_name != 'ruby'
 
-      config.builtin_hooks.each do |class_name, hooks|
-        Array(hooks).each do |hook|
-          require hook.package.package_name if hook.package.package_name && hook.package.package_name != 'ruby'
-          Array(hook.method_names).each do |method_name|
-            method_name = method_name.to_sym
-            base_cls = class_from_string.(class_name)
+            Array(hook.method_names).each do |method_name|
+              method_name = method_name.to_sym
+              base_cls = Util::class_from_string(class_name, must: false)
+              next unless base_cls
 
-            hook_method = lambda do |entry|
-              cls, method = entry
-              return false if config.never_hook?(cls, method)
+              hook_method = lambda do |entry|
+                cls, method = entry
+                return false if config.never_hook?(cls, method)
 
-              Hook::Method.new(hook.package, cls, method).activate
-            end
+                Hook::Method.new(hook.package, cls, method).activate
+              end
 
-            methods = []
-            methods << [ base_cls, base_cls.public_instance_method(method_name) ] rescue nil
-            if base_cls.respond_to?(:singleton_class)
-              methods << [ base_cls.singleton_class, base_cls.singleton_class.public_instance_method(method_name) ] rescue nil
-            end
-            methods.compact!
-            if methods.empty?
-              warn "Method #{method_name} not found on #{base_cls.name}"
-            else
-              methods.each(&hook_method)
+              methods = []
+              methods << [ base_cls, base_cls.public_instance_method(method_name) ] rescue nil
+              if base_cls.respond_to?(:singleton_class)
+                methods << [ base_cls.singleton_class, base_cls.singleton_class.public_instance_method(method_name) ] rescue nil
+              end
+              methods.compact!
+              if methods.empty?
+                warn "Method #{method_name} not found on #{base_cls.name}" if LOG
+              else
+                methods.each(&hook_method)
+              end
             end
           end
         end
       end
+
+      hook_loaded_code.(config.builtin_hooks, true)
+      hook_loaded_code.(config.gem_hooks, false)
     end
 
     protected
@@ -165,6 +179,8 @@ module AppMap
             next
           end
 
+          next if self.class.already_hooked?(method)
+
           warn "AppMap: Examining #{hook_cls} #{method.name}" if LOG
 
           disasm = RubyVM::InstructionSequence.disasm(method)

data/lib/appmap/util.rb

@@ -21,6 +21,14 @@ module AppMap
     WHITE   = "\e[37m"
 
     class << self
+      def class_from_string(fq_class, must: true)
+        fq_class.split('::').inject(Object) do |mod, class_name|
+          mod.const_get(class_name)
+        end
+      rescue NameError
+        raise if must
+      end
+
       def parse_function_name(name)
         package_tokens = name.split('/')
 

data/lib/appmap/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.67.1'
+  VERSION = '0.68.0'
 
   APPMAP_FORMAT_VERSION = '1.5.1'
 

data/spec/config_spec.rb

@@ -4,58 +4,7 @@ require 'rails_spec_helper'
 require 'appmap/config'
 
 describe AppMap::Config, docker: false do
-  it 'loads from a Hash' do
-    config_data = {
-      exclude: [],
-      name: 'test',
-      packages: [
-        {
-          path: 'path-1'
-        },
-        {
-          path: 'path-2',
-          exclude: [ 'exclude-1' ]
-        }
-      ],
-      functions: [
-        {
-          package: 'pkg',
-          class: 'cls',
-          function: 'fn',
-          label: 'lbl'
-        }
-      ]
-    }.deep_stringify_keys!
-    config = AppMap::Config.load(config_data)
-
-    config_expectation = {
-      exclude: [],
-      name: 'test',
-      packages: [
-        {
-          path: 'path-1',
-          handler_class: 'AppMap::Handler::Function'
-        },
-        {
-          path: 'path-2',
-          handler_class: 'AppMap::Handler::Function',
-          exclude: [ 'exclude-1' ]
-        }
-      ],
-      functions: [
-        {
-          package: 'pkg',
-          class: 'cls',
-          functions: [ :fn ],
-          labels: ['lbl']
-        }
-      ]
-    }.deep_stringify_keys!
-
-    expect(config.to_h.deep_stringify_keys!).to eq(config_expectation)
-  end
-
-  it 'interprets a function in canonical name format' do
+  it 'loads as expected' do
     config_data = {
       name: 'test',
       packages: [],
@@ -67,20 +16,212 @@ describe AppMap::Config, docker: false do
     }.deep_stringify_keys!
     config = AppMap::Config.load(config_data)
 
-    config_expectation = {
-      exclude: [],
-      name: 'test',
-      packages: [],
-      functions: [
+    expect(JSON.parse(JSON.generate(config.as_json))).to eq(JSON.parse(<<~FIXTURE))
+    {
+      "name": "test",
+      "appmap_dir": "tmp/appmap",
+      "packages": [
+      ],
+      "swagger_config": {
+        "project_name": null,
+        "project_version": "1.0",
+        "output_dir": "swagger",
+        "description": "Generate Swagger from AppMaps"
+      },
+      "depends_config": {
+        "base_dir": null,
+        "base_branches": [
+          "remotes/origin/main",
+          "remotes/origin/master"
+        ],
+        "test_file_patterns": [
+          "spec/**/*_spec.rb",
+          "test/**/*_test.rb"
+        ],
+        "dependent_tasks": [
+          "swagger"
+        ],
+        "description": "Bring AppMaps up to date with local file modifications, and updated derived data such as Swagger files",
+        "rspec_environment_method": "AppMap::Depends.test_env",
+        "minitest_environment_method": "AppMap::Depends.test_env",
+        "rspec_select_tests_method": "AppMap::Depends.select_rspec_tests",
+        "minitest_select_tests_method": "AppMap::Depends.select_minitest_tests",
+        "rspec_test_command_method": "AppMap::Depends.rspec_test_command",
+        "minitest_test_command_method": "AppMap::Depends.minitest_test_command"
+      },
+      "hook_paths": [
+        "pkg",
+        "#{Gem.loaded_specs['activesupport'].gem_dir}"
+      ],
+      "exclude": [
+      ],
+      "functions": [
         {
-          package: 'pkg',
-          class: 'cls',
-          functions: [ :fn ],
+          "cls": "cls",
+          "target_methods": {
+            "package": "pkg",
+            "method_names": [
+              "fn"
+            ]
+          }
         }
-      ]
-    }.deep_stringify_keys!
-
-    expect(config.to_h.deep_stringify_keys!).to eq(config_expectation)
+      ],
+      "builtin_hooks": {
+        "JSON::Ext::Parser": [
+          {
+            "package": "json",
+            "method_names": [
+              "parse"
+            ]
+          }
+        ],
+        "JSON::Ext::Generator::State": [
+          {
+            "package": "json",
+            "method_names": [
+              "generate"
+            ]
+          }
+        ],
+        "Net::HTTP": [
+          {
+            "package": "net/http",
+            "method_names": [
+              "request"
+            ]
+          }
+        ],
+        "OpenSSL::PKey::PKey": [
+          {
+            "package": "openssl",
+            "method_names": [
+              "sign"
+            ]
+          }
+        ],
+        "OpenSSL::X509::Request": [
+          {
+            "package": "openssl",
+            "method_names": [
+              "sign"
+            ]
+          },
+          {
+            "package": "openssl",
+            "method_names": [
+              "verify"
+            ]
+          }
+        ],
+        "OpenSSL::X509::Certificate": [
+          {
+            "package": "openssl",
+            "method_names": [
+              "sign"
+            ]
+          }
+        ],
+        "OpenSSL::PKCS5": [
+          {
+            "package": "openssl",
+            "method_names": [
+              "pbkdf2_hmac"
+            ]
+          },
+          {
+            "package": "openssl",
+            "method_names": [
+              "pbkdf2_hmac_sha1"
+            ]
+          }
+        ],
+        "OpenSSL::Cipher": [
+          {
+            "package": "openssl",
+            "method_names": [
+              "encrypt"
+            ]
+          },
+          {
+            "package": "openssl",
+            "method_names": [
+              "decrypt"
+            ]
+          }
+        ],
+        "Psych": [
+          {
+            "package": "yaml",
+            "method_names": [
+              "load"
+            ]
+          },
+          {
+            "package": "yaml",
+            "method_names": [
+              "load_stream"
+            ]
+          },
+          {
+            "package": "yaml",
+            "method_names": [
+              "parse"
+            ]
+          },
+          {
+            "package": "yaml",
+            "method_names": [
+              "parse_stream"
+            ]
+          },
+          {
+            "package": "yaml",
+            "method_names": [
+              "dump"
+            ]
+          },
+          {
+            "package": "yaml",
+            "method_names": [
+              "dump_stream"
+            ]
+          }
+        ]
+      },
+      "gem_hooks": {
+        "cls": [
+          {
+            "package": "pkg",
+            "method_names": [
+              "fn"
+            ]
+          }
+        ],
+        "ActiveSupport::Callbacks::CallbackSequence": [
+          {
+            "package": "activesupport",
+            "method_names": [
+              "invoke_before"
+            ]
+          },
+          {
+            "package": "activesupport",
+            "method_names": [
+              "invoke_after"
+            ]
+          }
+        ],
+        "ActiveSupport::SecurityUtils": [
+          {
+            "package": "activesupport",
+            "method_names": [
+              "secure_compare"
+            ]
+          }
+        ]
+      }
+    }
+    FIXTURE
   end
 
   context do
@@ -94,7 +235,8 @@ describe AppMap::Config, docker: false do
       expect(config.to_h).to eq(YAML.load(<<~CONFIG))
       :name: appmap-ruby
       :packages:
-      - :path: lib
+      - :name: lib
+        :path: lib
         :handler_class: AppMap::Handler::Function
         :shallow: false
       :functions: []

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appmap
 version: !ruby/object:Gem::Version
-  version: 0.67.1
+  version: 0.68.0
 platform: ruby
 authors:
 - Kevin Gilpin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-02 00:00:00.000000000 Z
+date: 2021-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -3405,6 +3405,10 @@ files:
 - ext/appmap/extconf.rb
 - lib/appmap.rb
 - lib/appmap/agent.rb
+- lib/appmap/builtin_hooks/json.yml
+- lib/appmap/builtin_hooks/net/http.yml
+- lib/appmap/builtin_hooks/openssl.yml
+- lib/appmap/builtin_hooks/yaml.yml
 - lib/appmap/class_map.rb
 - lib/appmap/command/agent_setup/init.rb
 - lib/appmap/command/agent_setup/status.rb
@@ -3423,6 +3427,10 @@ files:
 - lib/appmap/depends/test_runner.rb
 - lib/appmap/depends/util.rb
 - lib/appmap/event.rb
+- lib/appmap/gem_hooks/actionpack.yml
+- lib/appmap/gem_hooks/actionview.yml
+- lib/appmap/gem_hooks/activesupport.yml
+- lib/appmap/gem_hooks/cancancan.yml
 - lib/appmap/handler/function.rb
 - lib/appmap/handler/net_http.rb
 - lib/appmap/handler/rails/request_handler.rb