appmap 0.48.2 → 0.51.2

data/lib/appmap.rb

@@ -27,7 +27,7 @@ module AppMap
     # Gets the configuration. If there is no configuration, the default
     # configuration is initialized.
     def configuration
-      @configuration ||= initialize
+      @configuration ||= initialize_configuration
     end
 
     # Sets the configuration. This is only expected to happen once per
@@ -38,19 +38,34 @@ module AppMap
       @configuration = config
     end
 
-    # Configures AppMap for recording. Default behavior is to configure from "appmap.yml".
+    def default_config_file_path
+      ENV['APPMAP_CONFIG_FILE'] || 'appmap.yml'
+    end
+
+    # Configures AppMap for recording. Default behavior is to configure from
+    # APPMAP_CONFIG_FILE, or 'appmap.yml'. If no config file is available, a
+    # configuration will be automatically generated and used - and the user is prompted
+    # to create the config file.
+    #
     # This method also activates the code hooks which record function calls as trace events.
     # Call this function before the program code is loaded by the Ruby VM, otherwise
     # the load events won't be seen and the hooks won't activate.
-    def initialize(config_file_path = 'appmap.yml')
-      raise "AppMap configuration file #{config_file_path} does not exist" unless ::File.exists?(config_file_path)
-      warn "Configuring AppMap from path #{config_file_path}"
+    def initialize_configuration(config_file_path = default_config_file_path)
+      startup_message "Configuring AppMap from path #{config_file_path}"
       Config.load_from_file(config_file_path).tap do |configuration|
         self.configuration = configuration
         Hook.new(configuration).enable
       end
     end
 
+    def info(msg)
+      if defined?(::Rails) && defined?(::Rails.logger)
+        ::Rails.logger.info msg
+      else
+        warn msg
+      end
+    end
+
     # Used to start tracing, stop tracing, and record events.
     def tracing
       @tracing ||= Trace::Tracing.new
@@ -94,8 +109,60 @@ module AppMap
       @metadata ||= Metadata.detect.freeze
       @metadata.deep_dup
     end
+
+    def startup_message(msg)
+      if defined?(::Rails) && defined?(::Rails.logger) && ::Rails.logger
+        ::Rails.logger.debug msg
+      elsif ENV['DEBUG'] == 'true'
+        warn msg
+      end
+    end
   end
 end
 
-require 'appmap/railtie' if defined?(::Rails::Railtie)
-AppMap.initialize if ENV['APPMAP'] == 'true'
+lambda do
+  Initializer = Struct.new(:class_name, :module_name, :gem_module_name)
+
+  INITIALIZERS = {
+    'Rails::Railtie' => Initializer.new('AppMap::Railtie', 'appmap/railtie', 'railtie'),
+    'RSpec' => Initializer.new('AppMap::RSpec', 'appmap/rspec', 'rspec-core'),
+    'Minitest::Unit::TestCase' => Initializer.new('AppMap::Minitest', 'appmap/minitest', 'minitest')
+  }
+
+  TracePoint.new(:class) do |tp|
+    cls_name = tp.self.name
+    initializers = INITIALIZERS.delete(cls_name)
+    if initializers
+      initializers = [ initializers ] unless initializers.is_a?(Array)
+      next if Object.const_defined?(initializers.first.class_name)
+
+      gem_module_name = initializers.first.gem_module_name
+
+      AppMap.startup_message AppMap::Util.color(<<~LOAD_MSG, :magenta)
+      When 'appmap' was loaded, '#{gem_module_name}' had not been loaded yet. Now '#{gem_module_name}' has
+      just been loaded, so the following AppMap modules will be automatically required:
+
+      #{initializers.map(&:module_name).join("\n")}
+
+      To suppress this message, ensure '#{gem_module_name}' appears before 'appmap' in your Gemfile.
+      LOAD_MSG
+      initializers.each do |init|
+        require init.module_name
+      end
+    end
+  end.enable
+
+  if defined?(::Rails::Railtie)
+    require 'appmap/railtie'
+  end
+  
+  if defined?(::RSpec)
+    require 'appmap/rspec'
+  end
+  
+  if defined?(::Minitest)
+    require 'appmap/minitest'
+  end
+end.call
+
+AppMap.initialize_configuration if ENV['APPMAP'] == 'true'

data/lib/appmap/command/init.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'appmap/service/guesser'
+require 'appmap/util'
+
+module AppMap
+  module Command
+    InitStruct = Struct.new(:config_file)
+
+    class Init < InitStruct
+      def perform
+        if File.exist?(config_file)
+          puts AppMap::Util.color(%(The AppMap config file #{config_file} already exists.), :magenta)
+          return
+        end
+
+        ensure_directory_exists
+
+        config = {
+          'name' => Service::Guesser.guess_name,
+          'packages' => Service::Guesser.guess_paths.map { |path| { 'path' => path } }
+        }
+        content = YAML.dump(config).gsub("---\n", '')
+
+        File.write(config_file, content)
+        puts AppMap::Util.color(
+          %(The following AppMap config file #{config_file} has been created:),
+          :green
+        )
+        puts content
+      end
+
+      private
+
+      def ensure_directory_exists
+        dirname = File.dirname(config_file)
+        FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+      end
+    end
+  end
+end

data/lib/appmap/config.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require 'yaml'
 require 'appmap/handler/net_http'
 require 'appmap/handler/rails/template'
+require 'appmap/service/guesser'
 
 module AppMap
   class Config
@@ -167,8 +169,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 +217,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 +259,98 @@ 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
+          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'] || Service::Guesser.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(Service::Guesser.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
     end
 
@@ -289,7 +360,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/handler/rails/template.rb

@@ -14,16 +14,30 @@ module AppMap
         # The class name is generated from the template path. The package name is
         # 'app/views', and the method name is 'render'. The source location of the method
         # is, of course, the path to the view template.
-        TemplateMethod = Struct.new(:path) do
-          private_instance_methods :path
+        class TemplateMethod
           attr_reader :class_name
- 
+
+          attr_reader :path
+          private_instance_methods :path
+
           def initialize(path)
-            super
+            @path = path
 
             @class_name = path.parameterize.underscore
           end
-  
+
+          def id
+            [ package, path, name ]
+          end
+
+          def hash
+            id.hash
+          end
+
+          def eql?(other)
+            other.is_a?(TemplateMethod) && id.eql?(other.id)
+          end
+
           def package
             'app/views'
           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
 

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
 

data/lib/appmap/service/guesser.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module AppMap
+  module Service
+    class Guesser
+      POSSIBLE_PATHS = %w[app/controllers app/models lib]
+      class << self
+        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
+          POSSIBLE_PATHS.select { |path| File.directory?(path) }
+        end
+      end
+    end
+  end
+end