appmap 0.31.0

data/lib/appmap/middleware/remote_recording.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module AppMap
+  module Middleware
+    # RemoteRecording adds `/_appmap/record` routes to control recordings via HTTP requests
+    class RemoteRecording
+      def initialize(app)
+        require 'json'
+
+        @app = app
+      end
+
+      def event_loop
+        loop do
+          event = @tracer.next_event if @tracer
+          if event
+            @events << event.to_h
+          else
+            sleep 0.0001
+          end
+        end
+      end
+
+      def start_recording
+        return [ 409, 'Recording is already in progress' ] if @tracer
+
+        @events = []
+        @tracer = AppMap.tracing.trace
+        @event_thread = Thread.new { event_loop }
+        @event_thread.abort_on_exception = true
+
+        [ 200 ]
+      end
+
+      def stop_recording(req)
+        return [ 404, 'No recording is in progress' ] unless @tracer
+
+        tracer = @tracer
+        @tracer = nil
+
+        AppMap.tracing.delete(tracer)
+
+        @event_thread.exit
+        @event_thread.join
+        @event_thread = nil
+
+        # Delete the events which are calls to or returns from the URL path _appmap/record
+        # because these are not of interest to the user.
+        is_control_command_event = lambda do |event|
+          event[:event] == :call &&
+            event[:http_server_request] &&
+            event[:http_server_request][:path_info] == '/_appmap/record'
+        end
+        control_command_events = @events.select(&is_control_command_event)
+
+        is_return_from_control_command_event = lambda do |event|
+          event[:parent_id] && control_command_events.find { |e| e[:id] == event[:parent_id] }
+        end
+
+        @events.delete_if(&is_control_command_event)
+        @events.delete_if(&is_return_from_control_command_event)
+
+        metadata = AppMap.detect_metadata
+        metadata[:recorder] = {
+          name: 'remote_recording'
+        }
+
+        response = JSON.generate \
+          version: AppMap::APPMAP_FORMAT_VERSION,
+          classMap: AppMap.class_map(tracer.event_methods),
+          metadata: metadata,
+          events: @events
+
+        [ 200, response ]
+      end
+
+      def call(env)
+        req = Rack::Request.new(env)
+        return handle_record_request(req) if req.path == '/_appmap/record'
+
+        @app.call(env)
+      end
+
+      def recording_state
+        [ 200, JSON.generate({ enabled: recording? }) ]
+      end
+
+      def handle_record_request(req)
+        method = req.env['REQUEST_METHOD']
+
+        status, body = \
+          if method.eql?('GET')
+            recording_state
+          elsif method.eql?('POST')
+            start_recording
+          elsif method.eql?('DELETE')
+            stop_recording(req)
+          else
+            [ 404, '' ]
+          end
+
+        [status, { 'Content-Type' => 'application/json' }, [body || '']]
+      end
+
+      def html_response?(headers)
+        headers['Content-Type'] && headers['Content-Type'] =~ /html/
+      end
+
+      def recording?
+        !@event_thread.nil?
+      end
+    end
+  end
+end

data/lib/appmap/minitest.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'appmap/util'
+
+module AppMap
+  # Integration of AppMap with Minitest. When enabled with APPMAP=true, the AppMap tracer will
+  # be activated around each test.
+  module Minitest
+    APPMAP_OUTPUT_DIR = 'tmp/appmap/minitest'
+    LOG = false
+
+    def self.metadata
+      AppMap.detect_metadata
+    end
+
+    Recording = Struct.new(:test) do
+      def initialize(test)
+        super
+
+        warn "Starting recording of test #{test.class}.#{test.name}" if AppMap::Minitest::LOG
+        @trace = AppMap.tracing.trace
+      end
+
+      def finish
+        warn "Finishing recording of test #{test.class}.#{test.name}" if AppMap::Minitest::LOG
+
+        events = []
+        AppMap.tracing.delete @trace
+
+        events << @trace.next_event.to_h while @trace.event?
+
+        AppMap::Minitest.add_event_methods @trace.event_methods
+
+        class_map = AppMap.class_map(@trace.event_methods)
+
+        feature_group = test.class.name.underscore.split('_')[0...-1].join('_').capitalize
+        feature_name = test.name.split('_')[1..-1].join(' ')
+        scenario_name = [ feature_group, feature_name ].join(' ')
+
+        AppMap::Minitest.save scenario_name,
+                              class_map,
+                              events: events,
+                              feature_name: feature_name,
+                              feature_group_name: feature_group
+      end
+    end
+
+    @recordings_by_test = {}
+    @event_methods = Set.new
+
+    class << self
+      def init
+        warn 'Configuring AppMap recorder for Minitest'
+
+        FileUtils.mkdir_p APPMAP_OUTPUT_DIR
+      end
+
+      def begin_test(test)
+        @recordings_by_test[test.object_id] = Recording.new(test)
+      end
+
+      def end_test(test)
+        recording = @recordings_by_test.delete(test.object_id)
+        return warn "No recording found for #{test}" unless recording
+
+        recording.finish
+      end
+
+      def config
+        @config or raise "AppMap is not configured"
+      end
+
+      def add_event_methods(event_methods)
+        @event_methods += event_methods
+      end
+
+      def save(example_name, class_map, events: nil, feature_name: nil, feature_group_name: nil, labels: nil)
+        metadata = AppMap::Minitest.metadata.tap do |m|
+          m[:name] = example_name
+          m[:app] = AppMap.configuration.name
+          m[:feature] = feature_name if feature_name
+          m[:feature_group] = feature_group_name if feature_group_name
+          m[:frameworks] ||= []
+          m[:frameworks] << {
+            name: 'minitest',
+            version: Gem.loaded_specs['minitest']&.version&.to_s
+          }
+          m[:recorder] = {
+            name: 'minitest'
+          }
+        end
+
+        appmap = {
+          version: AppMap::APPMAP_FORMAT_VERSION,
+          metadata: metadata,
+          classMap: class_map,
+          events: events
+        }.compact
+        fname = AppMap::Util.scenario_filename(example_name)
+
+        File.write(File.join(APPMAP_OUTPUT_DIR, fname), JSON.generate(appmap))
+      end
+
+      def print_inventory
+        class_map = AppMap.class_map(@event_methods)
+        save 'Inventory', class_map, labels: %w[inventory]
+      end
+
+      def enabled?
+        ENV['APPMAP'] == 'true'
+      end
+
+      def run
+        init
+        at_exit do
+          print_inventory
+        end
+      end
+    end
+  end
+end
+
+if AppMap::Minitest.enabled?
+  require 'appmap'
+  require 'minitest/test'
+
+  class ::Minitest::Test
+    alias run_without_hook run
+
+    def run
+      AppMap::Minitest.begin_test self
+      begin
+        run_without_hook
+      ensure
+        AppMap::Minitest.end_test self
+      end
+    end
+  end
+
+  AppMap::Minitest.run
+end

data/lib/appmap/rails/action_handler.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'appmap/event'
+
+module AppMap
+  module Rails
+    module ActionHandler
+      Context = Struct.new(:id, :start_time)
+
+      module ContextKey
+        def context_key
+          "#{HTTPServerRequest.name}#call"
+        end
+      end
+
+      class HTTPServerRequest
+        include ContextKey
+
+        class Call < AppMap::Event::MethodEvent
+          attr_accessor :payload
+
+          def initialize(path, lineno, payload)
+            super AppMap::Event.next_id_counter, :call, HTTPServerRequest, :call, path, lineno, Thread.current.object_id
+
+            self.payload = payload
+          end
+
+          def to_h
+            super.tap do |h|
+              h[:http_server_request] = {
+                request_method: payload[:method],
+                path_info: payload[:path]
+              }
+
+              params = payload[:params]
+              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__
+                }
+              end
+            end
+          end
+        end
+
+        def call(_, started, finished, _, payload) # (name, started, finished, unique_id, payload)
+          event = Call.new(__FILE__, __LINE__, payload)
+          Thread.current[context_key] = Context.new(event.id, Time.now)
+          AppMap.tracing.record_event(event)
+        end
+      end
+
+      class HTTPServerResponse
+        include ContextKey
+
+        class Call < AppMap::Event::MethodReturnIgnoreValue
+          attr_accessor :payload
+
+          def initialize(path, lineno, payload, parent_id, elapsed)
+            super AppMap::Event.next_id_counter, :return, HTTPServerResponse, :call, path, lineno, Thread.current.object_id
+
+            self.payload = payload
+            self.parent_id = parent_id
+            self.elapsed = elapsed
+          end
+
+          def to_h
+            super.tap do |h|
+              h[:http_server_response] = {
+                status: payload[:status]
+              }
+            end
+          end
+        end
+
+        def call(_, started, finished, _, payload) # (name, started, finished, unique_id, payload)
+          return unless Thread.current[context_key]
+
+          context = Thread.current[context_key]
+          Thread.current[context_key] = nil
+
+          event = Call.new(__FILE__, __LINE__, payload, context.id, Time.now - context.start_time)
+          AppMap.tracing.record_event(event)
+        end
+      end
+    end
+  end
+end

data/lib/appmap/rails/sql_handler.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'appmap/event'
+
+module AppMap
+  module Rails
+    class SQLHandler
+      class SQLCall < AppMap::Event::MethodEvent
+        attr_accessor :payload
+
+        def initialize(path, lineno, payload)
+          super AppMap::Event.next_id_counter, :call, SQLHandler, :call, path, lineno, 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 explain_sql].each do |attribute|
+                sql_query[attribute] = payload[attribute] if payload[attribute]
+              end
+            end
+          end
+        end
+      end
+
+      class SQLReturn < AppMap::Event::MethodReturnIgnoreValue
+        def initialize(path, lineno, parent_id, elapsed)
+          super AppMap::Event.next_id_counter, :return, SQLHandler, :call, path, lineno, 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
+          def server_version
+            case database_type
+            when :postgres
+              ActiveRecord::Base.connection.postgresql_version
+            else
+              warn "Unable to determine database version for #{database_type.inspect}"
+            end
+          end
+
+          def database_type
+            return :postgres if ActiveRecord::Base.connection.respond_to?(:postgresql_version)
+
+            ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+          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(__FILE__, __LINE__, payload)
+          AppMap.tracing.record_event(call)
+          AppMap.tracing.record_event(SQLReturn.new(__FILE__, __LINE__, call.id, finished - started))
+        ensure
+          Thread.current[reentry_key] = nil
+        end
+      end
+    end
+  end
+end