heapy 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ababd2495856e5682c0f7f136ee0fe112304bc1a
-  data.tar.gz: db47b39aa2d4207dc27a1753c1444830aba758bb
+  metadata.gz: 3e96b6f7d59e467d22dfbd41cb13ce09e262b951
+  data.tar.gz: 2538b65bed82efdf2d1e11cc6f769189fcc31e9a
 SHA512:
-  metadata.gz: 5695269c2619549c931188225fd6b52f0d2acd343f92aba069a8e3cd937d0c97d2b6b15f2585bd96ae78c905708b8612a0ff51bcbfb4ce746f6bd6df423c62f4
-  data.tar.gz: b70fbde861babd816b71ee8da6c8ecafb06192740dc4dcbdbb19ad930578925d62ffbdf295566f9e2d938366e385281303a4b1c16ad86c9486ff6f4bb8131d13
+  metadata.gz: 79d5a795873c51551eb56082e5832f03a4f5a9c6d837d14f8b4d0deb2a78c7a7682bef9183d469cb18bd32c0f87e16b596a8c6db61ce7117e62533352735d2f6
+  data.tar.gz: 797916602227e525d04af3fb9d83cb373c954a6f3ec3cfec9aa38f1df81ae2e317681565518cd97d5751e85b703e096acd9d6802047c9c040921413b12fa612b

data/.gitignore

@@ -7,3 +7,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+tmp
+.DS_Store

data/.travis.yml

@@ -1,4 +1,4 @@
 language: ruby
 rvm:
-  - 2.2.3
+  - 2.3.2
 before_install: gem install bundler -v 1.10.6

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.1.3
+
+- I'm really bad at keeping a log of changes on this project sorry
+- Printing out the memory size for a generation
+- Printing out the total number of objects for the heap in the summary
+
 ## 0.1.1
 
 - Less memory retention when parsing large heap dumps.

data/README.md

@@ -73,6 +73,8 @@ $ heapy read tmp/2015-10-01T10:18:59-05:00-heap.dump 17
          92200  /app/vendor/bundle/ruby/2.2.0/gems/activesupport-4.2.3/lib/active_support/core_ext/numeric/conversions.rb:131
 ```
 
+### Reviewing all generations
+
 If you want to read all generations you can use the "all" directive
 
 ```
@@ -89,7 +91,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/heapy. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/schneems/heapy. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
 
 
 ## License

data/lib/heapy.rb

@@ -63,138 +63,8 @@ HALP
       end
     end
   end
+end
 
-  class Analyzer
-    def initialize(filename)
-      @filename = filename
-    end
-
-    def read
-      File.open(@filename) do |f|
-        f.each_line do |line|
-          begin
-            parsed = JSON.parse(line)
-            yield parsed
-          rescue JSON::ParserError
-            puts "Could not parse #{line}"
-          end
-        end
-      end
-    end
-
-    def drill_down(generation_to_inspect)
-      puts ""
-      puts "Analyzing Heap (Generation: #{generation_to_inspect})"
-      puts "-------------------------------"
-      puts ""
-
-      generation_to_inspect = Integer(generation_to_inspect) unless generation_to_inspect == "all"
-
-      #
-      memsize_hash    = Hash.new { |h, k| h[k] = 0  }
-      count_hash      = Hash.new { |h, k| h[k] = 0  }
-      string_count    = Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = 0  } }
-
-      reference_hash  = Hash.new { |h, k| h[k] = 0  }
-
-      read do |parsed|
-        generation = parsed["generation"] || 0
-        if generation_to_inspect == "all".freeze || generation == generation_to_inspect
-          next unless parsed["file"]
-
-          key = "#{ parsed["file"] }:#{ parsed["line"] }"
-          memsize_hash[key] += parsed["memsize"] || 0
-          count_hash[key]   += 1
-
-          if parsed["type"] == "STRING".freeze
-            string_count[parsed["value"]][key] += 1 if parsed["value"]
-          end
-
-          if parsed["references"]
-            reference_hash[key] += parsed["references"].length
-          end
-        end
-      end
-
-      raise "not a valid Generation: #{generation_to_inspect.inspect}" if memsize_hash.empty?
-
-      total_memsize = memsize_hash.inject(0){|count, (k, v)| count += v}
-
-      # /Users/richardschneeman/Documents/projects/codetriage/app/views/layouts/application.html.slim:1"=>[{"address"=>"0x7f8a4fbf2328", "type"=>"STRING", "class"=>"0x7f8a4d5dec68", "bytesize"=>223051, "capacity"=>376832, "encoding"=>"UTF-8", "file"=>"/Users/richardschneeman/Documents/projects/codetriage/app/views/layouts/application.html.slim", "line"=>1, "method"=>"new", "generation"=>36, "memsize"=>377065, "flags"=>{"wb_protected"=>true, "old"=>true, "long_lived"=>true, "marked"=>true}}]}
-      puts "allocated by memory (#{total_memsize}) (in bytes)"
-      puts "=============================="
-      memsize_hash = memsize_hash.sort {|(k1, v1), (k2, v2)| v2 <=> v1 }.first(50)
-      longest      = memsize_hash.first[1].to_s.length
-      memsize_hash.each do |file_line, memsize|
-        puts "  #{memsize.to_s.rjust(longest)}  #{file_line}"
-      end
-
-      total_count = count_hash.inject(0){|count, (k, v)| count += v}
-
-      puts ""
-      puts "object count (#{total_count})"
-      puts "=============================="
-      count_hash = count_hash.sort {|(k1, v1), (k2, v2)| v2 <=> v1 }.first(50)
-      longest      = count_hash.first[1].to_s.length
-      count_hash.each do |file_line, memsize|
-        puts "  #{memsize.to_s.rjust(longest)}  #{file_line}"
-      end
-
-      puts ""
-      puts "High Ref Counts"
-      puts "=============================="
-      puts ""
-
-      reference_hash = reference_hash.sort {|(k1, v1), (k2, v2)| v2 <=> v1 }.first(50)
-      longest      = count_hash.first[1].to_s.length
-
-      reference_hash.each do |file_line, count|
-        puts "  #{count.to_s.rjust(longest)}  #{file_line}"
-      end
-
-      puts ""
-      puts "Duplicate strings"
-      puts "=============================="
-      puts ""
-      value_count = {}
-
-      string_count.each do |string, location_count_hash|
-        value_count[string] = location_count_hash.values.inject(&:+)
-      end
-
-      value_count = value_count.sort {|(k1, v1), (k2, v2)| v2 <=> v1 }.first(50)
-      longest     = value_count.first[1].to_s.length
-
-      value_count.each do |string, c1|
-
-        puts " #{c1.to_s.rjust(longest)}  #{string.inspect}"
-        string_count[string].sort {|(k1, v1), (k2, v2)| v2 <=> v1 }.each do |file_line, c2|
-         puts " #{c2.to_s.rjust(longest)}  #{file_line}"
-       end
-       puts ""
-      end
-
-    end
-
-    def analyze
-      puts ""
-      puts "Analyzing Heap"
-      puts "=============="
-      default_key = "nil".freeze
-
-      # generation number is key, value is count
-      data = Hash.new {|h, k| h[k] = 0 }
+require 'heapy/analyzer'
+require 'heapy/alive'
 
-      read do |parsed|
-        data[parsed["generation"] || 0] += 1
-      end
-
-      data = data.sort {|(k1,v1), (k2,v2)| k1 <=> k2 }
-      max_length = [data.last[0].to_s.length, default_key.length].max
-      data.each do |generation, count|
-        generation = default_key if generation == 0
-        puts "Generation: #{ generation.to_s.rjust(max_length) } object count: #{ count }"
-      end
-    end
-  end
-end

data/lib/heapy/alive.rb

@@ -0,0 +1,269 @@
+require 'objspace'
+require 'stringio'
+
+module Heapy
+
+  # This is an experimental module and likely to change. Don't use in production.
+  #
+  # Use at your own risk. APIs are not stable.
+  #
+  # == What
+  #
+  # You can use it to trace objects to see if they are still "alive" in memory.
+  # Unlike the heapy CLI this is meant to be used in live running code.
+  #
+  # This works by retaining an object's address in memory, then running GC
+  # and taking a heap dump. If the object exists in the heap dump, it is retained.
+  # Since we have the whole heap dump we can also do things like find what is retaining
+  # your object preventing it from being collected.
+  #
+  # == Use It
+  #
+  # You need to first start tracing objects:
+  #
+  #   Heapy::Alive.start_object_trace!(heap_file: "./tmp/heap.json")
+  #
+  # Next in your code you want to specify the object ato trace
+  #
+  #   string = "hello world"
+  #   Heapy::Alive.trace_without_retain(string)
+  #
+  # When the code is done executing you can get a reference to all "tracer"
+  # objects by running:
+  #
+  #   Heapy::Alive.traced_objects.each do |tracer|
+  #     puts tracer.raw_json_hash if tracer.object_retained?
+  #   end
+  #
+  # A few helpful methods on `tracer` objects:
+  #
+  # - `raw_json_hash` returns the hash of the object from the heap dump.
+  # - `object_retained?` returns truthy if the object was still present in the heap dump.
+  # - `address` a string of the memory address of the object you're tracing.
+  # - `tracked_to_s` a string that represents the object you're tracing (default
+  #    is result of calling inspect on the method). You can pass in a custom representation
+  #    when initializing the object. Can be useful for when `inspect` on the object you
+  #    are tracing is too verbose.
+  # - `id2ref` returns the original object being traced (if it is still in memory).
+  # - `root?` returns false if the tracer isn't the root object.
+  #
+  # See `ObjectTracker` for more methods.
+  #
+  # If you want to see what retains an object, you can use `ObectTracker#retained_by`
+  # method (caution this is extremely expensive and requires re-walking the whole heap dump:
+  #
+  #   Heapy::Alive.traced_objects.each do |tracer|
+  #     if tracer.object_retained?
+  #       puts "Traced: #{tracer.raw_json_hash}"
+  #       tracer.retained_by.each do |retainer|
+  #         puts "  Retained by: #{retainer.raw_json_hash}"
+  #       end
+  #     end
+  #   end
+  #
+  # You can iterate up the whole retained tree by using the `retained_by` method on tracers
+  # returned. But again it's expensive. If you have large heap dump or if you're tracing a bunch
+  # of objects, continuously calling `retained_by` will take lots of time. We also don't
+  # do any circular dependency detection so if you have two objects that depend on each other,
+  # you may hit an infinite loop.
+  #
+  # If you know that you'll need the retained objects of the main objects you're tracing you can
+  # save re-walking the heap the first N times by using the `retained_by` flag:
+  #
+  #   Heapy::Alive.traced_objects(retained_by: true) do |tracer|
+  #     # ...
+  #   end
+  #
+  # This will pre-fetch the first level of "parents" for each object you're tracing.
+  #
+  # Did I mention this is all experimental and may change?
+  module Alive
+    @mutex = Mutex.new
+    @retain_hash = {}
+    @heap_file   = nil
+    @started     = false
+
+    def self.address_to_object(address)
+      obj_id = address.to_i(16) / 2
+      ObjectSpace._id2ref(obj_id)
+    rescue RangeError
+      nil
+    end
+
+    def self.start_object_trace!(heap_file: "./tmp/heap.json")
+      @mutex.synchronize do
+        @started   ||= true && ObjectSpace.trace_object_allocations_start
+        @heap_file ||= heap_file
+      end
+    end
+
+    def self.trace_without_retain(object, to_s: nil)
+      tracker = ObjectTracker.new(object_id: object.object_id, to_s: to_s || object.inspect)
+      @mutex.synchronize do
+        @retain_hash[tracker.address] = tracker
+      end
+    end
+
+    def self.retained_by(tracer: nil, address: nil)
+      target_address = address || tracer.address
+      tracer         = tracer  || @retain_hash[address]
+
+      raise "not a valid address #{target_address}" if target_address.nil?
+
+      retainer_array = []
+      Analyzer.new(@heap_file).read do |json_hash|
+        retainers_from_json_hash(json_hash, target_address: target_address, retainer_array: retainer_array)
+      end
+
+      retainer_array
+    end
+
+    class << self
+      private def retainers_from_json_hash(json_hash, retainer_array:, target_address:)
+        references = json_hash["references"]
+        return unless references
+
+        references.each do |address|
+          next unless address == target_address
+
+          if json_hash["root"]
+            retainer = RootTracker.new(json_hash)
+          else
+            address        = json_hash["address"]
+            representation = self.address_to_object(address)&.inspect || "object not traced".freeze
+            retainer = ObjectTracker.new(address: address, to_s: representation)
+            retainer.raw_json_hash = json_hash
+          end
+
+          retainer_array << retainer
+        end
+      end
+    end
+
+  private
+    @string_io = StringIO.new
+    # GIANT BALL OF HACKS || THERE BE DRAGONS
+    #
+    # There is so much I don't understand on why I need to do the things
+    # I'm doing in this method.
+    #
+    # Also see `living_dead` https://github.com/schneems/living_dead
+    def self.gc_start
+      # During debugging I found calling "puts" made some things
+      # mysteriously work, I have no idea why. If you remove this line
+      # then (more) tests fail. Maybe it has something to do with the way
+      # GC interacts with IO? I seriously have no idea.
+      #
+      @string_io.puts "=="
+
+      # Calling flush so we don't create a memory leak.
+      # Funny enough maybe calling flush without `puts` also works?
+      # IDK
+      #
+      @string_io.flush
+
+      # Calling GC multiple times fixes a different class of things
+      # Specifically the singleton_class.instance_eval tests.
+      # It might also be related to calling GC in a block, but changing
+      # to 1.times brings back failures.
+      #
+      # Calling 2 times results in eventual failure https://twitter.com/schneems/status/804369346910896128
+      # Calling 5 times results in eventual failure https://twitter.com/schneems/status/804382968307445760
+      # Trying 10 times
+      #
+      10.times { GC.start }
+    end
+  public
+
+    def self.traced_objects(retained_by: false)
+      raise "You aren't tracing anything call Heapy::Alive.trace_without_retain first" if @retain_hash.empty?
+      self.gc_start
+
+      ObjectSpace.dump_all(output: File.open(@heap_file,'w'))
+
+      retainer_address_array_hash = {}
+
+      Analyzer.new(@heap_file).read do |json_hash|
+        address = json_hash["address"]
+        tracer = @retain_hash[address]
+        next unless tracer
+        tracer.raw_json_hash = json_hash
+
+        if retained_by
+          retainers_from_json_hash(json_hash, target_address: address, retainer_array: tracer.retained_by)
+        end
+      end
+      @retain_hash.values
+    end
+
+    class RootTracker
+      def initialize(json)
+        @raw_json_hash = json
+      end
+
+      def references
+        []
+      end
+
+      def id2ref
+        raise "cannot turn root object into an object"
+      end
+
+      def root?
+        true
+      end
+
+      def address
+        raise "root does not have an address"
+      end
+
+      def object_retained?
+        true
+      end
+
+      def tracked_to_s
+        "ROOT"
+      end
+    end
+
+    class ObjectTracker
+      attr_reader :address, :tracked_to_s
+
+      def initialize(object_id: nil, address: nil, to_s: )
+        if object_id
+          @address = "0x#{ (object_id << 1).to_s(16) }"
+        else
+          @address = address
+        end
+
+        raise "must provide address: #{@address.inspect}" if @address.nil?
+
+        @tracked_to_s = to_s.dup
+        @retained_by  = nil
+      end
+
+      def id2ref
+        Heapy::Alive.address_to_object(address)
+      end
+
+      def root?
+        false
+      end
+
+      def object_retained?
+        raw_json_hash && raw_json_hash["address"]
+      end
+
+      def retainer_array
+        @retained_by ||= []
+        @retained_by
+      end
+
+      def retained_by
+        @retained_by || Heapy::Alive.retained_by(tracer: self)
+      end
+
+      attr_accessor :raw_json_hash
+    end
+  end
+end

data/lib/heapy/analyzer.rb

@@ -0,0 +1,151 @@
+module Heapy
+  class Analyzer
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def read
+      File.open(@filename) do |f|
+        f.each_line do |line|
+          begin
+            parsed = JSON.parse(line)
+            yield parsed
+          rescue JSON::ParserError
+            puts "Could not parse #{line}"
+          end
+        end
+      end
+    end
+
+    def drill_down(generation_to_inspect)
+      puts ""
+      puts "Analyzing Heap (Generation: #{generation_to_inspect})"
+      puts "-------------------------------"
+      puts ""
+
+      generation_to_inspect = Integer(generation_to_inspect) unless generation_to_inspect == "all"
+
+      #
+      memsize_hash    = Hash.new { |h, k| h[k] = 0  }
+      count_hash      = Hash.new { |h, k| h[k] = 0  }
+      string_count    = Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = 0  } }
+
+      reference_hash  = Hash.new { |h, k| h[k] = 0  }
+
+      read do |parsed|
+        generation = parsed["generation"] || 0
+        if generation_to_inspect == "all".freeze || generation == generation_to_inspect
+          next unless parsed["file"]
+
+          key = "#{ parsed["file"] }:#{ parsed["line"] }"
+          memsize_hash[key] += parsed["memsize"] || 0
+          count_hash[key]   += 1
+
+          if parsed["type"] == "STRING".freeze
+            string_count[parsed["value"]][key] += 1 if parsed["value"]
+          end
+
+          if parsed["references"]
+            reference_hash[key] += parsed["references"].length
+          end
+        end
+      end
+
+      raise "not a valid Generation: #{generation_to_inspect.inspect}" if memsize_hash.empty?
+
+      total_memsize = memsize_hash.inject(0){|count, (k, v)| count += v}
+
+      # /Users/richardschneeman/Documents/projects/codetriage/app/views/layouts/application.html.slim:1"=>[{"address"=>"0x7f8a4fbf2328", "type"=>"STRING", "class"=>"0x7f8a4d5dec68", "bytesize"=>223051, "capacity"=>376832, "encoding"=>"UTF-8", "file"=>"/Users/richardschneeman/Documents/projects/codetriage/app/views/layouts/application.html.slim", "line"=>1, "method"=>"new", "generation"=>36, "memsize"=>377065, "flags"=>{"wb_protected"=>true, "old"=>true, "long_lived"=>true, "marked"=>true}}]}
+      puts "allocated by memory (#{total_memsize}) (in bytes)"
+      puts "=============================="
+      memsize_hash = memsize_hash.sort {|(k1, v1), (k2, v2)| v2 <=> v1 }.first(50)
+      longest      = memsize_hash.first[1].to_s.length
+      memsize_hash.each do |file_line, memsize|
+        puts "  #{memsize.to_s.rjust(longest)}  #{file_line}"
+      end
+
+      total_count = count_hash.inject(0){|count, (k, v)| count += v}
+
+      puts ""
+      puts "object count (#{total_count})"
+      puts "=============================="
+      count_hash = count_hash.sort {|(k1, v1), (k2, v2)| v2 <=> v1 }.first(50)
+      longest      = count_hash.first[1].to_s.length
+      count_hash.each do |file_line, memsize|
+        puts "  #{memsize.to_s.rjust(longest)}  #{file_line}"
+      end
+
+      puts ""
+      puts "High Ref Counts"
+      puts "=============================="
+      puts ""
+
+      reference_hash = reference_hash.sort {|(k1, v1), (k2, v2)| v2 <=> v1 }.first(50)
+      longest      = count_hash.first[1].to_s.length
+
+      reference_hash.each do |file_line, count|
+        puts "  #{count.to_s.rjust(longest)}  #{file_line}"
+      end
+
+      if !string_count.empty?
+        puts ""
+        puts "Duplicate strings"
+        puts "=============================="
+        puts ""
+
+        value_count = {}
+
+        string_count.each do |string, location_count_hash|
+          value_count[string] = location_count_hash.values.inject(&:+)
+        end
+
+        value_count = value_count.sort {|(k1, v1), (k2, v2)| v2 <=> v1 }.first(50)
+        longest     = value_count.first[1].to_s.length
+
+        value_count.each do |string, c1|
+
+          puts " #{c1.to_s.rjust(longest)}  #{string.inspect}"
+          string_count[string].sort {|(k1, v1), (k2, v2)| v2 <=> v1 }.each do |file_line, c2|
+           puts " #{c2.to_s.rjust(longest)}  #{file_line}"
+         end
+         puts ""
+        end
+      end
+
+    end
+
+    def analyze
+      puts ""
+      puts "Analyzing Heap"
+      puts "=============="
+      default_key = "nil".freeze
+
+      # generation number is key, value is count
+      data = Hash.new {|h, k| h[k] = 0 }
+      mem = Hash.new {|h, k| h[k] = 0 }
+      total_count = 0
+      total_mem = 0
+
+      read do |parsed|
+        data[parsed["generation"] || 0] += 1
+        mem[parsed["generation"] || 0] += parsed["memsize"] || 0
+      end
+
+      data = data.sort {|(k1,v1), (k2,v2)| k1 <=> k2 }
+      max_length = [data.last[0].to_s.length, default_key.length].max
+      data.each do |generation, count|
+        generation = default_key if generation == 0
+        total_count += count
+        total_mem += mem[generation]
+        puts "Generation: #{ generation.to_s.rjust(max_length) } object count: #{ count }, mem: #{(mem[generation].to_f / 1024).round(1)} kb"
+      end
+
+      puts ""
+      puts "Heap total"
+      puts "=============="
+      puts "Generations (active): #{data.length}"
+      puts "Count: #{total_count}"
+      puts "Memory: #{(total_mem.to_f / 1024).round(1)} kb"
+    end
+  end
+end

data/lib/heapy/version.rb

@@ -1,3 +1,3 @@
 module Heapy
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/scratch.rb

@@ -1,16 +1,64 @@
-require 'objspace'
 
-ObjectSpace.trace_object_allocations_start
 
-array = []
-10_000.times do |x|
-  a = "#{x}_foo"
-  array << a
-end
 
-# GC.start
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../lib")))
+
+load File.expand_path(File.join(__FILE__, "../lib/heapy.rb"))
+
+
+# class Foo
+# end
+
+# class Bar
+# end
+
+# class Baz
+# end
+
+# def run
+#     foo = Foo.new
+#     Heapy::Alive.trace_without_retain(foo)
+#     foo.singleton_class
+#     foo = nil
+
+#     bar = Bar.new
+#     Heapy::Alive.trace_without_retain(bar)
+#     bar.singleton_class
+#     bar = nil
 
-file_name = "/tmp/#{Time.now.to_f}-heap.dump"
-ObjectSpace.dump_all(output: File.open(file_name, 'w'))
+#     baz = Baz.new
+#     Heapy::Alive.trace_without_retain(baz)
+#     baz.singleton_class
+#     baz = nil
+#   nil
+# end
 
-puts "bin/heapy read #{file_name}"
+# Heapy::Alive.start_object_trace!
+
+# run
+
+# objects = Heapy::Alive.traced_objects.each do |obj|
+#   puts "Address: #{obj.address} #{obj.tracked_to_s}\n  #{obj.raw_json_hash || "not found" }"
+# end
+
+Heapy::Alive.start_object_trace!
+
+def run
+  foo = ""
+  Heapy::Alive.trace_without_retain(foo)
+  b = []
+  b << foo
+  b
+end
+
+c = run
+
+objects = Heapy::Alive.traced_objects.each do |tracer|
+  puts "== Address: #{tracer.address} #{tracer.tracked_to_s}\n  #{tracer.raw_json_hash || "not found" }"
+  # tracer.raw_json_hash["references"].each do |address|
+  #   puts Heapy::Alive.address_to_object(address)
+  # end
+  Heapy::Alive.retained_by(tracer: tracer).each do |obj|
+    puts obj.inspect
+  end
+end

data/weird_memory/run.rb

@@ -0,0 +1,31 @@
+arg = ARGV.shift
+
+@fail_count = 0
+
+require 'fileutils'
+FileUtils.mkdir_p("tmp")
+
+def run(file, fail_count: @fail_count)
+  cmd = "bundle exec ruby #{file}"
+  puts "  $ #{ cmd }"
+  result = `#{cmd}`
+  @fail_count += 1 if result.match(/FAIL/)
+  puts "    " + result
+end
+
+if arg.nil? || arg.downcase == "all"
+  puts "== Running all directories (#{`ruby -v`.strip})"
+  Dir.glob("weird_memory/**/*.rb").each do |file|
+    next if file == __FILE__
+    run(file)
+  end
+else
+  puts "== Running examples in `#{arg}` directory (#{`ruby -v`.strip})"
+
+  Dir.glob("weird_memory/#{arg}/**/*.rb").each do |file|
+    run(file)
+  end
+end
+
+puts
+puts "Total failed: #{@fail_count}"

data/weird_memory/singleton_class/singleton_class.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+def run
+  string = ""
+  Heapy::Alive.trace_without_retain(string)
+  string.singleton_class
+  string
+
+  return nil
+end
+
+run
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/singleton_class/singleton_class_in_class.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+class Runner
+
+  def run
+    string = ""
+    Heapy::Alive.trace_without_retain(string)
+    string.singleton_class
+    string
+
+    return nil
+  end
+end
+
+Runner.new.run
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/singleton_class/singleton_class_in_proc.rb

@@ -0,0 +1,28 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+def run
+  -> {
+    string = ""
+    Heapy::Alive.trace_without_retain(string)
+    string.singleton_class
+    string
+  }.call
+
+  return nil
+end
+
+run
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/singleton_class/singleton_class_method_in_proc.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+def run
+  string = ""
+  Heapy::Alive.trace_without_retain(string)
+  string.singleton_class
+  string
+
+  return nil
+end
+
+-> { run }.call
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/singleton_class_instance_eval/singleton_class_instance_eval.rb

@@ -0,0 +1,27 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+def run
+  string = ""
+  Heapy::Alive.trace_without_retain(string)
+  string.singleton_class.instance_eval do
+  end
+  string
+
+  return nil
+end
+
+run
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/singleton_class_instance_eval/singleton_class_instance_eval_in_class.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+class Runner
+  def run
+    string = ""
+    Heapy::Alive.trace_without_retain(string)
+    string.singleton_class.instance_eval do
+    end
+    string
+
+    return nil
+  end
+end
+
+Runner.new.run
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/singleton_class_instance_eval/singleton_class_instance_eval_in_proc.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+def run
+  -> {
+    string = ""
+    Heapy::Alive.trace_without_retain(string)
+    string.singleton_class.instance_eval do
+    end
+    string
+  }.call
+
+  return nil
+end
+
+run
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/singleton_class_instance_eval/singleton_class_instance_eval_method_in_proc.rb

@@ -0,0 +1,27 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+def run
+  string = ""
+  Heapy::Alive.trace_without_retain(string)
+  string.singleton_class.instance_eval do
+  end
+  string
+
+  return nil
+end
+
+-> { run }.call
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/string/string.rb

@@ -0,0 +1,25 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+def run
+  string = ""
+  Heapy::Alive.trace_without_retain(string)
+  string
+
+  return nil
+end
+
+run
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/string/string_in_class.rb

@@ -0,0 +1,27 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+class Runner
+  def run
+    string = ""
+    Heapy::Alive.trace_without_retain(string)
+    string
+
+    return nil
+  end
+end
+
+Runner.new.run
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/string/string_in_proc.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+def run
+  -> {
+    string = ""
+    Heapy::Alive.trace_without_retain(string)
+    string
+  }.call
+  return nil
+end
+
+run
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/string/string_method_in_proc.rb

@@ -0,0 +1,25 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+def run
+  string = ""
+  Heapy::Alive.trace_without_retain(string)
+  string
+
+  return nil
+end
+
+-> {run}.call
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/times_map/times_map.rb

@@ -0,0 +1,28 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+def run
+  array = 1.times.map {
+    string = ""
+    Heapy::Alive.trace_without_retain(string)
+    string
+  }
+  array = nil
+  return nil
+end
+
+run
+
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/times_map/times_map_in_class.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+class Runner
+  def run
+    array = 1.times.map {
+      string = ""
+      Heapy::Alive.trace_without_retain(string)
+      string
+    }
+    array = nil
+    return nil
+  end
+end
+
+Runner.new.run
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/times_map/times_map_in_proc.rb

@@ -0,0 +1,30 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+def run
+  -> {
+    array = 1.times.map {
+      string = ""
+      Heapy::Alive.trace_without_retain(string)
+      string
+    }
+    array = nil
+  }.call
+
+  return nil
+end
+
+run
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

data/weird_memory/times_map/times_map_method_in_proc.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "../../../lib")))
+
+require 'heapy'
+
+
+Heapy::Alive.start_object_trace!(heap_file: ENV.fetch('HEAP_FILE') { 'tmp/heap.json' })
+
+def run
+  array = 1.times.map {
+    string = ""
+    Heapy::Alive.trace_without_retain(string)
+    string
+  }
+  array = nil
+  return nil
+end
+
+-> { run }.call
+
+alive_count = Heapy::Alive.traced_objects.select {|tracer|
+  tracer.object_retained?
+}.length
+# should return 0, no traced objects are returned
+
+
+expected = 0
+actual = alive_count
+result = expected == actual ? "PASS" : "FAIL"
+puts "#{result}: expected: #{expected}, actual: #{actual}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: heapy
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - schneems
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-23 00:00:00.000000000 Z
+date: 2017-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,9 +73,28 @@ files:
 - bin/heapy
 - heapy.gemspec
 - lib/heapy.rb
+- lib/heapy/alive.rb
+- lib/heapy/analyzer.rb
 - lib/heapy/version.rb
 - scratch.rb
 - trace.rb
+- weird_memory/run.rb
+- weird_memory/singleton_class/singleton_class.rb
+- weird_memory/singleton_class/singleton_class_in_class.rb
+- weird_memory/singleton_class/singleton_class_in_proc.rb
+- weird_memory/singleton_class/singleton_class_method_in_proc.rb
+- weird_memory/singleton_class_instance_eval/singleton_class_instance_eval.rb
+- weird_memory/singleton_class_instance_eval/singleton_class_instance_eval_in_class.rb
+- weird_memory/singleton_class_instance_eval/singleton_class_instance_eval_in_proc.rb
+- weird_memory/singleton_class_instance_eval/singleton_class_instance_eval_method_in_proc.rb
+- weird_memory/string/string.rb
+- weird_memory/string/string_in_class.rb
+- weird_memory/string/string_in_proc.rb
+- weird_memory/string/string_method_in_proc.rb
+- weird_memory/times_map/times_map.rb
+- weird_memory/times_map/times_map_in_class.rb
+- weird_memory/times_map/times_map_in_proc.rb
+- weird_memory/times_map/times_map_method_in_proc.rb
 homepage: https://github.com/schneems/heapy
 licenses:
 - MIT
@@ -96,7 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.0
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Inspects Ruby heap dumps