rails_metrics 0.1

data/app/views/rails_metrics/all.html.erb

@@ -0,0 +1,25 @@
+<% if @metrics.empty? %>
+  <h2>No metrics so far, navigate on your app and come back.</h2>
+<% else %>
+  <% content_for(:rails_metrics_header) do %>
+    <%= pagination_and_scopes_info(:metrics) %>
+
+    <% form_tag url_for(params.merge(:action => "destroy_all")), :method => :delete do %>
+      <%= submit_tag "Delete all", :onclick => "return confirm('Are you sure you want to delete those #{@metrics_count} metrics?')" %>
+    <% end %>
+  <% end %>
+
+  <table id="rails_metrics_table" class="all">
+    <tr>
+      <th>When<br /><%= link_to_order_by_scopes(:earliest, :latest) %></th>
+      <th>Name<br /><%= link_to_clear_by_scope(:name) %></th>
+      <th>Duration<br /><%= link_to_order_by_scopes(:slowest, :fastest) %></th>
+      <th>Payload</th>
+      <th></th>
+    </tr>
+
+    <%= render :partial => "row", :collection => @metrics, :as => :metric %>
+  </table>
+
+  <% paginate! %>
+<% end %>

data/app/views/rails_metrics/chart.html.erb

@@ -0,0 +1,49 @@
+<% content_for(:rails_metrics_header) do %>
+  Showing request #<%= @request.id %>
+  <div class="actions"><% add_action_links!(@request) %></div>
+<% end %>
+
+<div id="chart_container">
+  <div id="chart"></div>
+</div>
+
+<script type="text/javascript" charset="utf-8"> 
+  var r = Raphael("chart");
+  r.g.text(400, 30, "<%= @request.payload[:method] %> <%= @request.payload[:path] %> at <%= @request.started_at.strftime("%d %b %H:%M:%S") %>").attr({"font-size": 20});
+
+  var pie = r.g.piechart(250, 150, 100,
+    <%=raw @metrics.map { |m| m.exclusive_duration_in_ms }.inspect %>, {
+      legend: <%=raw @metrics.map { |m| "##.# ms - #{m.name}" }.inspect %>,
+      href: <%=raw @metrics.map { |m| "#rails_metric_#{m.id}" }.inspect %>,
+      cut: 0
+    }
+  );
+
+  pie.hover(function () {
+    this.sector.stop();
+    this.sector.scale(1.1, 1.1, this.cx, this.cy);
+    if (this.label) {
+      this.label[0].stop();
+      this.label[0].scale(1.5);
+      this.label[1].attr({"font-weight": 800});
+    }
+  }, function () {
+    this.sector.animate({scale: [1, 1, this.cx, this.cy]}, 500, "bounce");
+    if (this.label) {
+      this.label[0].animate({scale: 1}, 500, "bounce");
+      this.label[1].attr({"font-weight": 400});
+    }
+  });
+</script>
+
+<table id="rails_metrics_table" class="chart">
+  <tr>
+    <th>Name</th>
+    <th>Duration (exclusive)</th>
+    <th>Payload</th>
+    <th></th>
+  </tr>
+
+  <%= render :partial => "row", :collection => @metrics, :as => :metric,
+    :locals => { :skip_timestamps => true } %>
+</table>

data/app/views/rails_metrics/index.html.erb

@@ -0,0 +1,21 @@
+<% if @metrics.empty? %>
+  <h2>No requests so far, navigate on your app and come back.</h2>
+<% else %>
+  <% content_for(:rails_metrics_header) do %>
+    <%= pagination_and_scopes_info(:requests) %>
+  <% end %>
+
+  <table id="rails_metrics_table" class="requests">
+    <tr>
+      <th>When<br /><%= link_to_order_by_scopes(:earliest, :latest) %></th>
+      <th>Method</th>
+      <th>Path</th>
+      <th>Duration<br /><%= link_to_order_by_scopes(:slowest, :fastest) %></th>
+      <th></th>
+    </tr>
+
+    <%= render :partial => "request", :collection => @metrics, :as => :metric %>
+  </table>
+
+  <% paginate! %>
+<% end %>

data/app/views/rails_metrics/show.html.erb

@@ -0,0 +1,41 @@
+<% content_for(:rails_metrics_header) do %>
+  Showing metric #<%= @metric.id %>
+  <div class="actions"><% add_action_links!(@metric) %></div>
+<% end %>
+
+<table id="rails_metrics_table" class="show">
+  <tr>
+    <th>Key</th>
+    <th>Value</th>
+  </tr>
+
+  <tr class="odd">
+    <td>Name</td>
+    <td><%= link_to_set_by_scope @metric, :name %></td>
+  </tr>
+
+  <tr class="even">
+    <td>Request</td>
+    <td><%= link_to @metric.request_id, chart_rails_metric_path(@metric.request_id) %></td>
+  </tr>
+
+  <tr class="odd">
+    <td>Duration</td>
+    <td><%= @metric.duration_in_ms %> ms</td>
+  </tr>
+
+  <tr class="even">
+    <td>Payload</td>
+    <td class="payload"><%= payload_inspect(@metric.payload) %></td>
+  </tr>
+
+  <tr class="odd">
+    <td>Started at</td>
+    <td><%= @metric.started_at %></td>
+  </tr>
+
+  <tr class="even">
+    <td>Created at</td>
+    <td><%= @metric.created_at %></td>
+  </tr>
+</table>

data/config/routes.rb

@@ -0,0 +1,7 @@
+Rails::Application.routes.draw do |map|
+  resources :rails_metrics, :only => [:index, :show, :destroy] do
+    get :all, :on => :collection
+    get :chart, :on => :member
+    delete :destroy_all, :on => :collection
+  end
+end

data/lib/generators/rails_metrics_generator.rb

@@ -0,0 +1,40 @@
+class RailsMetricsGenerator < Rails::Generators::NamedBase
+  class_option :migration, :type => :boolean, :default => true
+
+  class_option :update, :type => :boolean, :default => false,
+                        :desc => "Just update public files, do not create a model"
+
+  def self.source_root
+    @_metrics_source_root ||= File.dirname(__FILE__)
+  end
+
+  def copy_public_files
+    directory "../../public", "public", :recursive => true
+    exit(0) if options.update?
+  end
+
+  def invoke_model
+    invoke "model", [name].concat(migration_columns),
+      :timestamps => false, :test_framework => false, :migration => options.migration?
+  end
+
+  def add_model_config
+    inject_into_class "app/models/#{file_name}.rb", class_name, <<-CONTENT
+  include RailsMetrics::ORM::#{Rails::Generators.options[:rails][:orm].to_s.camelize}
+CONTENT
+  end
+
+  def add_application_config
+    inject_into_class "config/application.rb", "Application", <<-CONTENT
+    # Set rails metrics store
+    config.rails_metrics.set_store = lambda { ::#{class_name} }
+
+CONTENT
+  end
+
+  protected
+
+  def migration_columns
+    %w(name:string duration:integer request_id:integer parent_id:integer payload:text started_at:datetime created_at:datetime)
+  end
+end

data/lib/rails_metrics.rb

@@ -0,0 +1,112 @@
+require 'active_support/core_ext/module/delegation'
+Thread.abort_on_exception = Rails.env.development? || Rails.env.test?
+
+module RailsMetrics
+  autoload :AsyncConsumer,    'rails_metrics/async_consumer'
+  autoload :Middleware,       'rails_metrics/middleware'
+  autoload :PayloadParser,    'rails_metrics/payload_parser'
+  autoload :Store,            'rails_metrics/store'
+  autoload :VERSION,          'rails_metrics/version'
+  autoload :VoidInstrumenter, 'rails_metrics/async_consumer'
+
+  module ORM
+    autoload :ActiveRecord, 'rails_metrics/orm/active_record'
+  end
+
+  # Set which store to use in RailsMetrics.
+  #
+  #   RailsMetrics.set_store { Metric }
+  #
+  def self.set_store(&block)
+    metaclass.send :define_method, :store, &block
+  end
+
+  # Place holder for the store.
+  def self.store; end
+
+  # Holds the events for a specific thread.
+  def self.events
+    Thread.current[:rails_metrics_events] ||= []
+  end
+
+  # Turn RailsMetrics on, i.e. make it listen to notifications during the block.
+  # At the end, it pushes notifications to the async consumer.
+  def self.listen_request
+    events = RailsMetrics.events
+    events.clear
+
+    Thread.current[:rails_metrics_listening] = true
+    result = yield
+
+    RailsMetrics.async_consumer.push(events.dup)
+    result
+  ensure
+    Thread.current[:rails_metrics_listening] = false
+    RailsMetrics.events.clear
+  end
+
+  # Returns if events are being registered or not.
+  def self.listening?
+    Thread.current[:rails_metrics_listening] || false
+  end
+
+  # Allow you to specify a condition to ignore a notification based
+  # on its name and/or payload. For example, if you want to ignore
+  # all notifications with empty payload, one can do:
+  #
+  #   RailsMetrics.ignore :with_empty_payload do |name, payload|
+  #     payload.empty?
+  #   end
+  #
+  # However, if you want to ignore something based solely on its
+  # name, you can use ignore_patterns instead:
+  #
+  #   RailsMetrics.ignore_patterns << /^some_noise_plugin/
+  #
+  def self.ignore(name, &block)
+    raise ArgumentError, "ignore expects a block" unless block_given?
+    ignore_lambdas[name] = block
+  end
+
+  # Stores the blocks given to ignore with their respective identifier in a hash.
+  def self.ignore_lambdas
+    @@ignore_lambdas ||= {}
+  end
+
+  # Stores ignore patterns that can be given as strings or regexps.
+  def self.ignore_patterns
+    @@ignore_patterns ||= []
+  end
+
+  # Holds the queue which store stuff in the database.
+  def self.async_consumer
+    @@async_consumer ||= AsyncConsumer.new do |events|
+      next if events.empty?
+      root = RailsMetrics.store.events_to_metrics_tree(events)
+      root.save_metrics!
+    end
+  end
+
+  # Wait until the async queue is consumed.
+  def self.wait
+    sleep(0.01) until async_consumer.finished?
+  end
+
+  # A notification is valid for storing if two conditions are met:
+  #
+  #   1) The instrumenter id which created the notification is not the same
+  #      instrumenter id of this thread. This means that notifications generated
+  #      inside this thread are stored in the database;
+  #
+  #   2) If the notification name does not match any ignored pattern;
+  #
+  def self.valid_for_storing?(args) #:nodoc:
+    name, payload = args[0].to_s, args[4]
+
+    RailsMetrics.listening? && RailsMetrics.store &&
+    !self.ignore_patterns.find { |p| String === p ? name == p : name =~ p } &&
+    !self.ignore_lambdas.values.any? { |b| b.call(name, payload) }
+  end
+end
+
+require 'rails_metrics/engine'

data/lib/rails_metrics/async_consumer.rb

@@ -0,0 +1,54 @@
+require 'thread'
+
+module RailsMetrics
+  # An instrumenter that does not send notifications. This is used in the
+  # AsyncQueue so saving events does not send any notifications, not even
+  # for logging.
+  class VoidInstrumenter < ::ActiveSupport::Notifications::Instrumenter
+    def instrument(name, payload={})
+      yield(payload) if block_given?
+    end
+  end
+
+  class AsyncConsumer
+    attr_reader :thread
+
+    def initialize(queue=Queue.new, &block)
+      @off   = true
+      @block = block
+      @queue = queue
+      @mutex = Mutex.new
+
+      @thread = Thread.new do
+        set_void_instrumenter
+        consume
+      end
+    end
+
+    def push(*args)
+      @mutex.synchronize { @off = false }
+      @queue.push(*args)
+    end
+
+    def finished?
+      @off
+    end
+
+  protected
+
+    def set_void_instrumenter #:nodoc:
+      Thread.current[:"instrumentation_#{notifier.object_id}"] = VoidInstrumenter.new(notifier)
+    end
+
+    def notifier #:nodoc:
+      ActiveSupport::Notifications.notifier
+    end
+
+    def consume #:nodoc:
+      while args = @queue.shift
+        @block.call(args)
+        @mutex.synchronize { @off = @queue.empty? }
+      end
+    end
+  end
+end

data/lib/rails_metrics/engine.rb

@@ -0,0 +1,29 @@
+module RailsMetrics
+  class Engine < ::Rails::Engine
+    engine_name :rails_metrics
+
+    # Add middleware
+    config.middleware.use RailsMetrics::Middleware
+
+    # Initialize configure parameters
+    config.rails_metrics.ignore_lambdas  = {}
+    config.rails_metrics.ignore_patterns = [ "action_controller.start_processing" ]
+
+    initializer "rails_metrics.set_ignores" do |app|
+      RailsMetrics.ignore_lambdas.merge!(app.config.rails_metrics.ignore_lambdas)
+      RailsMetrics.ignore_patterns.concat(app.config.rails_metrics.ignore_patterns)
+    end
+
+    initializer "rails_metrics.set_store" do |app|
+      if app.config.rails_metrics.set_store
+        RailsMetrics.set_store(&app.config.rails_metrics.set_store)
+      end
+    end
+
+    initializer "rails_metrics.start_subscriber" do
+      ActiveSupport::Notifications.subscribe do |*args|
+        RailsMetrics.events.push(args) if RailsMetrics.valid_for_storing?(args)
+      end
+    end
+  end
+end

data/lib/rails_metrics/middleware.rb

@@ -0,0 +1,27 @@
+module RailsMetrics
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env["PATH_INFO"] =~ /^\/rails_metrics/
+        @app.call(env)
+      else
+        RailsMetrics.listen_request do
+          response = notifications.instrument "rack.request",
+            :path => env["PATH_INFO"], :method => env["REQUEST_METHOD"],
+            :instrumenter_id => notifications.instrumenter.id do
+            @app.call(env)
+          end
+        end
+      end
+    end
+
+  protected
+
+    def notifications
+      ActiveSupport::Notifications
+    end
+  end
+end

data/lib/rails_metrics/orm/active_record.rb

@@ -0,0 +1,66 @@
+# Setup to ignore any query which is not a SELECT, INSERT, UPDATE
+# or DELETE and queries made by the own store.
+RailsMetrics.ignore :invalid_queries do |name, payload|
+  name == "active_record.sql" &&
+    (payload[:sql] !~ /^(SELECT|INSERT|UPDATE|DELETE)/ ||
+    RailsMetrics.store.connections_ids.include?(payload[:connection_id]))
+end
+
+module RailsMetrics
+  module ORM
+    # Include in your model to store metrics. For ActiveRecord, you need the
+    # following setup:
+    #
+    #   script/generate model Metric script/generate name:string duration:integer
+    #     request_id:integer parent_id:integer payload:text started_at:datetime created_at:datetime --skip-timestamps
+    #
+    # You can use any model name you wish. Next, you need to include
+    # RailsMetrics::ORM::ActiveRecord:
+    #
+    #   class Metric < ActiveRecord::Base
+    #     include RailsMetrics::ORM::ActiveRecord
+    #   end
+    #
+    module ActiveRecord
+      extend  ActiveSupport::Concern
+      include RailsMetrics::Store
+
+      included do
+        # Create a new connection pool just for the given resource
+        establish_connection(Rails.env)
+
+        # Set required validations
+        validates_presence_of :name, :started_at, :duration
+
+        # Serialize payload data
+        serialize :payload
+
+        # Select scopes
+        scope :requests,      where(:name => "rack.request")
+        scope :by_name,       lambda { |name| where(:name => name) }
+        scope :by_request_id, lambda { |request_id| where(:request_id => request_id) }
+
+        # Order scopes
+        # We need to add the id in the earliest and latest scope since the database
+        # does not store miliseconds. The id then comes as second criteria, since
+        # the ones started first are first saved in the database.
+        scope :earliest, order("started_at ASC, id ASC")
+        scope :latest,   order("started_at DESC, id DESC")
+        scope :slowest,  order("duration DESC")
+        scope :fastest,  order("duration ASC")
+      end
+
+      module ClassMethods
+        def connections_ids
+          self.connection_pool.connections.map(&:object_id)
+        end
+      end
+
+    protected
+
+      def save_metric!
+        save!
+      end
+    end
+  end
+end