appmap 0.66.1 → 0.68.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/handler/net_http.rb

@@ -2,6 +2,7 @@
 
 require 'appmap/event'
 require 'appmap/util'
+require 'rack'
 
 module AppMap
   module Handler
@@ -27,7 +28,7 @@ module AppMap
 
         self.request_method = request.method
         self.url = url
-        self.headers = AppMap::Util.select_headers(NetHTTP.request_headers(request))
+        self.headers = NetHTTP.copy_headers(request)
         self.params = Rack::Utils.parse_nested_query(query)
       end
 
@@ -55,22 +56,25 @@ module AppMap
     end
 
     class HTTPClientResponse < AppMap::Event::MethodReturnIgnoreValue
-      attr_accessor :status, :mime_type, :headers
+      attr_accessor :status, :headers
 
       def initialize(response, parent_id, elapsed)
         super AppMap::Event.next_id_counter, :return, Thread.current.object_id
 
-        self.status = response.code.to_i
+        if response
+          self.status = response.code.to_i
+          self.headers = NetHTTP.copy_headers(response)
+        else
+          self.headers = {}
+        end
         self.parent_id = parent_id
         self.elapsed = elapsed
-        self.headers = AppMap::Util.select_headers(NetHTTP.response_headers(response))
       end
 
       def to_h
         super.tap do |h|
           h[:http_client_response] = {
             status_code: status,
-            mime_type: mime_type,
             headers: headers
           }.compact
         end
@@ -79,17 +83,15 @@ module AppMap
 
     class NetHTTP
       class << self
-        def request_headers(request)
+        def copy_headers(obj)
           {}.tap do |headers|
-            request.each_header do |k,v|
-              key = [ 'HTTP', Util.underscore(k).upcase ].join('_')
-              headers[key] = v
+            obj.each_header do |key, value|
+              key = key.split('-').map(&:capitalize).join('-')
+              headers[key] = value
             end
           end
         end
-    
-        alias response_headers request_headers
-    
+
         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?

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

@@ -9,16 +9,14 @@ module AppMap
     module Rails
       module RequestHandler
         class HTTPServerRequest < AppMap::Event::MethodEvent
-          attr_accessor :normalized_path_info, :request_method, :path_info, :params, :mime_type, :headers, :authorization
+          attr_accessor :normalized_path_info, :request_method, :path_info, :params, :headers
 
           def initialize(request)
             super AppMap::Event.next_id_counter, :call, Thread.current.object_id
 
             self.request_method = request.request_method
             self.normalized_path_info = normalized_path(request)
-            self.mime_type = request.headers['Content-Type']
-            self.headers = AppMap::Util.select_headers(request.env)
-            self.authorization = request.headers['Authorization']
+            self.headers = AppMap::Util.select_rack_headers(request.env)
             self.path_info = request.path_info.split('?')[0]
             # ActionDispatch::Http::ParameterFilter is deprecated
             parameter_filter_cls = \
@@ -35,9 +33,7 @@ module AppMap
               h[:http_server_request] = {
                 request_method: request_method,
                 path_info: path_info,
-                mime_type: mime_type,
                 normalized_path_info: normalized_path_info,
-                authorization: authorization,
                 headers: headers,
               }.compact
 
@@ -72,23 +68,21 @@ module AppMap
         end
 
         class HTTPServerResponse < AppMap::Event::MethodReturnIgnoreValue
-          attr_accessor :status, :mime_type, :headers
+          attr_accessor :status, :headers
 
           def initialize(response, parent_id, elapsed)
             super AppMap::Event.next_id_counter, :return, Thread.current.object_id
 
             self.status = response.status
-            self.mime_type = response.headers['Content-Type']
             self.parent_id = parent_id
             self.elapsed = elapsed
-            self.headers = AppMap::Util.select_headers(response.headers)
+            self.headers = response.headers.dup
           end
 
           def to_h
             super.tap do |h|
               h[:http_server_response] = {
                 status_code: status,
-                mime_type: mime_type,
                 headers: headers
               }.compact
             end

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/minitest.rb

@@ -142,6 +142,7 @@ if AppMap::Minitest.enabled?
     alias run_without_hook run
 
     def run
+      GC.start
       AppMap::Minitest.begin_test self, name
       begin
         run_without_hook

data/lib/appmap/rspec.rb

@@ -87,6 +87,7 @@ module AppMap
         end
 
         warn "Starting recording of example #{example}@#{source_location}" if AppMap::RSpec::LOG
+        GC.start
         @trace = AppMap.tracing.trace
         @webdriver_port = webdriver_port.()
       end

data/lib/appmap/swagger/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 module AppMap

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('/')
 
@@ -108,8 +116,18 @@ module AppMap
         event
       end
 
-      def select_headers(env)
+      def select_rack_headers(env)
+        finalize_headers = lambda do |headers|
+          blank?(headers) ? nil : headers
+        end
+
         # Rack prepends HTTP_ to all client-sent headers.
+
+        if !env['rack.version']
+          warn "Request headers does not contain rack.version. HTTP_ prefix is not expected."
+          return finalize_headers.call(env.dup)
+        end
+
         matching_headers = env
           .select { |k,v| k.start_with? 'HTTP_'}
           .reject { |k,v| blank?(v) }
@@ -118,7 +136,7 @@ module AppMap
             value = kv[1]
             memo[key] = value
           end
-        blank?(matching_headers) ? nil : matching_headers
+        finalize_headers.call(matching_headers)
       end
 
       def normalize_path(path)

data/lib/appmap/version.rb

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

data/lib/appmap.rb

@@ -74,6 +74,6 @@ lambda do
     require 'appmap/depends'
   end
   
-end.call
+end.call unless ENV['APPMAP_AUTOREQUIRE'] == 'false'
 
-AppMap.initialize_configuration if ENV['APPMAP'] == 'true'
+AppMap.initialize_configuration if ENV['APPMAP'] == 'true' && ENV['APPMAP_INITIALIZE'] != 'false'