memory_profiler 0.9.14 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 187acbd9601ade1bb6ccdb60bfb4c305ada15097f02278529f8f6a6fc7d68666
-  data.tar.gz: 33d797db658d4a4507247a0ae9c4b92da568b86e9246f4571a94774b62285c6b
+  metadata.gz: e4c8c5a12cd11ab3f9c5ab852e6bca0cb442ccc25f54997f49243a19aa6cef9b
+  data.tar.gz: 5c0ca217ca3cbc0edca725071512688443ac24a5d3e9f28980d93d3dd30a323f
 SHA512:
-  metadata.gz: 977f958e6b9f3292053ccef51bcef01828cda7d29760f131687d21b00222950fbf1ec4629a7021bfdc4665e137c3f75cfd729a29db60b879a5c30f08da0de097
-  data.tar.gz: 1cc221f3bf20520a3063031a4d9830e3303d9d9182cafb746aa77d0059888a4a640f2d6dd39a925e31398664018c98e9324565247046310c15ef823419bb6baf
+  metadata.gz: 11d3bf57b920c915a0a98f6cea8798349983b0c64047f481ab1227301ff100a8de16f858ee7d21028d32e3dd04015446f77555bfd050755637714da5d1cc08b3
+  data.tar.gz: 46d2df335163a6ddc35ea3a0eff97573dc7b8a50d671e9aa8940a5acb300ea342d7eb38e10f03f39f3705c4e9ed318a336c68f72ddf39a5cdf4f6bb81b9cc7e5

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 1.0.1 - 23-10-2022
+
+- Adapts tests to Ruby 3.0 / 3.1
+- Lazy report evaluation
+- Tested under Truffle Ruby
+
+## 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

data/README.md

@@ -1,4 +1,4 @@
-[![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
@@ -7,7 +7,7 @@ A memory profiler for Ruby
 
 ## Requirements
 
-Ruby(MRI) Version 2.3.8 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
@@ -93,7 +112,7 @@ 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
+* `allocated_strings`: how many allocated strings to print - can be given a Integer
 * `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

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/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

@@ -16,7 +16,7 @@ module MemoryProfiler
           gemname
         elsif /\/rubygems[\.\/]/ =~ path
           "rubygems"
-        elsif /ruby\/2\.[^\/]+\/(?<stdlib>[^\/\.]+)/ =~ path
+        elsif /ruby\/\d\.[^\/]+\/(?<stdlib>[^\/\.]+)/ =~ path
           stdlib
         elsif /(?<app>[^\/]+\/(bin|app|lib))/ =~ path
           app
@@ -29,8 +29,35 @@ 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)

data/lib/memory_profiler/polychrome.rb

@@ -5,7 +5,7 @@ module MemoryProfiler
   class Polychrome
 
     def path(text)
-      gray(text)
+      blue(text)
     end
 
     def string(text)
@@ -13,7 +13,7 @@ module MemoryProfiler
     end
 
     def line(text)
-      gray(text)
+      cyan(text)
     end
 
     private

data/lib/memory_profiler/reporter.rb

@@ -34,8 +34,7 @@ module MemoryProfiler
     end
 
     def start
-      GC.start
-      GC.start
+      3.times { GC.start }
       GC.start
       GC.disable
 
@@ -49,8 +48,11 @@ module MemoryProfiler
       retained = StatHash.new.compare_by_identity
 
       GC.enable
-      GC.start
-      GC.start
+      # for whatever reason doing GC in a block is more effective at
+      # freeing objects.
+      # full_mark: true, immediate_mark: true, immediate_sweep: true are already default
+      3.times { GC.start }
+      # another start outside of the block to release the block
       GC.start
 
       # Caution: Do not allocate any new Objects between the call to GC.start and the completion of the retained
@@ -86,8 +88,6 @@ module MemoryProfiler
     # Iterates through objects in memory of a given generation.
     # Stores results along with meta data of objects collected.
     def object_list(generation)
-
-      rvalue_size = GC::INTERNAL_CONSTANTS[:RVALUE_SIZE]
       helper = Helpers.new
 
       result = StatHash.new.compare_by_identity
@@ -99,11 +99,7 @@ module MemoryProfiler
         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
@@ -118,7 +114,7 @@ module MemoryProfiler
           string = klass == String ? helper.lookup_string(obj) : nil
 
           # compensate for API bug
-          memsize = rvalue_size if memsize > 100_000_000_000
+          memsize = GC::INTERNAL_CONSTANTS[:RVALUE_SIZE] if memsize > 100_000_000_000
           result[obj.__id__] = MemoryProfiler::Stat.new(class_name, gem, file, location, memsize, string)
         rescue
           # give up if any any error occurs inspecting the object

data/lib/memory_profiler/results.rb

@@ -24,7 +24,16 @@ module MemoryProfiler
 
       TYPES.each do |type|
         METRICS.each do |metric|
-          attr_accessor "#{type}_#{metric}_by_#{name}"
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{type}_#{metric}_by_#{name}                                                  # def allocated_memory_by_file
+              @#{type}_#{metric}_by ||= {}                                                    #   @allocated_memory_by ||= {}
+                                                                                              #
+              @#{type}_#{metric}_by['#{name}'] ||= begin                                      #   @allocated_memory_by['file'] ||= begin
+                _, stat_attribute = @@lookups.find { |(n, _stat_attribute)| n == '#{name}' }  #     _, stat_attribute = @@lookups.find { |(n, _stat_attribute)| n == 'file' }
+                @#{type}.top_n_#{metric}(@top, stat_attribute)                                #     @allocated.top_n_memory(@top, stat_attribute)
+              end                                                                             #   end
+            end                                                                               # end
+          RUBY
         end
       end
     end
@@ -34,36 +43,37 @@ module MemoryProfiler
     register_type 'location', :location
     register_type 'class', :class_name
 
-    attr_accessor :strings_retained, :strings_allocated
+    attr_writer :strings_retained, :strings_allocated
     attr_accessor :total_retained, :total_allocated
     attr_accessor :total_retained_memsize, :total_allocated_memsize
 
-    def register_results(allocated, retained, top)
-
-      @@lookups.each do |name, stat_attribute|
-
-        memsize_results, count_results = allocated.top_n(top, stat_attribute)
-
-        self.send("allocated_memory_by_#{name}=", memsize_results)
-        self.send("allocated_objects_by_#{name}=", count_results)
-
-        memsize_results, count_results = retained.top_n(top, stat_attribute)
-
-        self.send("retained_memory_by_#{name}=", memsize_results)
-        self.send("retained_objects_by_#{name}=", count_results)
-      end
+    def initialize
+      @allocated = StatHash.new
+      @retained = StatHash.new
+      @top = 50
+    end
 
-      self.strings_allocated = string_report(allocated, top)
-      self.strings_retained = string_report(retained, top)
+    def register_results(allocated, retained, top)
+      @allocated = allocated
+      @retained = retained
+      @top = 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 strings_allocated
+      @strings_allocated ||= string_report(@allocated, @top)
+    end
+
+    def strings_retained
+      @strings_retained ||= string_report(@retained, @top)
+    end
+
     def scale_bytes(bytes)
       return "0 B" if bytes.zero?
 
@@ -73,19 +83,22 @@ module MemoryProfiler
     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 = 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
-        cutoff = grouped_strings.sort_by!(&:size)[-top].size
-        grouped_strings.keep_if { |list| list.size >= cutoff }
+        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 }
-        .first(top)
         .map! do |list|
           # Return array of [string, [[location, count], [location, count], ...]
           [
@@ -136,10 +149,10 @@ module MemoryProfiler
             end
           end
         end
-      end
 
-      io.puts
-      print_string_reports(io, options)
+        io.puts
+        print_string_reports(io, options)
+      end
 
       io.close if io.is_a? File
     end
@@ -159,7 +172,7 @@ module MemoryProfiler
       @normalize_path[path] ||= begin
         if %r!(/gems/.*)*/gems/(?<gemname>[^/]+)(?<rest>.*)! =~ path
           "#{gemname}#{rest}"
-        elsif %r!ruby/2\.[^/]+/(?<stdlib>[^/.]+)(?<rest>.*)! =~ path
+        elsif %r!ruby/\d\.[^/]+/(?<stdlib>[^/.]+)(?<rest>.*)! =~ path
           "ruby/lib/#{stdlib}#{rest}"
         elsif %r!(?<app>[^/]+/(bin|app|lib))(?<rest>.*)! =~ path
           "#{app}#{rest}"
@@ -171,6 +184,14 @@ module MemoryProfiler
 
     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

data/lib/memory_profiler/top_n.rb

@@ -5,27 +5,40 @@ module MemoryProfiler
     # 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)
+      [
+        top_n_memory(max, metric_method),
+        top_n_objects(max, metric_method)
+      ]
+    end
+
+    def top_n_memory(max, metric_method)
+      metric_memsize = Hash.new(0)
 
-      stat_totals =
-        self.values
-          .group_by(&metric_method)
-          .map do |metric, stats|
-            [metric, stats.reduce(0) { |sum, stat| sum + stat.memsize }, stats.size]
-          end
+      each_value do |value|
+        metric = value.send(metric_method)
+        metric_memsize[metric] += value.memsize
+      end
+
+      metric_memsize
+        .to_a
+        .sort_by! { |metric, memsize| [-memsize, metric] }
+        .take(max)
+        .map! { |metric, memsize| { data: metric, count: memsize } }
+    end
 
-      stats_by_memsize =
-        stat_totals
-          .sort_by! { |metric, memsize, _count| [-memsize, metric] }
-          .take(max)
-          .map! { |metric, memsize, _count| { data: metric, count: memsize } }
+    def top_n_objects(max, metric_method)
+      metric_objects_count = Hash.new(0)
 
-      stats_by_count =
-        stat_totals
-          .sort_by! { |metric, _memsize, count| [-count, metric] }
-          .take(max)
-          .map! { |metric, _memsize, count| { data: metric, count: count } }
+      each_value do |value|
+        metric = value.send(metric_method)
+        metric_objects_count[metric] += 1
+      end
 
-      [stats_by_memsize, stats_by_count]
+      metric_objects_count
+        .to_a
+        .sort_by! { |metric, count| [-count, metric] }
+        .take(max)
+        .map! { |metric, count| { data: metric, count: count } }
     end
   end
 end

data/lib/memory_profiler/version.rb

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

data/lib/memory_profiler.rb

@@ -9,6 +9,7 @@ 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)

metadata

@@ -1,26 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: memory_profiler
 version: !ruby/object:Gem::Version
-  version: 0.9.14
+  version: 1.0.1
 platform: ruby
 authors:
 - Sam Saffron
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-06-27 00:00:00.000000000 Z
+date: 2022-10-26 00:00:00.000000000 Z
 dependencies: []
-description: Memory profiling routines for Ruby 2.3+
+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,15 +45,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.3.20
+signing_key:
 specification_version: 4
-summary: Memory profiling routines for Ruby 2.3+
+summary: Memory profiling routines for Ruby 2.5+
 test_files: []