gem_footprint_analyzer 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ea3f3ac4a4cdc86a560ae500fdbdc59423afe2d28ac9f16f5fdc7efe5d433fc
-  data.tar.gz: 5baf82c20f15679d84b56f86e303e81325aadbc4577fdcc6bc36a388d0b92baa
+  metadata.gz: 13ad6f4a90d9f22d88152496807371138eecc8456b195ecf63597771c3e5f43d
+  data.tar.gz: 6f78c45ebac12fb4602c61d3ff59b71b9c8dc0dff0fb88a7344ce56506e0c4f1
 SHA512:
-  metadata.gz: 54b934c3cb13d9b564f52abc70adc1286c5842acb2e0c25d178131d6d1e653732f9a1d49df807004fc434089e97f119fbf32ddee75af29e488e1df415b58bbfe
-  data.tar.gz: 50bb084a66ae63808ee91acde1c257cda615cb28cb2ea2ee71463306e7d8ca2b59a3fcf1e4d09d2fe3ebef8e1c6fb12e4440b4a5c3f523a6108b03bf4d44fbdc
+  metadata.gz: 5aa544dacfe1ac6d74622d07ed884e92ddeb40203f460701a2afe05f691bd0df2d495bac22efb3dba8b32d0b678e925ede6d00fbfaf66fe1fcef472c541f83b0
+  data.tar.gz: 52ee797d7c5a24d16effc451eb9d64b5bfd577601767e2efd974d9b7fe013cddceca41d9d89aaffcefb7931f8ac75920869a63fb53e89696dc97b4d169e64459

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gem_footprint_analyzer (0.1.6)
+    gem_footprint_analyzer (0.1.7)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,32 +1,28 @@
 # GemFootprintAnalyzer
 [![Gem Version](https://badge.fury.io/rb/gem_footprint_analyzer.svg)](https://badge.fury.io/rb/gem_footprint_analyzer)
-[![Build Status](https://travis-ci.com/irvingwashington/gem_footprint_analyzer.svg?branch=master)](https://travis-ci.com/irvingwashington/gem_footprint_analyzer)
+[![Build Status](https://api.travis-ci.org/irvingwashington/gem_footprint_analyzer.svg?branch=master)](https://travis-ci.org/irvingwashington/gem_footprint_analyzer)
 
 A tool for analyzing time and RSS footprint of gems or standard library requires.
 Requires Ruby >= 2.2.0, works on Linux and MacOS.
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'gem_footprint_analyzer', require: false
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install gem_footprint_analyzer
-
 ## Usage
 
 You can use this gem with or without Bundler. Using Bundler is more convenient and does not have any
 impact on results, however you have to have `gem_footprint_analyzer` present in your Gemfile
 (use the development section).
 
+Banner
+```bash
+GemFootprintAnalyzer (0.1.6)
+Usage: bundle exec analyze_requires library_to_analyze [require]
+    -f, --formatter FORMATTER        Format output using selected formatter (json tree)
+    -n, --runs-num NUMBER            Number of runs
+    -r, --rubygems                   Require rubygems before the actual analyze
+    -g, --gemfile                    Analyze current Gemfile
+    -d, --debug                      Show debug information
+    -h, --help                       Show this message
+```
+
 1) with Bundler
 ```bash
 # Standard library
@@ -45,6 +41,57 @@ $ analyze_requires net/http
 $ RUBYLIB=/Users/irving/.gem/ruby/2.5.3/gems/activerecord-5.2.1/lib:/Users/irving/.gem/ruby/2.5.3/gems/activesupport-5.2.1/lib/:/Users/irving/.gem/ruby/2.5.3/gems/concurrent-ruby-1.0.5/lib:/Users/irving/.gem/ruby/2.5.3/gems/i18n-1.1.1/lib:/Users/irving/.gem/ruby/2.5.3/gems/activemodel-5.2.1/lib:/Users/irving/.gem/ruby/2.5.3/gems/arel-9.0.0/lib:/Users/irving/.gem/ruby/2.5.3/gems/tzinfo-1.2.5/lib:/Users/irving/.gem/ruby/2.5.3/gems/thread_safe-0.3.6/lib analyze_requries activerecord active_record
 ```
 
+## Analyzing Gemfile
+
+GemFootprintAnalyzer can be used to analyze the whole Gemfile of a given project.
+This way, it is cleary visible which gems take most time or consume most RSS on application start.
+You can also see what kind of impact does adding a new dependency have on the the project footprint.
+As processing of all gems might take a lot of time, it is advisable to set the number of runs to 1.
+
+```bash
+# Analyze the entire Gemfile, with a single run
+irving:~/Workspace/motoperf (master)$ bundle exec analyze_requires -gn1
+GemFootprintAnalyzer (0.1.6)
+
+Analyze results (average measured from 1 run(s))
+time is the amount of time given require has taken to complete
+RSS is total memory increase up to the point after the require
+
+name                          time   RSS after
+--------------------------------------------
+newrelic_rpm                 1540ms  38540KB
+draper                        242ms  31544KB
+activemodel-serializers-xml    46ms  29248KB
+slim                          261ms  29088KB
+dalli                         107ms  26036KB
+bcrypt                         31ms  25872KB
+will_paginate                  45ms  25848KB
+jbuilder                      190ms  25844KB
+jquery-rails                   17ms  25808KB
+uglifier                      135ms  25808KB
+sass-rails                   3379ms  25676KB
+pg                            108ms  13260KB
+rails                        3516ms  12612KB
+
+Total runtime 10.0740s
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'gem_footprint_analyzer', require: false
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gem_footprint_analyzer
+
 ## Example analyses (Ruby 2.5.3):
 
 ### timeout
@@ -397,7 +444,7 @@ Total runtime 0.9878s
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/gem_footprint_analyzer. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/irvingwashington/gem_footprint_analyzer. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 

data/exe/analyze_requires

@@ -3,6 +3,8 @@
 $LOAD_PATH.unshift(File.join(__dir__, '..', 'lib'))
 $LOAD_PATH.unshift('./lib') if Dir.exist?('lib')
 
+require 'bundler/setup' if ENV.key?('BUNDLER_VERSION')
+
 require 'gem_footprint_analyzer'
 
 cli = GemFootprintAnalyzer::CLI.new

data/lib/gem_footprint_analyzer.rb

@@ -4,6 +4,8 @@ require 'gem_footprint_analyzer/child_process'
 require 'gem_footprint_analyzer/analyzer'
 require 'gem_footprint_analyzer/average_runner'
 require 'gem_footprint_analyzer/cli'
+require 'gem_footprint_analyzer/cli/opts'
+require 'gem_footprint_analyzer/cli/utils'
 require 'gem_footprint_analyzer/core_ext/array'
 require 'gem_footprint_analyzer/core_ext/hash'
 require 'gem_footprint_analyzer/core_ext/file'

data/lib/gem_footprint_analyzer/analyzer.rb

@@ -6,18 +6,20 @@ module GemFootprintAnalyzer
   # is gathered in the child process and passed along to the parent.
   class Analyzer
     # @param fifos [Hash<Symbol>] Hash containing filenames of :child and :parent FIFO files
-    def initialize(fifos)
+    def initialize(fifos, options = {})
+      @options = options
       @fifos = fifos
     end
 
-    # @param library [String] name of the library or parameter for the gem method
-    #   (ex. 'activerecord', 'activesupport')
+    # @param library [String|nil] name of the library or parameter for the gem method
+    #   (ex. 'activerecord', 'activesupport').
+    #   Nil if user wants to analyze the whole Gemfile
     # @param require_string [String|nil] optional require string, if it differs from the gem name
     #   (ex. 'active_record', 'active_support/time')
     # @return [Array<Hash>] list of require-data-hashes, first element contains base level RSS,
     #   last element can be treated as a summary as effectively it consists of all the previous.
-    def test_library(library, require_string = nil)
-      child = ChildProcess.new(library, require_string, fifos)
+    def test_library(library = nil, require_string = nil)
+      child = ChildProcess.new(library, require_string, fifos, options)
       child.start_child
       parent_transport = init_transport
       requires = collect_requires(parent_transport, child.pid)
@@ -28,7 +30,7 @@ module GemFootprintAnalyzer
 
     private
 
-    attr_reader :fifos
+    attr_reader :fifos, :options
 
     def collect_requires(transport, process_id)
       requires_context = {base_rss: nil, requires: [], process_id: process_id, transport: transport}

data/lib/gem_footprint_analyzer/child_context.rb

@@ -12,19 +12,18 @@ module GemFootprintAnalyzer
     def initialize
       output Process.pid
       init_transport
+      require_rubygems_if_needed
+      require_bundler_if_needed
     end
 
     # Installs the require-spying code and starts requiring
     def start
       RequireSpy.spy_require(transport)
-      begin
-        require(require_string)
-      rescue LoadError => e
-        warn_about_load_error(e)
-        transport.exit_with_error(e)
-        exit 1
-      end
-      transport.done_and_wait_for_ack
+      error = try_require(require_string)
+      return transport.done_and_wait_for_ack unless error
+
+      transport.exit_with_error(error)
+      exit(1)
     end
 
     private
@@ -43,6 +42,26 @@ module GemFootprintAnalyzer
       ENV['require_string']
     end
 
+    def analyze_gemfile
+      ENV['analyze_gemfile']
+    end
+
+    def require_rubygems
+      ENV['require_rubygems']
+    end
+
+    def try_require(require_string)
+      error = nil
+      begin
+        analyze_gemfile ? Bundler.require : require(require_string)
+      rescue LoadError => error
+        warn_about_load_error(error)
+      rescue Exception => error # rubocop:disable Lint/RescueException
+        warn_about_error(error)
+      end
+      error
+    end
+
     def init_transport
       write_stream = File.open(child_fifo, 'w')
       read_stream = File.open(parent_fifo, 'r')
@@ -55,12 +74,28 @@ module GemFootprintAnalyzer
       STDOUT.flush
     end
 
+    def require_rubygems_if_needed
+      return unless require_rubygems
+
+      require 'rubygems'
+    end
+
+    def require_bundler_if_needed
+      return unless analyze_gemfile
+
+      require 'bundler/setup'
+    end
+
     def warn_about_load_error(error)
       possible_gem = error.message.split.last
       STDERR.puts "Cannot load '#{possible_gem}', this might be an issue with implicit require in" \
         " the '#{require_string}'"
       STDERR.puts "If '#{possible_gem}' is a gem, you can try adding it to the Gemfile explicitly" \
         ", running `bundle install` and trying again\n\n"
+      warn_about_error(error)
+    end
+
+    def warn_about_error(error)
       STDERR.puts error.backtrace
       STDERR.flush
     end

data/lib/gem_footprint_analyzer/child_process.rb

@@ -7,11 +7,12 @@ module GemFootprintAnalyzer
     LEGACY_RUBY_CMD = [RbConfig.ruby, '--disable=gem'].freeze
     RUBY_CMD = [RbConfig.ruby, '--disable=did_you_mean', '--disable=gem'].freeze
 
-    def initialize(library, require_string, fifos)
+    def initialize(library, require_string, fifos, options = {})
       @library = library
       @require_string = require_string || library
       @fifos = fifos
       @pid = nil
+      @options = options
     end
 
     def start_child
@@ -35,7 +36,7 @@ module GemFootprintAnalyzer
 
     private
 
-    attr_reader :require_string, :child_thread, :fifos
+    attr_reader :require_string, :child_thread, :fifos, :options
 
     def ruby_command
       if RbConfig::CONFIG['MAJOR'].to_i >= 2 && RbConfig::CONFIG['MINOR'].to_i >= 3
@@ -48,6 +49,8 @@ module GemFootprintAnalyzer
     def child_env_vars
       {
         'require_string' => require_string,
+        'require_rubygems' => options.key?(:rubygems) && 'true' || nil,
+        'analyze_gemfile' => options.key?(:analyze_gemfile) && 'true' || nil,
         'start_child_context' => 'true',
         'child_fifo' => fifos[:child],
         'parent_fifo' => fifos[:parent],

data/lib/gem_footprint_analyzer/cli.rb

@@ -1,4 +1,3 @@
-require 'optparse'
 require 'tmpdir'
 
 module GemFootprintAnalyzer
@@ -11,16 +10,16 @@ module GemFootprintAnalyzer
       @options[:debug] = false
       @options[:formatter] = 'tree'
 
-      try_require_bundler
+      @opts = Opts.new(@options)
     end
 
     # @param args [Array<String>] runs the analyzer with parsed args taken as options
     # @return [void]
     def run(args = ARGV)
-      opts_parser.parse!(args)
+      opts.parse!(args)
 
-      if args.empty?
-        puts opts_parser
+      if !analyze_gemfile? && args.empty?
+        puts opts.parser
         exit 1
       end
 
@@ -31,18 +30,19 @@ module GemFootprintAnalyzer
 
     def print_requires(options, args)
       requires_list_average = capture_requires(options, args)
-      at_exit { clean_up }
       formatter = formatter_instance(options)
-      puts formatter.new(options).format_list(requires_list_average)
+      output = formatter.new(options).format_list(requires_list_average)
+
+      Utils.safe_puts(output)
     end
 
-    attr_reader :options
+    attr_reader :options, :opts
 
     def capture_requires(options, args)
       GemFootprintAnalyzer::AverageRunner.new(options[:runs]) do
         fifos = init_fifos
 
-        GemFootprintAnalyzer::Analyzer.new(fifos).test_library(*args).tap do
+        GemFootprintAnalyzer::Analyzer.new(fifos, options).test_library(*args).tap do
           clean_up_fifos(fifos)
         end
       end.run
@@ -68,60 +68,8 @@ module GemFootprintAnalyzer
       GemFootprintAnalyzer::Formatters.const_get(options[:formatter].capitalize)
     end
 
-    def opts_parser # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      @opts_parser ||= OptionParser.new do |opts|
-        opts.banner = banner
-        opts.on('-f', '--formatter FORMATTER', %w[json tree],
-                'Format output using selected formatter (json tree)') do |formatter|
-
-          options[:formatter] = formatter
-        end
-
-        opts.on('-n', '--runs-num NUMBER', OptParse::DecimalInteger, 'Number of runs') do |runs|
-          fail OptionParser::InvalidArgument, 'must be a number greater than 0' if runs < 1
-
-          options[:runs] = runs
-        end
-
-        opts.on('-d', '--debug', 'Show debug information') do |debug|
-          opts.banner += debug_banner if debug
-
-          options[:debug] = debug
-        end
-
-        opts.on_tail('-h', '--help', 'Show this message') do
-          puts opts
-          exit
-        end
-      end
-    end
-
-    def banner
-      script_name = "bundle exec #{File.basename($PROGRAM_NAME)}"
-
-      "GemFootprintAnalyzer (#{GemFootprintAnalyzer::VERSION})\n" \
-        "Usage: #{script_name} library_to_analyze [require]"
-    end
-
-    def debug_banner
-      "\n(#{File.expand_path(File.join(File.dirname(__FILE__), '..'))})"
-    end
-
-    def clean_up
-      fork_waiters = Thread.list.select { |th| th.is_a?(Process::Waiter) }
-      fork_waiters.each do |waiter|
-        begin
-          Process.kill('TERM', waiter.pid)
-        rescue Errno::ESRCH
-          nil
-        end
-      end
-    end
-
-    def try_require_bundler
-      require 'bundler/setup'
-    rescue LoadError
-      nil
+    def analyze_gemfile?
+      options[:analyze_gemfile]
     end
   end
 end

data/lib/gem_footprint_analyzer/cli/opts.rb

@@ -0,0 +1,87 @@
+require 'optparse'
+
+module GemFootprintAnalyzer
+  class CLI
+    # A class dealing with command line options parsing, validation and displaying banner and
+    # help messages.
+    class Opts
+      # @param options [Hash<Symbol>]
+      def initialize(options)
+        @options = options
+      end
+
+      # @param args [Array<String>]
+      def parse!(args)
+        parser.parse!(args)
+      end
+
+      # @return [OptionParser]
+      def parser # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        @parser ||= OptionParser.new do |opts|
+          opts.banner = banner
+          opts.on('-f', '--formatter FORMATTER', %w[json tree],
+                  'Format output using selected formatter (json tree)') do |formatter|
+
+            options[:formatter] = formatter
+          end
+
+          opts.on('-n', '--runs-num NUMBER', OptParse::DecimalInteger, 'Number of runs') do |runs|
+            fail OptionParser::InvalidArgument, 'must be a number greater than 0' if runs < 1
+
+            options[:runs] = runs
+          end
+
+          opts.on('-r', '--rubygems', 'Require rubygems before the actual analyze') do |rubygems|
+            options[:rubygems] = rubygems
+          end
+
+          opts.on('-g', '--gemfile', 'Analyze current Gemfile') do
+            validate_bundler_presence
+
+            options[:rubygems] = true
+            options[:analyze_gemfile] = true
+          end
+
+          opts.on('-d', '--debug', 'Show debug information') do |debug|
+            opts.banner += debug_banner if debug
+
+            options[:debug] = debug
+          end
+
+          opts.on_tail('-h', '--help', 'Show this message') do
+            puts opts
+            exit
+          end
+        end
+      end
+
+      attr_reader :options
+
+      def banner
+        script_name = "bundle exec #{File.basename($PROGRAM_NAME)}"
+
+        "GemFootprintAnalyzer (#{GemFootprintAnalyzer::VERSION})\n" \
+          "Usage: #{script_name} library_to_analyze [require]"
+      end
+
+      def debug_banner
+        "\n(#{File.expand_path(File.join(File.dirname(__FILE__), '..'))})"
+      end
+
+      def validate_bundler_presence
+        require 'rubygems'
+        require 'bundler/setup'
+
+        Bundler.root
+      rescue LoadError => e
+        puts "Bundler gem is not available, please install it first (#{e})"
+
+        exit 1
+      rescue GemfileNotFound => e
+        puts "No Gemfile found (#{e})"
+
+        exit 1
+      end
+    end
+  end
+end

data/lib/gem_footprint_analyzer/cli/utils.rb

@@ -0,0 +1,16 @@
+module GemFootprintAnalyzer
+  class CLI
+    # A module containing helper methods for CLI
+    module Utils
+      def self.safe_puts(output)
+        output ||= "\n"
+
+        string_output = output.is_a?(String) ? output : output.join("\n")
+
+        puts string_output
+      rescue Errno::EPIPE
+        exit
+      end
+    end
+  end
+end

data/lib/gem_footprint_analyzer/formatters/json.rb

@@ -3,12 +3,12 @@ module GemFootprintAnalyzer
     # A formatter class outputting bare JSON.
     # Useful for integrating with other tools.
     class Json
-      require 'json'
-
       def initialize(*); end
 
       # @return [String] A JSON form of the requires_list array, last entry is the cumulated result.
       def format_list(requires_list)
+        require 'json'
+
         JSON.dump(requires_list)
       end
     end

data/lib/gem_footprint_analyzer/formatters/text_base.rb

@@ -16,8 +16,8 @@ module GemFootprintAnalyzer
         lines << "Analyze results (average measured from #{@options[:runs]} run(s))"
         lines << 'time is the amount of time given require has taken to complete'
         lines << 'RSS is total memory increase up to the point after the require'
-        lines << "\n"
-        lines.join("\n")
+        lines << ''
+        lines
       end
 
       # @return [String] Awesome text separator

data/lib/gem_footprint_analyzer/formatters/tree.rb

@@ -7,6 +7,8 @@ module GemFootprintAnalyzer
       INDENT = '  '.freeze
       # Formatter helper class representing a single results require entry.
       class Entry
+        BUNDLER_RUNTIME = 'bundler/runtime'.freeze
+
         def initialize(entry_hash, options = {})
           @entry_hash = entry_hash
           @options = options
@@ -34,6 +36,10 @@ module GemFootprintAnalyzer
           "#{name}#{debug_parent}"
         end
 
+        def top_level?
+          parent.nil? || parent == BUNDLER_RUNTIME
+        end
+
         private
 
         def debug_parent
@@ -62,7 +68,7 @@ module GemFootprintAnalyzer
           format_entry(entry, indent_level, ljust_value)
         end
 
-        (legend(ljust_value) + lines).join("\n")
+        (legend(ljust_value) + lines)
       end
 
       def legend(ljust_value)
@@ -81,9 +87,13 @@ module GemFootprintAnalyzer
       end
 
       def init_entries(requires_list)
-        requires_list.last(requires_list.size - 1).map do |entry_hash|
+        entries = requires_list.last(requires_list.size - 1).map do |entry_hash|
           Entry.new(entry_hash, @options)
         end
+
+        entries.select!(&:top_level?) if @options[:analyze_gemfile]
+
+        entries
       end
 
       def max_indent(entries)

data/lib/gem_footprint_analyzer/require_spy.rb

@@ -2,6 +2,10 @@ module GemFootprintAnalyzer
   # A module keeping hacks required to hijack {Kernel.require} and {Kernel.require_relative}
   # and plug in versions of them that communicate meta data to the {Analyzer}.
   module RequireSpy
+    # Suitable for versions 3.0.stable up to 5.2.1
+    ACTIVESUPPORT_REQUIRE_DEPENDENCY =
+      %r{active_support/dependencies\.rb.+(`require'|`load_dependency'|`block in require')\z}.freeze
+
     class << self
       def relative_path(caller_entry, require_name = nil)
         caller_file = caller_entry.split(':')[0]
@@ -11,67 +15,81 @@ module GemFootprintAnalyzer
         else
           full_path = caller_file
         end
-        load_path = $LOAD_PATH.find { |lp| full_path.start_with?(lp) }
+        load_path = load_paths.find { |lp| full_path.start_with?(lp) }
         full_path.sub(%r{\A#{load_path}/}, '')
       end
 
+      def load_paths
+        @load_paths ||= $LOAD_PATH.map { |path| File.expand_path(path) }
+      end
+
       def without_extension(name)
         name.sub(/\.rb\z/, '')
       end
 
       def first_foreign_caller(caller_list)
         ffc = caller_list.find do |c|
-          relative_path(c) !~ /gem_footprint_analyzer/
+          c !~ ACTIVESUPPORT_REQUIRE_DEPENDENCY &&
+            relative_path(c) !~ /gem_footprint_analyzer/
         end
         without_extension(relative_path(ffc)) if ffc
       end
 
       def spy_require(transport)
         alias_require_methods
-        define_timed_exec
 
-        define_require_relative
-        define_require(transport)
+        define_require_relatives
+        define_requires(transport)
       end
 
-      def alias_require_methods
-        Kernel.send :alias_method, :regular_require, :require
-        Kernel.send :alias_method, :regular_require_relative, :require_relative
+      def timed_exec
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result = yield
+        duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time).round(4)
+        [duration, result]
       end
 
-      def define_timed_exec
-        Kernel.send :define_method, :timed_exec do |&block|
-          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          block.call
-          (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time).round(4)
+      def alias_require_methods
+        kernels.each do |k|
+          k.send :alias_method, :regular_require, :require
+          k.send :alias_method, :regular_require_relative, :require_relative
         end
       end
 
-      def define_require(transport)
-        Kernel.send :define_method, :require do |name|
-          result = nil
+      def kernels
+        @kernels ||= [(class << ::Kernel; self; end), Kernel]
+      end
+
+      def define_requires(transport)
+        kernels.each { |k| define_require(k, transport) }
+      end
 
-          transport.ready
-          transport.wait_for_start
+      def define_require(klass, transport)
+        klass.send :define_method, :require do |name|
+          transport.ready_and_wait_for_start
+          duration, result = GemFootprintAnalyzer::RequireSpy.timed_exec { regular_require(name) }
+          bare_name = GemFootprintAnalyzer::RequireSpy.relative_path(name)
 
-          t = timed_exec { result = regular_require(name) }
+          transport.report_require(GemFootprintAnalyzer::RequireSpy.without_extension(bare_name),
+                                   GemFootprintAnalyzer::RequireSpy.first_foreign_caller(caller),
+                                   duration)
 
-          first_foreign_caller = GemFootprintAnalyzer::RequireSpy.first_foreign_caller(caller)
-          bare_name = GemFootprintAnalyzer::RequireSpy.without_extension(name)
-          transport.report_require(bare_name, first_foreign_caller || '', t)
           result
         end
       end
 
-      def define_require_relative
+      def define_require_relatives
         # As of Ruby 2.5.1, both :require and :require_relative use an unexposed native method
         # rb_safe_require, however it's challenging to plug into it and using original
         # :require_relative is not really possible (it does path calculation magic) so instead
         # we're redirecting :require_relative to the regular :require
-        Kernel.send :define_method, :require_relative do |name|
-          last_caller = caller(1..1).first
-          relative_path = GemFootprintAnalyzer::RequireSpy.relative_path(last_caller, name)
-          return require(relative_path)
+        kernels.each do |k|
+          k.send :define_method, :require_relative do |name|
+            last_caller = caller(1..1).first
+            relative_path = GemFootprintAnalyzer::RequireSpy.relative_path(last_caller, name)
+
+            require(relative_path)
+          end
         end
       end
     end

data/lib/gem_footprint_analyzer/transport.rb

@@ -24,7 +24,9 @@ module GemFootprintAnalyzer
     end
 
     # Blocks until a :start command is received from the read stream
-    def wait_for_start
+    def ready_and_wait_for_start
+      write_raw_command 'ready'
+
       while (cmd = read_one_command)
         msg, = cmd
         break if msg == :start
@@ -40,11 +42,6 @@ module GemFootprintAnalyzer
       end
     end
 
-    # Sends a ready command
-    def ready
-      write_raw_command 'ready'
-    end
-
     # Sends a start command
     def start
       write_raw_command 'start'
@@ -59,7 +56,7 @@ module GemFootprintAnalyzer
     # @param source [String] Name of the source file that required the library
     # @param duration [Float] Time which it took to complete the require
     def report_require(library, source, duration)
-      write_raw_command "rq: #{library.inspect},#{source.inspect},#{duration.inspect}"
+      write_raw_command "rq: #{library.inspect},#{(source || '').inspect},#{duration.inspect}"
     end
 
     # @param library [String] Name of the library that was required, but was already required before

data/lib/gem_footprint_analyzer/version.rb

@@ -1,3 +1,3 @@
 module GemFootprintAnalyzer
-  VERSION = '0.1.6'.freeze
+  VERSION = '0.1.7'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gem_footprint_analyzer
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Maciek Dubiński
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-15 00:00:00.000000000 Z
+date: 2018-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -102,6 +102,8 @@ files:
 - lib/gem_footprint_analyzer/child_context.rb
 - lib/gem_footprint_analyzer/child_process.rb
 - lib/gem_footprint_analyzer/cli.rb
+- lib/gem_footprint_analyzer/cli/opts.rb
+- lib/gem_footprint_analyzer/cli/utils.rb
 - lib/gem_footprint_analyzer/core_ext/array.rb
 - lib/gem_footprint_analyzer/core_ext/file.rb
 - lib/gem_footprint_analyzer/core_ext/hash.rb