memory_tracker 1.0.4 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c79259df69cdd525c49ddc55792f2bb791488868
-  data.tar.gz: 2cc3574d0fc057d5341d9ba13c8f6506e4838467
+  metadata.gz: adeca7dfc23c7e1fc6ba5c3411ed54639ca30b87
+  data.tar.gz: b94c7d23aa9f03912cdc4be6c025860428e97aa7
 SHA512:
-  metadata.gz: 392c9eacb37f3ac9d0bea50430122b2eab310aca4deb54ec718b8f10cda2819ab4f69a0e8cb462f4a2d3259854b872c33f3dbba16faaee88aabfe7bd21766e3f
-  data.tar.gz: 0c02a30970cc15140036cd97e819277ea8e1fb69eddd7d9bcb6afb71d64f24b9bedc49df61657a980d3c5d4f35de2303505b6ea82ae5ff7869b942d17e5b060d
+  metadata.gz: 67c83299b9e960365b3a8429402b2b05f63c8b4baeb589ceef5385d2f24c63be1d3d285629b35f718a3c0bac93953e88a65d732c31d73df6cae1498a126a6f22
+  data.tar.gz: d7d17859238f52bfac1cb69a4c00761444f64a08f339bed9c0c7c45f941edc5db05e6b058e1f9c9f2008ccb771b9b547e5f07da9a9ce7dbe68dcb85dda65c0a7

data/README.md

@@ -0,0 +1,71 @@
+# MemoryTracker
+
+MemoryTracker collects, analyzes and reports memory usage data of each controller action of a Rails application. The data will identify the parts of the application that are the most memory hungry, so that they can be fixed and the overall memory usage of the application be reduced.
+
+# Features
+* Collect stats on each controller action memory consumption.
+* Display stats on every controller action of the application in a engine webpage embedded in the gem.
+
+# Dashboard
+The dashboard is at /memtracker in the host application (but you need to mount the engine in the app first, see below).
+![Dashboard snapshot](https://github.com/plerohellec/memory_tracker/tree/master/docs/memory_tracker_dashboard.png?raw=true)
+
+# How?
+MemoryTracker uses system memory data and Ruby garbage collector statistics to find the memory currently used by The Rails processes, how many objects were allocated in Ruby heaps, how many heaps were created and how many times the garbage collector ran. The MemoryTracker middleware captures the data before and after each HHTP request and saves the deltas per controller/action in a variety of stores.
+
+MemoryTracker is implemented as a Rails engine and reports its statistics in a web page served by the application where it's embedded. The report currently includes data from the InMemoryStore.
+
+# Stores
+MemoryTracker currently comes with 3 stores.
+
+* The InMemoryStore keeps counters in memory for the process where it runs. This store in itself uses very little memory as it only keeps a set of counters per controller/action in the application. Since it doesn't do any IO, it is also extremely fast. The data is immediately available without any need for a background aggregation tasks.
+
+* The GcStatLogfile store simply write memory stats to a log file called '#{Rails.root}/log/memtracker_gcstat.log' after each HTTP request.
+
+* The UrlLogfileStore also stores data in a log file ('#{Rails.root}/log/memtracker_urls.log') but instead of writing the raw memory data, it records the URL that was requested along with the memory deltas between the current request and the previous one. It also highlights the urls where the deltas were the greatest. It's sometimes interesting to browse through this file URLs that are particularly greedy.
+
+
+# Enabling MemoryTracker
+Add it to your Gemfile:
+```ruby
+gem 'memory_tracker'
+```
+To get access to the MemoryTracker UI and see the stats, the engine must be mounted at config/routes.rb
+```ruby
+mount MemoryTracker::Engine => "/memtracker"
+```
+Once the app is running, go to /memtracker to review the list of controller actions.
+
+# Requirements
+The gem has been tested and is compatible with:
+* Ruby 2.0
+* Rails 3.2
+
+# Tips
+* Ruby processes rarely leak memory. Instead they allocate memory whenever they need it and never release it. This memory is not lost, it's still available to the process that allocated it but it's unavailable for all other processes in the system.
+* It doesn't matter if the average controller action in the application only consumes 50MB of memory, the size of the process will still reach 100MB if a single one of the controller actions requires 100MB. Therefore, the biggest bang for the bug is to be found in the action at the top of the list. Fix that one and the whole process memory will go down to the level of the second most expensive controller action.
+* You want the heap_used to be 0, always. If not 0, it means this controller action asked for an amount of memory that required the allocation of new heaps.
+* rss and vsize should be very low in a memory conscious application.
+* total_allocated_heaps should mostly be in the same range for all controller actions. Outliers are the ones causing memory bloat.
+* The stats are only meaningful in the production environment. Do not believe anything you see in the development environment. 
+
+# Coming soon
+* Redis store.
+* Store and report the most expensive URLs.
+* Support for Ruby 1.9 and Rails 4.
+
+# Contributing to memory_tracker
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+# Copyright
+
+Copyright (c) 2013 Philippe Le Rohellec. See LICENSE.txt for
+further details.
+

data/app/controllers/memory_tracker/dashboards_controller.rb

@@ -8,11 +8,22 @@ module MemoryTracker
     def index
       stats = MemoryTracker.instance.stats(:memory)
       @data = stats.to_a
-      sort_by = params[:sort_by] ? params[:sort_by].to_sym : :count
+      sort_by = params[:sort_by] ? params[:sort_by].downcase.to_sym : :count
       if @data.any? && @data.first.keys.include?(sort_by)
-        @data = @data.sort{ |a,b| b[sort_by].to_f/b[:num] <=> a[sort_by].to_f/a[:num] }
+        if [ :controller, :action ].include?(sort_by)
+          @data = @data.sort { |a,b| a[sort_by] <=> b[sort_by] }
+        elsif sort_by == :num
+          @data = @data.sort { |a,b| b[sort_by] <=> a[sort_by] }
+        else
+          @data = @data.sort{ |a,b| b[sort_by].to_f/b[:num] <=> a[sort_by].to_f/a[:num] }
+        end
       end
 
+      @pid = Process.pid
+      @rss = Request.rss
+      @vsize = Request.vsize
+      @num_heaps = GC.stat[:heap_used]
+
       respond_to do |format|
         format.json do
           render :json => @data.to_json

data/app/helpers/memory_tracker/dashboards_helper.rb

@@ -3,5 +3,14 @@ module MemoryTracker
     def link_to_dashboards(name)
       link_to(name, memory_tracker.dashboards_path(:sort_by => name))
     end
+
+    def display_num(val, num)
+      f = val.to_f / num
+      if f > 1000
+        f.to_i
+      else
+        '%.3f' % (val.to_f/num)
+      end
+    end
   end
 end

data/app/views/memory_tracker/dashboards/index.html.erb

@@ -1,3 +1,14 @@
+<h1>Current State</h1>
+<table width='300px'>
+<tr><td>Stats displayed for pid</td><td><%= @pid %></td></tr>
+<tr><td>Current RSS</td><td><%= '%.1f' % @rss %>MB</td></tr>
+<tr><td>Current VSIZE</td><td><%= '%.1f' % @vsize %>MB</td></tr>
+<tr><td>Number of ruby heaps</td><td><%= @num_heaps %></td></tr>
+</table>
+<br/>
+
+<hr>
+<h1>Average Deltas</h1>
 <% keys = [ :rss, :vsize, :count, :total_allocated_object, :heap_used ] %>
 <table width="100%">
   <tr>
@@ -14,8 +25,21 @@
       <td><%= "#{row[:action]}" %></td>
       <td><%= row[:num] %></td>
       <% keys.each do |key| %>
-        <td><%= '%.3f' % (row[key].to_f/row[:num]) %></td>
+        <td><%= display_num(row[key], row[:num]) %></td>
       <% end %>
     </tr>
   <% end %>
 </table>
+
+<h2>Legend</h2>
+<p>All numbers are average per controller action.</p>
+<i>
+<ul>
+<li>num: number of HTTP requests</li>
+<li>rss: resident memory (MB)</li>
+<li>vsize: virtual memory (MB)</lib>
+<li>count: number of times the garbage collector ran</li>
+<li>total_allocated_object: number of objects allocated on the ruby heaps</li>
+<li>heap_used: number of allocated ruby heaps</li>
+</ul>
+</i>

data/lib/memory_tracker/version.rb

@@ -1,3 +1,3 @@
 module MemoryTracker
-  VERSION = "1.0.4"
+  VERSION = "1.0.6"
 end

data/memory_tracker.gemspec

@@ -16,13 +16,13 @@ Gem::Specification.new do |s|
   s.email = "philippe@lerohellec.com"
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
     "Gemfile",
     "Gemfile.lock",
     "LICENSE.txt",
-    "README.rdoc",
+    "README.md",
     "Rakefile",
     "app/controllers/memory_tracker/application_controller.rb",
     "app/controllers/memory_tracker/dashboards_controller.rb",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memory_tracker
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.6
 platform: ruby
 authors:
 - Philippe Le Rohellec
@@ -87,12 +87,12 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE.txt
-- README.rdoc
+- README.md
 files:
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
-- README.rdoc
+- README.md
 - Rakefile
 - app/controllers/memory_tracker/application_controller.rb
 - app/controllers/memory_tracker/dashboards_controller.rb

data/README.rdoc

@@ -1,31 +0,0 @@
-= MemoryTracker
-
-MemoryTracker collects and analyzes memory usage data for each controller action of a Rails application. It's implemented as a Rails engine with a middleware that captures stats before and after each query. 
-
-== How?
-It uses GC.stats (Ruby garbage collector) to find how many objects were allocated, how many heaps were created and how many times the garbage collector ran.
-
-== Features
-* Collect stats on each controller action memory consumption.
-* Write a log file with GC.stat data.
-* The engine includes a couple of web pages that shows a summary of memory utilization per controller action.
-
-== Enable MemoryTracker in a Rails application
-In config/routes.rb
-  mount MemoryTracker::Engine, at: "/memory_tracker"
-
-== Contributing to memory_tracker
- 
-* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
-* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
-* Fork the project.
-* Start a feature/bugfix branch.
-* Commit and push until you are happy with your contribution.
-* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
-* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
-
-== Copyright
-
-Copyright (c) 2013 Philippe Le Rohellec. See LICENSE.txt for
-further details.
-