appmap 0.77.3 → 0.77.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6889544929fdf05360b3e528847aaa1e3c4a423c580b982d5ecbb3403a44f6aa
-  data.tar.gz: dad6b337385f4700b0974bf727329afa2bcd4c33f5a17bd951fd9516608a5798
+  metadata.gz: 4a3775abc9bff6d949fa377e2da5121414500735c37d9c5b9d6f03a7a2ae31a7
+  data.tar.gz: 7254e2e5c3f25f431cdb25e8d0512d55a155afd8b64647b255b3a8223b663f3f
 SHA512:
-  metadata.gz: 197d249f8aa3ca22766168688f3b31e3b9cdf4c16d20227012d77dc5d6d1eb16b7814af8e605b51a5dc5a60ef4861f8cfd3f7089878ff88b046fac59a15b52a3
-  data.tar.gz: 0e74d7f95043ea588f0a0ef9aca170765db7475c6009d6471ce2299885b59aca25eb4d87bb72cd7045a2a743b6b8c95fbb6348786d99cb938a269c73189a5234
+  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,10 @@
+## [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)
 
 

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

data/lib/appmap/hook/method.rb

@@ -1,17 +1,11 @@
 # frozen_string_literal: true
 
 module AppMap
-  NEW_RUBY = Util.ruby_minor_version >= 2.7
-  if NEW_RUBY && !Proc.instance_methods.include?(:ruby2_keywords)
-    warn "Ruby is #{RUBY_VERSION}, but Procs don't respond to #ruby2_keywords"
-  end
-
   class Hook
     SIGNATURES = {}
-
     LOOKUP_SIGNATURE = lambda do |id|
       method = super(id)
-    
+
       signature = SIGNATURES[[ method.owner, method.name ]]
       if signature
         method.singleton_class.module_eval do
@@ -20,36 +14,24 @@ module AppMap
           end
         end
       end
-    
+
       method
     end
-    
-    class Method
-      attr_reader :hook_package, :hook_class, :hook_method
 
-      # +method_display_name+ may be nil if name resolution gets
-      # deferred until runtime (e.g. for a singleton method on an
-      # embedded Struct).
-      attr_reader :method_display_name
+    # Single hooked method.
+    # Call #activate to override the original.
+    class Method
+      attr_reader :hook_package, :hook_class, :hook_method, :parameters, :arity
 
       HOOK_DISABLE_KEY = 'AppMap::Hook.disable'
       private_constant :HOOK_DISABLE_KEY
 
-      # Grab the definition of Time.now here, to avoid interfering
-      # with the method we're hooking.
-      TIME_NOW = Time.method(:now)
-      private_constant :TIME_NOW
-
-      ARRAY_OF_EMPTY_HASH = [{}.freeze].freeze
-
       def initialize(hook_package, hook_class, hook_method)
         @hook_package = hook_package
         @hook_class = hook_class
         @hook_method = hook_method
-
-        # Get the class for the method, if it's known.
-        @defined_class, method_symbol = Hook.qualify_method_name(@hook_method)
-        @method_display_name = [@defined_class, method_symbol, @hook_method.name].join if @defined_class
+        @parameters = hook_method.parameters
+        @arity = hook_method.arity
       end
 
       def activate
@@ -62,64 +44,6 @@ module AppMap
           warn "AppMap: Hooking #{msg} at line #{(hook_method.source_location || []).join(':')}"
         end
 
-        defined_class = @defined_class
-        hook_package = self.hook_package
-        hook_method = self.hook_method
-        before_hook = self.method(:before_hook)
-        after_hook = self.method(:after_hook)
-        with_disabled_hook = self.method(:with_disabled_hook)
-
-        is_array_containing_empty_hash = ->(obj) {
-          obj.is_a?(Array) && obj.length == 1 && obj[0].is_a?(Hash) && obj[0].size == 0
-        }
-
-        call_instance_method = lambda do |receiver, args, &block|
-          # https://github.com/applandinc/appmap-ruby/issues/153
-          if NEW_RUBY && is_array_containing_empty_hash.(args) && hook_method.arity == 1
-            hook_method.bind_call(receiver, {}, &block)
-          else
-            if NEW_RUBY
-              hook_method.bind_call(receiver, *args, &block)
-            else
-              hook_method.bind(receiver).call(*args, &block)
-            end
-          end
-        end
-
-        hook_method_def = Proc.new do |*args, &block|
-          # We may not have gotten the class for the method during
-          # initialization (e.g. for a singleton method on an embedded
-          # struct), so make sure we have it now.
-          defined_class, = Hook.qualify_method_name(hook_method) unless defined_class
-
-          reentrant = Thread.current[HOOK_DISABLE_KEY]
-          disabled_by_shallow_flag = \
-            -> { hook_package&.shallow? && AppMap.tracing.last_package_for_current_thread == hook_package }
-
-          enabled = true if AppMap.tracing.enabled? && !reentrant && !disabled_by_shallow_flag.call
-
-          enabled = false if %i[instance_eval instance_exec].member?(hook_method.name) && args.empty?
-
-          return call_instance_method.call(self, args, &block) unless enabled
-
-          call_event, start_time = with_disabled_hook.call do
-            before_hook.call(self, defined_class, args)
-          end
-          return_value = nil
-          exception = nil
-          begin
-            return_value = call_instance_method.call(self, args, &block)
-          rescue
-            exception = $ERROR_INFO
-            raise
-          ensure
-            with_disabled_hook.call do
-              after_hook.call(self, call_event, start_time, return_value, exception) if call_event
-            end
-          end
-        end
-        hook_method_def = hook_method_def.ruby2_keywords if hook_method_def.respond_to?(:ruby2_keywords)
-
         hook_method_parameters = hook_method.parameters.dup.freeze
         SIGNATURES[[ hook_class, hook_method.name ]] = hook_method_parameters
 
@@ -140,28 +64,42 @@ module AppMap
 
       protected
 
-      def before_hook(receiver, defined_class, args)
-        call_event = hook_package.handler_class.handle_call(defined_class, hook_method, receiver, args)
-        AppMap.tracing.record_event(call_event, package: hook_package, defined_class: defined_class, method: hook_method) if call_event
-        [ call_event, TIME_NOW.call ]
+      def gettime
+        Process.clock_gettime Process::CLOCK_MONOTONIC
+      end
+
+      def trace?
+        return false unless AppMap.tracing.enabled?
+        return false if Thread.current[HOOK_DISABLE_KEY]
+        return false if hook_package&.shallow? && AppMap.tracing.last_package_for_current_thread == hook_package
+
+        true
       end
 
-      def after_hook(_receiver, call_event, start_time, return_value, exception)
-        elapsed = TIME_NOW.call - start_time
-        return_event = hook_package.handler_class.handle_return(call_event.id, elapsed, return_value, exception)
+      def method_display_name
+        return @method_display_name if @method_display_name
+
+        return @method_display_name = [defined_class, method_symbol, hook_method.name].join if defined_class
+
+        "#{hook_method.name} (class resolution deferred)"
+      end
+
+      def defined_class
+        @defined_class ||= Hook.qualify_method_name(hook_method)&.first
+      end
+
+      def after_hook(_receiver, call_event, elapsed, return_value, exception)
+        return_event = handle_return(call_event.id, elapsed, return_value, exception)
         AppMap.tracing.record_event(return_event) if return_event
-        nil
       end
 
-      def with_disabled_hook(&function)
+      def with_disabled_hook
         # Don't record functions, such as to_s and inspect, that might be called
         # by the fn. Otherwise there can be a stack overflow.
         Thread.current[HOOK_DISABLE_KEY] = true
-        begin
-          function.call
-        ensure
-          Thread.current[HOOK_DISABLE_KEY] = false
-        end
+        yield
+      ensure
+        Thread.current[HOOK_DISABLE_KEY] = false
       end
     end
   end
@@ -189,3 +127,9 @@ unless ENV['APPMAP_NO_PATCH_MODULE'] == 'true'
     prepend AppMap::ModuleMethods
   end
 end
+
+if RUBY_VERSION < '3'
+  require 'appmap/hook/method/ruby2'
+else
+  require 'appmap/hook/method/ruby3'
+end

data/lib/appmap/hook.rb

@@ -118,7 +118,7 @@ module AppMap
                 cls, method = entry
                 return false if config.never_hook?(cls, method)
 
-                Hook::Method.new(hook.package, cls, method).activate
+                hook.package.handler_class.new(hook.package, cls, method).activate
               end
 
               methods = []
@@ -209,7 +209,7 @@ module AppMap
           package = config.lookup_package(hook_cls, method)
           next unless package
 
-          Hook::Method.new(package, hook_cls, method).activate
+          package.handler_class.new(package, hook_cls, method).activate
         end
       end
 

data/lib/appmap/version.rb

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

data/spec/hook_spec.rb

@@ -115,7 +115,7 @@ describe 'AppMap class Hooking', docker: false do
     require 'appmap/hook/method'
     package = config.lookup_package(hook_cls, method)
     expect(package).to be
-    hook_method = AppMap::Hook::Method.new(package, hook_cls, method)
+    hook_method = AppMap::Handler::Function.new(package, hook_cls, method)
     hook_method.activate
 
     tracer = AppMap.tracing.trace
@@ -1188,7 +1188,7 @@ describe 'AppMap class Hooking', docker: false do
       require 'appmap/hook/method'
 
       pkg = AppMap::Config::Package.new('fixtures/hook/prependend_override')
-      AppMap::Hook::Method.new(pkg, PrependedClass, PrependedClass.public_instance_method(:say_hello)).activate
+      AppMap::Handler::Function.new(pkg, PrependedClass, PrependedClass.public_instance_method(:say_hello)).activate
 
       tracer = AppMap.tracing.trace
       AppMap::Event.reset_id_counter

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appmap
 version: !ruby/object:Gem::Version
-  version: 0.77.3
+  version: 0.77.4
 platform: ruby
 authors:
 - Kevin Gilpin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-03-29 00:00:00.000000000 Z
+date: 2022-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -383,6 +383,8 @@ files:
 - lib/appmap/handler/rails/template.rb
 - lib/appmap/hook.rb
 - lib/appmap/hook/method.rb
+- lib/appmap/hook/method/ruby2.rb
+- lib/appmap/hook/method/ruby3.rb
 - lib/appmap/metadata.rb
 - lib/appmap/middleware/remote_recording.rb
 - lib/appmap/minitest.rb