allocation_stats 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67f90cfc4c5d04fb2be23255b4194c037a506ef4
-  data.tar.gz: 35c20f3a4e115f097f079c9f2c71e60eeadbf49a
+  metadata.gz: e58e350537667c95ba3ae3893f1ce695dd35276e
+  data.tar.gz: c7d1b50337b122cb95776005d6549bd453be4746
 SHA512:
-  metadata.gz: 1a7d4b6a68b4ef81ba559f87b1cf2eeca88548f294a06f53423e2839049cb5c609e23e956665a1025057c07d66d5604619f4aacd041f4b13d4a174f82febd169
-  data.tar.gz: 17d1f24af19d8668461b4d1d31bf7b24ac84b18986c26f3566056524e1bf1affdf5d7061cdd40e2ccfdae126661a02cc96c9dc6bc54457f7de47c873e126a7ea
+  metadata.gz: 2dbd708b65f3ff8187f3940239fae01aaf23f1047cd644adbfe6c40c073b6778ec34b6813fb6c4480330ef4b379a3e5e848b810f6e5c76e2b2733610d2e49ff8
+  data.tar.gz: be7d0661887495448fcce247692c5f32940e42172ffe343e6d52c77fc1ebdb88d51c8e973991e87e4d4d577928cd5b0ddafe6bcc441f7ff81ab837d87461b61e

data/CHANGELOG.markdown

@@ -1,3 +1,11 @@
+v0.1.5
+
+* Added: README is much more complete now.
+* Added: `AllocationStats.trace_rspec` is documented better.
+* Added: `AllocationStats.reace_rspec` now always burns once to prevent
+  `#autoload` from allocating where unexpected.
+* Fixed: typo in README; thanks @tjchambers
+
 v0.1.4
 
 * Added: Build status now tracked with Travis
@@ -5,6 +13,8 @@ v0.1.4
 * Fixed: alias order changed so that PWD is searched after GEMDIR and
   RUBYLIBDIR, in case of vendored bundler directory.
 * Added: `at_least` method for the AllocationsProxy, tested and documented
+* Added: `AllocationStats.trace_rspec` to trace an RSpec run, tested and
+  moderately documented
 
 v0.1.3
 

data/Gemfile

@@ -1,4 +1,4 @@
-# Copyright 2013 Google Inc. All Rights Reserved.
+# Copyright 2014 Google Inc. All Rights Reserved.
 # Licensed under the Apache License, Version 2.0, found in the LICENSE file.
 
 source "https://rubygems.org"

data/Gemfile.lock

@@ -2,7 +2,7 @@ GEM
   remote: https://rubygems.org/
   specs:
     coderay (1.0.9)
-    diff-lcs (1.2.4)
+    diff-lcs (1.2.5)
     docile (1.1.1)
     method_source (0.8.2)
     multi_json (1.8.2)
@@ -11,14 +11,14 @@ GEM
       method_source (~> 0.8)
       slop (~> 3.4)
     rake (10.1.0)
-    rspec (2.13.0)
-      rspec-core (~> 2.13.0)
-      rspec-expectations (~> 2.13.0)
-      rspec-mocks (~> 2.13.0)
-    rspec-core (2.13.1)
-    rspec-expectations (2.13.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.5)
       diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.13.1)
+    rspec-mocks (2.14.6)
     simplecov (0.8.2)
       docile (~> 1.1.0)
       multi_json

data/README.markdown

@@ -1,6 +1,25 @@
 AllocationStats [![Build Status](https://travis-ci.org/srawlins/allocation_stats.png?branch=master)](https://travis-ci.org/srawlins/allocation_stats)
 ===============
 
+* [Introduction](#introduction)
+  * [Install](#install)
+  * [Tabular output examples](#tabular-output-examples)
+  * [More on `trace_object_allocations()`](#more-on-trace_object_allocations)
+* [The API](#the-api)
+  * [`AllocationStats` API](#allocationstats-api)
+    * [Burn one](#burn-one)
+  * [`AllocationsProxy` API](#allocationsproxy-api)
+    * [What are faux attributes?](#what-are-faux-attributes)
+    * [What is `class_plus`?](#what-is-class_plus)
+* [Gotchas](#gotchas)
+  * [Allocations in C](#allocations-in-c)
+  * [`autoload`](#autoload)
+* [Examples](#examples)
+  * [Example from the specs](#example-from-the-specs)
+  * [A little slower](#a-little-slower)
+  * [Psych example](#psych-example)
+* [References](#references)
+
 Introduction
 ------------
 
@@ -28,7 +47,7 @@ or run the following command:
 gem install allocation_stats
 ```
 
-### Tabular Output examples
+### Tabular output examples
 
 It is very easy to get some simple statistics out of AllocationStats.
 Wrap some code with `AllocationStats.trace` and print out a listing of all of the
@@ -114,6 +133,191 @@ allocations.rb
 4
 ```
 
+To see some detailed examples, review the [Examples](#examples) section.
+
+The API
+-------
+
+### `AllocationStats` API
+
+The tracing of allocations can be kicked off in a few different ways, to provide flexibility:
+
+####  Block-style
+
+Just pass a block to `AllocationStats.trace`:
+
+```ruby
+stats = AllocationStats.trace do
+  # code to trace
+end
+```
+
+Or initialize an `AllocationStats`, then call `#trace` with a block:
+
+```ruby
+stats = AllocationStats.new
+stats.trace do
+  # code to trace
+end
+```
+
+#### Inline
+
+Wrap lines of code to trace with calls to `#trace` (or `#start`) and `#stop`:
+
+```ruby
+stats = AllocationStats.new
+stats.trace  # also stats.start
+# code to trace
+stats.stop
+```
+
+#### Burn One
+
+If you find a lot of allocations in `kernel_require.rb` or a lot of allocations
+of `RubyVM::InstructuinSequences`, you can "burn" one or more iterations.
+Instantiate your `AllocationStats` instance with the `burn` keyword, and trace
+your code block-style. For example: `AllocationStats.new(burn: 3).trace{ ... }`
+will first call the block 3 times, without tracing allocations, before calling
+the block a 4th time, tracing allocations.
+
+### `AllocationsProxy` API
+
+Here are the methods available on the `AllocationStats::AllocationsProxy`
+object that is returned by `AllocationStats#allocations`:
+
+* `#group_by`
+* `#from` takes one String argument, which will matched against the
+  allocation filename.
+* `#not_from` is the opposite of `#from`.
+* `#from_pwd` will filter the allocations down to those originating from `pwd`
+  (e.g. allocations originating from "my project")
+* `#where` accepts a hash of faux attribute keys. For example,
+
+  ```ruby
+  allocations.where(class: String)
+  ```
+
+  It does not yet accept lambdas as values, which _would_ enable
+  ActiveRecord-4-like calls, like
+
+  ```ruby
+  allocations.where(class: Array, size: ->(size) { size > 10 }
+  ```
+* `#at_least(n)` selects allocation groups with at least `n` allocations per group.
+* `#bytes`, which has an inconsistent definition, I think... TODO
+
+#### What are faux attributes?
+
+Valid values for `#group_by` and `#where` include:
+* instance variables on each `Allocation`. These include `:sourcefile`,
+  `:sourceline`, etc.
+* methods available on the objects that were allocated. These include things
+  like `:class`, or even `:size` if you know you only have objects that respond
+  to `:size`.
+* Allocation helper methods that return something special about the allocated
+  object. Right now this just includes `:class_plus`.
+
+I'm calling these things that you can group by or filter by, "faux attributes."
+
+#### What is `class_plus`?
+
+### Tracing RSpec
+
+You can trace an RSpec test suite by including this at the top of your
+`spec_helper.rb`:
+
+```ruby
+require 'allocation_stats'
+AllocationStats.trace_rspec
+```
+
+This will put hooks around your RSpec tests, tracing each RSpec test
+individually. When RSpec exits, the top sourcefile/sourceline/class
+combinations will be printed out.
+
+Tracing RSpec gives maintainers of existing libraries a great place to start to
+search for inefficiencies in their project. You can trace an RSpec run of your
+whole test suite, or a subset, and if any one spec allocates hundreds of
+objects from the same line, then it might be something worth investigating.
+
+Here's the example from [`examples/trace_specs/`](examples/trace_specs):
+
+```
+ rspec strings_spec.rb
+..
+
+Top 2 slowest examples (0.08615 seconds, 100.0% of total time):
+  Array of Strings allocates Strings and Arrays
+    0.0451 seconds ./strings_spec.rb:8
+  Array of Strings allocates more Strings
+    0.04105 seconds ./strings_spec.rb:12
+
+Finished in 0.08669 seconds
+2 examples, 0 failures
+
+Randomized with seed 56224
+
+Top 7 allocation sites:
+  5 allocations of String at <PWD>/strings.rb:2
+    during ./strings_spec.rb:8
+  2 allocations of Array at <PWD>/strings_spec.rb:9
+    during ./strings_spec.rb:8
+  2 allocations of Array at <PWD>/strings_spec.rb:13
+    during ./strings_spec.rb:12
+  1 allocations of Array at <PWD>/strings.rb:2
+    during ./strings_spec.rb:8
+  1 allocations of String at <PWD>/strings.rb:6
+    during ./strings_spec.rb:8
+  1 allocations of String at <PWD>/strings.rb:14
+    during ./strings_spec.rb:12
+  1 allocations of String at <PWD>/strings.rb:10
+    during ./strings_spec.rb:12
+```
+
+We are informed that during the spec at `strings_spec.rb:8`, there were 5x
+Strings allocated at `strings.rb:2`.
+
+`#trace_rspec` always burns each test run once, mostly to prevent `#autoload`
+from appearing in the allocations.
+
+Gotchas
+-------
+
+### Allocations in C
+
+If allocations occur in C code (such as a C extension), their allocation site
+will be somewhat obfuscated. The allocation will still be logged, but the
+sourcefile and sourceline will register as the deepest Ruby file that _called_
+a C function that maybe called other C functions that at some point allocated
+an object. This brings us to the next gotcha:
+
+### `autoload`
+
+`Kernel#autoload` is tricky! Autoloading can hide allocations (during the
+ensuing `require`) in a simple constant reference. For example, in the mail
+gem, tracing object allocations during `rspec spec/mail/body_spec.rb:339` makes
+it look like the following line allocates 219 Strings:
+
+```ruby
+#  lib/mail/configuration.rb
+
+28    def lookup_delivery_method(method)
+29      case method.is_a?(String) ? method.to_sym : method
+30      when nil
+31        Mail::SMTP  # <-- 219 Strings alloctated here?
+```
+
+To fight this, either [don't use
+autoload](https://www.ruby-forum.com/topic/3036681), which can be eased into
+with a fancy mechanism like mail's
+[#eager_autoload](https://github.com/mikel/mail/blob/master/lib/mail.rb), or
+rely on the `burn` mechanism. `AllocationStats.trace_rspec` always burns each
+test run once.
+
+Examples
+--------
+
 ### Example from the specs
 
 ```ruby
@@ -212,7 +416,7 @@ allocation information, accessible via `#allocations`. Let's look at the next
 line to see how we can pull useful information out:
 
 ```ruby
-  results = stats.allocations.group_by(:@sourcefile, :class).to_a
+results = stats.allocations.group_by(:@sourcefile, :class).to_a
 ```
 
 If you are used to chaining ActiveRecord relations, some of this might look
@@ -324,57 +528,6 @@ puts stats.allocations(alias_paths: true).group_by(:sourcefile, :class).to_text
 <RUBYLIBDIR>/psych/scalar_scanner.rb      MatchData                                 2
 ```
 
-### Burn One
-
-If you find a lot of allocations in `kernel_require.rb` or a lot of allocations
-of `RubyVM::InstructuinSequences`, you can "burn" one or more calls to your
-block with the `burn` keyword. For example:
-`AllocationStats.new(burn: 3).trace{ ... }` will first call the block 3 times,
-without tracing allocations, before calling the block a 4th time, tracing
-allocations.
-
-The API
--------
-
-So what methods are available on that AllocationsProxy thing? So far, the API
-consists of:
-
-* `#group_by`
-* `#from` takes one String argument, which will matched against the
-  allocation filename.
-* `#not_from` is the opposite of `#from`.
-* `#from_pwd` will filter the allocations down to those originating from `pwd`
-  (e.g. allocations originating from "my project")
-* `#where` accepts a hash of faux attribute keys. For example,
-
-  ```ruby
-  allocations.where(class: String)
-  ```
-
-  It does not yet accept lambdas as values, which _would_ enable
-  ActiveRecord-4-like calls, like
-
-  ```ruby
-  allocations.where(class: Array, size: ->(size) { size > 10 }
-  ```
-* `#at_least(n)` selects allocation groups with at least `n` allocations per group.
-* `#bytes`, which has an inconsistent definition, I think... TODO
-
-### What are faux attributes?
-
-Valid values for `#group_by` and `#where` include:
-* instance variables on each `Allocation`. These include `:sourcefile`,
-  `:sourceline`, etc.
-* methods available on the objects that were allocated. These include things
-  like `:class`, or even `:size` if you know you only have objects that respond
-  to `:size`.
-* Allocation helper methods that return something special about the allocated
-  object. Right now this just includes `:class_plus`.
-
-I'm calling these things that you can group by or filter by, "faux attributes."
-
-### What is `class_plus`?
-
 References
 ----------
 

data/Rakefile

@@ -1,4 +1,4 @@
-# Copyright 2013 Google Inc. All Rights Reserved.
+# Copyright 2014 Google Inc. All Rights Reserved.
 # Licensed under the Apache License, Version 2.0, found in the LICENSE file.
 
 require 'rspec/core/rake_task'

data/TODO

@@ -1,2 +1,3 @@
 * more in the README
 * binary
+* trace minitest

data/allocation_stats.gemspec

@@ -1,9 +1,9 @@
-# Copyright 2013 Google Inc. All Rights Reserved.
+# Copyright 2014 Google Inc. All Rights Reserved.
 # Licensed under the Apache License, Version 2.0, found in the LICENSE file.
 
 Gem::Specification.new do |spec|
   spec.name          = "allocation_stats"
-  spec.version       = "0.1.4"
+  spec.version       = "0.1.5"
   spec.authors       = ["Sam Rawlins"]
   spec.email         = ["sam.rawlins@gmail.com"]
   spec.homepage      = "https://github.com/srawlins/allocation_stats"

data/examples/trace_specs/strings.rb

@@ -0,0 +1,15 @@
+def an_array_of_strings
+  ["foo", "bar", "baz", "qux", "quux"]
+end
+
+def foo
+  "foo"
+end
+
+def teamwork
+  "Teamwork"
+end
+
+def tea
+  "Tea"
+end

data/examples/trace_specs/strings_spec.rb

@@ -0,0 +1,15 @@
+require "pry"
+
+require_relative File.join("..", "..", "lib", "allocation_stats")
+require_relative "strings"
+AllocationStats.trace_rspec
+
+describe "Array of Strings" do
+  it "allocates Strings and Arrays" do
+    expect(an_array_of_strings).to include(foo)
+  end
+
+  it "allocates more Strings" do
+    expect(teamwork).to include(tea)
+  end
+end

data/lib/allocation_stats.rb

@@ -1,10 +1,11 @@
-# Copyright 2013 Google Inc. All Rights Reserved.
+# Copyright 2014 Google Inc. All Rights Reserved.
 # Licensed under the Apache License, Version 2.0, found in the LICENSE file.
 
 require "objspace"
 require_relative "allocation_stats/core_ext/basic_object"
 require_relative "allocation_stats/allocation"
 require_relative "allocation_stats/allocations_proxy"
+require_relative "allocation_stats/trace_rspec"
 
 require "rubygems"
 

data/lib/allocation_stats/allocation.rb

@@ -1,4 +1,4 @@
-# Copyright 2013 Google Inc. All Rights Reserved.
+# Copyright 2014 Google Inc. All Rights Reserved.
 # Licensed under the Apache License, Version 2.0, found in the LICENSE file.
 
 require "json"
@@ -9,7 +9,8 @@ class AllocationStats
     # a convenience constants
     PWD = Dir.pwd
 
-    # a list of helper methods that Allocation provides on top of the object that was allocated.
+    # a list of helper methods that Allocation provides on top of the object
+    # that was allocated.
     HELPERS = [:class_plus, :gem]
 
     # a list of attributes that Allocation has on itself; inquiries in this
@@ -46,14 +47,17 @@ class AllocationStats
       @method_id  = ObjectSpace.allocation_method_id(object)
     end
 
+    # the sourcefile where the object was allocated
     def file; @sourcefile; end
-    #def line; @sourceline; end
+
     alias :line :sourceline
 
-    # If the source file has recognized paths in it, those portions of the full path will be aliased like so:
+    # If the source file has recognized paths in it, those portions of the full
+    # path will be aliased like so:
     #
     # * the present work directory is aliased to "<PWD>"
-    # * the Ruby lib directory (where the standard library lies) is aliased to "<RUBYLIBDIR>"
+    # * the Ruby lib directory (where the standard library lies) is aliased to
+    #   "<RUBYLIBDIR>"
     # * the Gem directory (where all gems lie) is aliased to "<GEMDIR>"
     #
     # @return the source file, aliased.
@@ -102,10 +106,10 @@ class AllocationStats
       end
     end
 
+    # Override Rubygems' Kernel#gem
+    #
     # @return [String] the name of the Rubygem where this allocation occurred.
     # @return [nil] if this allocation did not occur in a Rubygem.
-    #
-    # Override Rubygems' Kernel#gem
     def gem
       gem_regex = /#{AllocationStats::GEMDIR}#{File::SEPARATOR}
         gems#{File::SEPARATOR}
@@ -136,6 +140,11 @@ class AllocationStats
       as_json.to_json(*a)
     end
 
+    # @return either _the one_ class passed in, the two-to-four classes passed
+    #   in separated by commas, or `nil` if more than four classes were passed
+    #   in.
+    #
+    # @api private
     def element_classes(classes)
       if classes.size == 1
         classes.first

data/lib/allocation_stats/allocations_proxy.rb

@@ -1,4 +1,4 @@
-# Copyright 2013 Google Inc. All Rights Reserved.
+# Copyright 2014 Google Inc. All Rights Reserved.
 # Licensed under the Apache License, Version 2.0, found in the LICENSE file.
 
 class AllocationStats
@@ -84,6 +84,7 @@ class AllocationStats
       return self
     end
 
+    # Sort allocation groups by the number of allocations in each group.
     def sort_by_size
       @mappers << Proc.new do |allocations|
         allocations.sort_by { |key, value| -value.size }
@@ -174,12 +175,18 @@ class AllocationStats
       self
     end
 
-    def where(hash)
+    # Select allocations that match `conditions`.
+    #
+    # @param [Hash] conditions pairs of attribute names and values to be matched amongst allocations.
+    #
+    # @example select allocations of String objects:
+    #   allocations.where(class: String)
+    def where(conditions)
       @wheres << Proc.new do |allocations|
-        conditions = hash.inject({}) do |h, pair|
+        conditions = conditions.inject({}) do |memo, pair|
           faux, value = *pair
           getter = attribute_getters([faux]).first
-          h.merge(getter => value)
+          memo.merge(getter => value)
         end
 
         allocations.select do |allocation|

data/lib/allocation_stats/trace_rspec.rb

@@ -0,0 +1,118 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+# Licensed under the Apache License, Version 2.0, found in the LICENSE file.
+
+class AllocationStats
+  def self.trace_rspec
+    @top_sites = []
+
+    if (!const_defined?(:RSpec))
+      raise StandardError, "Cannot trace RSpec until RSpec is loaded"
+    end
+
+    ::RSpec.configure do |config|
+      config.around(&TRACE_RSPEC_HOOK)
+    end
+
+    at_exit do
+      puts AllocationStats.top_sites_text
+    end
+  end
+
+  TRACE_RSPEC_HOOK = proc do |example|
+     # TODO s/false/some config option/
+     if true  # wrap loosely
+       stats = AllocationStats.new(burn: 1).trace { example.run }
+     else      # wrap tightly
+       # Super hacky, but presumably more correct results?
+       stats = AllocationStats.new(burn: 1)
+       example_block = @example.instance_variable_get(:@example_block).clone
+
+       @example.instance_variable_set(
+         :@example_block,
+         Proc.new do
+           stats.trace { example_block.call }
+         end
+       )
+
+       example.run
+     end
+
+     allocations = stats.allocations(alias_paths: true).
+       not_from("rspec-core").not_from("rspec-expectations").not_from("rspec-mocks").
+       group_by(:sourcefile, :sourceline, :class).
+       sort_by_count
+
+     AllocationStats.add_to_top_sites(allocations.all, @example.location)
+  end
+
+  # Read the sorted list of the top "sites", that is, top file/line/class
+  # groups, encountered while tracing RSpec.
+  #
+  # @api private
+  def self.top_sites
+    @top_sites
+  end
+
+  # Write to the sorted list of the top "sites", that is, top file/line/class
+  # groups, encountered while tracing RSpec.
+  #
+  # @api private
+  def self.top_sites=(value)
+    @top_sites = value
+  end
+
+  # Add a Hash of allocation groups (derived from an
+  # `AllocationStats.allocations...group_by(...)`) to the top allocation sites
+  # (file/line/class groups).
+  #
+  # @param [Hash] allocations
+  # @param [String] location the RSpec spec location that was being executed
+  #        when the allocations occurred
+  # @param [Fixnum] limit size of the top sites Array
+  def self.add_to_top_sites(allocations, location, limit = 10)
+    if allocations.size > limit
+      allocations = allocations.to_a[0...limit].to_h  # top 10 or so
+    end
+
+    # TODO: not a great algorithm so far... can instead:
+    # * oly insert when an allocation won't be immediately dropped
+    # * insert into correct position and pop rather than sort and slice
+    allocations.each do |k,v|
+      next if k[0] =~ /spec_helper\.rb$/
+
+      if site = @top_sites.detect { |s| s[:key] == k }
+        if lower_idx = site[:counts].index { |loc, count| count < v.size }
+          site[:counts].insert(lower_idx, [location, v.size])
+        else
+          site[:counts] << [location, v.size]
+        end
+        site[:counts].pop if site[:counts].size > 3
+      else
+        @top_sites << { key: k, counts: [[location, v.size]] }
+      end
+    end
+
+    @top_sites = @top_sites.sort_by! { |site|
+      -site[:counts].map(&:last).max
+    }[0...limit]
+  end
+
+  # Textual String representing the sorted list of the top allocation sites.
+  # For each site, this String includes the number of allocations, the class,
+  # the sourcefile, the sourceline, and the location of the RSpec spec.
+  #
+  # @api private
+  def self.top_sites_text
+    return "" if @top_sites.empty?
+
+    result = "Top #{@top_sites.size} allocation sites:\n"
+    @top_sites.each do |site|
+      result << "  %s allocations at %s:%d\n" % [site[:key][2], site[:key][0], site[:key][1]]
+      site[:counts].each do |location, count|
+        result << "    %3d allocations during %s\n" % [count, location]
+      end
+    end
+
+    result
+  end
+end

data/spec/allocation_stats/allocations_proxy_spec.rb

@@ -1,4 +1,4 @@
-# Copyright 2013 Google Inc. All Rights Reserved.
+# Copyright 2014 Google Inc. All Rights Reserved.
 # Licensed under the Apache License, Version 2.0, found in the LICENSE file.
 
 require_relative File.join("..", "spec_helper")
@@ -167,7 +167,7 @@ describe AllocationStats::AllocationsProxy do
     results = stats.allocations.from_pwd.group_by(:class).all
     results.keys.size.should == 3
     results[[String]].size.should == 6
-    results[[Array]].size.should == 3  # one for empty *args in YAML.dump
+    results[[Array]].size.should == 2
     results[[Range]].size.should == 1
   end
 
@@ -247,7 +247,7 @@ describe AllocationStats::AllocationsProxy do
     files.should_not include("<GEMDIR>/gems/yajl-ruby-1.1.0/lib/yajl.rb")
   end
 
-  it "should be able to filter to just one path" do
+  it "should be able to filter to just one class" do
     stats = AllocationStats.trace do
       j = Yajl.dump(["one string", "two string"]) # lots of objects from Rbconfig::CONFIG["rubylibdir"]
     end

data/spec/allocation_stats_spec.rb

@@ -1,4 +1,4 @@
-# Copyright 2013 Google Inc. All Rights Reserved.
+# Copyright 2014 Google Inc. All Rights Reserved.
 # Licensed under the Apache License, Version 2.0, found in the LICENSE file.
 
 require_relative File.join("spec_helper")

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-# Copyright 2013 Google Inc. All Rights Reserved.
+# Copyright 2014 Google Inc. All Rights Reserved.
 # Licensed under the Apache License, Version 2.0, found in the LICENSE file.
 
 require "simplecov"
@@ -36,3 +36,152 @@ class MyClass
     (@c.size + 1).times { @c << "string" }
   end
 end
+
+# from rspec-core 2.14.7's spec_helper.rb: https://github.com/rspec/rspec-core/blob/v2.14.7/spec/spec_helper.rb#L31
+class NullObject
+  private
+  def method_missing(method, *args, &block)
+    # ignore
+  end
+end
+
+# from rspec-core 2.14.7's spec_helper.rb: https://github.com/rspec/rspec-core/blob/v2.14.7/spec/spec_helper.rb#L38
+#
+# THIS WILL NEED TO BE ENTIRELY REPLACED WHEN BUMPING TO RSPEC 3
+module Sandboxing
+  def self.sandboxed(&block)
+    @orig_config = RSpec.configuration
+    @orig_world  = RSpec.world
+    new_config = RSpec::Core::Configuration.new
+    new_world  = RSpec::Core::World.new(new_config)
+    RSpec.configuration = new_config
+    RSpec.world = new_world
+    object = Object.new
+    object.extend(RSpec::Core::SharedExampleGroup)
+
+    (class << RSpec::Core::ExampleGroup; self; end).class_eval do
+      alias_method :orig_run, :run
+      def run(reporter=nil)
+        orig_run(reporter || NullObject.new)
+      end
+    end
+
+    RSpec::Core::SandboxedMockSpace.sandboxed do
+      object.instance_eval(&block)
+    end
+  ensure
+    (class << RSpec::Core::ExampleGroup; self; end).class_eval do
+      remove_method :run
+      alias_method :run, :orig_run
+      remove_method :orig_run
+    end
+
+    RSpec.configuration = @orig_config
+    RSpec.world = @orig_world
+  end
+end
+
+############
+# from https://raw.github.com/rspec/rspec-core/v2.14.7/spec/support/sandboxed_mock_space.rb
+#
+# THIS WILL NEED TO BE ENTIRELY DELETED WHEN BUMPING TO RSPEC 3
+############
+require 'rspec/mocks'
+
+module RSpec
+  module Core
+    # Because rspec-core dog-foods itself, rspec-core's spec suite has
+    # examples that define example groups and examples and run them. The
+    # usual lifetime of an RSpec::Mocks::Proxy is for one example
+    # (the proxy cache gets cleared between each example), but since the
+    # specs in rspec-core's suite sometimes create test doubles and pass
+    # them to examples a spec defines and runs, the test double's proxy
+    # must live beyond the inner example: it must live for the scope
+    # of wherever it got defined. Here we implement the necessary semantics
+    # for rspec-core's specs:
+    #
+    # - #verify_all and #reset_all affect only mocks that were created
+    #   within the current scope.
+    # - Mock proxies live for the duration of the scope in which they are
+    #   created.
+    #
+    # Thus, mock proxies created in an inner example live for only that
+    # example, but mock proxies created in an outer example can be used
+    # in an inner example but will only be reset/verified when the outer
+    # example completes.
+    class SandboxedMockSpace < ::RSpec::Mocks::Space
+      def self.sandboxed
+        orig_space = RSpec::Mocks.space
+        RSpec::Mocks.space = RSpec::Core::SandboxedMockSpace.new
+
+        RSpec::Core::Example.class_eval do
+          alias_method :orig_run, :run
+          def run(*args)
+            RSpec::Mocks.space.sandboxed do
+              orig_run(*args)
+            end
+          end
+        end
+
+        yield
+      ensure
+        RSpec::Core::Example.class_eval do
+          remove_method :run
+          alias_method :run, :orig_run
+          remove_method :orig_run
+        end
+
+        RSpec::Mocks.space = orig_space
+      end
+
+      class Sandbox
+        attr_reader :proxies
+
+        def initialize
+          @proxies = Set.new
+        end
+
+        def verify_all
+          @proxies.each { |p| p.verify }
+        end
+
+        def reset_all
+          @proxies.each { |p| p.reset }
+        end
+      end
+
+      def initialize
+        @sandbox_stack = []
+        super
+      end
+
+      def sandboxed
+        @sandbox_stack << Sandbox.new
+        yield
+      ensure
+        @sandbox_stack.pop
+      end
+
+      def verify_all
+        return super unless sandbox = @sandbox_stack.last
+        sandbox.verify_all
+      end
+
+      def reset_all
+        return super unless sandbox = @sandbox_stack.last
+        sandbox.reset_all
+      end
+
+      def proxy_for(object)
+        new_proxy = !proxies.has_key?(object.__id__)
+        proxy = super
+
+        if new_proxy && sandbox = @sandbox_stack.last
+          sandbox.proxies << proxy
+        end
+
+        proxy
+      end
+    end
+  end
+end

data/spec/trace_rspec_spec.rb

@@ -0,0 +1,89 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+# Licensed under the Apache License, Version 2.0, found in the LICENSE file.
+
+require_relative File.join("spec_helper")
+
+RSpec.configure do |config|
+  config.around {|example| Sandboxing.sandboxed { example.run }}
+end
+
+describe "AllocationStats.trace_rspec" do
+  before do
+    AllocationStats.top_sites = []
+  end
+
+  describe "top_sites" do
+    before do
+      @a = [["<PWD>/foo.rb", 2, String], [:placeholder, :placeholder, :placeholder, :placeholder, :placeholder]]
+      @b = [["<PWD>/foo.rb", 3, Hash],   [:placeholder, :placeholder, :placeholder]]
+      @c = [["<PWD>/foo.rb", 1, Array],  [:placeholder, :placeholder]]
+      @d = [["<PWD>/foo.rb", 1, String], [:placeholder]]
+      @e = [["<PWD>/foo.rb", 4, String], [:placeholder, :placeholder, :placeholder, :placeholder, :placeholder, :placeholder]]
+      @f = [["<PWD>/foo.rb", 4, Array],  [:placeholder]]
+
+      @allocations01 = [@a, @b, @c, @d].to_h
+      @allocations02 = [@b, @c, @e, @f].to_h
+
+      @spec_location01 = "./spec/foo_spec.rb:3"
+      @spec_location02 = "./spec/foo_spec.rb:7"
+    end
+
+    it "adds allocation groups to the top allocation points, limiting each set of allocations" do
+      AllocationStats.add_to_top_sites(@allocations01, @spec_location01, 3)
+
+      expect(AllocationStats.top_sites.size).to be(3)
+
+      expect(AllocationStats.top_sites[0][:key]).to eq(@a.first)
+      expect(AllocationStats.top_sites[0][:counts]).to eq([[@spec_location01, 5]])
+
+      expect(AllocationStats.top_sites[1][:key]).to eq(@b.first)
+      expect(AllocationStats.top_sites[1][:counts]).to eq([[@spec_location01, 3]])
+
+      expect(AllocationStats.top_sites[2][:key]).to eq(@c.first)
+      expect(AllocationStats.top_sites[2][:counts]).to eq([[@spec_location01, 2]])
+    end
+
+    it "adds allocation groups to the top allocation points, organizing when too many" do
+      AllocationStats.add_to_top_sites(@allocations01, @spec_location01, 5)
+      AllocationStats.add_to_top_sites(@allocations02, @spec_location02, 5)
+
+      expect(AllocationStats.top_sites.size).to be(5)
+
+      expect(AllocationStats.top_sites[0][:key]).to eq(@e.first)
+      expect(AllocationStats.top_sites[0][:counts]).to eq([[@spec_location02, 6]])
+
+      expect(AllocationStats.top_sites[1][:key]).to eq(@a.first)
+      expect(AllocationStats.top_sites[1][:counts]).to eq([[@spec_location01, 5]])
+
+      expect(AllocationStats.top_sites[2][:key]).to eq(@b.first)
+      expect(AllocationStats.top_sites[2][:counts]).to eq([[@spec_location01, 3], [@spec_location02, 3]])
+
+      expect(AllocationStats.top_sites[3][:key]).to eq(@c.first)
+      expect(AllocationStats.top_sites[3][:counts]).to eq([[@spec_location01, 2], [@spec_location02, 2]])
+    end
+  end
+
+  describe "top_sites_text" do
+    let(:example_group) do
+      RSpec::Core::ExampleGroup.describe("group description") do
+        around(&AllocationStats::TRACE_RSPEC_HOOK)
+      end
+    end
+
+    it "prints top allocation sites after rspecs have run" do
+      example_group.example do
+        expect(["abc", "def", "ghi"]).to include("abc")
+      end
+
+      line = __LINE__ - 4
+      example_group.run
+      output = AllocationStats.top_sites_text
+
+      expect(output).to include("Top 2 allocation sites:\n")
+      expect(output).to include("  String allocations at <PWD>/spec/trace_rspec_spec.rb:#{line+1}\n")
+      expect(output).to include("    4 allocations during ./spec/trace_rspec_spec.rb:#{line}\n")
+      expect(output).to include("  Array allocations at <PWD>/spec/trace_rspec_spec.rb:#{line+1}\n")
+      expect(output).to include("    3 allocations during ./spec/trace_rspec_spec.rb:#{line}\n")
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: allocation_stats
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Sam Rawlins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-07 00:00:00.000000000 Z
+date: 2014-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -48,14 +48,17 @@ files:
 - examples/trace_object_allocations.rb
 - examples/trace_psych_group_by.rb
 - examples/trace_psych_keys.rb
-- lib/active_support/core_ext/module/delegation.rb
+- examples/trace_specs/strings.rb
+- examples/trace_specs/strings_spec.rb
 - lib/allocation_stats.rb
 - lib/allocation_stats/allocation.rb
 - lib/allocation_stats/allocations_proxy.rb
 - lib/allocation_stats/core_ext/basic_object.rb
+- lib/allocation_stats/trace_rspec.rb
 - spec/allocation_stats/allocations_proxy_spec.rb
 - spec/allocation_stats_spec.rb
 - spec/spec_helper.rb
+- spec/trace_rspec_spec.rb
 homepage: https://github.com/srawlins/allocation_stats
 licenses:
 - Apache v2
@@ -76,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Tooling for tracing object allocations in Ruby 2.1

data/lib/active_support/core_ext/module/delegation.rb

@@ -1,203 +0,0 @@
-# This file is part of Ruby on Rails (http://rubyonrails.org/) (original
-# location: https://github.com/rails/rails/raw/v4.0.0/activesupport/lib/active_support/core_ext/module/delegation.rb)
-#
-# Ruby on Rails is released under the MIT License (http://www.opensource.org/licenses/MIT).
-#
-# "Ruby on Rails" is a registered trademark of David Heinemeier Hansson.
-
-class Module
-  # Provides a +delegate+ class method to easily expose contained objects'
-  # public methods as your own.
-  #
-  # The macro receives one or more method names (specified as symbols or
-  # strings) and the name of the target object via the <tt>:to</tt> option
-  # (also a symbol or string).
-  #
-  # Delegation is particularly useful with Active Record associations:
-  #
-  #   class Greeter < ActiveRecord::Base
-  #     def hello
-  #       'hello'
-  #     end
-  #
-  #     def goodbye
-  #       'goodbye'
-  #     end
-  #   end
-  #
-  #   class Foo < ActiveRecord::Base
-  #     belongs_to :greeter
-  #     delegate :hello, to: :greeter
-  #   end
-  #
-  #   Foo.new.hello   # => "hello"
-  #   Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
-  #
-  # Multiple delegates to the same target are allowed:
-  #
-  #   class Foo < ActiveRecord::Base
-  #     belongs_to :greeter
-  #     delegate :hello, :goodbye, to: :greeter
-  #   end
-  #
-  #   Foo.new.goodbye # => "goodbye"
-  #
-  # Methods can be delegated to instance variables, class variables, or constants
-  # by providing them as a symbols:
-  #
-  #   class Foo
-  #     CONSTANT_ARRAY = [0,1,2,3]
-  #     @@class_array  = [4,5,6,7]
-  #
-  #     def initialize
-  #       @instance_array = [8,9,10,11]
-  #     end
-  #     delegate :sum, to: :CONSTANT_ARRAY
-  #     delegate :min, to: :@@class_array
-  #     delegate :max, to: :@instance_array
-  #   end
-  #
-  #   Foo.new.sum # => 6
-  #   Foo.new.min # => 4
-  #   Foo.new.max # => 11
-  #
-  # It's also possible to delegate a method to the class by using +:class+:
-  #
-  #   class Foo
-  #     def self.hello
-  #       "world"
-  #     end
-  #
-  #     delegate :hello, to: :class
-  #   end
-  #
-  #   Foo.new.hello # => "world"
-  #
-  # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
-  # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
-  # delegated to.
-  #
-  #   Person = Struct.new(:name, :address)
-  #
-  #   class Invoice < Struct.new(:client)
-  #     delegate :name, :address, to: :client, prefix: true
-  #   end
-  #
-  #   john_doe = Person.new('John Doe', 'Vimmersvej 13')
-  #   invoice = Invoice.new(john_doe)
-  #   invoice.client_name    # => "John Doe"
-  #   invoice.client_address # => "Vimmersvej 13"
-  #
-  # It is also possible to supply a custom prefix.
-  #
-  #   class Invoice < Struct.new(:client)
-  #     delegate :name, :address, to: :client, prefix: :customer
-  #   end
-  #
-  #   invoice = Invoice.new(john_doe)
-  #   invoice.customer_name    # => 'John Doe'
-  #   invoice.customer_address # => 'Vimmersvej 13'
-  #
-  # If the target is +nil+ and does not respond to the delegated method a
-  # +NoMethodError+ is raised, as with any other value. Sometimes, however, it
-  # makes sense to be robust to that situation and that is the purpose of the
-  # <tt>:allow_nil</tt> option: If the target is not +nil+, or it is and
-  # responds to the method, everything works as usual. But if it is +nil+ and
-  # does not respond to the delegated method, +nil+ is returned.
-  #
-  #   class User < ActiveRecord::Base
-  #     has_one :profile
-  #     delegate :age, to: :profile
-  #   end
-  #
-  #   User.new.age # raises NoMethodError: undefined method `age'
-  #
-  # But if not having a profile yet is fine and should not be an error
-  # condition:
-  #
-  #   class User < ActiveRecord::Base
-  #     has_one :profile
-  #     delegate :age, to: :profile, allow_nil: true
-  #   end
-  #
-  #   User.new.age # nil
-  #
-  # Note that if the target is not +nil+ then the call is attempted regardless of the
-  # <tt>:allow_nil</tt> option, and thus an exception is still raised if said object
-  # does not respond to the method:
-  #
-  #   class Foo
-  #     def initialize(bar)
-  #       @bar = bar
-  #     end
-  #
-  #     delegate :name, to: :@bar, allow_nil: true
-  #   end
-  #
-  #   Foo.new("Bar").name # raises NoMethodError: undefined method `name'
-  #
-  def delegate(*methods)
-    options = methods.pop
-    unless options.is_a?(Hash) && to = options[:to]
-      raise ArgumentError, 'Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, to: :greeter).'
-    end
-
-    prefix, allow_nil = options.values_at(:prefix, :allow_nil)
-
-    if prefix == true && to =~ /^[^a-z_]/
-      raise ArgumentError, 'Can only automatically set the delegation prefix when delegating to a method.'
-    end
-
-    method_prefix = \
-      if prefix
-        "#{prefix == true ? to : prefix}_"
-      else
-        ''
-      end
-
-    file, line = caller.first.split(':', 2)
-    line = line.to_i
-
-    to = to.to_s
-    to = 'self.class' if to == 'class'
-
-    methods.each do |method|
-      # Attribute writer methods only accept one argument. Makes sure []=
-      # methods still accept two arguments.
-      definition = (method =~ /[^\]]=$/) ? 'arg' : '*args, &block'
-
-      # The following generated methods call the target exactly once, storing
-      # the returned value in a dummy variable.
-      #
-      # Reason is twofold: On one hand doing less calls is in general better.
-      # On the other hand it could be that the target has side-effects,
-      # whereas conceptualy, from the user point of view, the delegator should
-      # be doing one call.
-      if allow_nil
-        module_eval(<<-EOS, file, line - 3)
-          def #{method_prefix}#{method}(#{definition})        # def customer_name(*args, &block)
-            _ = #{to}                                         #   _ = client
-            if !_.nil? || nil.respond_to?(:#{method})         #   if !_.nil? || nil.respond_to?(:name)
-              _.#{method}(#{definition})                      #     _.name(*args, &block)
-            end                                               #   end
-          end                                                 # end
-        EOS
-      else
-        exception = %(raise "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
-
-        module_eval(<<-EOS, file, line - 2)
-          def #{method_prefix}#{method}(#{definition})        # def customer_name(*args, &block)
-            _ = #{to}                                         #   _ = client
-            _.#{method}(#{definition})                        #   _.name(*args, &block)
-          rescue NoMethodError                                # rescue NoMethodError
-            if _.nil?                                         #   if _.nil?
-              #{exception}                                    #     # add helpful message to the exception
-            else                                              #   else
-              raise                                           #     raise
-            end                                               #   end
-          end                                                 # end
-        EOS
-      end
-    end
-  end
-end