appmap 0.45.0 → 0.48.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/fixtures/rails5_users_app/config/application.rb

@@ -38,8 +38,6 @@ module UsersApp
     # Initialize configuration defaults for originally generated Rails version.
     config.load_defaults 5.2
 
-    config.appmap.enabled = true if ENV['APPMAP'] == 'true' && !Rails.env.test?
-
     # Settings in config/environments/* take precedence over those specified here.
     # Application configuration can go into files in config/initializers
     # -- all .rb files in that directory are automatically loaded after loading

data/spec/fixtures/rails6_users_app/config/application.rb

@@ -38,8 +38,6 @@ module UsersApp
     # Initialize configuration defaults for originally generated Rails version.
     config.load_defaults 5.2
 
-    config.appmap.enabled = true if ENV['APPMAP'] == 'true' && !Rails.env.test?
-
     # Settings in config/environments/* take precedence over those specified here.
     # Application configuration can go into files in config/initializers
     # -- all .rb files in that directory are automatically loaded after loading

data/spec/hook_spec.rb

@@ -60,69 +60,18 @@ describe 'AppMap class Hooking', docker: false do
     config = AppMap::Config.new('hook_spec', [ package ], exclude: %w[ExcludeTest])
     AppMap.configuration = config
 
-    expect(config.never_hook?(ExcludeTest.new.method(:instance_method))).to be_truthy
-    expect(config.never_hook?(ExcludeTest.method(:cls_method))).to be_truthy
+    expect(config.never_hook?(ExcludeTest, ExcludeTest.new.method(:instance_method))).to be_truthy
+    expect(config.never_hook?(ExcludeTest, ExcludeTest.method(:cls_method))).to be_truthy
   end
 
-  it "handles an instance method named 'call' without issues" do
+  it "an instance method named 'call' will be ignored" do
     events_yaml = <<~YAML
-    ---
-    - :id: 1
-      :event: :call
-      :defined_class: MethodNamedCall
-      :method_id: call
-      :path: spec/fixtures/hook/method_named_call.rb
-      :lineno: 8
-      :static: false
-      :parameters:
-      - :name: :a
-        :class: Integer
-        :value: '1'
-        :kind: :req
-      - :name: :b
-        :class: Integer
-        :value: '2'
-        :kind: :req
-      - :name: :c
-        :class: Integer
-        :value: '3'
-        :kind: :req
-      - :name: :d
-        :class: Integer
-        :value: '4'
-        :kind: :req
-      - :name: :e
-        :class: Integer
-        :value: '5'
-        :kind: :req
-      :receiver:
-        :class: MethodNamedCall
-        :value: MethodNamedCall
-    - :id: 2
-      :event: :return
-      :parent_id: 1
-      :return_value:
-        :class: String
-        :value: 1 2 3 4 5
+    --- []
     YAML
 
     _, tracer = test_hook_behavior 'spec/fixtures/hook/method_named_call.rb', events_yaml do
       expect(MethodNamedCall.new.call(1, 2, 3, 4, 5)).to eq('1 2 3 4 5')
     end
-    class_map = AppMap.class_map(tracer.event_methods)
-    expect(Diffy::Diff.new(<<~CLASSMAP, YAML.dump(class_map)).to_s).to eq('')
-    ---
-    - :name: spec/fixtures/hook/method_named_call.rb
-      :type: package
-      :children:
-      - :name: MethodNamedCall
-        :type: class
-        :children:
-        - :name: call
-          :type: function
-          :location: spec/fixtures/hook/method_named_call.rb:8
-          :static: false
-    CLASSMAP
   end
 
   it 'can custom hook and label a function' do
@@ -163,7 +112,9 @@ describe 'AppMap class Hooking', docker: false do
     method = hook_cls.instance_method(:say_default)
 
     require 'appmap/hook/method'
-    hook_method = AppMap::Hook::Method.new(config.package_for_method(method), hook_cls, method)
+    package = config.lookup_package(hook_cls, method)
+    expect(package).to be
+    hook_method = AppMap::Hook::Method.new(package, hook_cls, method)
     hook_method.activate
 
     tracer = AppMap.tracing.trace
@@ -248,8 +199,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
@@ -861,7 +812,9 @@ describe 'AppMap class Hooking', docker: false do
       _, _, events = test_hook_behavior 'spec/fixtures/hook/compare.rb', nil do
         expect(Compare.compare('string', 'string')).to be_truthy
       end
+
       secure_compare_event = YAML.load(events).find { |evt| evt[:defined_class] == 'ActiveSupport::SecurityUtils' }
+      expect(secure_compare_event).to be_truthy
       secure_compare_event.delete(:lineno)
       secure_compare_event.delete(:path)
 

data/spec/railtie_spec.rb

@@ -4,7 +4,7 @@ describe 'AppMap tracer via Railtie' do
   include_context 'Rails app pg database', 'spec/fixtures/rails5_users_app' do 
     let(:env) { {} }
 
-    let(:cmd) { %(docker-compose run --rm -e RAILS_ENV -e APPMAP app ./bin/rails r "puts Rails.configuration.appmap.enabled.inspect") }
+    let(:cmd) { %(docker-compose run --rm -e RAILS_ENV=development -e APPMAP app ./bin/rails r "puts AppMap.instance_variable_get('@configuration').nil?") }
     let(:command_capture2) do
       require 'open3'
       Open3.capture3(env, cmd, chdir: fixture_dir).tap do |result|
@@ -23,20 +23,16 @@ describe 'AppMap tracer via Railtie' do
     let(:command_output) { command_capture2[0].strip }
     let(:command_result) { command_capture2[2] }
 
-    it 'is disabled by default' do
-      expect(command_output).to eq('nil')
+    describe 'with APPMAP=false' do
+      let(:env) { { 'APPMAP' => 'false' } }
+      it 'is disabled' do
+        expect(command_output).to eq('true')
+      end
     end
-
     describe 'with APPMAP=true' do
       let(:env) { { 'APPMAP' => 'true' } }
       it 'is enabled' do
-        expect(command_output.split("\n")).to include('true')
-      end
-      context 'and RAILS_ENV=test' do
-        let(:env) { { 'APPMAP' => 'true', 'RAILS_ENV' => 'test' } }
-        it 'is disabled' do
-          expect(command_output).to eq('nil')
-        end
+        expect(command_output).to eq('false')
       end
     end
   end

data/spec/util_spec.rb

@@ -4,8 +4,8 @@ require 'spec_helper'
 require 'appmap/util'
 
 describe AppMap::Util, docker: false do
-  let(:subject) { AppMap::Util.method(:scenario_filename) }
   describe 'scenario_filename' do
+    let(:subject) { AppMap::Util.method(:scenario_filename) }
     it 'leaves short names alone' do
       expect(subject.call('foobar')).to eq('foobar.appmap.json')
     end
@@ -18,4 +18,21 @@ describe AppMap::Util, docker: false do
       expect(subject.call(fname, max_length: 50)).to eq('abcdefghijklmno-RAd_SFbH1sUZ_OXfwPsfzw.appmap.json')
     end
   end
+  describe 'swaggerize path' do
+    it 'replaces rails-style parameters' do
+      expect(AppMap::Util.swaggerize_path('/org/:org_id(.:format)')).to eq('/org/{org_id}')
+    end
+
+    it 'strips the format specifier' do
+      expect(AppMap::Util.swaggerize_path('/org(.:format)')).to eq('/org')
+    end
+
+    it 'ignores malformed parameter specs' do
+      expect(AppMap::Util.swaggerize_path('/org/o:rg_id')).to eq('/org/o:rg_id')
+    end
+
+    it 'ignores already swaggerized paths' do
+      expect(AppMap::Util.swaggerize_path('/org/{org_id}')).to eq('/org/{org_id}')
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appmap
 version: !ruby/object:Gem::Version
-  version: 0.45.0
+  version: 0.48.0
 platform: ruby
 authors:
 - Kevin Gilpin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-03 00:00:00.000000000 Z
+date: 2021-05-19 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