dead_view_catcher 0.1

data/CHANGELOG.rdoc

@@ -0,0 +1,3 @@
+0.1 (January 12, 2011)
+
+* Initial release: tested against mongrel and unicorn on nix system

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Guillaume Luccisano - g-mai|: guillaume.luccisano
+
+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,45 @@
+= DeadViewCatcher
+
+DeadViewCatcher is a gem for Ruby on Rails giving you an easy way to find which views you are not using anymore in your app.
+This might be really useful for big Rails app maintained by a large team.
+
+Works with Rails 2.3 (Will be tested against Rails3 soon)
+
+== Usage
+
+Simply load the gem in your rails app.
+
+Then instantiate DeadViewCatcher during the boot:
+
+  DeadViewCatcher.watch!
+
+Now, at any time, you can send a TRAP signal to your rails instance in order to generate a dump of your views status:
+
+  kill -s TRAP pid_of_your_instance
+  
+If you want to generate a consolidated dump gathering data from all your Rails instances, just choose one instance and send it the URG signal:
+
+ kill -s URG pid_of_one_of_your_instances
+
+== Options
+
+The watch! method accepts some options :
+
+  # The correct grep string in order to select instances of your app for consolidated dumps
+  # This option is mandatory if you plan to use the consolidated dump feature
+  DeadViewCatcher.watch!(:grep => 'unicorn_rails worker')
+  
+  # Change the default signal
+  DeadViewCatcher.watch!(:signal => 'USR1')
+
+  # Change the consolidated default signal
+  DeadViewCatcher.watch!(:all_instances_signal => 'USR2')
+
+  # Change the default file for the dump
+  DeadViewCatcher.watch!(:file => '/tmp/somewhere.txt')
+
+
+When customizing the signal you want to catch, be careful when picking one, as your server might already catch some (like Unicorn does for USR1 and USR2).
+
+
+Copyright (c) 2011 Guillaume Luccisano - g-mai|: guillaume.luccisano, released under the MIT license

data/init.rb

@@ -0,0 +1 @@
+require 'dead_view_catcher'

data/lib/dead_view_catcher.rb

@@ -0,0 +1,169 @@
+module DeadViewCatcher
+  
+  # DeadViewCatcher help you find easily not used views in your Rails app.
+  # It's not really Thread safe and using globals, but it's on purpose.
+  
+  # Usage:
+  #
+  # Send a signal (TRAP by default) to one of your rails instance in order to create a dump of the dead views in tmp/dead_views.txt
+  #   kill -s TRAP pid
+  #
+  # If you want a more globalized stats, you can use the all instances signal (URG by default)
+  # This signal will agregate the results of all instances by sending to all instances the TRAP signal.
+  # Then it will dump the consolidated stats in tmp/dead_views.txt (the default file)
+  #
+  # Note: SIGUSR1 and SIGUSR2 is not used as it's used by unicorn :/
+
+  DefaultOptions = {:signal => 'TRAP', :file => 'tmp/dead_views.txt', :all_instances_signal => 'URG'}
+
+  def self.watch!(opts = {})
+    options = DefaultOptions.merge(opts)
+
+    $dead_view_catcher_started_on = Time.now
+    $dead_view_catcher_nb_render = 0
+    $dead_view_catcher_views = build_views_hash
+    $dead_view_last_exception = nil
+
+    watch_signal!(options)
+    watch_all_instances_signal!(options) if !options[:grep].blank?
+
+    ActionView::Template.send :include, DeadViewCatcher::Extensions::ActionView    
+  end
+  
+  # Building the views hash (Only using app/views folders)
+  def self.build_views_hash
+    views = ActiveSupport::OrderedHash.new
+
+    Dir.glob(File.join(Rails.root, 'app', 'views', '**', '*')).each do |v|
+      if File.stat(v).file? 
+        views[v.gsub(Rails.root, '').gsub(/^\//, '')] = 0
+      end
+    end
+    
+    return views
+  end
+  
+  def self.watch_signal!(options)
+    Signal.trap(options[:signal]) do
+      begin
+        puts ">> Dumping dead views..."
+        open(File.join(Rails.root, options[:file]), 'w+') do |fd|
+          fd.write(dump_hash($dead_view_catcher_views).to_yaml)
+        end
+      puts ">> Dead views dumped to #{options[:file]}"
+      rescue Exception => e
+        puts e.to_s + "\n" + e.backtrace.join("\n")
+      end
+    end
+  end
+  
+  def self.watch_all_instances_signal!(options)
+    Signal.trap(options[:all_instances_signal]) do
+      begin
+        puts ">> Starting gathering consolidated dead views..."
+        # Getting all process pids :
+        ps = `ps aux | grep -i "#{options[:grep]}"`.split("\n").select { |l| !l.index('grep') } 
+        pids = ps.collect { |l| (l.split(/ +/, 2)[1].to_i rescue nil) }.compact - [Process.pid]
+
+        last_pid = Process.pid
+        total_hash = dump_hash
+        total_hash[:pids] = [last_pid]
+        total_hash[:nb_instances] = 1
+
+        pids.each do |p|
+          # Sending the signal to other instances
+          `kill -s #{options[:signal]} #{p}`
+        
+          # Now waiting for the output
+          i = 0; l = nil
+          while (!(l = YAML.load_file(options[:file]) rescue nil) or l[:pid] != p) and i < 15
+            sleep 0.1
+            i += 1
+          end
+          
+          if l and l[:pid] and l[:pid] != last_pid
+            puts "  >> Agregating data from pid #{l[:pid]}"
+
+            # Agregating datas...
+            total_hash[:running_hours] += l[:running_hours]
+            total_hash[:views_rendered] += l[:views_rendered]
+            total_hash[:exception_caught] += l[:exception_caught]
+            total_hash[:pids] << l[:pid]
+            total_hash[:nb_instances] = total_hash[:pids].size
+            l[:complete_stats].each do |k, v|
+              total_hash[:complete_stats][k] += v
+            end
+
+            last_pid = l[:pid]
+          else
+            puts "  >> pid #{l[:pid]} skiped.."
+          end
+        end
+
+        total_hash[:dead_views] = dead_views(total_hash[:complete_stats])
+
+        open(File.join(Rails.root, options[:file]), 'w+') do |fd|
+          fd.write(total_hash.to_yaml)
+        end
+        puts ">> Consolidated Dead views dumped to #{options[:file]}"
+      rescue Exception => e
+        puts e.to_s + "\n" + e.backtrace.join("\n")
+      end
+    end
+  end
+  
+  def self.dead_views(h = nil)
+    h ||= $dead_view_catcher_views
+    deads = ActiveSupport::OrderedHash.new
+    h.keys.sort.each do |k|
+      if h[k] == 0
+        deads[k] = h[k]
+      end
+    end
+    deads
+  end
+  
+  def self.dump_hash(dead_views_hash = nil)
+    dump = ActiveSupport::OrderedHash.new
+    
+    dump[:running_hours] = ((Time.now - $dead_view_catcher_started_on) / 3600).round(2)
+    dump[:views_rendered] = $dead_view_catcher_nb_render
+    dump[:time] = Time.now
+    dump[:pid] = Process.pid
+    dump[:exception_caught] = [$dead_view_last_exception].compact
+    dump[:dead_views] = dead_views(dead_views_hash)
+    dump[:complete_stats] = $dead_view_catcher_views
+    dump
+  end
+  
+  module Extensions
+    module ActionView
+
+      def self.included(mod)
+        mod.send :alias_method, :dead_view_catcher_render, :render
+        mod.send :define_method, :render do |*opts|
+          view_catcher_rendered
+          dead_view_catcher_render(*opts)
+        end
+      end
+
+      def view_catcher_rendered
+        begin
+          rp = relative_path
+          if rp and rp.index('app/views') == 0
+            $dead_view_catcher_nb_render += 1
+            #Rails.logger.info "Rendering and counting: #{rp}"
+            begin
+              $dead_view_catcher_views[rp] += 1
+            rescue
+              raise "Index: #{rp} doesn't exist in dead_view_catcher_views Hash"
+            end
+          end
+        rescue Exception => e
+          $dead_view_last_exception = e.to_s + "\n" + e.backtrace.join("\n")
+        end
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: dead_view_catcher
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Guillaume Luccisano
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-12 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: DeadViewCatcher is a gem for Ruby on Rails giving you an easy way to find which views you are not using anymore in your app. Might be really useful for big Rails app.
+email: guillaume.luccisano@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/dead_view_catcher.rb
+- CHANGELOG.rdoc
+- MIT-LICENSE
+- README.rdoc
+- init.rb
+has_rdoc: true
+homepage: http://github.com/kwi/dead_view_catcher
+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: 19
+      segments: 
+      - 1
+      - 3
+      - 4
+      version: 1.3.4
+requirements: []
+
+rubyforge_project: dead_view_catcher
+rubygems_version: 1.4.1
+signing_key: 
+specification_version: 3
+summary: Find easily wich views you are not using anymore in your Rails app.
+test_files: []
+