memory_profiler 0.9.10 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36702507c9914c94dfb3218eff88eb04baedbfd19e17773b0cc0783003fbd773
-  data.tar.gz: 447062d601138e3640117983a523380f455798f921294d63f61e72da55c1a620
+  metadata.gz: dea36221189a4ea796d262870a9a09acf48fcfe3b6321814fc3e86cc1f4c37db
+  data.tar.gz: '059ab396fc3c0e928046dd3f5c0e6271a616a369f427ee8d134521bb934e8cd8'
 SHA512:
-  metadata.gz: 35cf530186236d02baa145fec37e519f24eb3322334154559af3f938b955c648ad8eb298b830e83d9ab1751842e49b59aa52f8c7b2e350c7f1fec77cd065d28a
-  data.tar.gz: a4d24d2a9c3f985fdbdec38c3d14b9dcb0db816aef70c2f590565c5a5e81beb5ffc353a56c220f814f3f135ee1d5a4a6c1e100b1a95b080a351eace0d3f0c6b6
+  metadata.gz: 69a830fb9ac126817342cc84e70f0796417d119ae337172a6b79a26d10e78a08146a4496915c384c7f993e8c514d43168e8e9d1d925acb856ca77092bdd1535e
+  data.tar.gz: 6de39e21847f551fac3b53107e5fa9d8cba5c6d00cfd39fb104432bc44f83008afefe9c46138ce4560e91880f245456b00f60718593198d735a379e4d93b8d71

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 1.0.0 - 02-12-2020
+
+- Added new CLI `ruby-memory-profiler` which can be used to profile scripts @fatkodima
+- Reduced memory usage when generating reports
+- Some optimizations for Ruby 2.7
+- Remove EOL Rubies: 2.3 and 2.4 are no longer supported (use an earlier version of the gem if needed)
+
+## 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
+- frozen string literal comment @RST-J
+- scale_bytes option @RST-J
+
+## 0.9.12
+- Correct bug under-reporting memory for large string allocation @sam
+
+## 0.9.11
+- Reduce memory needed for string allocation tracing @dgynn
+- Use yield rather than block.call to reduce an allocation @dgynn
+- Ensure string allocation locations sort consistently @dgynn
+
 ## 0.9.10
 - Add better detection for stdlib "gems"
 

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 TODO: Write your name
+Copyright (c) 2013 Sam Saffron
 
 MIT License
 

data/README.md

@@ -1,13 +1,13 @@
-[![Build Status](https://travis-ci.org/SamSaffron/memory_profiler.svg?branch=master)](https://travis-ci.org/SamSaffron/memory_profiler)
+[![CI](https://github.com/SamSaffron/memory_profiler/workflows/CI/badge.svg)](https://github.com/SamSaffron/memory_profiler/actions?query=workflow%3ACI)
 [![Gem Version](https://badge.fury.io/rb/memory_profiler.svg)](https://rubygems.org/gems/memory_profiler)
 
 # MemoryProfiler
 
-A memory profiler for Ruby 
+A memory profiler for Ruby
 
-## Requirements 
+## Requirements
 
-Ruby(MRI) Version 2.1.0 and above. 
+Ruby(MRI) Version 2.5.0 and above.
 
 ## Installation
 
@@ -25,6 +25,25 @@ Or install it yourself as:
 
 ## Usage
 
+There are two ways to use `memory_profiler`:
+* command line
+* convenience API
+
+### Command Line
+
+The easiest way to use memory_profiler is via the command line, which requires no modifications to your program. The basic usage is:
+```
+$ ruby-memory-profiler [options] <script.rb> [--] [script-options]
+```
+Where `script.rb` is the program you want to profile.
+
+For a full list of options, execute the following command:
+```
+ruby-memory-profiler -h
+```
+
+### Convenience API
+
 ```ruby
 require 'memory_profiler'
 report = MemoryProfiler.report do
@@ -52,7 +71,9 @@ be the only time you can retrieve the report using this API.
 
 ## Options
 
-The report method can take a few options:
+### `report`
+
+The `report` method can take a few options:
 
 * `top`: maximum number of entries to display in a report (default is 50)
 * `allow_files`: include only certain files from tracing - can be given as a String, Regexp, or array of Strings
@@ -84,7 +105,23 @@ allocated memory by file
 . . .
 ```
 
-Also you can print report to file. For this use `pretty_print` method with `to_file` option and `path_to_your_log_file` string:
+### `pretty_print`
+
+The `pretty_print` method can take a few options:
+
+* `to_file`: a path to your log file - can be given a String
+* `color_output`: a flag for whether to colorize output - can be given a Boolean
+* `retained_strings`: how many retained strings to print - can be given an Integer
+* `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.
+
+For example to report to file, use `pretty_print` method with `to_file` option and `path_to_your_log_file` string:
 ```
 $ pry
 pry> require 'memory_profiler'
@@ -364,7 +401,7 @@ The report breaks down 2 key concepts.
 
 **Allocated**: All object allocation and memory allocation during code block.
 
-As a general rule "retained" will always be smaller than or equal to allocated. 
+As a general rule "retained" will always be smaller than or equal to allocated.
 
 Memory profiler will tell you aggregate costs of the above, for example requiring the mime-types gem above results in approx 2MB of retained memory in 22K or so objects. The actual RSS cost will always be slightly higher as MRI heaps are not squashed to size and memory fragments. In future we may be able to calculate a rough long term GC cost of retained objects (for major GCs).
 

data/bin/ruby-memory-profiler

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "memory_profiler"
+
+exit MemoryProfiler::CLI.new.run(ARGV)

data/lib/memory_profiler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "memory_profiler/version"
 require "memory_profiler/helpers"
 require "memory_profiler/polychrome"
@@ -7,13 +9,14 @@ require "memory_profiler/stat"
 require "memory_profiler/stat_hash"
 require "memory_profiler/results"
 require "memory_profiler/reporter"
+require "memory_profiler/cli"
 
 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
@@ -26,5 +29,3 @@ module MemoryProfiler
     Reporter.current_reporter = nil
   end
 end
-
-

data/lib/memory_profiler/cli.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module MemoryProfiler
+  class CLI
+    BIN_NAME     = "ruby-memory-profiler"
+    VERSION_INFO = "#{BIN_NAME}  #{MemoryProfiler::VERSION}"
+
+    STATUS_SUCCESS = 0
+    STATUS_ERROR   = 1
+
+    DEFAULTS = {
+      ignore_files: "memory_profiler/lib"
+    }.freeze
+
+    REPORTER_KEYS = [
+      :top, :trace, :ignore_files, :allow_files
+    ].freeze
+
+    RESULTS_KEYS = [
+      :to_file, :color_output, :retained_strings, :allocated_strings,
+      :detailed_report, :scale_bytes, :normalize_paths
+    ].freeze
+
+    private_constant :BIN_NAME, :VERSION_INFO,:STATUS_SUCCESS, :STATUS_ERROR,
+                     :DEFAULTS, :REPORTER_KEYS, :RESULTS_KEYS
+
+    #
+
+    def run(argv)
+      options = {}
+      parser = option_parser(options)
+      parser.parse!(argv)
+
+      options = DEFAULTS.merge(options)
+
+      # Make sure the user specified at least one file
+      unless (script = argv.shift)
+        puts parser
+        puts ""
+        puts "#{VERSION_INFO}  |  ERROR: Must specify a script to run"
+        return STATUS_ERROR
+      end
+
+      MemoryProfiler.start(reporter_options(options))
+      load script
+
+      STATUS_SUCCESS
+    rescue OptionParser::InvalidOption, OptionParser::InvalidArgument, OptionParser::MissingArgument => e
+      puts parser
+      puts e.message
+      STATUS_ERROR
+    ensure
+      report = MemoryProfiler.stop
+      report&.pretty_print(**results_options(options))
+    end
+
+    private
+
+    def option_parser(options)
+      OptionParser.new do |opts|
+        opts.banner = <<~BANNER
+
+              #{VERSION_INFO}
+              A Memory Profiler for Ruby
+
+          Usage:
+              #{BIN_NAME} [options] <script.rb> [--] [script-options]
+        BANNER
+
+        opts.separator ""
+        opts.separator "Options:"
+
+        # Reporter options
+        opts.on("-m", "--max=NUM", Integer, "Max number of entries to output. (Defaults to 50)") do |arg|
+          options[:top] = arg
+        end
+
+        opts.on("--classes=CLASSES", Array, "A class or list of classes you explicitly want to trace.") do |arg|
+          options[:trace] = arg.map { |klass| Object.const_get(klass) }
+        end
+
+        opts.on("--ignore-files=REGEXP", "A regular expression used to exclude certain files from tracing.") do |arg|
+          options[:ignore_files] = "#{arg}|memory_profiler/lib"
+        end
+
+        opts.on("--allow-files=FILES", Array, "A string or list of strings to selectively include in tracing.") do |arg|
+          options[:allow_files] = arg
+        end
+
+        opts.separator ""
+
+        # Results options
+        opts.on("-o", "--out=FILE", "Write output to a file instead of STDOUT.") do |arg|
+          options[:to_file] = arg
+        end
+
+        opts.on("--[no-]color", "Force color output on or off. (Enabled by default)") do |arg|
+          options[:color_output] = arg
+        end
+
+        opts.on("--retained-strings=NUM", Integer, "How many retained strings to print.") do |arg|
+          options[:retained_strings] = arg
+        end
+
+        opts.on("--allocated-strings=NUM", Integer, "How many allocated strings to print.") do |arg|
+          options[:allocated_strings] = arg
+        end
+
+        opts.on("--[no-]detailed", "Print detailed information. (Enabled by default)") do |arg|
+          options[:detailed_report] = arg
+        end
+
+        opts.on("--scale-bytes", "Calculates unit prefixes for the numbers of bytes.") do
+          options[:scale_bytes] = true
+        end
+
+        opts.on("--normalize-paths", "Print location paths relative to gem's source directory.") do
+          options[:normalize_paths] = true
+        end
+
+        opts.on("--pretty", "Easily enable options 'scale-bytes' and 'normalize-paths'") do
+          options[:scale_bytes] = options[:normalize_paths] = true
+        end
+
+        opts.separator ""
+
+        opts.on_tail("-h", "--help", "Show this help message.") do
+          puts opts
+          exit
+        end
+
+        opts.on_tail("-v", "--version", "Show program version.") do
+          puts VERSION_INFO
+          exit
+        end
+      end
+    end
+
+    def reporter_options(options)
+      options.select { |k, _v| REPORTER_KEYS.include?(k) }
+    end
+
+    def results_options(options)
+      options.select { |k, _v| RESULTS_KEYS.include?(k) }
+    end
+  end
+end

data/lib/memory_profiler/helpers.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module MemoryProfiler
   class Helpers
 
     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
@@ -13,13 +15,13 @@ module MemoryProfiler
         if /(\/gems\/.*)*\/gems\/(?<gemname>[^\/]+)/ =~ path
           gemname
         elsif /\/rubygems[\.\/]/ =~ path
-          "rubygems".freeze
+          "rubygems"
         elsif /ruby\/2\.[^\/]+\/(?<stdlib>[^\/\.]+)/ =~ path
           stdlib
         elsif /(?<app>[^\/]+\/(bin|app|lib))/ =~ path
           app
         else
-          "other".freeze
+          "other"
         end
     end
 
@@ -27,12 +29,42 @@ module MemoryProfiler
       @location_cache[file][line] ||= "#{file}:#{line}"
     end
 
-    def lookup_class_name(klass)
-      @class_name_cache[klass] ||= ((klass.is_a?(Class) && klass.name) || '<<Unknown>>').to_s
+    KERNEL_CLASS_METHOD = Kernel.instance_method(:class)
+    if UnboundMethod.method_defined?(:bind_call)
+      def object_class(obj)
+        klass = obj.class rescue nil
+        unless Class === klass
+          # attempt to determine the true Class when .class returns something other than a Class
+          klass = KERNEL_CLASS_METHOD.bind_call(obj)
+        end
+        klass
+      end
+    else
+      def object_class(obj)
+        klass = obj.class rescue nil
+        unless Class === klass
+          # attempt to determine the true Class when .class returns something other than a Class
+          klass = KERNEL_CLASS_METHOD.bind(obj).call
+        end
+        klass
+      end
+    end
+
+    if Object.name.frozen? # Since Ruby 2.7 Module#name no longer allocate a new string
+      def lookup_class_name(klass)
+        ((klass.is_a?(Class) && klass.name) || '<<Unknown>>').to_s
+      end
+    else
+      def lookup_class_name(klass)
+        @class_name_cache[klass] ||= ((klass.is_a?(Class) && klass.name) || '<<Unknown>>').to_s
+      end
     end
 
     def lookup_string(obj)
-      @string_cache[obj] ||= String.new << obj
+      # 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]
     end
   end
 end

data/lib/memory_profiler/monochrome.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MemoryProfiler
 
   class Monochrome
@@ -15,4 +17,4 @@ module MemoryProfiler
     end
   end
 
-end
+end

data/lib/memory_profiler/polychrome.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module MemoryProfiler
 
   class Polychrome
 
     def path(text)
-      gray(text)
+      blue(text)
     end
 
     def string(text)
@@ -11,7 +13,7 @@ module MemoryProfiler
     end
 
     def line(text)
-      gray(text)
+      cyan(text)
     end
 
     private

data/lib/memory_profiler/reporter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'objspace'
 module MemoryProfiler
   # Reporter is the top level API used for generating memory reports.
@@ -27,11 +29,13 @@ 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
 
     def start
+      GC.start
+      GC.start
       GC.start
       GC.disable
 
@@ -46,6 +50,8 @@ module MemoryProfiler
 
       GC.enable
       GC.start
+      GC.start
+      GC.start
 
       # Caution: Do not allocate any new Objects between the call to GC.start and the completion of the retained
       #          lookups. It is likely that a new Object would reuse an object_id from a GC'd object.
@@ -65,7 +71,7 @@ module MemoryProfiler
     def run(&block)
       start
       begin
-        block.call
+        yield
       rescue Exception
         ObjectSpace.trace_object_allocations_stop
         GC.enable
@@ -82,7 +88,6 @@ module MemoryProfiler
     def object_list(generation)
 
       rvalue_size = GC::INTERNAL_CONSTANTS[:RVALUE_SIZE]
-      rvalue_size_adjustment = RUBY_VERSION < '2.2' ? rvalue_size : 0
       helper = Helpers.new
 
       result = StatHash.new.compare_by_identity
@@ -90,15 +95,11 @@ module MemoryProfiler
       ObjectSpace.each_object do |obj|
         next unless ObjectSpace.allocation_generation(obj) == generation
 
-        file = ObjectSpace.allocation_sourcefile(obj) || "(no name)".freeze
+        file = ObjectSpace.allocation_sourcefile(obj) || "(no name)"
         next if @ignore_files && @ignore_files =~ file
         next if @allow_files && !(@allow_files =~ file)
 
-        klass = obj.class rescue nil
-        unless Class === klass
-          # attempt to determine the true Class when .class returns something other than a Class
-          klass = Kernel.instance_method(:class).bind(obj).call
-        end
+        klass = helper.object_class(obj)
         next if @trace && !trace.include?(klass)
 
         begin
@@ -107,9 +108,11 @@ module MemoryProfiler
           class_name = helper.lookup_class_name(klass)
           gem        = helper.guess_gem(file)
 
-          string     = klass == String ? helper.lookup_string(obj) : nil
+          # 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
 
-          memsize = ObjectSpace.memsize_of(obj) + rvalue_size_adjustment
           # compensate for API bug
           memsize = rvalue_size if memsize > 100_000_000_000
           result[obj.__id__] = MemoryProfiler::Stat.new(class_name, gem, file, location, memsize, string)

data/lib/memory_profiler/results.rb

@@ -1,12 +1,31 @@
+# frozen_string_literal: true
+
 module MemoryProfiler
   class Results
+    UNIT_PREFIXES = {
+      0 => 'B',
+      3 => 'kB',
+      6 => 'MB',
+      9 => 'GB',
+      12 => 'TB',
+      15 => 'PB',
+      18 => 'EB',
+      21 => 'ZB',
+      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
 
@@ -34,29 +53,52 @@ 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)
 
       self.total_allocated = allocated.size
-      self.total_allocated_memsize = allocated.values.map!(&:memsize).inject(0, :+)
+      self.total_allocated_memsize = total_memsize(allocated)
       self.total_retained = retained.size
-      self.total_retained_memsize = retained.values.map!(&:memsize).inject(0, :+)
+      self.total_retained_memsize = total_memsize(retained)
 
       self
     end
 
+    def scale_bytes(bytes)
+      return "0 B" if bytes.zero?
+
+      scale = Math.log10(bytes).div(3) * 3
+      scale = 24 if scale > 24
+      "%.2f #{UNIT_PREFIXES[scale]}" % (bytes / 10.0**scale)
+    end
+
     def string_report(data, top)
-      data.values
-          .keep_if { |stat| stat.string_value }
-          .map! { |stat| [stat.string_value, stat.location] }
-          .group_by { |string, _location| string }
-          .sort_by {|string, list| [-list.size, string] }
-          .first(top)
-          .map { |string, list| [string, list.group_by { |_string, location| location }
-                                             .map { |location, locations| [location, locations.size] }
-                                ]
-          }
+      grouped_strings = Hash.new { |hash, key| hash[key] = [] }
+      data.each_value do |stat|
+        if stat.string_value
+          grouped_strings[stat.string_value.object_id] << stat
+        end
+      end
+
+      grouped_strings = grouped_strings.values
+
+      if grouped_strings.size > top
+        grouped_strings.sort_by!(&:size)
+        grouped_strings = grouped_strings.drop(grouped_strings.size - top)
+      end
+
+      grouped_strings
+        .sort! { |a, b| a.size == b.size ? a[0].string_value <=> b[0].string_value : b.size <=> a.size }
+        .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
@@ -66,6 +108,8 @@ module MemoryProfiler
     # @option opts [Integer] :retained_strings how many retained strings to print
     # @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
@@ -76,64 +120,124 @@ module MemoryProfiler
       color_output = options.fetch(:color_output) { io.respond_to?(:isatty) && io.isatty }
       @colorize = color_output ? Polychrome.new : Monochrome.new
 
-      io.puts "Total allocated: #{total_allocated_memsize} bytes (#{total_allocated} objects)"
-      io.puts "Total retained:  #{total_retained_memsize} bytes (#{total_retained} objects)"
+      if options[:scale_bytes]
+        total_allocated_output = scale_bytes(total_allocated_memsize)
+        total_retained_output  = scale_bytes(total_retained_memsize)
+      else
+        total_allocated_output = "#{total_allocated_memsize} bytes"
+        total_retained_output  = "#{total_retained_memsize} bytes"
+      end
 
-      if options[:detailed_report] != false
-        io.puts
-        ["allocated", "retained"]
-            .product(["memory", "objects"])
-            .product(["gem", "file", "location", "class"])
-            .each do |(type, metric), name|
-              dump "#{type} #{metric} by #{name}", self.send("#{type}_#{metric}_by_#{name}"), io
+      io.puts "Total allocated: #{total_allocated_output} (#{total_allocated} objects)"
+      io.puts "Total retained:  #{total_retained_output} (#{total_retained} objects)"
+
+      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[0..200].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)
-      io.puts description
+    private
+
+    def total_memsize(stat_hash)
+      sum = 0
+      stat_hash.each_value do |stat|
+        sum += stat.memsize
+      end
+      sum
+    end
+
+    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|
-          io.puts "#{item[:count].to_s.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/stat.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MemoryProfiler
   class Stat
 

data/lib/memory_profiler/stat_hash.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MemoryProfiler
   class StatHash < Hash
     include TopN

data/lib/memory_profiler/top_n.rb

@@ -1,20 +1,36 @@
+# frozen_string_literal: true
+
 module MemoryProfiler
   module TopN
     # Fast approach for determining the top_n entries in a Hash of Stat objects.
     # 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]
+      metric_memsize = Hash.new(0)
+      metric_objects_count = Hash.new(0)
+
+      each_value do |value|
+        metric = value.send(metric_method)
+
+        metric_memsize[metric] += value.memsize
+        metric_objects_count[metric] += 1
       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 =
+        metric_memsize
+          .to_a
+          .sort_by! { |metric, memsize| [-memsize, metric] }
+          .take(max)
+          .map! { |metric, memsize| { data: metric, count: memsize } }
 
-      [stats_by_memsize, stats_by_count]
+      stats_by_count =
+        metric_objects_count
+          .to_a
+          .sort_by! { |metric, count| [-count, metric] }
+          .take(max)
+          .map! { |metric, count| { data: metric, count: count } }
 
+      [stats_by_memsize, stats_by_count]
     end
   end
 end

data/lib/memory_profiler/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MemoryProfiler
-  VERSION = "0.9.10"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,26 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: memory_profiler
 version: !ruby/object:Gem::Version
-  version: 0.9.10
+  version: 1.0.0
 platform: ruby
 authors:
 - Sam Saffron
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-02-15 00:00:00.000000000 Z
+date: 2020-12-01 00:00:00.000000000 Z
 dependencies: []
-description: Memory profiling routines for Ruby 2.1+
+description: Memory profiling routines for Ruby 2.5+
 email:
 - sam.saffron@gmail.com
-executables: []
+executables:
+- ruby-memory-profiler
 extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- bin/ruby-memory-profiler
 - lib/memory_profiler.rb
+- lib/memory_profiler/cli.rb
 - lib/memory_profiler/helpers.rb
 - lib/memory_profiler/monochrome.rb
 - lib/memory_profiler/polychrome.rb
@@ -34,7 +37,7 @@ homepage: https://github.com/SamSaffron/memory_profiler
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -42,16 +45,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
-summary: Memory profiling routines for Ruby 2.1+
+summary: Memory profiling routines for Ruby 2.5+
 test_files: []