memtf 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f77e6fb9813978dda4987dc20dddb424c4a1c1b5
-  data.tar.gz: 6f5b28f54b82938efadaa508f09e5d550a1a2978
+  metadata.gz: 6c248874dd670cf32b12d58d1ffb8c10f799cfa8
+  data.tar.gz: a9c0bd0d27092285884f10abe2191a5672b7ac2f
 SHA512:
-  metadata.gz: df1fe991d654a1c019e72121bd4c4fa38fbc8564727dc29ce0e6faa8dc2684c735e440b96758aca6bc50dd462fdeb3176aa8513978e14ffc73ce6a94d69af660
-  data.tar.gz: 9abcd938d071c1728be1e6609f89747492d80df7b9087d510e50266a9b5a304b2aab4e418e8f0c438d0e666269fbf949d9fd2bf767223ae96280a4ee5fbe110b
+  metadata.gz: 69e7d5eff222b8860da1f6821f418358d80087782ab6f0fb02a7b8b0d5e164945a91f358c126a735085e7301e4336b8d14441a09ef4af5bb7586b2fd6825df64
+  data.tar.gz: d683378a0345795576cb00db1145a60f4ed095a4ffcd5d22fd3a8141bb2be52536aa7a072e2a6765e92b33f640e441d96cec552383a72259ffdd80c515fe3eb1

data/.gitignore

@@ -3,6 +3,7 @@
 .bundle
 .config
 .yardoc
+.DS_Store
 Gemfile.lock
 InstalledFiles
 _yardoc
@@ -15,3 +16,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+

data/README.md

@@ -1,3 +1,4 @@
+[![Gem Version](https://badge.fury.io/rb/memtf.png)](http://badge.fury.io/rb/memtf)
 [![Build Status](https://secure.travis-ci.org/dresselm/memtf.png)](http://travis-ci.org/dresselm/memtf)
 
 # Memtf
@@ -6,6 +7,22 @@ A simple utility to help isolate memory leaks in your ruby applications.
 
 ## Why do we need another 'memory profiler'?
 
+Simplicity and focus.  This utility is limited in its features, but should help you quickly isolate the
+class that is causing the bloat.  This alone may be enough.  No patches to ruby, no complicated setup and
+no confusing output.
+
+Future releases will support a second pass to drill into a given class.  Hopefully this 2-stroke approach
+will be sufficient for most memory leaks.
+
+In the meantime, here are some other memory utilities that may help:
+
+* [perftools](https://github.com/tmm1/perftools.rb) - Aman Gupta, enough said - low-level sampling profiler
+* [memprof](https://github.com/ice799/memprof) - Joe Damato, not sure which versions of ruby are supported
+* [rubymass](https://github.com/archan937/ruby-mass) - pure ruby and easy to use
+* [memlog](https://rubygems.org/gems/memlog) - pure ruby and extremely limited, but may help you get started
+
+Let me know if there are others that I should add to the above list.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -46,21 +63,34 @@ The APIs used by the gem require ruby 1.9.3+.
 	>   500000.times { |i| leaky_array << "#{i % 2}-#{Time.now.to_i}" }
     > end
 
-    +-----------------------------+---------+---------+--------+
-    | Class                       | Objects | Leakage | Impact |
-    +-----------------------------+---------+---------+--------+
-    | Array                       | 2189    | 4.972MB | 96.85% |
-    | RubyVM::InstructionSequence | 99      | 0.127MB | 2.47%  |
-    | Module                      | 18      | 0.017MB | 0.33%  |
-    | Class                       | 13      | 0.010MB | 0.20%  |
-    | String                      | 663007  | 0.006MB | 0.12%  |
-    | Regexp                      | 2       | 0.001MB | 0.02%  |
-    | Hash                        | 9       | 0.001MB | 0.02%  |
-    | Thread                      | 0       | 0.000MB | 0.00%  |
-    +-----------------------------+---------+---------+--------+
+    +-----------------------------+--------+---------+---------+---------+---------+
+    | Class                       | Impact | Leakage | Change  | Objects | Change  |
+    +-----------------------------+--------+---------+---------+---------+---------+
+    | Array                       | 96.85% | 4.972MB | 4.972MB | 2189    | 1985    |
+    | RubyVM::InstructionSequence | 2.47%  | 0.127MB | 0.000MB | 99      | 0       |
+    | Module                      | 0.33%  | 0.017MB | 0.002MB | 18      | 0       |
+    | Class                       | 0.20%  | 0.010MB | 0.001MB | 13      | 0       |
+    | String                      | 0.12%  | 0.006MB | 0.001MB | 663007  | 123650  |
+    | Regexp                      | 0.02%  | 0.001MB | 0.000MB | 2       | 0       |
+    | Hash                        | 0.02%  | 0.001MB | 0.001MB | 9       | 2       |
+    | Thread                      | 0.00%  | 0.000MB | 0.000MB | 0       | 0       |
+    +-----------------------------+--------+---------+---------+---------+---------+
 
 ## What should I do with these results?
 
+If there is an obvious Class that is impacting the overall memory footprint asymmetrically, then
+you should focus further efforts on that and identifying where it is referenced and what it
+references.
+
+If there is no obvious Class, then either you need to better reproduce the leak (more iterations,
+execute different paths, etc), or multiple Classes are leaking.  If the latter, then try to create
+a focused test that narrows down the leak.
+
+If the highlighted Class is a generic container, like Array or Hash, the leak is probably one or more
+Classes referenced within the container. I am working on additional functionality to expose the most
+likely candidates.  While I build out this and other additional functionality, please use the tools
+mentioned above to help isolate the leak.
+
 ## Contributing
 
 1. Fork it

data/lib/memtf.rb

@@ -1,18 +1,25 @@
+# A simple utility to help isolate memory leaks.  Two
+# memory snapshots are compared to determine which
+# classes, if any, are leaking.
 module Memtf
-  # Represents the starting
+  # Represents the starting memory snapshot
   START = :start
-  # Represents the end of a run
+  # Represents the ending memory snapshot
   STOP  = :stop
 
   class << self
     attr_accessor :runner
 
+    # Generate an initial memory snapshot.
+    #
     # @param [Hash] options
     # @return [Runner]
     def start(options={})
       self.runner = Runner.run(START, options)
     end
 
+    # Generate a final memory snapshot.
+    #
     # @param [Hash] options
     def stop(options={})
       default_group = self.runner.group
@@ -21,6 +28,9 @@ module Memtf
       self.runner = nil
     end
 
+    # Generate an initial memory snapshot, execute
+    # the block, then generate the final memory snapshot.
+    #
     # @param [Hash] options
     def around(options={}, &block)
       start(options)

data/lib/memtf/analyzer.rb

@@ -1,22 +1,32 @@
-require 'objspace'
-
+# Encapsulates logic that measures the memory footprint of all
+# objects at a given point in time and compares the memory footprints
+# of two points in time.
 class Memtf::Analyzer
 
-  attr_reader :threshold, :filter
+  attr_reader :threshold, :filter, :memory_tracker
 
+  # The threshold of total memory consumption required
+  # to be included in the output
   DEFAULT_THRESHOLD = 0.005
+  # Represents 1 million bytes
   MB = 1024.0**2
 
+  # Determine the memory footprint of each class and filter out classes
+  # that do not meet the configured threshold.
+  #
   # @param [Hash] options
   def self.analyze(options={})
     new(options).analyze
   end
 
+  # Compare the memory footprints for the start and end memory snapshots
+  # within the same snapshot group.
+  #
   # @param [String] group
   # @return [Hash]
   def self.analyze_group(group)
-    start_analysis = Memtf::Persistance.load(Memtf::START,  group)
-    end_analysis   = Memtf::Persistance.load(Memtf::STOP,   group)
+    start_analysis = Memtf::Persistance.load(Memtf::START, group)
+    end_analysis   = Memtf::Persistance.load(Memtf::STOP,  group)
 
     comparison    = {}
     total_memsize = 0
@@ -29,32 +39,41 @@ class Memtf::Analyzer
         start_val = start_stats.nil? ? 0 : start_stats[stat_key]
         end_val   = end_stats[stat_key]
         delta     = end_val - start_val
-        comparison[clazz][stat_key] = delta
 
-        # Perhaps just compare this
-        total_memsize += delta if stat_key == 'size'
+        comparison[clazz][stat_key]            = end_val
+        comparison[clazz]["#{stat_key}_delta"] = delta
+
+        total_memsize += end_val if stat_key == 'size'
       end
     end
 
     # Determine the relative memory impact of each class
+    # TODO look into object count impact via ObjectSpace.count_objects
     comparison.keys.each do |klazz|
       stats           = comparison[klazz]
-      stats['impact'] = stats['size'] / total_memsize
+      stats['impact'] = (stats['size']*1.0) / total_memsize
     end
 
     comparison
   end
 
   def initialize(options={})
-    @filter    = options[:filter]
-    @threshold = options.fetch(:threshold, DEFAULT_THRESHOLD)
+    @filter         = options[:filter]
+    @threshold      = options.fetch(:threshold, DEFAULT_THRESHOLD)
+    @memory_tracker = options.fetch(:memory_tracker, Memtf::Analyzer::Memory)
   end
 
+  # Determine the memory footprint of each class and filter out classes
+  # that do not meet the configured threshold.
+  #
   # @return [Hash]
   def analyze
+    # Signal a new GC to attempt to clear out non-leaked memory
+    # TODO investigate ObjectSpace.garbage_collect
     GC.start
 
     classes_stats = {}
+    # TODO investigate ObjectSpace.count_objects_size[:TOTAL]
     total_memsize = 0
 
     # Track the memory footprint of each class
@@ -69,13 +88,15 @@ class Memtf::Analyzer
     #     'String' => [2,1]
     #   }
     #
-    ObjectSpace.each_object do |obj|
+    memory_tracker.iterate do |obj|
       if (clazz = obj.class).respond_to?(:name)
         class_name    = clazz.name
         class_stats   = (classes_stats[class_name] ||= [])
 
-        obj_memsize   = ObjectSpace.memsize_of(obj)
+        obj_memsize   = memory_tracker.size_of(obj)
         class_stats   << obj_memsize
+
+        # Note: could also use ObjectSpace.memsize_of_all(clazz)
         total_memsize += obj_memsize
       end
     end
@@ -143,4 +164,6 @@ class Memtf::Analyzer
     smh_hash
   end
 
-end
+end
+
+require 'memtf/analyzer/memory'

data/lib/memtf/analyzer/memory.rb

@@ -0,0 +1,21 @@
+require 'objspace'
+
+# Encapsulate implementation of object memory tracking
+class Memtf::Analyzer::Memory
+  class << self
+    # Iterate over each object on the heap
+    def iterate(&block)
+      ObjectSpace.each_object do |obj|
+        block.call(obj)
+      end
+    end
+
+    # Calculate the memory allocated to a given Object in bytes
+    #
+    # @param [Object] object
+    # @return [Number]
+    def size_of(object)
+      ObjectSpace.memsize_of(object)
+    end
+  end
+end

data/lib/memtf/persistance.rb

@@ -1,10 +1,15 @@
 require 'fileutils'
 require 'multi_json'
 
+# Encapsulates the logic and mechanism for saving
+# and loading raw memory data.
 class Memtf::Persistance
+  # The directory where raw data is stored
   OUTPUT_DIR = "tmp/memtf"
 
   class << self
+    # Serialize group data to the filesystem.
+    #
     # @param [String] name
     # @param [String] group
     # @param [Object] payload
@@ -12,17 +17,19 @@ class Memtf::Persistance
       group_directory = group_dir(group)
       FileUtils.mkdir_p("#{group_directory}")
 
-      save_file = "#{group_directory}/#{name}.json"
+      save_file = "#{group_directory}/#{name}-#{Process.pid}.json"
       File.open(save_file, 'w+') do |f|
-        f.puts ::MultiJson.encode(payload)
+        f.print ::MultiJson.encode(payload)
       end
     end
 
+    # De-serialize group data from the filesystem.
+    #
     # @param [String] name
     # @param [String] group
     # @return [Object]
     def load(name, group)
-      load_file = "#{group_dir(group)}/#{name}.json"
+      load_file = "#{group_dir(group)}/#{name}-#{Process.pid}.json"
       ::MultiJson.decode File.read(load_file)
     end
 
@@ -34,4 +41,4 @@ class Memtf::Persistance
       "#{OUTPUT_DIR}/#{group}"
     end
   end
-end
+end

data/lib/memtf/reporter.rb

@@ -1,9 +1,23 @@
 require 'terminal-table'
 
+# Encapsulates the formatting and output of Memtf analysis.
+#
+# Example Report:
+#
+#   +-----------------------------+--------+---------+---------+---------+---------+
+#   | Class                       | Impact | Leakage | Change  | Objects | Change  |
+#   +-----------------------------+--------+---------+---------+---------+---------+
+#   | Array                       | 96.85% | 4.972MB | 4.972MB | 2189    | 1985    |
+#   ...
+#
 class Memtf::Reporter
+  # The report table headers
+  HEADERS = ['Class', 'Impact', 'Leakage', 'Change', 'Objects', 'Change']
 
   attr_reader :group, :options
 
+  # Print the analysis in a concise tabular format.
+  #
   # @param [String] group
   def self.report(group)
     new(group).report
@@ -14,12 +28,19 @@ class Memtf::Reporter
     @options = options
   end
 
+  # Print the analysis in a concise tabular format.
+  #
   # @return [Terminal::Table]
   def report
-    Terminal::Table.new(:headings => ['Class', 'Objects', 'Leakage', 'Impact']) do |t|
+    Terminal::Table.new(:headings => HEADERS) do |t|
       group_analysis = Memtf::Analyzer.analyze_group(group)
       group_analysis.sort_by { |k,v| -v['impact'] }.each do |k,v|
-        t << [k,v['count'],to_MB(v['size']),to_pct(v['impact'])]
+        t << [k,
+              to_pct(v['impact']),
+              to_MB(v['size']),
+              to_MB(v['size_delta']),
+              v['count'],
+              v['count_delta']]
       end
     end
   end
@@ -35,4 +56,4 @@ class Memtf::Reporter
   def to_pct(num)
     "%.2f%" % [num * 100]
   end
-end
+end

data/lib/memtf/runner.rb

@@ -1,6 +1,10 @@
+# Encapsulates the multiple steps required to accomplish
+# Memtf analysis and reporting.
 class Memtf::Runner
 	attr_reader :group, :options, :report
 
+  # Run the Memtf analysis and reporting.
+  #
   # @param [String] stage
   # @param [Hash] options
 	def self.run(stage, options={})
@@ -12,7 +16,10 @@ class Memtf::Runner
 		@options = options
 	end
 
+  # Run the Memtf analysis and reporting.
+  #
   # @param [String] stage
+  # @return [Memtf::Runner]
 	def run(stage)
 		analysis = Memtf::Analyzer.analyze(options)
     Memtf::Persistance.save(stage, group, analysis)
@@ -25,4 +32,4 @@ class Memtf::Runner
 
 		self
 	end
-end
+end

data/lib/memtf/utilities.rb

@@ -1,4 +1,5 @@
+# Common utilities
 module Memtf::Utilities
 end
 
-require 'memtf/utilities/array'
+require 'memtf/utilities/array'

data/lib/memtf/utilities/array.rb

@@ -1,10 +1,15 @@
+# Monkeypatch Array with various utilities.
 module Memtf::Utilities::Array
+
+  # Add up all array elements.
+  #
   # @return [Number]
   def sum
 		inject(0) { |sum, elem| sum + elem }
 	end
 end
 
+# Only monkeypatch if the method has not been defined already.
 unless Array.method_defined? :sum
 	Array.send :include, Memtf::Utilities::Array
-end
+end

data/lib/memtf/version.rb

@@ -1,3 +1,3 @@
 module Memtf
-  VERSION = "0.0.2"
+  VERSION = "0.0.3" #nodoc
 end

data/memtf.gemspec

@@ -22,10 +22,11 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'terminal-table'
 
   spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "fakefs"
+  spec.add_development_dependency "guard-rspec"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "guard-rspec"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "yard"
 end

data/spec/lib/memtf/analyzer_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe Memtf::Analyzer do
+  let(:options)   { {} }
+
+  describe '.analyze' do
+    it 'should create a new Analyzer' do
+      mock_analyzer = double(described_class)
+      mock_analyzer.stub(:analyze)
+      described_class.should_receive(:new).with(options).and_return(mock_analyzer)
+
+      described_class.analyze(options)
+    end
+
+    it 'should delegate to analyze' do
+      mock_analyzer = double(described_class)
+      described_class.stub(:new).with(options).and_return(mock_analyzer)
+      mock_analyzer.should_receive(:analyze).and_return({})
+
+      described_class.analyze(options)
+    end
+  end
+
+  describe '.analyze_group' do
+    let(:start_data) {
+      {
+       'Array'   => {'count' => 1, 'size' => 10},
+       'Hash'    => {'count' => 2, 'size' => 5},
+       'Fixnum'  => {'count' => 2, 'size' => 10},
+       'Others*' => {'count' => 3, 'size' => 4}
+      }
+    }
+    let(:end_data) {
+      {
+       'Array'   => {'count' => 3, 'size' => 50},
+       'Hash'    => {'count' => 4, 'size' => 20},
+       'Fixnum'  => {'count' => 8, 'size' => 20},
+       'Others*' => {'count' => 6, 'size' => 10}
+      }
+    }
+    let(:group) { 'test_group' }
+
+    it 'should load the start data' do
+      Memtf::Persistance.should_receive(:load).with(Memtf::START,group).and_return(start_data)
+      Memtf::Persistance.stub(:load).with(Memtf::STOP,group).and_return(end_data)
+
+      described_class.analyze_group(group)
+    end
+
+    it 'should load the end data' do
+      Memtf::Persistance.stub(:load).with(Memtf::START,group).and_return(start_data)
+      Memtf::Persistance.should_receive(:load).with(Memtf::STOP,group).and_return(end_data)
+
+      described_class.analyze_group(group)
+    end
+
+    it 'should compare the start and end object counts' do
+      Memtf::Persistance.stub(:load).with(Memtf::START,group).and_return(start_data)
+      Memtf::Persistance.stub(:load).with(Memtf::STOP,group).and_return(end_data)
+
+      output       = described_class.analyze_group(group)
+      count_deltas = output.values.map { |o| o['count_delta']}
+      count_deltas.should_not be_empty
+      count_deltas.size.should == 4
+      count_deltas.should == [(3-1),(4-2),(8-2),(6-3)]
+    end
+
+    it 'should compare the start and end memory sizes' do
+      Memtf::Persistance.stub(:load).with(Memtf::START,group).and_return(start_data)
+      Memtf::Persistance.stub(:load).with(Memtf::STOP,group).and_return(end_data)
+
+      output      = described_class.analyze_group(group)
+      size_deltas = output.values.map { |o| o['size_delta']}
+      size_deltas.should_not be_empty
+      size_deltas.size.should == 4
+      size_deltas.should == [(50-10),(20-5),(20-10),(10-4)]
+    end
+
+    it 'should generate an impact value' do
+      Memtf::Persistance.stub(:load).with(Memtf::START,group).and_return(start_data)
+      Memtf::Persistance.stub(:load).with(Memtf::STOP,group).and_return(end_data)
+
+      output  = described_class.analyze_group(group)
+      impacts = output.values.map { |o| o['impact'] }
+      impacts.should_not be_empty
+      impacts.size.should == 4
+      # The impact is calculates as memory size of class
+      # compared to the total memory size
+      impacts.should == [0.5,0.2,0.2,0.1]
+    end
+  end
+
+  describe '#analyze' do
+    class StubbedMemoryTracker
+      STRING1 = 'some_string'
+      STRING2 = 'some_other_string'
+      ARRAY1  = [1,2,3,4,5,6]
+      HASH1   = {'foo' => 'bar'}
+
+      def self.iterate(&block)
+        [STRING1, STRING2, ARRAY1, HASH1].each do |obj|
+          block.call(obj)
+        end
+      end
+
+      def self.size_of(obj)
+        case obj
+        when STRING1 then convert_to_mb(10)
+        when STRING2 then convert_to_mb(20)
+        when ARRAY1  then convert_to_mb(90)
+        when HASH1   then convert_to_mb(0.005)
+        else
+          0
+        end
+      end
+
+      def self.convert_to_mb(integer)
+        integer * 1024**2
+      end
+    end
+
+    let(:options)  {
+      {
+        :memory_tracker => StubbedMemoryTracker,
+        :threshold      => 0.05
+      }
+    }
+    let(:analyzer) { described_class.new(options) }
+
+    it 'should try to initiate garbage collection' do
+      GC.should_receive(:start)
+
+      analyzer.analyze
+    end
+
+    it 'should calculate the total memory allocated to each class' do
+      analysis = analyzer.analyze
+
+      analysis.should_not be_nil
+      analysis['Array'][:size].should  == 90.0
+      analysis['String'][:size].should == 20.0 + 10.0
+    end
+
+    it 'should calculate the number of objects of each class in memory' do
+      analysis = analyzer.analyze
+
+      analysis.should_not be_nil
+      analysis['Array'][:count].should  == 1
+      analysis['String'][:count].should == 2
+    end
+
+    it 'should isolate classes that exceed a given memory threshold' do
+      analysis = analyzer.analyze
+
+      analysis.should_not be_nil
+      analysis['Hash'].should be_nil # doesn't meet threshold
+    end
+
+    it 'should generate an aggregated Others* row' do
+      analysis = analyzer.analyze
+
+      analysis.should_not be_nil
+      analysis['Others*'][:size].should == 0.005
+      analysis['Others*'][:count].should == 1
+    end
+  end
+end

data/spec/lib/memtf/persistance_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Memtf::Persistance do
+  include FakeFS::SpecHelpers
+
+  let(:name)  { 'test_name'  }
+  let(:group) { 'test_group' }
+  let(:date)  { '2013-12-26' }
+  let(:pid)   { 9 }
+
+  let(:expected_dir)       { "tmp/memtf/#{group}" }
+  let(:expected_file_path) { "#{expected_dir}/#{name}-#{pid}.json" }
+
+  before(:each) do
+    Process.stub(:pid).and_return(pid)
+  end
+
+  describe '.save' do
+    let(:payload) {{ :test => :payload }}
+
+    context 'when the group directory does not exist' do
+      it 'should create the directory' do
+        Dir.exist?(expected_dir).should == false
+        described_class.save(name, group, payload)
+        Dir.exist?(expected_dir).should == true
+      end
+    end
+
+    it 'should save the payload' do
+      expected_file_path = "#{expected_dir}/#{name}-#{pid}.json"
+      File.exist?(expected_file_path).should == false
+      described_class.save(name, group, payload)
+      File.exist?(expected_file_path).should == true
+    end
+
+    it 'should encode the payload' do
+      described_class.save(name, group, payload)
+      f = File.read(expected_file_path)
+      expect(f).to eq "{\"test\":\"payload\"}"
+    end
+  end
+
+  describe '.load' do
+    before(:each) do
+      FileUtils.mkdir_p(expected_dir)
+      File.open(expected_file_path, 'w+') do |f|
+        f.print("{\"test\":\"payload\"}")
+      end
+    end
+
+    it 'should load the payload' do
+      payload = described_class.load(name, group)
+      expect(payload).not_to be_nil
+    end
+
+    it 'should decode the payload' do
+      payload = described_class.load(name, group)
+      expect(payload).to eq({ 'test' => 'payload' })
+    end
+
+    context 'when the file does not exist' do
+      it 'should raise an Errno::ENOENT error' do
+        expect {
+          described_class.load("bogus_name", group)
+        }.to raise_error(Errno::ENOENT)
+      end
+    end
+  end
+end

data/spec/lib/memtf/reporter_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Memtf::Reporter do
+
+  let(:group)    { 'test_group' }
+  let(:reporter) { described_class.new(group) }
+
+  describe '.report' do
+
+    it 'should initialize a new reporter' do
+      reporter.stub(:report)
+      described_class.should_receive(:new).with(group).and_return(reporter)
+
+      described_class.report(group)
+    end
+
+    it 'should delegate to report' do
+      described_class.stub(:new).and_return(reporter)
+      reporter.should_receive(:report)
+
+      described_class.report(group)
+    end
+  end
+
+  describe '#report' do
+    let(:analysis) {
+      {
+        'key1' => {'size' => 2,  'size_delta' => 0,  'count' => 1000, 'count_delta' => 50,  'impact' => 0.02},
+        'key2' => {'size' => 78, 'size_delta' => 76, 'count' => 600,  'count_delta' => 500, 'impact' => 0.78},
+        'key3' => {'size' => 20, 'size_delta' => 15, 'count' => 50,   'count_delta' => 25,  'impact' => 0.20}
+      }
+    }
+
+    it 'should delegate to Memtf::Analyzer.analyze_group' do
+      Memtf::Analyzer.should_receive(:analyze_group).with(group).and_return(analysis)
+
+      reporter.report
+    end
+
+    it 'should sort the analysis by impact' do
+      Memtf::Analyzer.stub(:analyze_group).with(group).and_return(analysis)
+
+      table = reporter.report
+      table.rows.map {|r| r.cells.first.value }.should == ['key2', 'key3', 'key1']
+    end
+
+    it 'should print headers' do
+      Memtf::Analyzer.stub(:analyze_group).with(group).and_return(analysis)
+
+      table = reporter.report
+      table.headings.cells.map(&:value).should == ["Class", "Impact", "Leakage", "Change", "Objects", "Change"]
+    end
+
+    it 'should convert impact to a human readable percentage' do
+      Memtf::Analyzer.stub(:analyze_group).with(group).and_return(analysis)
+
+      table = reporter.report
+      table.rows.map {|r| r.cells[1].value }.should == ['78.00%','20.00%','2.00%']
+    end
+
+    it 'should convert sizes to human readable MB' do
+      Memtf::Analyzer.stub(:analyze_group).with(group).and_return(analysis)
+
+      table = reporter.report
+      table.rows.map {|r| r.cells[2].value }.should == ['78.000MB','20.000MB','2.000MB']
+      table.rows.map {|r| r.cells[3].value }.should == ['76.000MB','15.000MB','0.000MB']
+    end
+
+  end
+
+end

data/spec/lib/memtf_spec.rb

@@ -58,4 +58,4 @@ describe Memtf do
       Memtf.around(options,&lambda)
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,2 +1,30 @@
+require 'fakefs/spec_helpers'
 require 'simplecov'
+
 require 'memtf'
+
+# Silence stdout:
+# https://gist.github.com/adamstegman/926858
+
+# Redirects stderr and stdout to /dev/null.
+def silence_output
+  @orig_stderr = $stderr
+  @orig_stdout = $stdout
+
+  # redirect stderr and stdout to /dev/null
+  $stderr = File.new('/dev/null', 'w')
+  $stdout = File.new('/dev/null', 'w')
+end
+
+# Replace stdout and stderr so anything else is output correctly.
+def enable_output
+  $stderr = @orig_stderr
+  $stdout = @orig_stdout
+  @orig_stderr = nil
+  @orig_stdout = nil
+end
+
+RSpec.configure do |config|
+  config.before(:all) { silence_output }
+  config.after(:all)  { enable_output  }
+end

metadata

@@ -1,139 +1,153 @@
 --- !ruby/object:Gem::Specification
 name: memtf
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Matthew Dressel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-24 00:00:00.000000000 Z
+date: 2013-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: terminal-table
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: fakefs
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: guard-rspec
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: A simple utility to help you isolate the little bastards that are stealing
@@ -144,10 +158,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".ruby-gemset"
-- ".ruby-version"
-- ".travis.yml"
+- .gitignore
+- .ruby-gemset
+- .ruby-version
+- .travis.yml
 - CHANGELOG.md
 - Gemfile
 - Guardfile
@@ -156,6 +170,7 @@ files:
 - Rakefile
 - lib/memtf.rb
 - lib/memtf/analyzer.rb
+- lib/memtf/analyzer/memory.rb
 - lib/memtf/persistance.rb
 - lib/memtf/reporter.rb
 - lib/memtf/runner.rb
@@ -164,6 +179,9 @@ files:
 - lib/memtf/version.rb
 - memtf.gemspec
 - spec/integration/memtf_spec.rb
+- spec/lib/memtf/analyzer_spec.rb
+- spec/lib/memtf/persistance_spec.rb
+- spec/lib/memtf/reporter_spec.rb
 - spec/lib/memtf_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/dresselm/memtf
@@ -176,22 +194,25 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Leaking memory like a sieve? Cursing? Memtf is here to help.
 test_files:
 - spec/integration/memtf_spec.rb
+- spec/lib/memtf/analyzer_spec.rb
+- spec/lib/memtf/persistance_spec.rb
+- spec/lib/memtf/reporter_spec.rb
 - spec/lib/memtf_spec.rb
 - spec/spec_helper.rb
 has_rdoc: