leakmon 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in leakmon.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Mitsunori Komatsu
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,98 @@
+# Leakmon
+
+A Ruby library to monitor leaked objects
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'leakmon'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install leakmon
+
+## Usage
+
+If you want to monitor the objects of specific class, then include Leakmon into the class.
+  
+    require 'leakmon'
+
+    class Foo
+      attr_accessor :dummy
+    end
+
+    class Foo
+      include Leakmon
+    end
+
+    Foo.release_hook('puts "i am released."')  # This is option hook, for debug.
+
+    15.times do
+      o = Foo.new
+      o.dummy = 'x' * 100 * 1024 * 1024  # For GC.
+      sleep 0.5
+    end
+
+    Leakmon.list_remaining_objects.each{|rec| p rec}  # Array of the remaining objects (not garbage collected).
+
+    # You can filter the objects by :time keyword.
+    Leakmon.list_remaining_objects(:time => 8).each{|rec| p rec}  # Only older than 8 sec.
+
+Then "i am released." will be printed when some Foo instances are collected. At the last code, the remaining objects will be dumped.
+
+    i am released.
+       :
+    i am released.
+    ["Foo__fdbef6946", {:time=>Sun Aug 09 00:11:49 +0900 2009, :caller=>["leakmon.rb:136:in `new'", "leakmon.rb:136", "leakmon.rb:135:in `times'", "leakmon.rb:135"]}]
+    ["Foo__fdbef8f52", {:time=>Sun Aug 09 00:11:50 +0900 2009, :caller=>["leakmon.rb:136:in `new'", "leakmon.rb:136", "leakmon.rb:135:in `times'", "leakmon.rb:135"]}]
+    ["Foo__fdbef8dfe", {:time=>Sun Aug 09 00:11:55 +0900 2009, :caller=>["leakmon.rb:136:in `new'", "leakmon.rb:136", "leakmon.rb:135:in `times'", "leakmon.rb:135"]}]
+    ["Foo__fdbef8c28", {:time=>Sun Aug 09 00:11:57 +0900 2009, :caller=>["leakmon.rb:136:in `new'", "leakmon.rb:136", "leakmon.rb:135:in `times'", "leakmon.rb:135"]}]
+    ["Foo__fdbef8912", {:time=>Sun Aug 09 00:11:59 +0900 2009, :caller=>["leakmon.rb:136:in `new'", "leakmon.rb:136", "leakmon.rb:135:in `times'", "leakmon.rb:135"]}]
+    ["Foo__fdbef87c8", {:time=>Sun Aug 09 00:12:00 +0900 2009, :caller=>["leakmon.rb:136:in `new'", "leakmon.rb:136", "leakmon.rb:135:in `times'", "leakmon.rb:135"]}]
+    ["Foo__fdbef84ee", {:time=>Sun Aug 09 00:12:02 +0900 2009, :caller=>["leakmon.rb:136:in `new'", "leakmon.rb:136", "leakmon.rb:135:in `times'", "leakmon.rb:135"]}]
+    ["Foo__fdbef8386", {:time=>Sun Aug 09 00:12:04 +0900 2009, :caller=>["leakmon.rb:136:in `new'", "leakmon.rb:136", "leakmon.rb:135:in `times'", "leakmon.rb:135"]}]
+    ["Foo__fdbef8110", {:time=>Sun Aug 09 00:12:05 +0900 2009, :caller=>["leakmon.rb:136:in `new'", "leakmon.rb:136", "leakmon.rb:135:in `times'", "leakmon.rb:135"]}]
+    ["Foo__fdbef7ea4", {:time=>Sun Aug 09 00:12:07 +0900 2009, :caller=>["leakmon.rb:136:in `new'", "leakmon.rb:136", "leakmon.rb:135:in `times'", "leakmon.rb:135"]}]
+    ["Foo__fdbef8f3e", {:time=>Sun Aug 09 00:12:09 +0900 2009, :caller=>["leakmon.rb:136:in `new'", "leakmon.rb:136", "leakmon.rb:135:in `times'", "leakmon.rb:135"]}]
+    ["Foo__fdbef8f34", {:time=>Sun Aug 09 00:12:10 +0900 2009, :caller=>["leakmon.rb:136:in `new'", "leakmon.rb:136", "leakmon.rb:135:in `times'", "leakmon.rb:135"]}]
+    ["Foo__fdbef8e76", {:time=>Sun Aug 09 00:12:12 +0900 2009, :caller=>["leakmon.rb:136:in `new'", "leakmon.rb:136", "leakmon.rb:135:in `times'", "leakmon.rb:135"]}]
+    i am released.
+       :
+    i am released.
+
+You can monitor almost all of classes. Instead of "include Leakmon" in the class definition, call Leakmon.include_in_subclasses. But some classes are not supported, Time (sorry...) and implemented classes in ruby such as String and so on.
+
+    Leakmon.include_in_subclasses(Object)  # If you monitor IO and the sub classes, set the argument IO.
+
+Finally, there is TCP/IP interface.
+
+    Leakmon.tcp_server('0.0.0.0', 4321)
+
+And using TCP/IP client, you can monitor the realtime information by 'list' command.
+
+    $ telnet localhost 4321
+    Trying ::1...
+    Trying 127.0.0.1...
+    Connected to localhost.
+    Escape character is '^]'.
+    list
+    now: Sun Aug 09 00:48:59 +0900 2009
+    ["Rational__fdbe7752e", {:time=>Sun Aug 09 00:48:56 +0900 2009, :caller=>["/usr/lib/ruby/1.8/rational.rb:94:in `new'", "/usr/lib/ruby/1.8/rational.rb:94:in `new!'", "/usr/lib/ruby/1.8/rational.rb:337:in `coerce'", "/usr/lib/ruby/1.8/date.rb:503:in `-'", "/usr/lib/ruby/1.8/date.rb:503:in `jd_to_ajd'", "/usr/lib/ruby/1.8/date.rb:754:in `new'", "leakmon.rb:155", "leakmon.rb:154:in `times'", "leakmon.rb:154"]}]
+      :
+    list 8   <== Only the remaining objects older than 8 sec ago.
+      :
+    quit     <== Command for quit TCP/IP interface.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec
+

data/leakmon.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/leakmon/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Mitsunori Komatsu"]
+  gem.email         = ["komamitsu@gmail.com"]
+  gem.description   = %q{A Ruby library to monitor leaked objects}
+  gem.summary       = %q{A Ruby library to monitor leaked objects}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "leakmon"
+  gem.require_paths = ["lib"]
+  gem.version       = Leakmon::VERSION
+  gem.add_development_dependency "rspec", "~> 2.13.0"
+end

data/lib/leakmon.rb

@@ -0,0 +1,163 @@
+require "leakmon/version"
+
+module Leakmon
+  class LeakmonString < String; end
+
+  class LeakmonArray < Array; end
+
+  class LeakmonHash < Hash; end
+
+  class LeakmonTime < Time; end
+
+  class LeakmonMutex < Mutex; end
+
+  class << self
+    def include_with_subclasses(klass = Object)
+      ObjectSpace.each_object(class << klass; self; end) do |cls|
+        next if out_of_scope?(cls)
+        cls.__send__(:include, Leakmon)
+      end
+    end
+
+    def list_remaining_objects(cond = {})
+      leakmon_mutex.synchronize do
+        cond.keys.inject(remaining_objects) {|objs, cond_key|
+          new_objs = nil
+
+          case cond_key
+          when :time
+            now = LeakmonTime.now
+            new_objs = objs.select do |obj_k, obj_v|
+              obj_v[:time] < now - cond[cond_key]
+            end
+          else
+            raise "Invalid list option [#{cond_key}]"
+          end
+
+          new_objs
+        }.sort_by{|k, v| v[:time]}
+      end
+    end
+
+    def clear_remaining_objects
+      leakmon_mutex.synchronize do
+        @remaining_objects = LeakmonHash.new
+      end
+    end
+
+    def included(base)
+      class << base
+        @leakmon_included ||= false
+        return if @leakmon_included
+        @leakmon_included = true
+      end
+
+      return unless base.private_methods.include?(:initialize)
+      begin
+        base.__send__(:alias_method, :initialize_without_leakmon, :initialize)
+      rescue NameError
+        return
+      end
+      base.__send__(:alias_method, :initialize, :initialize_with_leakmon)
+
+      def base.release_hook(proc_str)
+        @@leakmon_release_hook = proc_str
+      end
+    end
+
+    def tcp_server(host, port)
+      require 'thread'
+      require 'socket'
+
+      Thread.new do
+        @leakmon_tcp_server = TCPServer.new(host, port)
+        @leakmon_tcp_server.setsockopt(:SOCKET, :REUSEADDR, true)
+        loop do
+          Thread.new(@leakmon_tcp_server.accept) do |c|
+            while command_line = c.gets.strip
+              next if command_line.empty?
+
+              command, *args = command_line.split(/\s+/)
+
+              case command
+              when 'list'
+                cond = args.empty? ? {} : {:time => Integer(args[0])}
+                c.puts "now: #{Time.now}"
+                Leakmon.list_remaining_objects(cond).each do |obj|
+                  c.puts(obj.inspect)
+                end
+              when 'quit'
+                c.close
+                Thread.exit
+              else
+                c.puts 'unknown command'
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def leakmon_register(obj, caller)
+      return if out_of_scope?(obj.class)
+      leakmon_mutex.synchronize do
+        remaining_objects[Leakmon.leakmon_key(obj)] = {:time => Time.now, :caller => caller}
+      end
+    end
+
+    def leakmon_key(obj)
+      sprintf("%s__%0x", obj.class, obj.object_id)
+    end
+
+    def leakmon_release_proc(klass, key, proc_str)
+      proc {
+        instance_eval(proc_str)
+        leakmon_release(klass, key)
+      }
+    end
+
+    def leakmon_release(klass, key)
+      return if out_of_scope?(klass)
+      leakmon_mutex.synchronize do
+        remaining_objects.delete(key)
+      end
+    end
+
+    private
+    def leakmon_mutex
+      @leakmon_mutex ||= LeakmonMutex.new
+      @leakmon_mutex
+    end
+
+    def out_of_scope?(klass)
+      [Leakmon, LeakmonTime, LeakmonMutex, LeakmonString, LeakmonArray].include?(klass)
+    end
+
+    def remaining_objects
+      @remaining_objects ||= LeakmonHash.new
+      @remaining_objects
+    end
+  end
+
+  private
+  def register_leakmon(caller)
+    Leakmon.leakmon_register(self, caller)
+    @@leakmon_release_hook ||= nil
+    prc = Leakmon.leakmon_release_proc(
+      self.class,
+      Leakmon.leakmon_key(self),
+      @@leakmon_release_hook
+    )
+    ObjectSpace.define_finalizer(self, prc)
+    # ObjectSpace.define_finalizer(self, proc {|id| puts "hoge #{id}"})
+  end
+
+  def initialize_with_leakmon(*args, &blk)
+    return if caller.detect do |c|
+      c =~ /in `initialize_with_leakmon'/ || c =~ /in `include_with_subclasses'/
+    end
+    initialize_without_leakmon(*args, &blk)
+    register_leakmon(caller)
+  end
+end
+

data/lib/leakmon/version.rb

@@ -0,0 +1,3 @@
+module Leakmon
+  VERSION = "0.0.1"
+end

data/spec/leakmon_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe Leakmon do
+  context "when a class including Leakmon has instantiated some objects finalized or not" do
+    class Foo
+      include Leakmon
+    end
+
+    total_obj_num = 10 
+    gc_obj_num = 4
+
+    $output = StringIO.new
+    Foo.release_hook("$output.puts 'hoge'")
+
+    foos = []
+    total_obj_num.times do |i|
+      sleep 1 if i == total_obj_num - 1
+      foos << Foo.new
+    end
+
+    gc_obj_num.times do |i|
+      foos[i] = nil
+    end
+    GC.start
+
+    describe "release_fook" do
+      it "the block is evaluated whenever the object is finalized" do
+        msg_count = 0
+        $output.rewind
+        $output.each_line do |line|
+          msg_count += 1
+          line.should == "hoge\n"
+        end
+        msg_count.should == gc_obj_num
+      end 
+    end
+
+    describe "list_remaining_objects" do
+      it "prints remaining objects to stdout" do
+        remains = Leakmon.list_remaining_objects
+        remains.size.should == (total_obj_num - gc_obj_num)
+      end 
+    end
+
+    describe "tcp_server" do
+      require 'socket'
+      port = 9876
+
+      Leakmon.tcp_server('0.0.0.0', port)
+
+      sleep 0.3
+      client = TCPSocket.new('127.0.0.1', port)
+
+      def test_list(client, cmd, expected_obj_count)
+        count = 0
+        t = Thread.new do
+          client.puts cmd
+          client.each_line do |l|
+            l.should =~ (count.zero? ? %r|\Anow: | : %r|\A\["Foo__|)
+            count += 1
+          end
+        end
+        sleep 0.2
+        Thread.kill t
+        count.should == 1 + expected_obj_count
+      end
+
+      context 'list' do
+        it "returns remaining objects as response" do
+          test_list(client, 'list', total_obj_num - gc_obj_num)
+        end
+      end
+
+      context 'list (sec)' do
+        it "returns remaining objects survive the specified seconds as response" do
+          test_list(client, 'list 1', total_obj_num - gc_obj_num - 1)
+        end
+      end
+
+      context 'quit' do
+        it "disconnect the connection" do
+          client.puts 'quit'
+          client.gets.should be_nil
+        end
+      end
+    end
+  end
+
+  context 'include_with_subclasses' do
+    it do
+      Leakmon.clear_remaining_objects
+
+      class User
+        attr_accessor :name, :created_at
+        def initialize(name)
+          @name = name
+          @created_at = Time.now
+        end
+      end
+
+      class PremiumUser < User
+      end
+
+      Leakmon.include_with_subclasses(Object)
+
+      users = []
+      users << User.new('komamitsu')
+      users << User.new('hogehoge')
+      users << PremiumUser.new('hogehoge')
+
+      user_count = 0
+      premium_user_count = 0
+      Leakmon.list_remaining_objects.each do |obj_info|
+        case obj_info.first
+        when /\AUser__/ then user_count += 1
+        when /\APremiumUser__/ then premium_user_count += 1
+        else raise "An unexpected remaining object: #{obj_info.first}"
+        end
+      end
+
+      user_count.should eq(2)
+      premium_user_count.should eq(1)
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'leakmon'
+
+RSpec.configure do |config|
+end
+

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: leakmon
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Mitsunori Komatsu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &12735160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: *12735160
+description: A Ruby library to monitor leaked objects
+email:
+- komamitsu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- leakmon.gemspec
+- lib/leakmon.rb
+- lib/leakmon/version.rb
+- spec/leakmon_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: A Ruby library to monitor leaked objects
+test_files:
+- spec/leakmon_spec.rb
+- spec/spec_helper.rb