appmap 0.39.0 → 0.41.2

data/lib/appmap/config.rb

@@ -16,20 +16,20 @@ module AppMap
         end
 
         def build_from_gem(gem, shallow: true, package_name: nil, exclude: [], labels: [])
-          gem_paths(gem).map do |gem_path|
-            Package.new(gem_path, gem, package_name, exclude, labels, shallow)
+          if %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)
         end
 
         private_class_method :new
 
         protected
 
-        def gem_paths(gem)
+        def gem_path(gem)
           gemspec = Gem.loaded_specs[gem] or raise "Gem #{gem.inspect} not found"
-          gemspec.source_paths.map do |path|
-            File.join(gemspec.gem_dir, path)
-          end
+          gemspec.gem_dir
         end
       end
 
@@ -57,32 +57,36 @@ module AppMap
     # 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', package_name: 'active_support', labels: %w[security crypto])),
-      'ActionView::Renderer' => Hook.new(:render, Package.build_from_path('action_view', package_name: 'action_view', labels: %w[view]))
+      '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])),
     }.freeze
 
     BUILTIN_METHODS = {
       'OpenSSL::PKey::PKey' => Hook.new(:sign, OPENSSL_PACKAGES),
-      'Digest::Instance' => Hook.new(:digest, 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[http io])),
-      'Net::SMTP' => Hook.new(:send, Package.build_from_path('net/smtp', package_name: 'net/smtp', labels: %w[smtp email io])),
-      'Net::POP3' => Hook.new(:mails, Package.build_from_path('net/pop3', package_name: 'net/pop', labels: %w[pop pop3 email io])),
-      'Net::IMAP' => Hook.new(:send_command, Package.build_from_path('net/imap', package_name: 'net/imap', labels: %w[imap email io])),
-      'Marshal' => Hook.new(%i[dump load], Package.build_from_path('marshal', labels: %w[serialization marshal])),
-      'Psych' => Hook.new(%i[dump dump_stream load load_stream parse parse_stream], Package.build_from_path('yaml', package_name: 'psych', labels: %w[serialization yaml])),
-      'JSON::Ext::Parser' => Hook.new(:parse, Package.build_from_path('json', package_name: 'json', labels: %w[serialization json])),
-      'JSON::Ext::Generator::State' => Hook.new(:generate, Package.build_from_path('json', package_name: 'json', labels: %w[serialization json])),
+      '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])),
     }.freeze
 
-    attr_reader :name, :packages
+    attr_reader :name, :packages, :exclude
 
-    def initialize(name, packages = [])
+    def initialize(name, packages = [], exclude = [])
       @name = name
       @packages = packages
+      @exclude = exclude
     end
 
     class << self
@@ -105,44 +109,60 @@ module AppMap
             shallow = true if shallow.nil?
             Package.build_from_gem(gem, exclude: package['exclude'] || [], shallow: shallow)
           else
-            [ Package.build_from_path(path, exclude: package['exclude'] || [], shallow: package['shallow']) ]
+            Package.build_from_path(path, exclude: package['exclude'] || [], shallow: package['shallow'])
           end
-        end.flatten
-        Config.new config_data['name'], packages
+        end.compact
+        Config.new config_data['name'], packages, config_data['exclude'] || []
       end
     end
 
     def to_h
       {
         name: name,
-        packages: packages.map(&:to_h)
+        packages: packages.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)
+    end
+
+    def package_hooked_by_class(method)
       defined_class, _, method_name = ::AppMap::Hook.qualify_method_name(method)
-      package = find_package(defined_class, method_name)
-      return package if package
+      return find_package(defined_class, method_name)
+    end
 
+    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.find do |pkg|
+      packages.select { |pkg| pkg.path }.find do |pkg|
         (location_file.index(pkg.path) == 0) &&
           !pkg.exclude.find { |p| location_file.index(p) }
       end
     end
 
-    def included_by_location?(method)
-      !!package_for_method(method)
+    def never_hook?(method)
+      defined_class, separator, method_name = ::AppMap::Hook.qualify_method_name(method)
+      return true if exclude.member?(defined_class) || exclude.member?([ defined_class, separator, method_name ].join)
     end
 
+    # always_hook? indicates a method that should always be hooked.
     def always_hook?(defined_class, method_name)
       !!find_package(defined_class, method_name)
     end
 
+    # 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)
+    end
+
     def find_package(defined_class, method_name)
       hook = find_hook(defined_class)
       return nil unless hook

data/lib/appmap/event.rb

@@ -38,6 +38,15 @@ module AppMap
 
         protected
 
+        # Heuristic for dynamically defined class whose name can be nil
+        def best_class_name(value)
+          value_cls = value.class
+          while value_cls.name.nil?
+            value_cls = value_cls.superclass
+          end
+          value_cls.name
+        end
+
         def custom_display_string(value)
           case value
           when File
@@ -77,6 +86,7 @@ module AppMap
 
       class << self
         def build_from_invocation(mc = MethodCall.new, defined_class, method, receiver, arguments)
+          defined_class ||= 'Class'
           mc.tap do
             static = receiver.is_a?(Module)
             mc.defined_class = defined_class
@@ -110,14 +120,14 @@ module AppMap
                 end
               {
                 name: param_name,
-                class: value.class.name,
+                class: best_class_name(value),
                 object_id: value.__id__,
                 value: display_string(value),
                 kind: param_type
               }
             end
             mc.receiver = {
-              class: receiver.class.name,
+              class: best_class_name(receiver),
               object_id: receiver.__id__,
               value: display_string(receiver)
             }
@@ -172,7 +182,7 @@ module AppMap
           mr.tap do |_|
             if return_value
               mr.return_value = {
-                class: return_value.class.name,
+                class: best_class_name(return_value),
                 value: display_string(return_value),
                 object_id: return_value.__id__
               }
@@ -183,7 +193,7 @@ module AppMap
               while next_exception
                 exception_backtrace = next_exception.backtrace_locations.try(:[], 0)
                 exceptions << {
-                  class: next_exception.class.name,
+                  class: best_class_name(next_exception),
                   message: next_exception.message,
                   object_id: next_exception.__id__,
                   path: exception_backtrace&.path,

data/lib/appmap/hook.rb

@@ -6,6 +6,9 @@ module AppMap
   class Hook
     LOG = (ENV['APPMAP_DEBUG'] == 'true' || ENV['DEBUG'] == 'true')
 
+    OBJECT_INSTANCE_METHODS = %i[! != !~ <=> == === =~ __id__ __send__ class clone define_singleton_method display dup enum_for eql? equal? extend freeze frozen? hash inspect instance_eval instance_exec instance_of? instance_variable_defined? instance_variable_get instance_variable_set instance_variables is_a? itself kind_of? method methods nil? object_id private_methods protected_methods public_method public_methods public_send remove_instance_variable respond_to? send singleton_class singleton_method singleton_methods taint tainted? tap then to_enum to_s to_h to_a trust untaint untrust untrusted? yield_self].freeze
+    OBJECT_STATIC_METHODS = %i[! != !~ < <= <=> == === =~ > >= __id__ __send__ alias_method allocate ancestors attr attr_accessor attr_reader attr_writer autoload autoload? class class_eval class_exec class_variable_defined? class_variable_get class_variable_set class_variables clone const_defined? const_get const_missing const_set constants define_method define_singleton_method deprecate_constant display dup enum_for eql? equal? extend freeze frozen? hash include include? included_modules inspect instance_eval instance_exec instance_method instance_methods instance_of? instance_variable_defined? instance_variable_get instance_variable_set instance_variables is_a? itself kind_of? method method_defined? methods module_eval module_exec name new nil? object_id prepend private_class_method private_constant private_instance_methods private_method_defined? private_methods protected_instance_methods protected_method_defined? protected_methods public_class_method public_constant public_instance_method public_instance_methods public_method public_method_defined? public_methods public_send remove_class_variable remove_instance_variable remove_method respond_to? send singleton_class singleton_class? singleton_method singleton_methods superclass taint tainted? tap then to_enum to_s trust undef_method untaint untrust untrusted? yield_self].freeze
+
     @unbound_method_arity = ::UnboundMethod.instance_method(:arity)
     @method_arity = ::Method.instance_method(:arity)
 
@@ -42,12 +45,17 @@ module AppMap
       tp = TracePoint.new(:end) do |trace_point|
         cls = trace_point.self
 
-        instance_methods = cls.public_instance_methods(false)
-        class_methods = cls.singleton_class.public_instance_methods(false) - instance_methods
+        instance_methods = cls.public_instance_methods(false) - OBJECT_INSTANCE_METHODS
+        class_methods = cls.singleton_class.public_instance_methods(false) - instance_methods - OBJECT_STATIC_METHODS
 
         hook = lambda do |hook_cls|
           lambda do |method_id|
-            method = hook_cls.public_instance_method(method_id)
+            method = begin
+              hook_cls.public_instance_method(method_id)
+            rescue NameError
+              warn "AppMap: Method #{hook_cls} #{method.name} is not accessible" if LOG
+              return
+            end
 
             warn "AppMap: Examining #{hook_cls} #{method.name}" if LOG
 
@@ -55,6 +63,8 @@ module AppMap
             # Skip methods that have no instruction sequence, as they are obviously trivial.
             next unless disasm
 
+            next if config.never_hook?(method)
+
             next unless \
               config.always_hook?(hook_cls, method.name) ||
               config.included_by_location?(method)
@@ -76,6 +86,8 @@ module AppMap
       tp.enable(&block)
     end
 
+    # 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
 
@@ -89,6 +101,7 @@ module AppMap
         require hook.package.package_name if hook.package.package_name
         Array(hook.method_names).each do |method_name|
           method_name = method_name.to_sym
+
           cls = class_from_string.(class_name)
           method = \
             begin
@@ -97,6 +110,8 @@ module AppMap
               cls.method(method_name) rescue nil
             end
 
+          next if config.never_hook?(method)
+
           if method
             Hook::Method.new(hook.package, cls, method).activate
           else

data/lib/appmap/hook/method.rb

@@ -35,7 +35,7 @@ module AppMap
                 else
                   "#{hook_method.name} (class resolution deferred)"
                 end
-          warn "AppMap: Hooking " + msg
+          warn "AppMap: Hooking #{msg} at line #{(hook_method.source_location || []).join(':')}"
         end
 
         defined_class = @defined_class

data/lib/appmap/rails/request_handler.rb

@@ -47,9 +47,14 @@ module AppMap
 
         private
 
-        def normalized_path(request)
-          route = ::Rails.application.routes.router.enum_for(:recognize, request).first
-          route.first.path.spec.to_s if route
+        def normalized_path(request, router = ::Rails.application.routes.router)
+          router.recognize request do |route, _|
+            app = route.app
+            next unless app.matches? request
+            return normalized_path request, app.rack_app.routes.router if app.engine?
+
+            return route.path.spec.to_s
+          end
         end
       end
 

data/lib/appmap/railtie.rb

@@ -5,13 +5,9 @@ module AppMap
   class Railtie < ::Rails::Railtie
     config.appmap = ActiveSupport::OrderedOptions.new
 
-    initializer 'appmap.init' do |_| # params: app
-      require 'appmap'
-    end
-
     # appmap.subscribe subscribes to ActiveSupport Notifications so that they can be recorded as
     # AppMap events.
-    initializer 'appmap.subscribe', after: 'appmap.init' do |_| # params: app
+    initializer 'appmap.subscribe' do |_| # params: app
       require 'appmap/rails/sql_handler'
       require 'appmap/rails/request_handler'
       ActiveSupport::Notifications.subscribe 'sql.sequel', AppMap::Rails::SQLHandler.new

data/lib/appmap/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.39.0'
+  VERSION = '0.41.2'
 
   APPMAP_FORMAT_VERSION = '1.4'
 end

data/spec/abstract_controller_base_spec.rb

@@ -8,7 +8,7 @@ describe 'AbstractControllerBase' do
         FileUtils.rm_rf tmpdir
         FileUtils.mkdir_p tmpdir
         cmd = <<~CMD.gsub "\n", ' '
-          docker-compose run --rm -e APPMAP=true
+          docker-compose run --rm -e RAILS_ENV=test -e APPMAP=true
           -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec #{spec_name}
         CMD
         run_cmd cmd, chdir: fixture_dir
@@ -137,7 +137,7 @@ describe 'AbstractControllerBase' do
                   'name' => 'Renderer',
                   'children' => include(hash_including(
                     'name' => 'render',
-                    'labels' => ['view']
+                    'labels' => ['mvc.view']
                   ))
                 ))
               ))

data/spec/config_spec.rb

@@ -7,6 +7,7 @@ require 'appmap/config'
 describe AppMap::Config, docker: false do
   it 'loads from a Hash' do
     config_data = {
+      exclude: [],
       name: 'test',
       packages: [
         {

data/spec/fixtures/hook/exclude.rb

@@ -0,0 +1,15 @@
+class ExcludeTest
+  def instance_method
+    'instance_method'
+  end
+
+  class << self
+    def singleton_method
+      'singleton_method'
+    end
+  end
+
+  def self.cls_method
+    'class_method'
+  end
+end

data/spec/fixtures/hook/labels.rb

@@ -0,0 +1,6 @@
+# @label has-cls-label
+class ClassWithLabel
+  # @label has-fn-label
+  def fn_with_label
+  end
+end

data/spec/fixtures/rails5_users_app/Gemfile

@@ -33,11 +33,10 @@ appmap_options = \
     { path: appmap_path }
   else
     {}
-  end.merge(require: %w[appmap appmap/railtie])
-
-gem 'appmap', appmap_options
+  end.merge(require: %w[appmap])
 
 group :development, :test do
+  gem 'appmap', appmap_options
   gem 'cucumber-rails', require: false
   gem 'rspec-rails'
   # Required for Sequel, since without ActiveRecord, the Rails transactional fixture support

data/spec/fixtures/rails5_users_app/appmap.yml

@@ -1,4 +1,7 @@
 name: rails5_users_app
 packages:
-  - path: app
+  - path: app/models
+    labels: [ mvc.model ]
+  - path: app/controllers
+    labels: [ mvc.controller ]
   - gem: sequel

data/spec/fixtures/rails5_users_app/config/application.rb

@@ -19,6 +19,8 @@ when 'activerecord'
   require 'active_record/railtie'
 end
 
+require 'appmap/railtie' if defined?(AppMap)
+
 # require "active_storage/engine"
 # require "action_mailer/railtie"
 # require "action_cable/engine"

data/spec/fixtures/rails5_users_app/docker-compose.yml

@@ -19,6 +19,9 @@ services:
     environment:
       RAILS_ENV:
       ORM_MODULE:
+      PGHOST: pg
+      PGPORT: '5432'
+      DATABASE_URL: postgres://postgres@pg
       APPMAP:
     volumes:
     - .:/src/app

data/spec/fixtures/rails6_users_app/Gemfile

@@ -34,11 +34,10 @@ appmap_options = \
     { path: appmap_path }
   else
     {}
-  end.merge(require: %w[appmap appmap/railtie])
-
-gem 'appmap', appmap_options
+  end.merge(require: %w[appmap])
 
 group :development, :test do
+  gem 'appmap', appmap_options
   gem 'cucumber-rails', require: false
   gem 'rspec-rails'
   # Required for Sequel, since without ActiveRecord, the Rails transactional fixture support

data/spec/fixtures/rails6_users_app/appmap.yml

@@ -1,5 +1,8 @@
 name: rails6_users_app
 packages:
-  - path: app
+  - path: app/models
+    labels: [ mvc.model ]
+  - path: app/controllers
+    labels: [ mvc.controller ]
   - gem: sequel