allocation_stats 0.1.1

data/Rakefile

@@ -0,0 +1,11 @@
+# Copyright 2013 Google Inc. All Rights Reserved.
+# Licensed under the Apache License, Version 2.0, found in the LICENSE file.
+
+require 'rspec/core/rake_task'
+require 'yard'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+YARD::Rake::YardocTask.new

data/TODO

@@ -0,0 +1,3 @@
+* release first gem version
+* more in the README
+* binary

data/allocation_stats.gemspec

@@ -0,0 +1,21 @@
+# Copyright 2013 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.1"
+  spec.authors       = ["Sam Rawlins"]
+  spec.email         = ["sam.rawlins@gmail.com"]
+  spec.license       = "Apache v2"
+  spec.summary       = "Tooling for tracing object allocations in Ruby 2.1"
+  spec.description   = "Tooling for tracing object allocations in Ruby 2.1"
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rspec"
+
+  # ">= 2.1.0" seems logical, but rubygems thought that "2.1.0.dev.0" did not fit that bill.
+  # "> 2.0.0" was my next guess, but apparently "2.0.0.247" _does_ fit that bill.
+  spec.required_ruby_version = "> 2.0.99"
+end

data/examples/my_class.rb

@@ -0,0 +1,6 @@
+class MyClass
+  def my_method
+    @hash = {2 => "foo", 3 => "bar", 5 => "baz"}
+    @string = "quux"
+  end
+end

data/examples/trace_my_class_group_by.rb

@@ -0,0 +1,11 @@
+class MyClass
+  def my_method
+    @hash = {2 => "foo", 3 => "bar", 5 => "baz"}
+    @string = "quux"
+  end
+end
+
+require File.join(__dir__, "..", "lib", "allocation_stats")
+
+stats = AllocationStats.trace { MyClass.new.my_method }
+puts stats.allocations.group_by(:sourcefile, :sourceline, :class).to_text

data/examples/trace_my_class_raw.rb

@@ -0,0 +1,11 @@
+class MyClass
+  def my_method
+    @hash = {2 => "foo", 3 => "bar", 5 => "baz"}
+    @string = "quux"
+  end
+end
+
+require File.join(__dir__, "..", "lib", "allocation_stats")
+
+stats = AllocationStats.trace { MyClass.new.my_method }
+puts stats.allocations.to_text(columns: [:sourcefile, :sourceline, :class_path, :method_id, :class])

data/examples/trace_object_allocations.rb

@@ -0,0 +1,7 @@
+require 'objspace'
+
+ObjectSpace.trace_object_allocations do
+  a = [2,3,5,7,11,13,17,19,23,29,31]
+  puts ObjectSpace.allocation_sourcefile(a)
+  puts ObjectSpace.allocation_sourceline(a)
+end

data/examples/trace_psych_group_by.rb

@@ -0,0 +1,8 @@
+require "yaml"
+require File.join(__dir__, "..", "lib", "allocation_stats")
+
+stats = AllocationStats.trace do
+  y = YAML.dump(["one string", "two string"]) # lots of objects from Rbconfig::CONFIG["rubylibdir"]
+end
+
+puts stats.allocations(alias_paths: true).group_by(:sourcefile, :class).to_text

data/examples/trace_psych_keys.rb

@@ -0,0 +1,8 @@
+require "yaml"
+require File.join(__dir__, "..", "lib", "allocation_stats")
+
+stats = AllocationStats.trace do
+  y = YAML.dump(["one string", "two string"]) # lots of objects from Rbconfig::CONFIG["rubylibdir"]
+end
+
+stats.allocations.group_by(:sourcefile, :class).all.keys.each { |key| puts key.inspect }

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

@@ -0,0 +1,203 @@
+# 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

data/lib/allocation_stats.rb

@@ -0,0 +1,144 @@
+# Copyright 2013 Google Inc. All Rights Reserved.
+# Licensed under the Apache License, Version 2.0, found in the LICENSE file.
+
+require "objspace"
+require_relative "allocation_stats/allocation"
+require_relative "allocation_stats/allocations_proxy"
+
+require "rubygems"
+
+# Container for an aggregation of object allocation data. Pass a block to
+# {#trace AllocationStats.new.trace}. Then use the AllocationStats object's public
+# interface to dig into the data and discover useful information.
+class AllocationStats
+  # a convenience constant
+  RUBYLIBDIR = RbConfig::CONFIG["rubylibdir"]
+
+  # a convenience constant
+  GEMDIR = Gem.dir
+
+  # @!attribute [rw] burn
+  # @return [Fixnum]
+  # burn count for block tracing. Defaults to 0. When called with a block,
+  # #trace will yield the block @burn-times before actually tracing the object
+  # allocations. This offers the benefit of pre-memoizing objects, and loading
+  # any required Ruby files before tracing.
+  attr_accessor :burn
+
+  attr_accessor :gc_profiler_report
+
+  # @!attribute [r] new_allocations
+  # @return [Array]
+  # allocation data for all new objects that were allocated
+  # during the {#initialize} block. It is better to use {#allocations}, which
+  # returns an {AllocationsProxy}, which has a much more convenient,
+  # domain-specific API for filtering, sorting, and grouping {Allocation}
+  # objects, than this plain Array object.
+  attr_reader :new_allocations
+
+  def initialize(burn: 0)
+    @burn = burn
+  end
+
+  def self.trace(&block)
+    allocation_stats = AllocationStats.new
+    allocation_stats.trace(&block)
+  end
+
+  def trace(&block)
+    if block_given?
+      trace_block(&block)
+    else
+      start
+    end
+  end
+
+  def trace_block
+    @burn.times { yield }
+
+    GC.start
+    GC.disable
+
+    @existing_object_ids = {}
+
+    ObjectSpace.each_object.to_a.each do |object|
+      @existing_object_ids[object.object_id / 1000] ||= []
+      @existing_object_ids[object.object_id / 1000] << object.object_id
+    end
+
+    ObjectSpace.trace_object_allocations {
+      yield
+    }
+
+    collect_new_allocations
+    ObjectSpace.trace_object_allocations_clear
+    profile_and_start_gc
+
+    return self
+  end
+
+  def start
+    GC.start
+    GC.disable
+
+    @existing_object_ids = {}
+
+    ObjectSpace.each_object.to_a.each do |object|
+      @existing_object_ids[object.object_id / 1000] ||= []
+      @existing_object_ids[object.object_id / 1000] << object.object_id
+    end
+
+    ObjectSpace.trace_object_allocations_start
+
+    return self
+  end
+
+  def collect_new_allocations
+    @new_allocations = []
+    ObjectSpace.each_object.to_a.each do |object|
+      next if ObjectSpace.allocation_sourcefile(object).nil?
+      next if ObjectSpace.allocation_sourcefile(object) == __FILE__
+      next if @existing_object_ids[object.object_id / 1000] &&
+              @existing_object_ids[object.object_id / 1000].include?(object.object_id)
+
+      @new_allocations << Allocation.new(object)
+    end
+  end
+
+  def stop
+    collect_new_allocations
+    ObjectSpace.trace_object_allocations_stop
+    ObjectSpace.trace_object_allocations_clear
+    profile_and_start_gc
+  end
+
+  # Inspect @new_allocations, the canonical array of {Allocation} objects.
+  def inspect
+    @new_allocations.inspect
+  end
+
+  # Proxy for the @new_allocations array that allows for individual filtering,
+  # sorting, and grouping of the Allocation objects.
+  def allocations(alias_paths: false)
+    AllocationsProxy.new(@new_allocations, alias_paths: alias_paths)
+  end
+
+  def profile_and_start_gc
+    GC::Profiler.enable
+    GC.enable
+    GC.start
+    @gc_profiler_report = GC::Profiler.result
+    GC::Profiler.disable
+  end
+  private :profile_and_start_gc
+end
+
+if ENV["TRACE_PROCESS_ALLOCATIONS"]
+  $allocation_stats = AllocationStats.new.trace
+
+  at_exit do
+    $allocation_stats.stop
+    puts "Object Allocation Report"
+    puts "------------------------"
+  end
+end