rack_proctitle 1.0.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010 Arya Asemanfar
+
+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,34 @@
+# About  
+RackProctitle allows you to see what request a given server process is handling. By running "watch -n 0.1 ‘ps aux | grep “USER\|rack” ’ you can see all your rack processes, what request they’re currently handling and for how long (or if they’re idle), what their last request was and how long it took, how many requests have been handled in the life of this process, and the requests in queue.
+
+It ends up being really useful to diagnose problems.
+
+Example output:
+
+    rack/14a0b0 [1/682]: handling 0.0s /users/6014086
+
+You can set a prefix, which will replace “rack” in the line above, and you can set an _APPLICATION\_VERSION_ constant which will be after the prefix. You can use this to distinguish between different rack processes if you run multiple applications on the same machine.
+
+Concept and output formatting is based on Alexander Staubo’s [mongrel\_proctitle][mongrel_proctitle] but has more features, is thread safe, and is Rack compatible. For more information on why mongrel\_proctitle is not thread safe, [read this post][blog_post].
+
+
+# Usage
+    sudo gem install rack_proctitle
+
+In some file somewhere (optional):
+
+    APPLICATION_VERSION = File.read(File.join(RAILS\_ROOT, “REVISION”))[0,6] # if you use Capistrano, which creates a REVISION file for you.
+
+In your rackup file (prefix is optional):  
+
+    use RackProctitle, :prefix => “application_name”
+
+We use _watch_ to get a continuously updating status of our rack processes:
+
+    watch -n 0.1 ‘ps aux | grep “USER\|application_name” | grep -v grep ; uptime; hostname’
+
+The _watch_ linux utility is one of those things that is hard to Google, so here's the link if it's not installed or not in your package manager: [http://procps.sourceforge.net/](http://procps.sourceforge.net/)
+
+
+[mongrel_proctitle]: http://github.com/alexstaubo/mongrel_proctitle
+[blog_post]: http://asemanfar.com/Request-Queue-via-Mongrel-Proctitle

data/lib/rack_proctitle.rb

@@ -0,0 +1,94 @@
+class RackProctitle
+  def initialize(app, options = nil)
+    @app = app
+    
+    @title = "#{(options && options.delete(:prefix)) || 'rack'}"
+    @title << "/#{APPLICATION_VERSION}" if defined?(APPLICATION_VERSION)
+    @title << " [%d/%d]: %s"
+    
+    @mutex = Mutex.new
+    @request_threads = []
+    @total_request_count = 0
+    
+    start_updater_thread
+  end
+
+  def call(env)
+    ensure_updater_thread_running
+    Thread.current[:request_str] = ((env["REQUEST_URI"].nil? || env["REQUEST_URI"].empty?) ? "/" : env["REQUEST_URI"]).split("?", 2)[0]
+    Thread.current[:arrived_at] = Time.now.to_f
+    @mutex.synchronize do
+      @request_threads.push(Thread.current)
+      set_request_list_title
+    end
+    
+    begin
+      @app.call(env)
+    ensure
+      @mutex.synchronize do
+        @total_request_count += 1
+
+        @last_time = Time.now.to_f - Thread.current[:arrived_at].to_f
+        @last_request_str = Thread.current[:request_str].to_s
+
+        @request_threads.delete(Thread.current)
+        set_request_list_title
+      end
+    end
+  end
+
+  protected
+  # This exists for cases like unicorn where the instance initialized and then the process is forked.
+  # Threads don't live through forks, so we have to start a new one inside each new process.
+  def ensure_updater_thread_running
+    if @pid != ::Process.pid
+      start_updater_thread
+    end
+  end
+  
+  def start_updater_thread
+    @updater_thread.kill if @updater_thread
+    @pid = ::Process.pid
+    @updater_thread = Thread.new do
+      while true
+        @mutex.synchronize do
+          set_request_list_title
+        end
+        sleep 0.5
+      end
+    end
+  end
+  
+  def set_request_list_title
+    current_status = if @request_threads.empty?
+      idle_message
+    else
+      now = Time.now.to_f
+      list = @request_threads.inject([]) do |str, thread|
+        str << "#{time_delta_abbriv(now - thread[:arrived_at])} #{thread[:request_str]}"
+      end.join(" | ")
+      "handling #{list}"
+    end
+    
+    $0 = @title % [@request_threads.size, @total_request_count, current_status]
+  end
+
+  def idle_message
+    str = "idle#{' '*20}" # the spacing is for visual distinction in a list of processes.
+    str << "[last #{time_delta_abbriv(@last_time)} #{@last_request_str}]" if @last_time && @last_request_str
+    str
+  end
+  
+  TIME_DELTA_STRS = %w{%.1fs %dm%ds %dh%dm %dd%dh}
+  def time_delta_abbriv(delta)
+    if delta < 60
+      TIME_DELTA_STRS[0] % delta
+    elsif delta < 3600
+      TIME_DELTA_STRS[1] % [delta.to_i / 60, delta.to_i % 60]
+    elsif delta < 86400
+      TIME_DELTA_STRS[2] % [delta.to_i / 3600, (delta.to_i % 3600) / 60]
+    else
+      TIME_DELTA_STRS[3] % [delta.to_i / 86400, (delta.to_i % 86400) / 3600]
+    end
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: rack_proctitle
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Arya Asemanfar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-16 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: aryaasemanfar@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- lib/rack_proctitle.rb
+- LICENSE
+- README.md
+has_rdoc: true
+homepage: http://github.com/arya/rack_proctitle
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A utility to update the proctite of Rack process with helpful information.
+test_files: []
+