memory_profiler 0.9.13 → 0.9.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df0b1ccbb40909e048bc0064c0f340997ab72629274a71704885c0d1988eb14c
-  data.tar.gz: 73181a0702537823a3f040c1dbe64a8a432ef945fdc761d923b094c8194a57ce
+  metadata.gz: 187acbd9601ade1bb6ccdb60bfb4c305ada15097f02278529f8f6a6fc7d68666
+  data.tar.gz: 33d797db658d4a4507247a0ae9c4b92da568b86e9246f4571a94774b62285c6b
 SHA512:
-  metadata.gz: db95ae6758da369bba200ccc7da4af2c01115f9c2d55d607a5e2e0bf135825a65acb0b44393870bdc0cc8fb4e1d0310533e40560721ab9a22856f175f661d58f
-  data.tar.gz: e6e9ca6e80929277f9d937c516d6582d206360b086e38ccd15ce7fe2d4a9be14c684749f665a8151affd54bcc107068493a815bc0d4f60caa4660a473954717e
+  metadata.gz: 977f958e6b9f3292053ccef51bcef01828cda7d29760f131687d21b00222950fbf1ec4629a7021bfdc4665e137c3f75cfd729a29db60b879a5c30f08da0de097
+  data.tar.gz: 1cc221f3bf20520a3063031a4d9830e3303d9d9182cafb746aa77d0059888a4a640f2d6dd39a925e31398664018c98e9324565247046310c15ef823419bb6baf

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.9.14 - 28-06-2019
+
+- Pass 'normalize_path: true' to pretty_print to have locations stripped
+- Improve number formatting
+
 ## 0.9.13 - 22-03-2019
 
 - remove support explicitly for all EOL rubies, 2.1 and 2.2

data/README.md

@@ -96,6 +96,9 @@ The `pretty_print` method can take a few options:
 * `allocated_strings`: how many allocated strings to print - can be given a String
 * `detailed_report`: should report include detailed information - can be given a Boolean
 * `scale_bytes`: flag to convert byte units (e.g. 183200000 is reported as 183.2 MB, rounds with a precision of 2 decimal digits) - can be given a Boolean
+* `normalize_paths`: flag to remove a gem's directory path from printed locations - can be given a Boolean
+*Note: normalized path of a "location" from Ruby's stdlib will be prefixed with `ruby/lib/`. e.g.: `ruby/lib/set.rb`, `ruby/lib/pathname.rb`, etc.*
+
 
 Check out `Results#pretty_print` for more details.
 

data/lib/memory_profiler.rb

@@ -11,11 +11,11 @@ require "memory_profiler/results"
 require "memory_profiler/reporter"
 
 module MemoryProfiler
-  def self.report(opts={},&block)
-    Reporter.report(opts,&block)
+  def self.report(opts = {}, &block)
+    Reporter.report(opts, &block)
   end
 
-  def self.start(opts={})
+  def self.start(opts = {})
     unless Reporter.current_reporter
       Reporter.current_reporter = Reporter.new(opts)
       Reporter.current_reporter.start
@@ -28,5 +28,3 @@ module MemoryProfiler
     Reporter.current_reporter = nil
   end
 end
-
-

data/lib/memory_profiler/helpers.rb

@@ -5,7 +5,7 @@ module MemoryProfiler
 
     def initialize
       @gem_guess_cache = Hash.new
-      @location_cache = Hash.new { |h,k| h[k] = Hash.new.compare_by_identity }
+      @location_cache = Hash.new { |h, k| h[k] = Hash.new.compare_by_identity }
       @class_name_cache = Hash.new.compare_by_identity
       @string_cache = Hash.new
     end
@@ -37,7 +37,7 @@ module MemoryProfiler
       # This string is shortened to 200 characters which is what the string report shows
       # The string report can still list unique strings longer than 200 characters
       #   separately because the object_id of the shortened string will be different
-      @string_cache[obj] ||= String.new << obj[0,200]
+      @string_cache[obj] ||= String.new << obj[0, 200]
     end
   end
 end

data/lib/memory_profiler/monochrome.rb

@@ -17,4 +17,4 @@ module MemoryProfiler
     end
   end
 
-end
+end

data/lib/memory_profiler/reporter.rb

@@ -29,7 +29,7 @@ module MemoryProfiler
     # @option opts :ignore_files a regular expression used to exclude certain files from tracing
     # @option opts :allow_files a string or array of strings to selectively include in tracing
     # @return [MemoryProfiler::Results]
-    def self.report(opts={}, &block)
+    def self.report(opts = {}, &block)
       self.new(opts).run(&block)
     end
 
@@ -115,7 +115,7 @@ module MemoryProfiler
           # we do memsize first to avoid freezing as a side effect and shifting
           # storage to the new frozen string, this happens on @hash[s] in lookup_string
           memsize = ObjectSpace.memsize_of(obj)
-          string     = klass == String ? helper.lookup_string(obj) : nil
+          string = klass == String ? helper.lookup_string(obj) : nil
 
           # compensate for API bug
           memsize = rvalue_size if memsize > 100_000_000_000

data/lib/memory_profiler/results.rb

@@ -14,12 +14,18 @@ module MemoryProfiler
       24 => 'YB'
     }.freeze
 
+    TYPES   = ["allocated", "retained"].freeze
+    METRICS = ["memory", "objects"].freeze
+    NAMES   = ["gem", "file", "location", "class"].freeze
+
     def self.register_type(name, stat_attribute)
       @@lookups ||= []
       @@lookups << [name, stat_attribute]
 
-      ["allocated", "retained"].product(["objects", "memory"]).each do |type, metric|
-        attr_accessor "#{type}_#{metric}_by_#{name}"
+      TYPES.each do |type|
+        METRICS.each do |metric|
+          attr_accessor "#{type}_#{metric}_by_#{name}"
+        end
       end
     end
 
@@ -47,7 +53,6 @@ module MemoryProfiler
         self.send("retained_objects_by_#{name}=", count_results)
       end
 
-
       self.strings_allocated = string_report(allocated, top)
       self.strings_retained = string_report(retained, top)
 
@@ -64,30 +69,33 @@ module MemoryProfiler
 
       scale = Math.log10(bytes).div(3) * 3
       scale = 24 if scale > 24
-      "#{(bytes / 10.0**scale).round(2)} #{UNIT_PREFIXES[scale]}"
+      "%.2f #{UNIT_PREFIXES[scale]}" % (bytes / 10.0**scale)
     end
 
     def string_report(data, top)
-      grouped_strings = data.values.
-        keep_if { |stat| stat.string_value }.
-        group_by { |stat| stat.string_value.object_id }.
-        values
+      grouped_strings = data.values
+        .keep_if  { |stat| stat.string_value }
+        .group_by { |stat| stat.string_value.object_id }
+        .values
 
       if grouped_strings.size > top
         cutoff = grouped_strings.sort_by!(&:size)[-top].size
         grouped_strings.keep_if { |list| list.size >= cutoff }
       end
 
-      grouped_strings.
-        sort! { |a, b| a.size == b.size ? a[0].string_value <=> b[0].string_value : b.size <=> a.size }.
-        first(top).
-        # Return array of [string, [[location, count], [location, count], ...]
-        map! { |list| [list[0].string_value,
-                       list.group_by { |stat| stat.location }.
-                            map { |location, stat_list| [location, stat_list.size] }.
-                            sort_by!(&:last).reverse!
-                      ]
-        }
+      grouped_strings
+        .sort! { |a, b| a.size == b.size ? a[0].string_value <=> b[0].string_value : b.size <=> a.size }
+        .first(top)
+        .map! do |list|
+          # Return array of [string, [[location, count], [location, count], ...]
+          [
+            list[0].string_value,
+            list.group_by { |stat| stat.location }
+              .map { |location, stat_list| [location, stat_list.size] }
+              .sort_by!(&:last)
+              .reverse!
+          ]
+        end
     end
 
     # Output the results of the report
@@ -98,6 +106,7 @@ module MemoryProfiler
     # @option opts [Integer] :allocated_strings how many allocated strings to print
     # @option opts [Boolean] :detailed_report should report include detailed information
     # @option opts [Boolean] :scale_bytes calculates unit prefixes for the numbers of bytes
+    # @option opts [Boolean] :normalize_paths print location paths relative to gem's source directory.
     def pretty_print(io = $stdout, **options)
       # Handle the special case that Ruby PrettyPrint expects `pretty_print`
       # to be a customized pretty printing function for a class
@@ -110,72 +119,114 @@ module MemoryProfiler
 
       if options[:scale_bytes]
         total_allocated_output = scale_bytes(total_allocated_memsize)
-        total_retained_output = scale_bytes(total_retained_memsize)
+        total_retained_output  = scale_bytes(total_retained_memsize)
       else
         total_allocated_output = "#{total_allocated_memsize} bytes"
-        total_retained_output = "#{total_retained_memsize} bytes"
+        total_retained_output  = "#{total_retained_memsize} bytes"
       end
 
       io.puts "Total allocated: #{total_allocated_output} (#{total_allocated} objects)"
       io.puts "Total retained:  #{total_retained_output} (#{total_retained} objects)"
 
-      if options[:detailed_report] != false
-        io.puts
-        ["allocated", "retained"]
-            .product(["memory", "objects"])
-            .product(["gem", "file", "location", "class"])
-            .each do |(type, metric), name|
-              scale_data = metric == "memory" && options[:scale_bytes]
-              dump "#{type} #{metric} by #{name}", self.send("#{type}_#{metric}_by_#{name}"), io, scale_data
+      unless options[:detailed_report] == false
+        TYPES.each do |type|
+          METRICS.each do |metric|
+            NAMES.each do |name|
+              dump_data(io, type, metric, name, options)
             end
+          end
+        end
       end
 
       io.puts
-      dump_strings(io, "Allocated", strings_allocated, limit: options[:allocated_strings])
-      io.puts
-      dump_strings(io, "Retained", strings_retained, limit: options[:retained_strings])
+      print_string_reports(io, options)
 
       io.close if io.is_a? File
     end
 
-    private
-
-    def dump_strings(io, title, strings, limit: nil)
-      return unless strings
-
-      if limit
-        return if limit == 0
-        strings = strings[0...limit]
+    def print_string_reports(io, options)
+      TYPES.each do |type|
+        dump_opts = {
+          normalize_paths: options[:normalize_paths],
+          limit: options["#{type}_strings".to_sym]
+        }
+        dump_strings(io, type, dump_opts)
       end
+    end
 
-      io.puts "#{title} String Report"
-      io.puts @colorize.line("-----------------------------------")
-      strings.each do |string, stats|
-        io.puts "#{stats.reduce(0) { |a, b| a + b[1] }.to_s.rjust(10)}  #{@colorize.string((string.inspect))}"
-        stats.sort_by { |x, y| [-y, x] }.each do |location, count|
-          io.puts "#{@colorize.path(count.to_s.rjust(10))}  #{location}"
+    def normalize_path(path)
+      @normalize_path ||= {}
+      @normalize_path[path] ||= begin
+        if %r!(/gems/.*)*/gems/(?<gemname>[^/]+)(?<rest>.*)! =~ path
+          "#{gemname}#{rest}"
+        elsif %r!ruby/2\.[^/]+/(?<stdlib>[^/.]+)(?<rest>.*)! =~ path
+          "ruby/lib/#{stdlib}#{rest}"
+        elsif %r!(?<app>[^/]+/(bin|app|lib))(?<rest>.*)! =~ path
+          "#{app}#{rest}"
+        else
+          path
         end
-        io.puts
       end
-      nil
     end
 
-    def dump(description, data, io, scale_data)
-      io.puts description
+    private
+
+    def print_title(io, title)
+      io.puts
+      io.puts title
       io.puts @colorize.line("-----------------------------------")
+    end
+
+    def print_output(io, topic, detail)
+      io.puts "#{@colorize.path(topic.to_s.rjust(10))}  #{detail}"
+    end
+
+    def dump_data(io, type, metric, name, options)
+      print_title  io, "#{type} #{metric} by #{name}"
+      data = self.send "#{type}_#{metric}_by_#{name}"
+
+      scale_data = metric == "memory" && options[:scale_bytes]
+      normalize_paths = options[:normalize_paths]
+
       if data && !data.empty?
         data.each do |item|
-          data_string = scale_data ? scale_bytes(item[:count]) : item[:count].to_s
-          io.puts "#{data_string.rjust(10)}  #{item[:data]}"
+          count = scale_data ? scale_bytes(item[:count]) : item[:count]
+          value = normalize_paths ? normalize_path(item[:data]) : item[:data]
+          print_output io, count, value
         end
       else
         io.puts "NO DATA"
       end
-      io.puts
+
+      nil
     end
 
-  end
+    def dump_strings(io, type, options)
+      strings = self.send("strings_#{type}") || []
+      return if strings.empty?
 
-end
+      options = {} unless options.is_a?(Hash)
+
+      if (limit = options[:limit])
+        return if limit == 0
+        strings = strings[0...limit]
+      end
 
+      normalize_paths = options[:normalize_paths]
 
+      print_title(io, "#{type.capitalize} String Report")
+      strings.each do |string, stats|
+        print_output io, (stats.reduce(0) { |a, b| a + b[1] }), @colorize.string(string.inspect)
+        stats.sort_by { |x, y| [-y, x] }.each do |location, count|
+          location = normalize_path(location) if normalize_paths
+          print_output io, count, location
+        end
+        io.puts
+      end
+
+      nil
+    end
+
+  end
+
+end

data/lib/memory_profiler/top_n.rb

@@ -6,17 +6,26 @@ module MemoryProfiler
     # Returns results for both memory (memsize summed) and objects allocated (count) as a tuple.
     def top_n(max, metric_method)
 
-      stat_totals = self.values.group_by(&metric_method).map do |metric, stats|
-        [metric, stats.reduce(0) { |sum, stat| sum + stat.memsize }, stats.size]
-      end
+      stat_totals =
+        self.values
+          .group_by(&metric_method)
+          .map do |metric, stats|
+            [metric, stats.reduce(0) { |sum, stat| sum + stat.memsize }, stats.size]
+          end
 
-      stats_by_memsize = stat_totals.sort_by! { |metric, memsize, _count| [-memsize, metric] }.take(max).
-          map! { |metric, memsize, _count| { data: metric, count: memsize } }
-      stats_by_count = stat_totals.sort_by! { |metric, _memsize, count| [-count, metric] }.take(max).
-          map! { |metric, _memsize, count| { data: metric, count: count } }
+      stats_by_memsize =
+        stat_totals
+          .sort_by! { |metric, memsize, _count| [-memsize, metric] }
+          .take(max)
+          .map! { |metric, memsize, _count| { data: metric, count: memsize } }
 
-      [stats_by_memsize, stats_by_count]
+      stats_by_count =
+        stat_totals
+          .sort_by! { |metric, _memsize, count| [-count, metric] }
+          .take(max)
+          .map! { |metric, _memsize, count| { data: metric, count: count } }
 
+      [stats_by_memsize, stats_by_count]
     end
   end
 end

data/lib/memory_profiler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MemoryProfiler
-  VERSION = "0.9.13"
+  VERSION = "0.9.14"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: memory_profiler
 version: !ruby/object:Gem::Version
-  version: 0.9.13
+  version: 0.9.14
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-22 00:00:00.000000000 Z
+date: 2019-06-27 00:00:00.000000000 Z
 dependencies: []
 description: Memory profiling routines for Ruby 2.3+
 email: