rails_metrics 0.1

data/test/orm/active_record_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+class ActiveRecordTest < ActiveSupport::TestCase
+  setup do
+    Metric.delete_all
+  end
+
+  test "does not store own queries as notifications" do
+    Metric.all
+    wait
+    assert Metric.all.empty?
+  end
+
+  test "does not store queries other than SELECT, INSERT, UPDATE and DELETE" do
+    User.connection.send(:select, "SHOW tables;")
+    wait
+    assert Metric.all.empty?
+  end
+
+  test "serializes payload" do
+    metric = Metric.new
+    metric.configure(["metric", Time.now, Time.now, "id", {:foo => :bar}])
+    metric.save!
+    assert_equal Hash[:foo => :bar], metric.payload 
+  end
+
+  test "is invalid when name is blank" do
+    metric = Metric.new
+    assert metric.invalid?
+    assert "can't be blank", metric.errors["name"].join
+  end
+
+  test "is invalid when started_at is blank" do
+    metric = Metric.new
+    assert metric.invalid?
+    assert "can't be blank", metric.errors["started_at"].join
+  end
+
+  test "is invalid when duration is blank" do
+    metric = Metric.new
+    assert metric.invalid?
+    assert "can't be blank", metric.errors["duration"].join
+  end
+
+  test "responds to all required named scopes" do
+    [ :by_name, :by_request_id, :latest,
+      :earliest, :slowest, :fastest, :requests ].each do |method|
+      assert_respond_to Metric, method
+    end
+  end
+end

data/test/payload_parser_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class PayloadParserTest < ActiveSupport::TestCase
+  setup do
+    @_previous_parsers = RailsMetrics::PayloadParser.parsers.dup
+  end
+
+  teardown do
+    RailsMetrics::PayloadParser.parsers.replace @_previous_parsers
+  end
+
+  delegate :add, :ignore, :filter, :to => RailsMetrics::PayloadParser
+
+  test "a non registered parser returns payload as is" do
+    assert_equal Hash[:some => :info], filter("rails_metrics.something", :some => :info)
+  end
+
+  test "a parser with hash converts into method calls" do
+    add "rails_metrics.something", :except => [:foo, :bar]
+    assert_equal Hash[:some => :info], filter("rails_metrics.something", :some => :info,
+                                              :foo => :baz, :bar => :baz)
+  end
+
+  test "a parser with a block calls the block with payload" do
+    add "rails_metrics.something" do |payload|
+      assert_equal Hash[:some => :info], payload
+      { :foo => :bar }
+    end
+    assert_equal Hash[:foo => :bar], filter("rails_metrics.something", :some => :info)
+  end
+
+  test "a parser can be ignored" do
+    ignore "rails_metrics.something"
+    assert_nil filter("rails_metrics.something", :some => :info)
+  end
+end

data/test/rails_metrics_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class RailsMetricsTest < ActiveSupport::TestCase
+  setup do
+    RailsMetrics.set_store { MockStore }
+    MockStore.instances.clear
+  end
+
+  test "send instrumentation event to the specified store" do
+    instrument "rails_metrics.something"
+    wait
+  
+    assert_equal 2, MockStore.instances.size
+    assert_equal "rails_metrics.something", MockStore.instances.first.name
+  end
+
+  test "does not send an event to the store if it matches an ignored pattern" do
+    RailsMetrics.ignore_patterns << /rails_metrics/
+
+    begin
+      instrument "rails_metrics.something"
+      wait
+      assert MockStore.instances.none? { |m| m.name == "rails_metrics.something" }
+    ensure
+      RailsMetrics.ignore_patterns.pop
+    end
+  end
+
+  test "does not send an event to the store if it was generated inside it" do
+    instrument "rails_metrics.kicker"
+    wait
+
+    assert_equal 2, MockStore.instances.size
+    assert MockStore.instances.first.kicked?
+    assert_equal "rails_metrics.kicker", MockStore.instances.first.name
+  end
+
+  test "does not send an event if not listening" do
+    ActiveSupport::Notifications.instrument "rails_metrics.kicker"
+    wait
+    assert_equal 0, MockStore.instances.size
+  end
+end

data/test/store_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+class StoreTest < ActiveSupport::TestCase
+  setup do
+    RailsMetrics.set_store { MockStore }
+    MockStore.instances.clear
+  end
+
+  def sample_args
+    time = Time.now
+    ["rails_metrics.example", time, time + 1, 1, { :some => :info }]
+  end
+
+  def store!(args=sample_args)
+    metric = Metric.new
+    metric.configure(args)
+    metric
+  end
+
+  test "sets the name" do
+    assert_equal "rails_metrics.example", store!.name
+  end
+
+  test "sets the duration" do
+    assert_equal 1000000, store!.duration
+    assert_equal 1000000, store!.duration_in_us
+    assert_equal 1000, store!.duration_in_ms
+  end
+
+  test "sets started at" do
+    assert_kind_of Time, store!.started_at
+  end
+
+  test "sets the payload" do
+    assert_equal Hash[:some => :info], store!.payload
+  end
+
+  test "nested instrumentations are saved nested" do
+    instrument "rails_metrics.parent" do
+      instrument "rails_metrics.child" do
+      end
+    end
+
+    instrument "rails_metrics.another"
+
+    assert_equal 5, MockStore.instances.size
+    child, parent, request, another, another_request = MockStore.instances
+
+    assert_equal request.id, request.request_id
+    assert_equal request.id, parent.request_id
+    assert_equal request.id, parent.parent_id
+    assert_equal request.id, child.request_id
+    assert_equal parent.id, child.parent_id
+
+    assert parent.parent_of?(child)
+    assert child.child_of?(parent)
+
+    assert !parent.parent_of?(another)
+    assert !another.parent_of?(parent)
+    assert !parent.child_of?(another)
+    assert !another.child_of?(parent)
+  end
+
+  test "tree can be created from nested instrumentations" do
+    instrument "rails_metrics.parent" do
+      instrument "rails_metrics.child" do
+      end
+    end
+
+    child, parent, request = MockStore.instances
+    root = RailsMetrics.store.mount_tree(MockStore.instances)
+
+    assert_equal "rails_metrics.child", child.name
+    assert_equal "rails_metrics.parent", parent.name
+    assert_equal "rack.request", request.name
+
+    assert root.rack_request?
+    assert [parent], root.children
+    assert [child], parent.children
+  end
+end

data/test/support/helpers.rb

@@ -0,0 +1,16 @@
+class ActiveSupport::TestCase
+  # Execute the block setting the given values and restoring old values after
+  # the block is executed.
+  def swap(object, new_values)
+    old_values = {}
+    new_values.each do |key, value|
+      old_values[key] = object.send key
+      object.send :"#{key}=", value
+    end
+    yield
+  ensure
+    old_values.each do |key, value|
+      object.send :"#{key}=", value
+    end
+  end
+end

data/test/support/instrumentation.rb

@@ -0,0 +1,18 @@
+class ActiveSupport::TestCase
+  def wait
+    RailsMetrics.wait
+  end
+
+  # Fake a request instrumentation.
+  def instrument(*args, &block)
+    if RailsMetrics.listening?
+      ActiveSupport::Notifications.instrument(*args, &block)
+    else
+      RailsMetrics.listen_request do
+        ActiveSupport::Notifications.instrument "rack.request" do
+          ActiveSupport::Notifications.instrument(*args, &block)
+        end
+      end
+    end
+  end
+end

data/test/support/mock_store.rb

@@ -0,0 +1,34 @@
+class ActiveSupport::TestCase
+  class MockStore
+    include RailsMetrics::Store
+
+    attr_accessor :id, :name, :parent_id, :request_id, :started_at, :duration, :payload
+
+    def self.instances
+      @instances ||= []
+    end
+
+    def initialize
+      self.class.instances << self
+    end
+
+    def kicked?
+      @kicked || false
+    end
+
+    def new_record?
+      true
+    end
+
+  protected
+
+    def save_metric!
+      self.id ||= (rand * 1000).to_i
+
+      if self.name == "rails_metrics.kicker"
+        @kicked = true
+        ActiveSupport::Notifications.instrument("rails_metrics.inside_store")
+      end
+    end
+  end
+end

data/test/support/webrat/integrations/rails.rb

@@ -0,0 +1,31 @@
+require 'webrat/core/elements/field'
+
+module Webrat
+  Field.class_eval do
+    def parse_rails_request_params(params)
+      Rack::Utils.parse_nested_query(params)
+    end
+  end
+end
+
+module ActionController #:nodoc:
+  IntegrationTest.class_eval do
+    include Webrat::Methods
+    include Webrat::Matchers
+ 
+    # The Rails version of within supports passing in a model and Webrat
+    # will apply a scope based on Rails' dom_id for that model.
+    #
+    # Example:
+    #   within User.last do
+    #     click_link "Delete"
+    #   end
+    def within(selector_or_object, &block)
+      if selector_or_object.is_a?(String)
+        super
+      else
+        super('#' + RecordIdentifier.dom_id(selector_or_object), &block)
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,32 @@
+# Configure Rails Envinronment
+ENV["RAILS_ENV"] = "test"
+
+# To test RailsMetrics, you need to:
+#
+#   1) Install latest bundler with "gem install bundler"
+#   2) bundle install
+#   3) rake prepare
+#   4) rake test
+#
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require "rails/test_help"
+
+ActionMailer::Base.delivery_method = :test
+ActionMailer::Base.perform_deliveries = true
+ActionMailer::Base.default_url_options[:host] = "test.com"
+
+Webrat.configure do |config|
+  config.mode = :rails
+  config.open_error_files = false
+end
+
+# Add support to load paths so we can overwrite broken webrat setup
+$:.unshift File.expand_path('../support', __FILE__)
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+class ActiveSupport::TestCase
+  setup do
+    wait
+    RailsMetrics.set_store { Metric }
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: rails_metrics
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- "Jos\xC3\xA9 Valim"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-15 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Metrics measurement for your app on top of ActiveSupport::Notifications
+email: contact@engineyard.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- CHANGELOG.rdoc
+- Gemfile
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- TODO.rdoc
+- app/controllers/rails_metrics_controller.rb
+- app/helpers/rails_metrics_helper.rb
+- app/views/layouts/rails_metrics.html.erb
+- app/views/rails_metrics/_request.html.erb
+- app/views/rails_metrics/_row.html.erb
+- app/views/rails_metrics/all.html.erb
+- app/views/rails_metrics/chart.html.erb
+- app/views/rails_metrics/index.html.erb
+- app/views/rails_metrics/show.html.erb
+- config/routes.rb
+- lib/generators/rails_metrics_generator.rb
+- lib/rails_metrics.rb
+- lib/rails_metrics/async_consumer.rb
+- lib/rails_metrics/engine.rb
+- lib/rails_metrics/middleware.rb
+- lib/rails_metrics/orm/active_record.rb
+- lib/rails_metrics/payload_parser.rb
+- lib/rails_metrics/store.rb
+- lib/rails_metrics/version.rb
+- public/images/rails_metrics/arrow_down.png
+- public/images/rails_metrics/arrow_up.png
+- public/images/rails_metrics/cancel.png
+- public/images/rails_metrics/chart_pie.png
+- public/images/rails_metrics/page_white_delete.png
+- public/images/rails_metrics/page_white_go.png
+- public/images/rails_metrics/tick.png
+- public/javascripts/rails_metrics/g.pie-min.js
+- public/javascripts/rails_metrics/g.raphael-min.js
+- public/javascripts/rails_metrics/raphael-min.js
+- public/stylesheets/rails_metrics.css
+has_rdoc: true
+homepage: http://github.com/engineyard
+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: Metrics measurement for your app on top of ActiveSupport::Notifications
+test_files: 
+- test/dummy/app/controllers/application_controller.rb
+- test/dummy/app/controllers/users_controller.rb
+- test/dummy/app/helpers/application_helper.rb
+- test/dummy/app/models/metric.rb
+- test/dummy/app/models/notification.rb
+- test/dummy/app/models/user.rb
+- test/dummy/config/application.rb
+- test/dummy/config/boot.rb
+- test/dummy/config/environment.rb
+- test/dummy/config/environments/development.rb
+- test/dummy/config/environments/production.rb
+- test/dummy/config/environments/test.rb
+- test/dummy/config/initializers/backtrace_silencers.rb
+- test/dummy/config/initializers/cookie_verification_secret.rb
+- test/dummy/config/initializers/session_store.rb
+- test/dummy/config/routes.rb
+- test/dummy/db/migrate/20100106152343_create_metrics.rb
+- test/dummy/db/migrate/20100108120821_create_users.rb
+- test/integration/instrumentation_test.rb
+- test/integration/navigation_test.rb
+- test/orm/active_record_test.rb
+- test/payload_parser_test.rb
+- test/rails_metrics_test.rb
+- test/store_test.rb
+- test/support/helpers.rb
+- test/support/instrumentation.rb
+- test/support/mock_store.rb
+- test/support/webrat/integrations/rails.rb
+- test/test_helper.rb