appmap 0.45.1 → 0.46.0

data/spec/class_map_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe 'AppMap::ClassMap' do
   describe '.build_from_methods' do
     it 'includes method comment' do
-      map = AppMap.class_map([scoped_method((method :test_method))])
+      map = AppMap.class_map([ruby_method((method :test_method))])
       function = dig_map(map, 5)[0]
       expect(function).to include(:comment)
     end
@@ -15,8 +15,8 @@ describe 'AppMap::ClassMap' do
       'test method body'
     end
 
-    def scoped_method(method)
-      AppMap::Trace::ScopedMethod.new AppMap::Config::Package.new, method.receiver.class.name, method, false
+    def ruby_method(method)
+      AppMap::Trace::RubyMethod.new AppMap::Config::Package.new, method.receiver.class.name, method, false
     end
 
     def dig_map(map, depth)

data/spec/hook_spec.rb

@@ -250,8 +250,8 @@ describe 'AppMap class Hooking', docker: false do
     _, tracer = invoke_test_file 'spec/fixtures/hook/instance_method.rb' do
       InstanceMethod.new.say_default
     end
-    expect(tracer.event_methods.to_a.map(&:defined_class)).to eq([ 'InstanceMethod' ])
-    expect(tracer.event_methods.to_a.map(&:to_s)).to eq([ InstanceMethod.public_instance_method(:say_default).to_s ])
+    expect(tracer.event_methods.to_a.map(&:class_name)).to eq([ 'InstanceMethod' ])
+    expect(tracer.event_methods.to_a.map(&:name)).to eq([ InstanceMethod.public_instance_method(:say_default).name ])
   end
 
   it 'builds a class map of invoked methods' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appmap
 version: !ruby/object:Gem::Version
-  version: 0.45.1
+  version: 0.46.0
 platform: ruby
 authors:
 - Kevin Gilpin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-04 00:00:00.000000000 Z
+date: 2021-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -348,14 +348,15 @@ files:
 - lib/appmap/event.rb
 - lib/appmap/handler/function.rb
 - lib/appmap/handler/net_http.rb
+- lib/appmap/handler/rails/request_handler.rb
+- lib/appmap/handler/rails/sql_handler.rb
+- lib/appmap/handler/rails/template.rb
 - lib/appmap/hook.rb
 - lib/appmap/hook/method.rb
 - lib/appmap/metadata.rb
 - lib/appmap/middleware/remote_recording.rb
 - lib/appmap/minitest.rb
 - lib/appmap/open.rb
-- lib/appmap/rails/request_handler.rb
-- lib/appmap/rails/sql_handler.rb
 - lib/appmap/railtie.rb
 - lib/appmap/record.rb
 - lib/appmap/rspec.rb

data/lib/appmap/rails/request_handler.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require 'appmap/event'
-require 'appmap/hook'
-
-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
-
-        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.path_info = request.path_info.split('?')[0]
-          # ActionDispatch::Http::ParameterFilter is deprecated
-          parameter_filter_cls = \
-            if defined?(ActiveSupport::ParameterFilter)
-              ActiveSupport::ParameterFilter
-            else
-              ActionDispatch::Http::ParameterFilter
-            end
-          self.params = parameter_filter_cls.new(::Rails.application.config.filter_parameters).filter(request.params)
-        end
-
-        def to_h
-          super.tap do |h|
-            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
-
-            unless params.blank?
-              h[:message] = params.keys.map do |key|
-                val = params[key]
-                {
-                  name: key,
-                  class: val.class.name,
-                  value: self.class.display_string(val),
-                  object_id: val.__id__,
-                }.tap do |message|
-                  properties = object_properties(val)
-                  message[:properties] = properties if properties
-                end
-              end
-            end
-          end
-        end
-
-        private
-
-        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
-
-      class HTTPServerResponse < AppMap::Event::MethodReturnIgnoreValue
-        attr_accessor :status, :mime_type, :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)
-        end
-
-        def to_h
-          super.tap do |h|
-            h[:http_server_response] = {
-              status_code: status,
-              mime_type: mime_type,
-              headers: headers
-            }.compact
-          end
-        end
-      end
-
-      class HookMethod < AppMap::Hook::Method
-        def initialize
-          # ActionController::Instrumentation has issued start_processing.action_controller and
-          # process_action.action_controller since Rails 3. Therefore it's a stable place to hook
-          # the request. Rails controller notifications can't be used directly because they don't
-          # provide response headers, and we want the Content-Type.
-          super(nil, ActionController::Instrumentation, ActionController::Instrumentation.instance_method(:process_action))
-        end
-
-        protected
-
-        def before_hook(receiver, defined_class, _) # args
-          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 ]
-        end
-
-        def after_hook(receiver, call_event, start_time, _, _) # return_value, exception
-          elapsed = TIME_NOW.call - start_time
-          return_event = HTTPServerResponse.new receiver.response, call_event.id, elapsed
-          AppMap.tracing.record_event return_event
-        end
-      end
-    end
-  end
-end

data/lib/appmap/rails/sql_handler.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require 'appmap/event'
-
-module AppMap
-  module Rails
-    class SQLHandler
-      class SQLCall < AppMap::Event::MethodCall
-        attr_accessor :payload
-
-        def initialize(payload)
-          super AppMap::Event.next_id_counter, :call, Thread.current.object_id
-
-          self.payload = payload
-        end
-
-        def to_h
-          super.tap do |h|
-            h[:sql_query] = {
-              sql: payload[:sql],
-              database_type: payload[:database_type]
-            }.tap do |sql_query|
-              %i[server_version].each do |attribute|
-                sql_query[attribute] = payload[attribute] if payload[attribute]
-              end
-            end
-          end
-        end
-      end
-
-      class SQLReturn < AppMap::Event::MethodReturnIgnoreValue
-        def initialize(parent_id, elapsed)
-          super AppMap::Event.next_id_counter, :return, Thread.current.object_id
-
-          self.parent_id = parent_id
-          self.elapsed = elapsed
-        end
-      end
-
-      module SQLExaminer
-        class << self
-          def examine(payload, sql:)
-            return unless (examiner = build_examiner)
-
-            payload[:server_version] = examiner.server_version
-            payload[:database_type] = examiner.database_type.to_s
-          end
-
-          protected
-
-          def build_examiner
-            if defined?(Sequel)
-              SequelExaminer.new
-            elsif defined?(ActiveRecord)
-              ActiveRecordExaminer.new
-            end
-          end
-        end
-
-        class SequelExaminer
-          def server_version
-            Sequel::Model.db.server_version
-          end
-
-          def database_type
-            Sequel::Model.db.database_type.to_sym
-          end
-
-          def execute_query(sql)
-            Sequel::Model.db[sql].all
-          end
-        end
-
-        class ActiveRecordExaminer
-          @@db_version_warning_issued = {}
-          
-          def issue_warning
-            db_type = database_type
-            return if @@db_version_warning_issued[db_type]
-            warn("AppMap: Unable to determine database version for #{db_type.inspect}") 
-            @@db_version_warning_issued[db_type] = true
-          end
-          
-          def server_version
-            ActiveRecord::Base.connection.try(:database_version) || issue_warning
-          end
-
-          def database_type
-            type = ActiveRecord::Base.connection.adapter_name.downcase.to_sym
-            type = :postgres if type == :postgresql
-
-            type
-          end
-
-          def execute_query(sql)
-            ActiveRecord::Base.connection.execute(sql).inject([]) { |memo, r| memo << r; memo }
-          end
-        end
-      end
-
-      def call(_, started, finished, _, payload) # (name, started, finished, unique_id, payload)
-        return if AppMap.tracing.empty?
-
-        reentry_key = "#{self.class.name}#call"
-        return if Thread.current[reentry_key] == true
-
-        Thread.current[reentry_key] = true
-        begin
-          sql = payload[:sql].strip
-
-          # Detect whether a function call within a specified filename is present in the call stack.
-          find_in_backtrace = lambda do |file_name, function_name = nil|
-            Thread.current.backtrace.find do |line|
-              tokens = line.split(':')
-              matches_file = tokens.find { |t| t.rindex(file_name) == (t.length - file_name.length) }
-              matches_function = function_name.nil? || tokens.find { |t| t == "in `#{function_name}'" }
-              matches_file && matches_function
-            end
-          end
-
-          # Ignore SQL calls which are made while establishing a new connection.
-          #
-          # Example:
-          # /path/to/ruby/2.6.0/gems/sequel-5.20.0/lib/sequel/connection_pool.rb:122:in `make_new'
-          return if find_in_backtrace.call('lib/sequel/connection_pool.rb', 'make_new')
-          # lib/active_record/connection_adapters/abstract/connection_pool.rb:811:in `new_connection'
-          return if find_in_backtrace.call('lib/active_record/connection_adapters/abstract/connection_pool.rb', 'new_connection')
-
-          # Ignore SQL calls which are made while inspecting the DB schema.
-          #
-          # Example:
-          # /path/to/ruby/2.6.0/gems/sequel-5.20.0/lib/sequel/model/base.rb:812:in `get_db_schema'
-          return if find_in_backtrace.call('lib/sequel/model/base.rb', 'get_db_schema')
-          # /usr/local/bundle/gems/activerecord-5.2.3/lib/active_record/model_schema.rb:466:in `load_schema!'
-          return if find_in_backtrace.call('lib/active_record/model_schema.rb', 'load_schema!')
-          return if find_in_backtrace.call('lib/active_model/attribute_methods.rb', 'define_attribute_methods')
-          return if find_in_backtrace.call('lib/active_record/connection_adapters/schema_cache.rb')
-
-          SQLExaminer.examine payload, sql: sql
-
-          call = SQLCall.new(payload)
-          AppMap.tracing.record_event(call)
-          AppMap.tracing.record_event(SQLReturn.new(call.id, finished - started))
-        ensure
-          Thread.current[reentry_key] = nil
-        end
-      end
-    end
-  end
-end