appmap 0.77.2 → 0.78.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c287b504d552b0f627f6343e61f42835b144d12f3dea4e9f8a6e33bd72dbc581
-  data.tar.gz: b00990f93c7961487a0c4ea6bc1f0828c3efa391578100de41600cc72ee1727d
+  metadata.gz: 8dce970e998105e2e322410b204af7a0ff48790cd177225468e9b49c75651fdb
+  data.tar.gz: d93b8f4f0690bf5ade69b2c08e4354d3043567fc4bf6018d6e68084eece08be9
 SHA512:
-  metadata.gz: 0245f3bb4e483b6fba7326d759af828022e4339e05a293144e628c7fae558d744b105a0d3be8f44caa106f9b7b056fb3886176f3cdd513fe400c18126c4b7488
-  data.tar.gz: 84cf727259f8ec5bad21b9d2ce799bc0753aeaeca0047fcf4296a0e5782d392a28340d44af0c08ab5d6a44fddb7baea4ea784ddd65e942329f159cf9eb4eac5b
+  metadata.gz: bea7fecb6bbae7feb68fa649ecba6276b3d497312ff99054c527d2f74117b584dd7119fa8e4a346b0091089786e90a0a2f2f375f1bc94a0e5437dfa8cff99e20
+  data.tar.gz: 913ab70d04467c584ecf5edfe4c8d60807974cf3d01eb9f2107ceaaa8677c157dc3b0e4130b6e90dcdaba3ba055b4a5268b40e94d0054eb6c41d1146205b0eff

data/.rubocop.yml

@@ -19,6 +19,7 @@ Layout/LineLength:
 
 Metrics/BlockLength:
   ExcludedMethods:
+  - describe
   - it
   - context
 

data/.travis.yml

@@ -33,13 +33,6 @@ before_install:
       && nvm use --lts \
       && npm i -g yarn
 
-jobs:
-  include:
-  - stage: test
-    env:
-      # GEM_ALTERNATIVE_NAME only needed for deployment 
-      - GEM_ALTERNATIVE_NAME=''
-
 before_deploy:
   - |
     npm i -g \

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+# [0.78.0](https://github.com/applandinc/appmap-ruby/compare/v0.77.4...v0.78.0) (2022-04-04)
+
+
+### Features
+
+* Hook and label Kernel#eval ([e0c151d](https://github.com/applandinc/appmap-ruby/commit/e0c151d1371f5bed5597ffd0d3bfebb8bca247c2))
+
+## [0.77.4](https://github.com/applandinc/appmap-ruby/compare/v0.77.3...v0.77.4) (2022-04-04)
+
+
+### Bug Fixes
+
+* Update Rails request handler to the new hook architecture ([595b39a](https://github.com/applandinc/appmap-ruby/commit/595b39abb030c1dcf85c83e4717c25d4c5177d4d))
+
+## [0.77.3](https://github.com/applandinc/appmap-ruby/compare/v0.77.2...v0.77.3) (2022-03-29)
+
+
+### Bug Fixes
+
+* Rescue exceptions when calling Class#to_s ([f59f2f6](https://github.com/applandinc/appmap-ruby/commit/f59f2f6b39664ff050486c88ff1b859ca0db48d8))
+
 ## [0.77.2](https://github.com/applandinc/appmap-ruby/compare/v0.77.1...v0.77.2) (2022-03-25)
 
 

data/Rakefile

@@ -2,6 +2,21 @@ $: << File.join(__dir__, 'lib')
 require 'appmap/version'
 GEM_VERSION = AppMap::VERSION
 
+# Make sure the local version is not behind the one on
+# rubygems.org (it's ok if they're the same).
+#
+# If it is behind, the fixture images won't get updated with the gem
+# built from the local source, so you'll wind up testing the rubygems
+# version instead.
+unless ENV['SKIP_VERSION_CHECK']
+  require 'json'
+  require 'net/http'
+  rubygems_version = JSON.parse(Net::HTTP.get(URI.parse('https://rubygems.org/api/v1/gems/appmap.json')))['version']
+  if Gem::Version.new(GEM_VERSION) < Gem::Version.new(rubygems_version)
+    raise "#{GEM_VERSION} < #{rubygems_version}. Rebase to avoid build issues."
+  end
+end
+
 require 'rake/testtask'
 require 'rdoc/task'
 
@@ -24,7 +39,7 @@ RUBY_VERSIONS=%w[2.6 2.7 3.0 3.1].select do |version|
 
   false
 end
-FIXTURE_APPS=%w[rack_users_app rails6_users_app rails5_users_app]
+FIXTURE_APPS=[:rack_users_app, :rails6_users_app, :rails5_users_app, :rails7_users_app => {:ruby_version => '>= 2.7'}]
 
 def run_cmd(*cmd)
   $stderr.puts "Running: #{cmd}"
@@ -83,7 +98,17 @@ namespace :build do
     RUBY_VERSIONS.each do |ruby_version|
       namespace ruby_version do
         desc "build:fixtures:#{ruby_version}"
-        FIXTURE_APPS.each do |app|
+        FIXTURE_APPS.each do |app_spec|
+          app = if app_spec.instance_of?(Hash)
+            app_spec = app_spec.flatten
+            version_rqt = Gem::Requirement.create(app_spec[1][:ruby_version])
+            next unless version_rqt =~ (Gem::Version.new(ruby_version))
+            app = app_spec[0]
+          else
+            app = app_spec
+          end.to_s
+
+
           desc app
           task app => ["base:#{ruby_version}"] do
             build_app_image(app, ruby_version)
@@ -109,12 +134,13 @@ def run_specs(ruby_version, task_args)
   # description), because it's not intended to be invoked directly
   RSpec::Core::RakeTask.new("rspec_#{ruby_version}", [:specs]) do |task, args|
     task.exclude_pattern = 'spec/fixtures/**/*_spec.rb'
+    task.rspec_opts = '-f doc'
     if args.count > 0
       # There doesn't appear to be a value for +pattern+ that will
       # cause it to be ignored. Setting it to '' or +nil+ causes an
       # empty argument to get passed to rspec, which confuses it.
       task.pattern = 'never match this'
-      task.rspec_opts = args.to_a.join(' ')
+      task.rspec_opts += " " + args.to_a.join(' ')
     end
   end
 

data/ext/appmap/appmap.c

@@ -1,4 +1,5 @@
 #include <ruby.h>
+#include <ruby/debug.h>
 #include <ruby/intern.h>
 
 // Seems like CLASS_OR_MODULE_P should really be in a header file in
@@ -39,7 +40,7 @@ am_define_method_with_arity(VALUE mod, VALUE name, VALUE arity, VALUE proc)
 {
   VALUE arities_key = rb_intern(ARITIES_KEY);
   VALUE arities = rb_ivar_get(mod, arities_key);
-  
+
   if (arities == Qundef || NIL_P(arities)) {
     arities = rb_hash_new();
     rb_ivar_set(mod, arities_key, arities);
@@ -62,7 +63,7 @@ am_get_method_arity(VALUE method, VALUE orig_arity_method)
   }
   // Didn't find one, call the original method.
   if (NIL_P(arity)) {
-    VALUE bound_method = rb_funcall(orig_arity_method, rb_intern("bind"), 1, method);    
+    VALUE bound_method = rb_funcall(orig_arity_method, rb_intern("bind"), 1, method);
     arity = rb_funcall(bound_method, rb_intern("call"), 0);
   }
 
@@ -83,11 +84,29 @@ am_method_arity(VALUE method)
   return am_get_method_arity(method, orig_method_arity);
 }
 
+static VALUE
+bindings_callback(const rb_debug_inspector_t *dbg_context, void *level)
+{
+  const int i = NUM2INT((VALUE) level);
+  if (i >= RARRAY_LEN(rb_debug_inspector_backtrace_locations(dbg_context))) {
+    return Qnil;
+  } else {
+    return rb_debug_inspector_frame_binding_get(dbg_context, i);
+  }
+}
+
+static VALUE
+am_previous_bindings(VALUE self, VALUE level)
+{
+  return rb_debug_inspector_open(bindings_callback, (void *) level);
+}
+
 void Init_appmap() {
   VALUE appmap = rb_define_module("AppMap");
   am_AppMapHook = rb_define_class_under(appmap, "Hook", rb_cObject);
 
   rb_define_singleton_method(am_AppMapHook, "singleton_method_owner_name", singleton_method_owner_name, 1);
+  rb_define_module_function(appmap, "caller_binding", am_previous_bindings, 1);
 
   rb_define_method(rb_cModule, "define_method_with_arity", am_define_method_with_arity, 3);
   rb_define_method(rb_cUnboundMethod, "arity", am_unbound_method_arity, 0);

data/lib/appmap/builtin_hooks/ruby.yml

@@ -14,14 +14,17 @@
   - String#unpack1
   require_name: ruby
   label: string.unpack
-#- methods:
+- methods:
+  - Kernel#eval
+  require_name: ruby
+  label: lang.eval
+  handler_class: AppMap::Handler::Eval
 # TODO: eval does not happen in the right context, and therefore any new constants
 # which are defined are placed on the wrong module/class.
-#  - Kernel#eval
 #  - Binding#eval
 #  - BasicObject#instance_eval
 # These methods cannot be hooked as far as I can tell.
-# Why? When calling one of these functions, the context at the point of 
+# Why? When calling one of these functions, the context at the point of
 # definition is used. It's not possible to bind class_eval to a new context.
 #  - Module#class_eval
 #  - Module#module_eval

data/lib/appmap/config.rb

@@ -450,7 +450,15 @@ module AppMap
 
       # Hook a method which is specified by class and method name.
       def package_for_code_object
-        class_name = cls.to_s.index('#<Class:') == 0 ? cls.to_s['#<Class:'.length...-1] : cls.name
+        class_name = begin
+                       cls.to_s.index('#<Class:') == 0 ? cls.to_s['#<Class:'.length...-1] : cls.name
+                     rescue
+                       # Calling #to_s on some Rails classes
+                       # (e.g. those generated to represent
+                       # associations) will raise an exception. Fall
+                       # back to using the class name.
+                       cls.name
+                     end
         Array(config.gem_hooks[class_name])
           .find { |hook| hook.include_method?(method.name) }
           &.package

data/lib/appmap/handler/eval.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'appmap/handler/function'
+
+module AppMap
+  module Handler
+    # Handler class for Kernel#eval.
+    #
+    # Second argument to eval is a Binding, which despite the name (and
+    # the accessible methods) in addition to locals and receiver also
+    # encapsulates the entire execution context, in particular including
+    # the lexical scope. This is especially important for constant lookup
+    # and definition.
+    #
+    # If the binding is not provided, by default eval will run in the
+    # current frame. Since we call it here, this will mean the #do_call
+    # frame, which would make AppMap::Handler::Eval the lexical scope
+    # for constant lookup and definition; as a consequence
+    # eg. `eval "class Foo; end"` would define
+    # AppMap::Handler::Eval::Foo instead of defining it in
+    # the module where the original call was made.
+    #
+    # To avoid this, we explicitly substitute the correct execution
+    # context, up several stack frames.
+    class Eval < Function
+      # The depth of the frame we need to pluck out:
+      # 1. Hook::Method#do_call
+      # 2. Hook::Method#trace_call
+      # 3. Hook::Method#call
+      # 4. proc generated by Hook::Method#hook_method_def
+      # 5. the (intended) frame of the original eval that we hooked
+      # Note it needs to be adjusted if this call sequence changes.
+      FRAME_DEPTH = 5
+
+      def do_call(receiver, src = nil, context = nil, *rest)
+        context ||= AppMap.caller_binding FRAME_DEPTH
+        hook_method.bind(receiver).call(src, context, *rest)
+      end
+    end
+  end
+end

data/lib/appmap/handler/function.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
 require 'appmap/event'
+require 'appmap/hook/method'
 
 module AppMap
   module Handler
-    module Function
-      class << self
-        def handle_call(defined_class, hook_method, receiver, args)
-          AppMap::Event::MethodCall.build_from_invocation(defined_class, hook_method, receiver, args)
-        end
+    # Base handler class, will emit method call and return events.
+    class Function < Hook::Method
+      def handle_call(receiver, args)
+        AppMap::Event::MethodCall.build_from_invocation(defined_class, hook_method, receiver, args)
+      end
 
-        def handle_return(call_event_id, elapsed, return_value, exception)
-          AppMap::Event::MethodReturn.build_from_invocation(call_event_id, return_value, exception, elapsed: elapsed)
-        end
+      def handle_return(call_event_id, elapsed, return_value, exception)
+        AppMap::Event::MethodReturn.build_from_invocation(call_event_id, return_value, exception, elapsed: elapsed)
       end
     end
   end

data/lib/appmap/handler/net_http.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'appmap/event'
+require 'appmap/hook/method'
 require 'appmap/util'
 require 'rack'
 
@@ -81,29 +82,29 @@ module AppMap
       end
     end
 
-    class NetHTTP
-      class << self
-        def copy_headers(obj)
-          {}.tap do |headers|
-            obj.each_header do |key, value|
-              key = key.split('-').map(&:capitalize).join('-')
-              headers[key] = value
-            end
+    # Handler class for HTTP requests.
+    # Emits HTTP request events instead of method calls.
+    class NetHTTP < Hook::Method
+      def self.copy_headers(obj)
+        {}.tap do |headers|
+          obj.each_header do |key, value|
+            key = key.split('-').map(&:capitalize).join('-')
+            headers[key] = value
           end
         end
+      end
 
-        def handle_call(defined_class, hook_method, receiver, args)
-          # request will call itself again in a start block if it's not already started.
-          return unless receiver.started?
+      def handle_call(receiver, args)
+        # request will call itself again in a start block if it's not already started.
+        return unless receiver.started?
 
-          http = receiver
-          request = args.first
-          HTTPClientRequest.new(http, request)
-        end
+        http = receiver
+        request = args.first
+        HTTPClientRequest.new(http, request)
+      end
 
-        def handle_return(call_event_id, elapsed, return_value, exception)
-          HTTPClientResponse.new(return_value, call_event_id, elapsed)
-        end
+      def handle_return(call_event_id, elapsed, return_value, exception)
+        HTTPClientResponse.new(return_value, call_event_id, elapsed)
       end
     end
   end

data/lib/appmap/handler/rails/request_handler.rb

@@ -100,15 +100,14 @@ module AppMap
 
           protected
 
-          def before_hook(receiver, defined_class, _) # args
+          def before_hook(receiver, *)
             call_event = HTTPServerRequest.new(receiver.request)
             # http_server_request events are i/o and do not require a package name.
             AppMap.tracing.record_event call_event, defined_class: defined_class, method: hook_method
-            [ call_event, TIME_NOW.call ]
+            call_event
           end
 
-          def after_hook(receiver, call_event, start_time, _, _) # return_value, exception
-            elapsed = TIME_NOW.call - start_time
+          def after_hook(receiver, call_event, elapsed, *)
             return_event = HTTPServerResponse.new receiver.response, call_event.id, elapsed
             AppMap.tracing.record_event return_event
           end

data/lib/appmap/handler/rails/template.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'appmap/handler/function'
 require 'appmap/event'
 
 module AppMap
@@ -9,7 +10,7 @@ module AppMap
         LOG = (ENV['APPMAP_TEMPLATE_DEBUG'] == 'true' || ENV['DEBUG'] == 'true')
 
         # All the code which is touched by the AppMap is recorded in the classMap.
-        # This duck-typed 'method' is used to represent a view template as a package, 
+        # This duck-typed 'method' is used to represent a view template as a package,
         # class, and method in the classMap.
         # The class name is generated from the template path. The package name is
         # 'app/views', and the method name is 'render'. The source location of the method
@@ -41,31 +42,31 @@ module AppMap
           def package
             'app/views'
           end
-  
+
           def name
             'render'
           end
-  
+
           def source_location
             path
           end
-  
+
           def static
             true
           end
-  
+
           def comment
             nil
           end
-  
+
           def labels
             [ 'mvc.template' ]
           end
         end
-  
+
         # TemplateCall is a type of function call which is specialized to view template rendering. Since
         # there isn't really a perfect method in Rails to hook, this one is synthesized from the available
-        # information. 
+        # information.
         class TemplateCall < AppMap::Event::MethodEvent
           # This is basically the +self+ parameter.
           attr_reader :render_instance
@@ -75,19 +76,19 @@ module AppMap
           attr_accessor :ready
 
           alias ready? ready
- 
+
           def initialize(render_instance)
             super :call
-  
+
             AppMap::Event::MethodEvent.build_from_invocation(:call, event: self)
             @ready = false
             @render_instance = render_instance
           end
-  
+
           def static?
             true
           end
-    
+
           def to_h
             super.tap do |h|
               h[:defined_class] = path ? path.parameterize.underscore : 'inline_template'
@@ -103,71 +104,76 @@ module AppMap
             end.compact
           end
         end
- 
+
         TEMPLATE_RENDERER = 'appmap.handler.rails.template.renderer'
 
         # Hooks the ActionView::Resolver methods +find_all+, +find_all_anywhere+. The resolver is used
         # during template rendering to lookup the template file path from parameters such as the
         # template name, prefix, and partial (boolean).
-        class ResolverHandler
-          class << self
-            # Handled as a normal function call.
-            def handle_call(defined_class, hook_method, receiver, args)
-              name, prefix, partial = args
-              warn "Resolver: #{{ name: name, prefix: prefix, partial: partial }}" if LOG
-
-              AppMap::Handler::Function.handle_call(defined_class, hook_method, receiver, args)
-            end
+        class ResolverHandler < AppMap::Handler::Function
+          def handle_call(receiver, args)
+            name, prefix, partial = args
+            warn "Resolver: #{{ name: name, prefix: prefix, partial: partial }}" if LOG
 
-            # When the resolver returns, look to see if there is template rendering underway.
-            # If so, populate the template path. In all cases, add a TemplateMethod so that the
-            # template will be recorded in the classMap.
-            def handle_return(call_event_id, elapsed, return_value, exception)
-              renderer = Array(Thread.current[TEMPLATE_RENDERER]).last
-              path_obj = Array(return_value).first
-              
-              warn "Resolver return: #{path_obj}" if LOG
-
-              if path_obj
-                path = if path_obj.respond_to?(:identifier) && path_obj.inspect.index('#<')
-                  path_obj.identifier
-                else
-                  path_obj.inspect
-                end
-                path = path[Dir.pwd.length + 1..-1] if path.index(Dir.pwd) == 0
-                AppMap.tracing.record_method(TemplateMethod.new(path))
-                renderer.path ||= path if renderer
-              end
+            super
+          end
 
-              AppMap::Handler::Function.handle_return(call_event_id, elapsed, return_value, exception)
-            end
+          # When the resolver returns, look to see if there is template rendering underway.
+          # If so, populate the template path. In all cases, add a TemplateMethod so that the
+          # template will be recorded in the classMap.
+          def handle_return(call_event_id, elapsed, return_value, exception)
+            renderer = Array(Thread.current[TEMPLATE_RENDERER]).last
+            path_obj = Array(return_value).first
+
+            warn "Resolver return: #{path_obj}" if LOG
+
+            record_template_path renderer, path_obj
+
+            super
+          end
+
+          def record_template_path(renderer, path_obj)
+            return unless path_obj
+
+            path = path_from_obj path_obj
+            AppMap.tracing.record_method(TemplateMethod.new(path))
+            renderer.path ||= path if renderer
+          end
+
+          def path_from_obj(path_obj)
+            path =
+              if path_obj.respond_to?(:identifier) && path_obj.inspect.index('#<')
+                path_obj.identifier
+              else
+                path_obj.inspect
+              end
+            path = path[Dir.pwd.length + 1..] if path.index(Dir.pwd) == 0
+            path
           end
         end
 
         # Hooks the ActionView::Renderer method +render+. This method is used by Rails to perform
         # template rendering. The TemplateCall event which is emitted by this handler has a
-        # +path+ parameter, which is nil until it's filled in by a ResolverHandler. 
-        class RenderHandler
-          class << self
-            def handle_call(defined_class, hook_method, receiver, args)
-              # context, options
-              _, options = args
-
-              warn "Renderer: #{options}" if LOG
-
-              TemplateCall.new(receiver).tap do |call|
-                Thread.current[TEMPLATE_RENDERER] ||= []
-                Thread.current[TEMPLATE_RENDERER] << call
-              end
-            end
-  
-            def handle_return(call_event_id, elapsed, return_value, exception)
-              template_call = Array(Thread.current[TEMPLATE_RENDERER]).pop
-              template_call.ready = true
+        # +path+ parameter, which is nil until it's filled in by a ResolverHandler.
+        class RenderHandler < AppMap::Hook::Method
+          def handle_call(receiver, args)
+            # context, options
+            _, options = args
+
+            warn "Renderer: #{options}" if LOG
 
-              AppMap::Event::MethodReturnIgnoreValue.build_from_invocation(call_event_id, elapsed: elapsed)
+            TemplateCall.new(receiver).tap do |call|
+              Thread.current[TEMPLATE_RENDERER] ||= []
+              Thread.current[TEMPLATE_RENDERER] << call
             end
           end
+
+          def handle_return(call_event_id, elapsed, _return_value, _exception)
+            template_call = Array(Thread.current[TEMPLATE_RENDERER]).pop
+            template_call.ready = true
+
+            AppMap::Event::MethodReturnIgnoreValue.build_from_invocation(call_event_id, elapsed: elapsed)
+          end
         end
       end
     end

data/lib/appmap/hook/method/ruby2.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+def ruby2_keywords(*); end unless respond_to?(:ruby2_keywords, true)
+
+module AppMap
+  class Hook
+    # Delegation methods for Ruby 2.
+    # cf. https://eregon.me/blog/2019/11/10/the-delegation-challenge-of-ruby27.html
+    class Method
+      ruby2_keywords def call(receiver, *args, &block)
+        return do_call(receiver, *args, &block) unless trace?
+
+        call_event = with_disabled_hook { before_hook receiver, *args }
+        trace_call call_event, receiver, *args, &block
+      end
+
+      protected
+
+      def before_hook(receiver, *args)
+        call_event = handle_call(receiver, args)
+        if call_event
+          AppMap.tracing.record_event \
+            call_event,
+            package: hook_package,
+            defined_class: defined_class,
+            method: hook_method
+        end
+        call_event
+      end
+
+      ruby2_keywords def do_call(receiver, *args, &block)
+        hook_method.bind(receiver).call(*args, &block)
+      end
+
+      ruby2_keywords def trace_call(call_event, receiver, *args, &block)
+        start_time = gettime
+        begin
+          return_value = do_call(receiver, *args, &block)
+        rescue # rubocop:disable Style/RescueStandardError
+          exception = $ERROR_INFO
+          raise
+        ensure
+          with_disabled_hook { after_hook receiver, call_event, gettime - start_time, return_value, exception } \
+            if call_event
+        end
+      end
+
+      def hook_method_def
+        this = self
+        proc { |*args, &block| this.call self, *args, &block }.tap do |hook|
+          hook.ruby2_keywords if hook.respond_to? :ruby2_keywords
+        end
+      end
+    end
+  end
+end