appmap 0.18.1

data/lib/appmap/middleware/remote_recording.rb

@@ -0,0 +1,122 @@
+# 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 'appmap/command/record'
+        require 'appmap/command/upload'
+        require 'appmap/trace/tracer'
+        require 'appmap/config'
+        require 'json'
+
+        @app = app
+        @features = AppMap.inspect(config)
+        @functions = @features.map(&:collect_functions).flatten
+      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 [ false, 'Recording is already in progress' ] if @tracer
+
+        @events = []
+        @tracer = AppMap::Trace.tracers.trace(@functions)
+        @event_thread = Thread.new { event_loop }
+        @event_thread.abort_on_exception = true
+
+        [ true ]
+      end
+
+      def stop_recording(req)
+        return [ false, 'No recording is in progress' ] unless @tracer
+
+        tracer = @tracer
+        @tracer = nil
+
+        AppMap::Trace.tracers.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)
+
+        require 'appmap/command/record'
+        metadata = AppMap::Command::Record.detect_metadata
+
+        response = JSON.generate(classMap: @features, metadata: metadata, events: @events)
+
+        [ true, 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 = 200 if status == true
+        status = 500 if status == false
+
+        [status, { 'Content-Type' => 'application/text' }, [body || '']]
+      end
+
+      def html_response?(headers)
+        headers['Content-Type'] && headers['Content-Type'] =~ /html/
+      end
+
+      def config
+        @config ||= AppMap::Config.load_from_file 'appmap.yml'
+      end
+
+      def recording?
+        !@event_thread.nil?
+      end
+    end
+  end
+end

data/lib/appmap/parser.rb

@@ -0,0 +1,60 @@
+require 'parser/current'
+require 'set'
+
+module AppMap
+  class Parser
+    def initialize(file_path: nil, code: nil)
+      @file_path = file_path
+      @code = code
+    end
+
+    def to_s
+      "Parse code #{file_path.inspect}"
+    end
+
+    # Parse the contents of a file into a list of features.
+    def parse
+      parse_tree, comments = parse_code_and_comments
+      parse_nodes = build_parse_nodes parse_tree
+      [ parse_nodes, comments ]
+    end
+
+    protected
+
+    def file_path
+      @file_path || '<inline>'
+    end
+
+    def code
+      @code ||= File.read(file_path)
+    end
+
+    def parse_code_and_comments
+      ::Parser::CurrentRuby.parse_with_comments(code)
+    rescue ::Parser::SyntaxError, EncodingError
+      warn "Unable to parse #{file_path.inspect} : #{$!.message}"
+      [ [], [] ]
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def build_parse_nodes(parse_tree)
+      parse_nodes = []
+      visit_methods = lambda do |node, ancestors|
+        return unless node.respond_to?(:type)
+
+        parse_node = build_parse_node(node, file_path, ancestors)
+        parse_nodes << parse_node if parse_node
+
+        ancestors << node
+        node.children.each do |child|
+          visit_methods.call(child, ancestors)
+        end
+        ancestors.pop
+      end
+      visit_methods.call(parse_tree, [])
+      parse_nodes
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+end
+

data/lib/appmap/rails/action_handler.rb

@@ -0,0 +1,77 @@
+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::Trace::MethodEvent
+          attr_accessor :payload
+
+          def initialize(path, lineno, payload)
+            super AppMap::Trace::MethodEvent.next_id, :call, HTTPServerRequest, :call, path, lineno, false, 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]
+              }
+              h[:message] = payload[:params]
+            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::Trace.tracers.record_event(event)
+        end
+      end
+
+      class HTTPServerResponse
+        include ContextKey
+
+        class Call < AppMap::Trace::MethodReturnIgnoreValue
+          attr_accessor :payload
+
+          def initialize(path, lineno, payload, parent_id, elapsed)
+            super AppMap::Trace::MethodEvent.next_id, :return, HTTPServerResponse, :call, path, lineno, false, 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::Trace.tracers.record_event(event)
+        end
+      end
+    end
+  end
+end

data/lib/appmap/rails/sql_handler.rb

@@ -0,0 +1,148 @@
+require 'appmap/trace/tracer'
+
+module AppMap
+  module Rails
+    class SQLHandler
+      class SQLCall < AppMap::Trace::MethodEvent
+        attr_accessor :payload
+
+        def initialize(path, lineno, payload)
+          super AppMap::Trace::MethodEvent.next_id, :call, SQLHandler, :call, path, lineno, false, 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::Trace::MethodReturnIgnoreValue
+        def initialize(path, lineno, parent_id, elapsed)
+          super AppMap::Trace::MethodEvent.next_id, :return, SQLHandler, :call, path, lineno, false, 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::Trace.tracers.empty?
+
+        reentry_key = "#{self.class.name}#call"
+        return if Thread.current[reentry_key] == true
+
+        Thread.current[reentry_key] = true
+        begin
+          sql = payload[:sql].strip
+          sql_upper = sql.upcase
+
+          return unless WHITELIST.find { |keyword| sql_upper.index(keyword) == 0 }
+
+          # 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::Trace.tracers.record_event(call)
+          AppMap::Trace.tracers.record_event(SQLReturn.new(__FILE__, __LINE__, call.id, finished - started))
+        ensure
+          Thread.current[reentry_key] = nil
+        end
+      end
+
+      WHITELIST = %w[SELECT INSERT UPDATE DELETE].freeze
+    end
+  end
+end

data/lib/appmap/railtie.rb

@@ -0,0 +1,32 @@
+module AppMap
+  class Railtie < ::Rails::Railtie
+    config.appmap = ActiveSupport::OrderedOptions.new
+
+    initializer 'appmap.trace' do |app|
+      lambda do
+        return unless app.config.appmap.enabled
+
+        require 'appmap'
+        require 'appmap/config'
+        config = AppMap::Config.load_from_file 'appmap.yml'
+
+        require 'appmap/command/record'
+        require 'json'
+        AppMap::Command::Record.new(config).perform do |features, events|
+          File.open('appmap.json', 'w').write JSON.generate(classMap: features, events: events)
+        end
+      end.call
+    end
+
+    initializer 'appmap.subscribe', after: 'appmap.trace' do |_| # params: app
+      lambda do
+        require 'appmap/rails/sql_handler'
+        require 'appmap/rails/action_handler'
+        ActiveSupport::Notifications.subscribe('sql.sequel', AppMap::Rails::SQLHandler.new)
+        ActiveSupport::Notifications.subscribe('sql.active_record', AppMap::Rails::SQLHandler.new)
+        ActiveSupport::Notifications.subscribe('start_processing.action_controller', AppMap::Rails::ActionHandler::HTTPServerRequest.new)
+        ActiveSupport::Notifications.subscribe('process_action.action_controller', AppMap::Rails::ActionHandler::HTTPServerResponse.new)
+      end.call
+    end
+  end
+end

data/lib/appmap/rspec/parse_node.rb

@@ -0,0 +1,41 @@
+require 'forwardable'
+
+module AppMap
+  module RSpec
+    # ParseNodeStruct wraps a generic AST parse node.
+    ParseNodeStruct = Struct.new(:node, :file_path, :ancestors) do
+    end
+
+    # ParseNode wraps a generic AST parse node.
+    class ParseNode < ParseNodeStruct
+      extend Forwardable
+
+      def_delegators :node, :type, :location
+
+      class << self
+        # Build a ParseNode from an AST node.
+        def from_node(node, file_path, ancestors)
+          case node.type
+          when :block
+            BlockParseNode.new(node, file_path, ancestors.dup)
+          end
+        end
+      end
+    end
+
+    # A Ruby block.
+    class BlockParseNode < ParseNode
+      def to_s
+        "RSpec block at #{file_path} #{first_line}:#{last_line}"
+      end
+
+      def first_line
+        node.location.first_line
+      end
+
+      def last_line
+        node.location.last_line
+      end
+    end
+  end
+end

data/lib/appmap/rspec/parser.rb

@@ -0,0 +1,15 @@
+require 'appmap/parser'
+require 'appmap/rspec/parse_node'
+
+module AppMap
+  module RSpec
+    # Parser processes a Ruby into a list of parse nodes and a list of comments.
+    class Parser < ::AppMap::Parser
+      protected
+
+      def build_parse_node(node, file_path, ancestors)
+        ParseNode.from_node(node, file_path, ancestors)
+      end
+    end
+  end
+end