appmap 0.43.0 → 0.47.0

data/lib/appmap/rails/request_handler.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require 'appmap/event'
-require 'appmap/hook'
-
-module AppMap
-  module Rails
-    module RequestHandler
-      # Host and User-Agent will just introduce needless variation.
-      # Content-Type and Authorization get their own fields in the request.
-      IGNORE_HEADERS = %w[host user_agent content_type authorization].map(&:upcase).map {|h| "HTTP_#{h}"}.freeze
-
-      class << self
-        def selected_headers(env)
-          # Rack prepends HTTP_ to all client-sent headers.
-          matching_headers = env
-            .select { |k,v| k.start_with? 'HTTP_'}
-            .reject { |k,v| IGNORE_HEADERS.member?(k) }
-            .reject { |k,v| v.blank? }
-            .each_with_object({}) do |kv, memo|
-              key = kv[0].sub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
-              value = kv[1]
-              memo[key] = value
-            end
-          matching_headers.blank? ? nil : matching_headers
-        end
-      end
-
-      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 = RequestHandler.selected_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
-
-            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
-
-        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 = RequestHandler.selected_headers(response.headers)
-        end
-
-        def to_h
-          super.tap do |h|
-            h[:http_server_response] = {
-              status: 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

data/test/cli_test.rb

@@ -1,116 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'English'
-
-class CLITest < Minitest::Test
-  OUTPUT_FILENAME = File.expand_path('../tmp/appmap.json', __dir__)
-  STATS_OUTPUT_FILENAME = File.expand_path('../tmp/stats.txt', __dir__)
-
-  def setup
-    FileUtils.rm_f OUTPUT_FILENAME
-    FileUtils.rm_f STATS_OUTPUT_FILENAME
-  end
-
-  def test_record
-    output = Dir.chdir 'test/fixtures/cli_record_test' do
-      `#{File.expand_path '../exe/appmap', __dir__} record -o #{OUTPUT_FILENAME} ./lib/cli_record_test/main.rb`.strip
-    end
-
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    assert File.file?(OUTPUT_FILENAME), "#{OUTPUT_FILENAME} does not exist"
-    assert_equal 'Hello', output
-    output = JSON.parse(File.read(OUTPUT_FILENAME))
-    assert output['classMap'], 'Output should contain classMap'
-    assert output['events'], 'Output should contain events'
-  end
-
-  def test_stats_to_file
-    Dir.chdir 'test/fixtures/cli_record_test' do
-      `#{File.expand_path '../exe/appmap', __dir__} record -o #{OUTPUT_FILENAME} ./lib/cli_record_test/main.rb`.strip
-    end
-    assert_equal 0, $CHILD_STATUS.exitstatus
-
-    output = Dir.chdir 'test/fixtures/cli_record_test' do
-      `#{File.expand_path '../exe/appmap', __dir__} stats -o #{STATS_OUTPUT_FILENAME} #{OUTPUT_FILENAME}`.strip
-    end
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    assert_equal '', output
-    assert File.file?(OUTPUT_FILENAME), "#{OUTPUT_FILENAME} does not exist"
-  end
-
-
-  def test_stats_text
-    Dir.chdir 'test/fixtures/cli_record_test' do
-      `#{File.expand_path '../exe/appmap', __dir__} record -o #{OUTPUT_FILENAME} ./lib/cli_record_test/main.rb`.strip
-    end
-    assert_equal 0, $CHILD_STATUS.exitstatus
-
-    output = Dir.chdir 'test/fixtures/cli_record_test' do
-      `#{File.expand_path '../exe/appmap', __dir__} stats -o - #{OUTPUT_FILENAME}`.strip
-    end
-
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    assert_equal <<~OUTPUT.strip, output.strip
-    Class frequency:
-    ----------------
-    1	Main
-
-    Method frequency:
-    ----------------
-    1	Main.say_hello
-    OUTPUT
-  end
-
-  def test_stats_json
-    Dir.chdir 'test/fixtures/cli_record_test' do
-      `#{File.expand_path '../exe/appmap', __dir__} record -o #{OUTPUT_FILENAME} ./lib/cli_record_test/main.rb`.strip
-    end
-    assert_equal 0, $CHILD_STATUS.exitstatus
-
-    output = Dir.chdir 'test/fixtures/cli_record_test' do
-      `#{File.expand_path '../exe/appmap', __dir__} stats -f json -o - #{OUTPUT_FILENAME}`.strip
-    end
-
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    assert_equal <<~OUTPUT.strip, output.strip
-    {
-      "class_frequency": [
-        {
-          "name": "Main",
-          "count": 1
-        }
-      ],
-      "method_frequency": [
-        {
-          "name": "Main.say_hello",
-          "count": 1
-        }
-      ]
-    }
-    OUTPUT
-  end
-
-  def test_record_to_default_location
-    Dir.chdir 'test/fixtures/cli_record_test' do
-      system({ 'APPMAP_FILE' => OUTPUT_FILENAME }, "#{File.expand_path '../exe/appmap', __dir__} record ./lib/cli_record_test/main.rb")
-    end
-
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    assert File.file?(OUTPUT_FILENAME), 'appmap.json does not exist'
-  end
-
-  def test_record_to_stdout
-    output = Dir.chdir 'test/fixtures/cli_record_test' do
-      `#{File.expand_path '../exe/appmap', __dir__} record -o - ./lib/cli_record_test/main.rb`
-    end
-
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    # Event path
-    assert_includes output, %("path":"lib/cli_record_test/main.rb")
-    # Function location
-    assert_includes output, %("location":"lib/cli_record_test/main.rb:3")
-    assert !File.file?(OUTPUT_FILENAME), "#{OUTPUT_FILENAME} should not exist"
-  end
-end