appmap 0.48.0 → 0.51.0

data/lib/appmap/config.rb

@@ -167,8 +167,10 @@ module AppMap
       ),
       package_hooks('actionpack',
         [
-          method_hook('ActionDispatch::Request::Session', %i[destroy [] dig values []= clear update delete fetch merge], %w[http.session]),
-          method_hook('ActionDispatch::Cookies::CookieJar', %i[[]= clear update delete recycle], %w[http.session]),
+          method_hook('ActionDispatch::Request::Session', %i[[] dig values fetch], %w[http.session.read]),
+          method_hook('ActionDispatch::Request::Session', %i[destroy[]= clear update delete merge], %w[http.session.write]),
+          method_hook('ActionDispatch::Cookies::CookieJar', %i[[]= clear update delete recycle], %w[http.session.read]),
+          method_hook('ActionDispatch::Cookies::CookieJar', %i[[]= clear update delete recycle], %w[http.session.write]),
           method_hook('ActionDispatch::Cookies::EncryptedCookieJar', %i[[]= clear update delete recycle], %w[http.cookie crypto.encrypt])
         ],
         package_name: 'action_dispatch'
@@ -213,15 +215,22 @@ module AppMap
       # This is happening: Method send_command not found on Net::IMAP
       # 'Net::IMAP' => TargetMethods.new(:send_command, Package.build_from_path('net/imap', package_name: 'net/imap', labels: %w[protocol.email.imap])),
       # 'Marshal' => TargetMethods.new(%i[dump load], Package.build_from_path('marshal', labels: %w[format.marshal])),
-      'Psych' => TargetMethods.new(%i[dump dump_stream load load_stream parse parse_stream], Package.build_from_path('yaml', package_name: 'psych', labels: %w[format.yaml])),
-      'JSON::Ext::Parser' => TargetMethods.new(:parse, Package.build_from_path('json', package_name: 'json', labels: %w[format.json])),
-      'JSON::Ext::Generator::State' => TargetMethods.new(:generate, Package.build_from_path('json', package_name: 'json', labels: %w[format.json])),
+      'Psych' => [
+        TargetMethods.new(%i[load load_stream parse parse_stream], Package.build_from_path('yaml', package_name: 'psych', labels: %w[format.yaml.parse])),
+        TargetMethods.new(%i[dump dump_stream], Package.build_from_path('yaml', package_name: 'psych', labels: %w[format.yaml.generate])),
+      ],
+      'JSON::Ext::Parser' => TargetMethods.new(:parse, Package.build_from_path('json', package_name: 'json', labels: %w[format.json.parse])),
+      'JSON::Ext::Generator::State' => TargetMethods.new(:generate, Package.build_from_path('json', package_name: 'json', labels: %w[format.json.generate])),
     }.freeze
 
-    attr_reader :name, :packages, :exclude, :hooked_methods, :builtin_hooks
+    attr_reader :name, :appmap_dir, :packages, :exclude, :hooked_methods, :builtin_hooks
 
-    def initialize(name, packages, exclude: [], functions: [])
+    def initialize(name,
+      packages: [],
+      exclude: [],
+      functions: [])
       @name = name
+      @appmap_dir = AppMap::DEFAULT_APPMAP_DIR
       @packages = packages
       @hook_paths = Set.new(packages.map(&:path))
       @exclude = exclude
@@ -248,38 +257,119 @@ module AppMap
     class << self
       # Loads configuration data from a file, specified by the file name.
       def load_from_file(config_file_name)
-        require 'yaml'
-        load YAML.safe_load(::File.read(config_file_name))
+        logo = lambda do
+          Util.color(<<~LOGO, :magenta)
+             ___             __  ___
+            / _ | ___  ___  /  |/  /__ ____
+           / __ |/ _ \\/ _ \\/ /|_/ / _ `/ _ \\
+          /_/ |_/ .__/ .__/_/  /_/\\_,_/ .__/
+               /_/  /_/              /_/
+          LOGO
+        end
+
+        config_present = true if File.exists?(config_file_name)
+
+        config_data = if config_present
+          require 'yaml'
+          YAML.safe_load(::File.read(config_file_name))
+        else
+          warn logo.()
+          warn ''
+          warn Util.color(%Q|NOTICE: The AppMap config file #{config_file_name} was not found!|, :magenta, bold: true)
+          warn ''
+          warn Util.color(<<~MISSING_FILE_MSG, :magenta)
+          AppMap uses this file to customize its behavior. For example, you can use
+          the 'packages' setting to indicate which local file paths and dependency
+          gems you want to include in the AppMap. Since you haven't provided specific
+          settings, the appmap gem will try and guess some reasonable defaults.
+          To suppress this message, create the file:
+          
+          #{Pathname.new(config_file_name).expand_path}.
+          
+          Here are the default settings that will be used in the meantime. You can
+          copy and paste this example to start your appmap.yml.
+          MISSING_FILE_MSG
+          {}
+        end
+        load(config_data).tap do |config|
+          config_yaml = {
+            'name' => config.name,
+            'packages' => config.packages.select{|p| p.path}.map do |pkg|
+              { 'path' => pkg.path }
+            end,
+            'exclude' => []
+          }.compact
+          unless config_present
+            warn Util.color(YAML.dump(config_yaml), :magenta)
+            warn logo.()
+          end
+        end
       end
 
       # Loads configuration from a Hash.
       def load(config_data)
-        functions = (config_data['functions'] || []).map do |function_data|
-          package = function_data['package']
-          cls = function_data['class']
-          functions = function_data['function'] || function_data['functions']
-          raise 'AppMap class configuration should specify package, class and function(s)' unless package && cls && functions
-          functions = Array(functions).map(&:to_sym)
-          labels = function_data['label'] || function_data['labels']
-          labels = Array(labels).map(&:to_s) if labels
-          Function.new(package, cls, labels, functions)
+        name = config_data['name'] || guess_name
+        config_params = {
+          exclude: config_data['exclude']
+        }.compact
+
+        if config_data['functions']
+          config_params[:functions] = config_data['functions'].map do |function_data|
+            package = function_data['package']
+            cls = function_data['class']
+            functions = function_data['function'] || function_data['functions']
+            raise %q(AppMap config 'function' element should specify 'package', 'class' and 'function' or 'functions') unless package && cls && functions
+
+            functions = Array(functions).map(&:to_sym)
+            labels = function_data['label'] || function_data['labels']
+            labels = Array(labels).map(&:to_s) if labels
+            Function.new(package, cls, labels, functions)
+          end
         end
-        packages = (config_data['packages'] || []).map do |package|
-          gem = package['gem']
-          path = package['path']
-          raise 'AppMap package configuration should specify gem or path, not both' if gem && path
-
-          if gem
-            shallow = package['shallow']
-            # shallow is true by default for gems
-            shallow = true if shallow.nil?
-            Package.build_from_gem(gem, exclude: package['exclude'] || [], shallow: shallow)
+
+        config_params[:packages] = \
+          if config_data['packages']
+            config_data['packages'].map do |package|
+              gem = package['gem']
+              path = package['path']
+              raise %q(AppMap config 'package' element should specify 'gem' or 'path', not both) if gem && path
+
+              if gem
+                shallow = package['shallow']
+                # shallow is true by default for gems
+                shallow = true if shallow.nil?
+                Package.build_from_gem(gem, exclude: package['exclude'] || [], shallow: shallow)
+              else
+                Package.build_from_path(path, exclude: package['exclude'] || [], shallow: package['shallow'])
+              end
+            end.compact
           else
-            Package.build_from_path(path, exclude: package['exclude'] || [], shallow: package['shallow'])
+            Array(guess_paths).map do |path|
+              Package.build_from_path(path)
+            end
           end
-        end.compact
-        exclude = config_data['exclude'] || []
-        Config.new config_data['name'], packages, exclude: exclude, functions: functions
+
+        Config.new name, config_params
+      end
+
+      def guess_name
+        reponame = lambda do
+          next unless File.directory?('.git')
+
+          repo_name = `git config --get remote.origin.url`.strip
+          repo_name.split('/').last.split('.').first unless repo_name == ''
+        end
+        dirname = -> { Dir.pwd.split('/').last }
+
+        reponame.() || dirname.()
+      end
+
+      def guess_paths
+        if defined?(::Rails)
+          %w[app/controllers app/models]
+        elsif File.directory?('lib')
+          %w[lib]
+        end
       end
     end
 
@@ -289,7 +379,7 @@ module AppMap
         packages: packages.map(&:to_h),
         functions: @functions.map(&:to_h),
         exclude: exclude
-      }
+      }.compact
     end
 
     # Determines if methods defined in a file path should possibly be hooked.

data/lib/appmap/event.rb

@@ -213,7 +213,7 @@ module AppMap
                 exception_backtrace = next_exception.backtrace_locations.try(:[], 0)
                 exceptions << {
                   class: best_class_name(next_exception),
-                  message: next_exception.message,
+                  message: display_string(next_exception.message),
                   object_id: next_exception.__id__,
                   path: exception_backtrace&.path,
                   lineno: exception_backtrace&.lineno

data/lib/appmap/hook.rb

@@ -36,7 +36,7 @@ module AppMap
 
     def initialize(config)
       @config = config
-      @trace_locations = []
+      @trace_enabled = []
       # Paths that are known to be non-tracing
       @notrace_paths = Set.new
     end
@@ -47,10 +47,8 @@ module AppMap
 
       hook_builtins
 
-      @trace_begin = TracePoint.new(:class, &method(:trace_class))
       @trace_end = TracePoint.new(:end, &method(:trace_end))
-
-      @trace_begin.enable(&block)
+      @trace_end.enable(&block)
     end
 
     # hook_builtins builds hooks for code that is built in to the Ruby standard library.
@@ -96,29 +94,22 @@ module AppMap
 
     protected
 
-    def trace_class(trace_point)
-      path = trace_point.path
-
-      return if @notrace_paths.member?(path)
-
-      if config.path_enabled?(path)
-        location = trace_location(trace_point)
-        warn "Entering hook-enabled location #{location}" if Hook::LOG || Hook::LOG_HOOK
-        @trace_locations << location
-        unless @trace_end.enabled?
-          warn "Enabling hooking" if Hook::LOG || Hook::LOG_HOOK
-          @trace_end.enable
-        end
-      else
-        @notrace_paths << path
-      end
-    end
-
     def trace_location(trace_point)
       [ trace_point.path, trace_point.lineno ].join(':')
     end
 
     def trace_end(trace_point)
+      location = trace_location(trace_point)
+      warn "Class or module ends at location #{trace_location(trace_point)}" if Hook::LOG || Hook::LOG_HOOK
+
+      path = trace_point.path
+      enabled = !@notrace_paths.member?(path) && config.path_enabled?(path)
+      if !enabled
+        warn "Not hooking - path is not enabled" if Hook::LOG || Hook::LOG_HOOK
+        @notrace_paths << path
+        return
+      end
+
       cls = trace_point.self
 
       instance_methods = cls.public_instance_methods(false) - OBJECT_INSTANCE_METHODS
@@ -151,7 +142,8 @@ module AppMap
           warn "AppMap: Examining #{hook_cls} #{method.name}" if LOG
 
           disasm = RubyVM::InstructionSequence.disasm(method)
-          # Skip methods that have no instruction sequence, as they are obviously trivial.
+          # Skip methods that have no instruction sequence, as they are either have no body or they are or native.
+          # TODO: Figure out how to tell the difference?
           next unless disasm
 
           package = config.lookup_package(hook_cls, method)
@@ -170,13 +162,6 @@ module AppMap
         #   uninitialized constant Faraday::Connection
         warn "NameError in #{__FILE__}: #{$!.message}"
       end
-
-      location = @trace_locations.pop
-      warn "Leaving hook-enabled location #{location}" if Hook::LOG || Hook::LOG_HOOK
-      if @trace_locations.empty?
-        warn "Disabling hooking" if Hook::LOG || Hook::LOG_HOOK
-        @trace_end.disable
-      end
     end
   end
 end

data/lib/appmap/minitest.rb

@@ -54,15 +54,21 @@ module AppMap
 
     @recordings_by_test = {}
     @event_methods = Set.new
+    @recording_count = 0
 
     class << self
       def init
-        warn 'Configuring AppMap recorder for Minitest'
-
         FileUtils.mkdir_p APPMAP_OUTPUT_DIR
       end
 
+      def first_recording?
+        @recording_count == 0
+      end
+
       def begin_test(test, name)
+        AppMap.info 'Configuring AppMap recorder for Minitest' if first_recording?
+        @recording_count += 1
+
         @recordings_by_test[test.object_id] = Recording.new(test, name)
       end
 
@@ -98,7 +104,7 @@ module AppMap
           if exception
             m[:exception] = {
               class: exception.class.name,
-              message: exception.to_s
+              message: AppMap::Event::MethodEvent.display_string(exception.to_s)
             }
           end
         end

data/lib/appmap/railtie.rb

@@ -3,6 +3,13 @@
 module AppMap
   # Railtie connects the AppMap recorder to Rails-specific features.
   class Railtie < ::Rails::Railtie
+    initializer 'appmap.remote_recording' do
+      require 'appmap/middleware/remote_recording'
+      Rails.application.config.middleware.insert_after \
+        Rails::Rack::Logger,
+        AppMap::Middleware::RemoteRecording
+    end
+
     # appmap.subscribe subscribes to ActiveSupport Notifications so that they can be recorded as
     # AppMap events.
     initializer 'appmap.subscribe' do |_| # params: app

data/lib/appmap/rspec.rb

@@ -139,15 +139,21 @@ module AppMap
 
     @recordings_by_example = {}
     @event_methods = Set.new
+    @recording_count = 0
 
     class << self
       def init
-        warn 'Configuring AppMap recorder for RSpec'
-
         FileUtils.mkdir_p APPMAP_OUTPUT_DIR
       end
 
+      def first_recording?
+        @recording_count == 0
+      end
+
       def begin_spec(example)
+        AppMap.info 'Configuring AppMap recorder for RSpec' if first_recording?
+        @recording_count += 1
+
         @recordings_by_example[example.object_id] = Recording.new(example)
       end
 
@@ -183,7 +189,7 @@ module AppMap
           if exception
             m[:exception] = {
               class: exception.class.name,
-              message: exception.to_s
+              message: AppMap::Event::MethodEvent.display_string(exception.to_s)
             }
           end
         end

data/lib/appmap/util.rb

@@ -1,7 +1,24 @@
 # frozen_string_literal: true
 
+require 'bundler'
+
 module AppMap
   module Util
+    # https://wynnnetherland.com/journal/a-stylesheet-author-s-guide-to-terminal-colors/
+    # Embed in a String to clear all previous ANSI sequences.
+    CLEAR   = "\e[0m"
+    BOLD    = "\e[1m"
+
+    # Colors
+    BLACK   = "\e[30m"
+    RED     = "\e[31m"
+    GREEN   = "\e[32m"
+    YELLOW  = "\e[33m"
+    BLUE    = "\e[34m"
+    MAGENTA = "\e[35m"
+    CYAN    = "\e[36m"
+    WHITE   = "\e[37m"
+
     class << self
       # scenario_filename builds a suitable file name from a scenario name.
       # Special characters are removed, and the file name is truncated to fit within
@@ -94,7 +111,7 @@ module AppMap
       end
 
       def normalize_path(path)
-        if path.index(Dir.pwd) == 0
+        if path.index(Dir.pwd) == 0 && !path.index(Bundler.bundle_path.to_s)
           path[Dir.pwd.length + 1..-1]
         else
           path
@@ -126,6 +143,12 @@ module AppMap
           FileUtils.mv tempfile.path, filename
         end
       end
+
+      def color(text, color, bold: false)
+        color = Util.const_get(color.to_s.upcase) if color.is_a?(Symbol)
+        bold  = bold ? BOLD : ""
+        "#{bold}#{color}#{text}#{CLEAR}"
+      end
     end
   end
 end

data/lib/appmap/version.rb

@@ -3,7 +3,9 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.48.0'
+  VERSION = '0.51.0'
 
   APPMAP_FORMAT_VERSION = '1.5.1'
+
+  DEFAULT_APPMAP_DIR = 'tmp/appmap'.freeze
 end

data/spec/abstract_controller_base_spec.rb

@@ -1,9 +1,30 @@
 require 'rails_spec_helper'
 
 describe 'Rails' do
+  shared_context 'rails integration test setup' do
+    def tmpdir
+      'tmp/spec/AbstractControllerBase'
+    end
+
+    unless use_existing_data?
+      before(:all) do
+        FileUtils.rm_rf tmpdir
+        FileUtils.mkdir_p tmpdir
+        run_spec 'spec/controllers/users_controller_spec.rb'
+        run_spec 'spec/controllers/users_controller_api_spec.rb'
+      end
+    end
+
+    let(:appmap) { JSON.parse File.read File.join tmpdir, 'appmap/rspec', appmap_json_file }
+    let(:appmap_json_path) { File.join(tmpdir, 'appmap/rspec', appmap_json_file) }
+    let(:appmap) { JSON.parse File.read(appmap_json_path) }
+    let(:events) { appmap['events'] }
+  end
+
   %w[5 6].each do |rails_major_version| # rubocop:disable Metrics/BlockLength
     context "#{rails_major_version}" do
       include_context 'Rails app pg database', "spec/fixtures/rails#{rails_major_version}_users_app" unless use_existing_data?
+      include_context 'rails integration test setup'
 
       def run_spec(spec_name)
         cmd = <<~CMD.gsub "\n", ' '
@@ -13,24 +34,6 @@ describe 'Rails' do
         run_cmd cmd, chdir: fixture_dir
       end
 
-      def tmpdir
-        'tmp/spec/AbstractControllerBase'
-      end
-
-      unless use_existing_data?
-        before(:all) do
-          FileUtils.rm_rf tmpdir
-          FileUtils.mkdir_p tmpdir
-          run_spec 'spec/controllers/users_controller_spec.rb'
-          run_spec 'spec/controllers/users_controller_api_spec.rb'
-        end
-      end
-
-      let(:appmap) { JSON.parse File.read File.join tmpdir, 'appmap/rspec', appmap_json_file }
-      let(:appmap_json_path) { File.join(tmpdir, 'appmap/rspec', appmap_json_file) }
-      let(:appmap) { JSON.parse File.read(appmap_json_path) }
-      let(:events) { appmap['events'] }
-
       describe 'an API route' do
         describe 'creating an object' do
           let(:appmap_json_file) do
@@ -253,4 +256,40 @@ describe 'Rails' do
       end
     end
   end
+
+  describe 'with default appmap.yml' do
+    include_context 'Rails app pg database', "spec/fixtures/rails5_users_app" unless use_existing_data?
+    include_context 'rails integration test setup'
+
+    def run_spec(spec_name)
+      cmd = <<~CMD.gsub "\n", ' '
+        docker-compose run --rm -e RAILS_ENV=test -e APPMAP=true -e APPMAP_CONFIG_FILE=no/such/file
+        -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec #{spec_name}
+      CMD
+      run_cmd cmd, chdir: fixture_dir
+    end
+
+    let(:appmap_json_file) do
+      'Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json'
+    end
+
+    it 'http_server_request is recorded' do
+      expect(events).to include(
+        hash_including(
+          'http_server_request' => hash_including(
+            'request_method' => 'POST',
+            'path_info' => '/api/users'
+          )
+        )
+      )
+    end
+
+    it 'controller method is recorded' do
+      expect(events).to include hash_including(
+        'defined_class' => 'Api::UsersController',
+        'method_id' => 'build_user',
+        'path' => 'app/controllers/api/users_controller.rb',
+      )
+    end
+  end
 end