gc_hacks 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+rdoc
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/LICENCSE

@@ -0,0 +1,23 @@
+The MIT License
+
+Copyright (c) 2009 {XING AG}[http://www.xing.com/]
+Copyright (c) 2009 {Stefan Kaes}[http://railsexpress.de]
+
+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.rdoc

@@ -0,0 +1,54 @@
+= GC Hacks for Ruby
+
+A plugin for Rails which allows one to obtain heap dumps from a running rails app for
+example. It should work for mongrel and passenger hosted apps.
+
+
+== Author
+
+Stefan Kaes <skaes@railexpress.de>
+
+
+== Usage
+
+Obtain the processid of a rails process, then invoke one of the following commands:
+
+* start_gc_trace pid      # turns on gc tracing in the given process
+* stop_gc_trace pid       # stop gc tracing
+* dump_heap pid           # dump current heap to "#{tmp_dir}/heap.#{Process.pid}.#{@heap_dump_count}.dump"
+
+
+== Prerequisites
+
+You won't have much fun with this code unless you use a patched ruby which supports dumping
+heap information, compiled with GC_DEBUG enabled.
+
+I recommend my patched version of ruby 1.8.7, which you can get as follows:
+
+  git clone git://github.com/skaes/matzruby.git
+  cd matzruby
+  git checkout ruby187pl202patched
+  autoconf
+  ./configure --enable-gcdebug --prefix=/usr/local/ruby187pl202
+  make
+  sudo make install
+  sudo make install-doc
+
+
+== Installation
+
+Place it in vendor/plugins, as usual.
+
+
+== Acknowledgments
+
+Development of this plugin was sponsored by Xing (http://www.xing.com)
+
+
+== TODO
+
+* I think this code should be a gem.
+* move railsbench analyze_heap_dump command into the gem.
+
+
+

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'gc_hacks'
+  rdoc.options << '--line-numbers' << '--inline-source' << '--quiet'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :rdoc

data/bin/dump_heap

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__)+'/../lib/gc_hacks'
+GCHacks.send_command("HEAPDUMP", ARGV.first.to_i)

data/bin/start_gc_trace

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__)+'/../lib/gc_hacks'
+GCHacks.send_command("STARTTRACE", ARGV.first.to_i)

data/bin/stop_gc_trace

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__)+'/../lib/gc_hacks'
+GCHacks.send_command("STOPTRACE", ARGV.first.to_i)

data/gc_hacks.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "gc_hacks/version"
+
+Gem::Specification.new do |s|
+  s.name        = "gc_hacks"
+  s.version     = GCHacks::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Stefan Kaes"]
+  s.email       = ["skaes@railsexpress.de"]
+  s.homepage    = "https://github.com/skaes/gc_hacks"
+  s.summary     = %q{GC tracing/Heap dumping support for Rails processes}
+  s.description = %q{This gem allows you to send GC related commands to a running Rails process}
+
+  s.rubyforge_project = "gc_hacks"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/init.rb

@@ -0,0 +1,15 @@
+if defined?(PhusionPassenger)
+  class PhusionPassenger::AbstractRequestHandler
+    alias_method :original_reset_signal_handlers, :reset_signal_handlers
+
+    def reset_signal_handlers
+      original_reset_signal_handlers
+      GCHacks.install_signal_handlers
+    end
+
+    protected :original_reset_signal_handlers, :reset_signal_handlers
+  end
+
+else
+  GCHacks.install_signal_handlers
+end

data/lib/gc_hacks/version.rb

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

data/lib/gc_hacks.rb

@@ -0,0 +1,137 @@
+require "fileutils"
+
+module GCHacks
+
+  extend self
+
+  def logger
+    @logger ||=
+      if defined?(Rails)
+        Rails.logger
+      elsif defined?(RAILS_DEFAULT_LOGGER)
+        RAILS_DEFAULT_LOGGER
+      else
+        Logger.new($stdout)
+      end
+  end
+
+  def root
+    @root ||=
+      if defined?(Rails)
+        Rails.root.to_s
+      elsif defined?(RAILS_ROOT)
+        RAILS_ROOT
+      else
+        find_rails_root
+      end
+  end
+
+  def find_rails_root
+    while !cwd_is_a_rails_project?
+      if FileUtils.pwd == "/"
+        $stderr.puts "could not determine rails project root. please cd into your rails project"
+        exit 1
+      end
+      FileUtils.cd ".."
+    end
+    FileUtils.pwd
+  end
+
+  def cwd_is_a_rails_project?
+    File.exist?("config/environment.rb") && File.directory?("tmp") && File.directory?("log")
+  end
+
+  def install_signal_handlers
+    # WINCH is the only signal we can receive without mongrel/passenger side effects
+    trap("WINCH"){ check_and_run_commands }
+  end
+
+  def send_command(cmd, pid)
+    File.open(CMD_FILE, "w"){|f| f.puts cmd}
+    Process.kill("WINCH", pid)
+  end
+
+  def check_and_run_commands
+    read_command_file.each do |cmd|
+      case cmd.chomp
+      when 'HEAPDUMP'   then heap_dump
+      when 'STARTTRACE' then start_trace
+      when 'STOPTRACE'  then stop_trace
+      else
+        logger.info "unknown gc command: '#{cmd}'"
+      end
+    end
+  ensure
+    remove_command_file
+  end
+
+  CMD_FILE = File.expand_path("#{root}/tmp/gc_command.txt")
+
+  def read_command_file
+    File.exist?(CMD_FILE) ? File.read(CMD_FILE) : []
+  end
+
+  def remove_command_file
+    File.exist?(CMD_FILE) && File.unlink(CMD_FILE)
+  end
+
+  def can_trace?
+    GC.respond_to?(:log_file)
+  end
+
+  def can_dump?
+    GC.respond_to?(:dump_file_and_line_info)
+  end
+
+  def log_dir
+    @log_dir ||= File.expand_path("#{root}/log")
+  end
+
+  def log_dir=(dir)
+    @log_dir = File.expand_path(dir)
+  end
+
+  def tmp_dir
+    @tmp_dir ||= File.expand_path("#{root}/tmp")
+  end
+
+  def tmp_dir=(dir)
+    @tmp_dir = File.expand_path(dir)
+  end
+
+  def start_trace
+    unless can_trace?
+      logger.info "cannot start GC trace. GC.enable_trace is undefined"
+      return
+    end
+    GC.log_file "#{log_dir}/gctrace-#{Process.pid}.log" unless GC.log_file
+    GC.enable_trace
+    logger.info "GC-tracing: enabled"
+  end
+
+  def stop_trace
+    unless can_trace?
+      logger.info "cannot stop GC trace. GC.disable_trace is undefined"
+      return
+    end
+    GC.disable_trace
+    logger.info "GC-tracing: disabled"
+  end
+
+  def heap_dump
+    unless can_dump?
+      logger.info "cannot dump heap. GC.dump_file_and_line_info is undefined"
+      return
+    end
+    @heap_dump_count ||= 0
+    filename = "#{tmp_dir}/heap.#{Process.pid}.#{@heap_dump_count}.dump"
+    msg = "** Dumping heap ..."
+    $stderr.puts msg; logger.info msg
+    GC.start;GC.start # two calls to get rid of finalizer created garbage
+    GC.dump_file_and_line_info(filename, true)
+    msg = "** Run 'railsbench analyze_heap_dump #{filename}' to analyze."
+    $stderr.puts msg; logger.info msg
+    @heap_dump_count += 1
+  end
+
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require File.expand_path('../../init.rb', __FILE__)

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: gc_hacks
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Stefan Kaes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-08 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: This gem allows you to send GC related commands to a running Rails process
+email: 
+- skaes@railsexpress.de
+executables: 
+- dump_heap
+- start_gc_trace
+- stop_gc_trace
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENCSE
+- README.rdoc
+- Rakefile
+- bin/dump_heap
+- bin/start_gc_trace
+- bin/stop_gc_trace
+- gc_hacks.gemspec
+- init.rb
+- lib/gc_hacks.rb
+- lib/gc_hacks/version.rb
+- rails/init.rb
+has_rdoc: true
+homepage: https://github.com/skaes/gc_hacks
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: gc_hacks
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: GC tracing/Heap dumping support for Rails processes
+test_files: []
+