bumbler 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3a7deedba252b3c5836103a614d7e04626aa153be9b35333c3953a25f3fa00d
-  data.tar.gz: 760e452d990cf7e5dd1acde8721965617a7bce7920c0f754dafe35611fe424c4
+  metadata.gz: 5a60e2a6c84fbfe256e680819c7e7782fbe1b02c8719967d98debdf89dcb85ca
+  data.tar.gz: 2c94bb726e5f97523fff0c80674f60119e5b247d62d3d5e047594aa2bacd7835
 SHA512:
-  metadata.gz: 3e26fb2fa428af240918200c18e0eff3aeb21d7a4dc41353293def318201d970113009c068278159158b896fbef19e9fe7f314ef4e4dce230c3d31857168bce1
-  data.tar.gz: 58a116e619d03388c2610f412a54d2da481b62c0061c2ff783ef4b216fd7979e20a14eca494db36e18e7a25e6e853bac273d43e09dd956ed481eaeaf25b55546
+  metadata.gz: f7644c6cdb5b218d01fa3b9c47835a3be6e1a9260dc94d15d9628b021b4653f1330963c7084cba7947e9569858f92174fadd7510a088a0407dfeefde413b7860
+  data.tar.gz: 4f5019ba1b21b83ef31a40be91fe911ad915d0d1030527206476485d81c8342e8db3f7e2c47582d71ffdbedbf4fe5439244f5e8bc774274971b06b2da44b5f95

data/MIT-LICENSE.md

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+=====================
+
+Copyright (c) 2014 Ian MacLeod <ian@nevir.net>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,83 @@
+Bumbler
+=======
+
+Find slow loading gems in your [Bundler](http://gembundler.com/)-based projects!
+
+Bumbler tracks how long the main require of each gem takes,
+for example with `gem 'bar'` it tracks `require 'bar'`. If the gem name and the require name are different,
+add `require:` manually for correct time tracking, for example `gem 'bar-foo', require: 'bar_foo'`.
+This reuquire tracking can sometimes lead to false positives, because of dependencies,
+for example `foo` requires `rails` which leads to `foo` being marked as slow.
+
+For rails projects it loads `config/environment.rb`, for all others it runs `Bundler.require *Bundler.groups`.
+
+```bash
+gem install bumbler
+cd project && bumbler
+```
+
+### Custom entrypoints
+
+Add bumbler to your Gemfile
+```ruby
+gem 'bumbler'
+```
+
+```
+RUBYOPT=-rbumbler/go bundle exec ruby -r./lib/foo.rb -e Bumbler::Stats.print_slow_items
+```
+
+### Custom threshold
+
+Set the minimum number of milliseconds before something slow is listed. For
+example, to show anything >= 10ms:
+
+```bash
+bumbler -t 10
+```
+
+### Rails: Track load-time of initializers
+
+See how slow your app's initializers are (`./config/initializers/*`), as well as
+the initializers for any engines you rely on.
+
+```bash
+bumbler --initializers
+```
+
+### Show all loaded gems
+
+Rails:
+
+```bash
+bumbler --all
+```
+
+Ruby:
+
+```bash
+-e Bumbler::Stats.print_tracked_items
+```
+
+
+Development
+-----------
+
+### Rails
+
+We don't have any integration tests with rails, so when touching rails code make sure to test it in a real app.
+
+```Ruby
+cd my-rails-app && ~/Code/tools/bumbler/bin/bumbler
+```
+
+### Release new version
+
+`rake bump:[major|minor|patch] && rake release`
+
+
+License
+-------
+
+Bumbler is MIT licensed. [See the accompanying file](MIT-LICENSE.md) for the full
+text.

data/bin/bumbler

@@ -1,30 +1,35 @@
 #!/usr/bin/env ruby
-add_load_path = lambda do
-  path = File.join(File.dirname(__FILE__), '..', 'lib')
-  $LOAD_PATH << path unless $LOAD_PATH.include? path
-end
+# frozen_string_literal: true
 
-add_load_path.call # in case we execute via ./bin
+# in case we execute via ./bin
+add_load_path = -> do
+  local_lib = File.expand_path('../lib', __dir__)
+  $LOAD_PATH << local_lib unless $LOAD_PATH.include? local_lib
+end
+add_load_path.call
 
 require 'optparse'
 require 'bumbler'
 
 options = {}
 OptionParser.new do |parser|
-  parser.banner = <<BANNER
-Bumbler shows how long loading your bundle components take.
+  parser.banner = <<~BANNER
+    Bumbler shows how long loading your bundle components take.
 
-Usage:
-    bumbler
+    Usage:
+        bumbler
 
-Options:
-BANNER
-  parser.on("-t", "--threshold MILISECONDS", Integer, "Threshold in ms to be listed as slow") { |t| options[:threshold] = t }
+    Options:
+  BANNER
+  parser.on("-t", "--threshold MILLISECONDS", Integer, "Threshold in ms to be listed as slow") { |t| options[:threshold] = t }
   parser.on("--initializers", "Show load time of initializers") { options[:initializers] = true }
+  parser.on("--all", "Show all load times") { options[:all] = true }
   parser.on("-h", "--help", "Show this.") { puts parser; exit }
-  parser.on('-v', '--version', 'Show Version'){ puts Bumbler::VERSION; exit}
+  parser.on('-v', '--version', 'Show Version') { puts Bumbler::VERSION; exit }
 end.parse!
 
+abort "Not arguments supported" unless ARGV.empty?
+
 Bumbler::Hooks.slow_threshold = options[:threshold] if options[:threshold]
 
 if options[:initializers]
@@ -32,10 +37,18 @@ if options[:initializers]
   add_load_path.call # bundler kicks us out
   require 'bumbler/track_initializers'
   require './config/environment'
-else
+elsif File.exist?('./config/environment')
   require 'bumbler/go'
   require './config/environment'
   add_load_path.call # bundler kicks us out
+else
+  require 'bumbler/go'
+  Bundler.require(*Bundler.definition.groups)
 end
 
-Bumbler::Stats.all_slow_items
+Bumbler::Stats.print_overview
+if options[:all]
+  Bumbler::Stats.print_tracked_items
+else
+  Bumbler::Stats.print_slow_items
+end

data/lib/bumbler.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bumbler
   autoload :Bundler,  'bumbler/bundler'
   autoload :Hooks,    'bumbler/hooks'

data/lib/bumbler/bundler.rb

@@ -1,54 +1,45 @@
+# frozen_string_literal: true
 module Bumbler
   module Bundler
     class << self
       # Returns which gem a require maps to, or nil.
       def gem_for_require(path)
-        self.read_bundler_environment if @require_map.nil?
-        
-        return @require_map[path]
+        @require_map[path]
       end
-      
-      def require_started(path)
-        gem_name = self.gem_for_require(path)
-        return unless gem_name
-        
-        Bumbler::Progress.item_started(:bundler, gem_name)
+
+      def require_started(gem_name)
+        Bumbler::Progress.item_started(gem_name)
       end
-      
-      def require_finished(path, load_time)
-        self.read_bundler_environment if @gem_state.nil?
-        
-        # Tick it off for the gem.
-        gem_name = self.gem_for_require(path)
-        return unless gem_name
-        
+
+      def require_finished(gem_name, path, time)
         @gem_state[gem_name][path] = true
-        
         if @gem_state[gem_name].values.all?
-          Bumbler::Progress.item_finished(:bundler, gem_name, load_time)
+          Bumbler::Progress.item_finished(gem_name, time)
         end
       end
-      
-      def start!
-        self.read_bundler_environment
-      end
-      
+
       def read_bundler_environment
         @require_map = {}
         @gem_state = {}
-        
+
         ::Bundler.environment.current_dependencies.each do |spec|
-          @gem_state[spec.name] = {}
-          
-          Array(spec.autorequire || spec.name).each do |path|
-            # Handle explicitly required gems
-            path = spec.name if path == true
-            
-            @require_map[path] = spec.name
-            @gem_state[spec.name][path] = false
+          gem_name = spec.name
+          @gem_state[gem_name] = {}
+
+          # TODO: this is horrible guess-work ... we need to get the gems load-path instead
+          paths =
+            if !spec.autorequire || spec.autorequire == [true]
+              [gem_name]
+            else
+              spec.autorequire
+            end
+
+          paths.each do |path|
+            @require_map[path] = gem_name
+            @gem_state[gem_name][path] = false
           end
-          
-          Bumbler::Progress.register_item(:bundler, spec.name)
+
+          Bumbler::Progress.register_item(gem_name)
         end
       end
     end

data/lib/bumbler/go.rb

@@ -1,20 +1,14 @@
+# frozen_string_literal: true
 require 'bumbler'
+require 'bundler'
 
-# Do nothing unless we're in a bundle
-begin
-  require 'bundler'
-  # This raises if there isn't a gemfile in our root
-  Bundler.default_gemfile
-  # Workaround for Ruby 2.3, see: github.com/nevir/Bumbler/issues/12
-  Bumbler::Bundler
+# This raises if there isn't a gemfile in our root
+Bundler.default_gemfile
 
-  # Kick it off
-  Bumbler::Hooks.hook_require!
-  Bumbler::Hooks.watch_require!
+# Workaround for Ruby 2.3, see: github.com/nevir/Bumbler/issues/12
+Bumbler::Bundler.name
 
-  Bumbler::Bundler.start!
-  Bumbler::Progress.start!
-
-rescue
-  # Welp, if we fail, we fail.
-end
+# Kick it off
+Bumbler::Bundler.read_bundler_environment
+Bumbler::Hooks.hook_require!
+Bumbler::Hooks.watch_require!

data/lib/bumbler/hooks.rb

@@ -1,18 +1,15 @@
+# frozen_string_literal: true
 module Bumbler
   module Hooks
     @slow_threshold = 100.0
-    @previous_gems = {}
+    @started_items = {}
     @slow_requires = {}
 
     # Everything's a class method (we're a singleton)
     class << self
-      def slow_threshold=(time)
-        @slow_threshold = time
-      end
+      attr_writer :slow_threshold
 
-      def slow_requires
-        @slow_requires
-      end
+      attr_reader :slow_requires
 
       # Inject our custom handling of require into the Kernel.
       def hook_require!
@@ -29,7 +26,7 @@ module Bumbler
             end
           end
 
-          orig_instance_require = self.instance_method(:require)
+          orig_instance_require = instance_method(:require)
           define_method(:require) do |path, *args|
             ::Bumbler::Hooks.handle_require(path) do
               orig_instance_require.bind(self).call(path, *args)
@@ -44,7 +41,7 @@ module Bumbler
       def watch_require!
         ::Kernel.module_eval do
           # It isn't previously defined in Kernel.  This could be a bit dangerous, though.
-          def self.method_added(method_name, *args)
+          def self.method_added(method_name, *_args)
             if method_name == :require && !::Bumbler::Hooks.hooking_require?
               # Fix those hooks.
               ::Bumbler::Hooks.hook_require!
@@ -59,31 +56,31 @@ module Bumbler
 
       # Actually do something about a require here.
       def handle_require(path, &block)
-        # break out early if we're already handling this
+        # break out early if we're already handling the path
         return yield if path == @previous_require
         @previous_require = path
 
-        # Shortcut unless we're tracking the gem
-        gem_name = Bumbler::Bundler.gem_for_require(path)
-        return yield unless gem_name
+        # ignore untracked gem
+        return yield unless (gem_name = Bumbler::Bundler.gem_for_require(path))
 
-        # Track load starts
-        Bumbler::Bundler.require_started(path) unless @previous_gems[gem_name]
-        @previous_gems[gem_name] = true
+        # track load starts
+        Bumbler::Bundler.require_started(gem_name) unless @started_items[gem_name]
+        @started_items[gem_name] = true
 
         time, result = benchmark(path, &block)
 
-        Bumbler::Bundler.require_finished(path, time) if result
+        # TODO: for items with multiple paths we need to add the times
+        Bumbler::Bundler.require_finished(gem_name, path, time) if result
 
         result
       end
 
       def benchmark(key)
-        start = Time.now.to_f
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         result = yield
-        time = (Time.now.to_f - start) * 1000 # ms
+        time = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000 # ms
         @slow_requires[key] = time if time > @slow_threshold
-        return time, result
+        [time, result]
       end
     end
   end

data/lib/bumbler/progress.rb

@@ -1,44 +1,38 @@
+# frozen_string_literal: true
+# TODO: replace with ruby-progressbar dependency
 module Bumbler
   module Progress
     @item_count   = 0
     @loaded_items = 0
 
-    # registry[item_type][item_name] = {:time => 123.45}
-    @registry = Hash.new { |h,k| h[k] = {} }
+    # registry[item_name] = 123.45
+    @registry = {}
 
     class << self
-      def registry
-        @registry
-      end
+      attr_reader :registry
 
-      def register_item(type, name)
+      def register_item(name)
         # Build a blank key for the item
-        unless @registry[type][name]
-          @item_count  += 1
-        end
+        @item_count += 1 unless @registry[name]
 
-        @registry[type][name] = {}
+        @registry[name] = nil
       end
 
-      def item_started(type, name)
-        @curr_item = {:type => type, :name => name}
+      def item_started(name)
+        @curr_item = { name: name }
 
-        self.render_progress
+        render_progress
       end
 
-      def item_finished(type, name, time)
-        @registry[type][name] = {:time => time}
+      def item_finished(name, time)
+        @registry[name] = time
 
-        @loaded_items  += 1
+        @loaded_items += 1
 
-        @prev_item = {:type => type, :name => name, :time => time}
-        @curr_item = nil if @curr_item && @curr_item[:name] == @prev_item[:name] && @curr_item[:type] == @prev_item[:type]
-
-        self.render_progress
-      end
+        @prev_item = { name: name, time: time }
+        @curr_item = nil if @curr_item && @curr_item[:name] == name
 
-      def start!
-        # No-op for now.
+        render_progress
       end
 
       def tty_width
@@ -48,11 +42,11 @@ module Bumbler
       def bar(width)
         inner_size = width - 2
 
-        fill_size = [((@loaded_items.to_f / @item_count.to_f) * inner_size).to_i, inner_size].min
-        fill  = '#' * fill_size
+        fill_size = [((@loaded_items / @item_count.to_f) * inner_size).to_i, inner_size].min
+        fill = '#' * fill_size
         empty = ' ' * (inner_size - fill_size)
 
-        return "[#{fill}#{empty}]"
+        "[#{fill}#{empty}]"
       end
 
       def render_progress
@@ -64,12 +58,12 @@ module Bumbler
         #   (##/##) <current>...   <prev> (####.##ms)
         #
         # Skip the current if there isn't enough room
-        count   = '(%s/%d) ' % [@loaded_items.to_s.rjust(@item_count.to_s.size), @item_count]
+        count   = format('(%s/%d) ', @loaded_items.to_s.rjust(@item_count.to_s.size), @item_count)
         current = @curr_item ? "#{@curr_item[:name]}... " : ''
-        prev    = @prev_item ? '%s (%sms)' % [@prev_item[:name], ('%.2f' % @prev_item[:time]).rjust(7)] : ''
+        prev    = @prev_item ? format('%s (%sms)', @prev_item[:name], ('%.2f' % @prev_item[:time]).rjust(7)) : ''
 
         if $stdout.tty?
-          width = self.tty_width
+          width = tty_width
 
           print "\r\e[A\r\e[A" if @outputted_once
           @outputted_once = true
@@ -78,7 +72,7 @@ module Bumbler
           space_for_current = width - (count.length + prev.length)
 
           # Render the progress
-          puts self.bar(width)
+          puts bar(width)
 
           if space_for_current >= current.length
             puts count + current + prev.rjust(width - count.length - current.length)
@@ -86,7 +80,7 @@ module Bumbler
             puts count + prev.rjust(width - count.length)
           end
         elsif @curr_item
-          puts '%s %s' % [count, @curr_item[:name]]
+          puts format('%s %s', count, @curr_item[:name])
         end
       end
     end

data/lib/bumbler/stats.rb

@@ -1,28 +1,30 @@
+# frozen_string_literal: true
 module Bumbler
   module Stats
     class << self
-      def tracked_items
-        Bumbler::Progress.registry.each do |type, items|
-          puts "Stats for #{type} items:"
-          
-          items.to_a.sort_by! {|n,d| d[:time].to_f}.each do |name, info|
-            if info[:time]
-              puts '  %s  %s' % [('%.2f' % info[:time]).rjust(8), name]
-            else
-              puts "  pending:  #{name}"
-            end
+      def print_overview
+        registry = Bumbler::Progress.registry
+        puts "#{registry.count { |_n, time| time }} of #{registry.size} gems required"
+      end
+
+      def print_tracked_items
+        Bumbler::Progress.registry.sort_by { |_n, time| time.to_f }.each do |name, time|
+          if time
+            puts format('  %s  %s', ('%.2f' % time).rjust(8), name)
+          else
+            puts "  pending:  #{name}"
           end
         end
-        
+
         self
       end
-      
-      def all_slow_items
+
+      def print_slow_items
         puts "Slow requires:"
-        Bumbler::Hooks.slow_requires.to_a.sort_by! {|n,t| t}.each do |name, time|
-          puts '  %s  %s' % [('%.2f' % time).rjust(8), name]
+        Bumbler::Hooks.slow_requires.to_a.sort_by! { |_n, t| t }.each do |name, time|
+          puts format('  %s  %s', ('%.2f' % time).rjust(8), name)
         end
-        
+
         self
       end
     end

data/lib/bumbler/track_initializers.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 Rails::Engine.prepend(Module.new do
   def load(file, *)
     initializer = file.sub(Rails.root.to_s, ".")

data/lib/bumbler/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bumbler
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: bumbler
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Ian MacLeod
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-16 00:00:00.000000000 Z
+date: 2019-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: bump
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bump
+  name: maxitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +39,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: maxitest
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -52,8 +66,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Why stare blankly at your terminal window when you can clutter it up
-  with awesome progress bars?
+description: Find slowly loading gems for your Bundler-based projects
 email:
 - ian@nevir.net
 executables:
@@ -61,6 +74,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- MIT-LICENSE.md
+- README.md
 - bin/bumbler
 - lib/bumbler.rb
 - lib/bumbler/bundler.rb
@@ -82,7 +97,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.0
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -92,5 +107,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: Track the load progress of your Bundler-based projects
+summary: Find slowly loading gems for your Bundler-based projects
 test_files: []