appmap 0.77.1 → 0.77.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b186892e87c9138a6bd540c82dd899e5d9b4671748ba7219c7d685175509d625
-  data.tar.gz: 0f917bd67d06fab65b568b55c68405206fdf942cd72854a6cff845e021970d80
+  metadata.gz: 4a3775abc9bff6d949fa377e2da5121414500735c37d9c5b9d6f03a7a2ae31a7
+  data.tar.gz: 7254e2e5c3f25f431cdb25e8d0512d55a155afd8b64647b255b3a8223b663f3f
 SHA512:
-  metadata.gz: afb2787068a4b7dca1c7b5226f82864c1ce8e5d32c88db7caf554f7c9d6cfbcd1d817e37f1ac691a573d36da4da53ea057c4c3d39c0e985e0969cfed9c63f7ae
-  data.tar.gz: 3b7f117ebe7f4b732cc81bd412bea46dd51b356db78a228561b3b9cf5c581b05d91e081b6cd699ad31d33e82fbd3d31548ccb91478c0fe7648357c947d6ef18a
+  metadata.gz: cf54fd237e40750eff85fb4723651a747ba6e69214ea04acae1a95964a09e4a800ea1de31dbc4f7dec7d26c585ef7fb9167a3e97eb36e9b0c14003240696d6d6
+  data.tar.gz: 81f413c5e21379b145a99f9882db9faea3d27e75ef56df7a8a928ce0b74f141c26025300cf0449fbf00128eb4991d99c94316f4fb522c5bd25042fb6ad2cfff3

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.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)
+
+
+### Bug Fixes
+
+* Pass the proper openapi-template arg ([05cbfde](https://github.com/applandinc/appmap-ruby/commit/05cbfdebdf80e3df2105a943ad892d5a7df614d7))
+
 ## [0.77.1](https://github.com/applandinc/appmap-ruby/compare/v0.77.0...v0.77.1) (2022-03-24)
 
 

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/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/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

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module AppMap
+  class Hook
+    # Delegation methods for Ruby 3.
+    class Method
+      def call(receiver, *args, **kwargs, &block)
+        return do_call(receiver, *args, **kwargs, &block) unless trace?
+
+        call_event = with_disabled_hook { before_hook receiver, *args, **kwargs }
+        trace_call call_event, receiver, *args, **kwargs, &block
+      end
+
+      protected
+
+      def before_hook(receiver, *args, **kwargs)
+        args = [*args, kwargs] if !kwargs.empty? || keyrest?
+        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
+
+      def keyrest?
+        @keyrest ||= parameters.map(&:last).include? :keyrest
+      end
+
+      def do_call(receiver, *args, **kwargs, &block)
+        hook_method.bind_call(receiver, *args, **kwargs, &block)
+      end
+
+      def trace_call(call_event, receiver, *args, **kwargs, &block)
+        start_time = gettime
+        begin
+          return_value = do_call(receiver, *args, **kwargs, &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, **kwargs, &block| this.call self, *args, **kwargs, &block }
+      end
+    end
+  end
+end