fiveruns-dash-rails 0.7.1

data/README.rdoc

@@ -0,0 +1,73 @@
+= FiveRuns Dash recipe for Ruby on Rails
+
+Provides a Ruby API to push metrics from a Rails app to the FiveRuns Dash service, http://dash.fiveruns.com, currently in beta.
+
+You'll need a Dash account before using this library.
+
+== Installation
+
+This library is released as a gem from the official repository at http://github.com/fiveruns/dash-rails
+
+  sudo gem install fiveruns-dash-rails --source 'http://gems.github.com'
+
+== Usage
+
+See the Ruby Language Guide http://dash.fiveruns.com/help/ruby.html for information on how to use this library. 
+
+== Authors
+
+The FiveRuns Development Team & Dash community
+
+== Dependencies
+
+* The fiveruns-dash-ruby gem (see http://github.com/fiveruns/dash-ruby)
+* The json gem (as a dependency for fiveruns-dash-ruby)
+
+== Rails versions
+
+Dash has been tested with Rails 2.2 and 2.1.  It may (or may not) work with Rails 2.0 applications.
+
+We haven't done a lot of testing with the gem being unpacked in Rails apps.  YMMV; please let us know if you have issues.
+
+== Platforms
+
+This library has only been tested on OSX and Linux.  See the notes for fiveruns-dash-ruby for more information: http://github.com/fiveruns/dash-ruby
+
+== Contributing
+
+As an open source project, we welcome community contributions!
+
+The best way to contribute is by sending pull requests via GitHub.  The official repository for this project is:
+
+  http://github.com/fiveruns/dash-rails
+
+== Support
+
+Please join the dash-users Google group, http://groups.google.com/group/dash-users
+
+You can also contact us via Twitter, Campfire, or email; see the main help page, http://dash.fiveruns.com/help, for details.
+
+== License
+
+  # (The FiveRuns License)
+  #
+  # Copyright (c) 2006-2008 FiveRuns Corporation
+  # 
+  # 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/Rakefile

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.verbose = true
+  t.test_files = FileList['test/*_test.rb']
+  t.libs  << 'lib'
+end
+
+task :default => :test
+
+begin 
+  require 'jeweler' 
+
+  Jeweler::Tasks.new do |s| 
+    s.name = "dash-rails" 
+    s.rubyforge_project = 'fiveruns'
+    s.summary = "FiveRuns Dash recipe for Ruby on Rails" 
+    s.email = "dev@fiveruns.com" 
+    s.homepage = "http://github.com/fiveruns/dash-rails" 
+    s.description = "Provides an API to send metrics from Rails applications to the FiveRuns Dash service" 
+    s.authors = ["FiveRuns Development Team"] 
+    s.files =  FileList['README.rdoc', 'Rakefile', 'version.yml', 'init.rb', "{lib,rails,test}/**/*", ] 
+    s.add_dependency 'fiveruns-dash-ruby', '>= 0.7.1' 
+  end 
+rescue LoadError 
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com" 
+end
+
+NAME = "dash-rails"
+AUTHOR = "FiveRuns Development Team"
+EMAIL = "dev@fiveruns.com"
+HOMEPAGE = "http://dash.fiveruns.com/"
+SUMMARY = "FiveRuns Dash library for Ruby on Rails"
+
+task :coverage do
+  rm_f "coverage"
+  rm_f "coverage.data"
+  rcov = "rcov --exclude gems --exclude version.rb --sort coverage --text-summary --html -o coverage"
+  system("#{rcov} test/*_test.rb")
+  if ccout = ENV['CC_BUILD_ARTIFACTS']
+    FileUtils.rm_rf '#{ccout}/coverage'
+    FileUtils.cp_r 'coverage', ccout
+  end
+  system "open coverage/index.html" if PLATFORM['darwin']
+end

data/init.rb

@@ -0,0 +1,2 @@
+# For Rails < 2.1.0
+require File.dirname(__FILE__) << '/rails/init'

data/lib/fiveruns/dash/rails.rb

@@ -0,0 +1,166 @@
+require File.dirname(__FILE__) << "/rails/version"
+require File.dirname(__FILE__) << "/rails/startup"
+
+if START_FIVERUNS_DASH_RAILS
+  
+  module Fiveruns
+    module Dash
+    
+      module Rails
+      
+        class << self
+          attr_accessor :server
+        end
+      
+        def self.queue_size
+          return 0 unless server_type
+          case server_type
+          when :mongrel
+            server.workers.list.length
+          else
+            0 # Skip
+          end
+        end
+      
+        def self.server_type
+          return @server_type if defined?(@server_type)
+          @server_type = if server          
+            case server.class.to_s
+            when /Mongrel/
+              :mongrel
+            else
+              ::Fiveruns::Dash.logger.warn "Unrecognized app server type: #{server.class}, not collecting queue size"
+              false
+            end
+          else
+            ::Fiveruns::Dash.logger.warn "Could not find app server, not collecting queue size"
+            nil
+          end
+        end
+                    
+        def self.load_recipes
+          Dir[File.dirname(__FILE__) << "/recipes/**/*.rb"].each do |file|
+            require file
+          end
+        end
+      
+        def self.start(tokens = {}, &block)
+          return if Fiveruns::Dash.session.reporter.started?
+          ::Rails::Initializer.send(:include, Fiveruns::Dash::Rails::Initializer)
+          store_dash_start_block do 
+            configure(tokens, &block) unless tokens.empty?
+            if Fiveruns::Dash.configuration.ready?
+              RAILS_DEFAULT_LOGGER.info "Starting Dash"
+              Fiveruns::Dash.session.start 
+            else
+              log_error unless env == 'development'
+            end
+          end
+        end
+        
+        def self.store_dash_start_block(&block)
+          @dash_start_block = block
+        end
+        
+        def self.dash_start_block
+          @dash_start_block ||= lambda {}
+        end
+        
+        
+        def self.configure(tokens = {}, &block)
+          tokens.each do |environment, token|
+            if environment.to_s == self.env
+              Fiveruns::Dash.configure({:app => token}, &block)
+              break
+            end
+          end
+        end
+        
+        def self.log_error
+          # TODO: Add URL for help
+          message =<<-EOM
+  FiveRuns Dash [Rails] (v#{Version::STRING}) Application token missing
+    ===
+    In config/initializers/dash.rb or at the bottom of config/environment.rb, please add:
+
+      Fiveruns::Dash::Rails.configure :#{env} => 'YOUR-#{env.upcase}-ENV-APP-TOKEN-HERE'
+
+    You can also set app tokens for other environments (eg, staging), at the same time.
+    See http://todo/path/to/help for more information
+    ===
+          EOM
+          RAILS_DEFAULT_LOGGER.warn(message.strip)
+        end
+        
+        def self.env
+          ::Rails.env # >= Rails 2.1
+        rescue
+          ENV['RAILS_ENV'] # <= Rails 2.0 
+        end
+        
+        module ActionContext
+      
+          def self.included(base)
+            base.send(:include, InstanceMethods)
+            base.alias_method_chain :perform_action, :fiveruns_dash_context
+            base.extend(ClassMethods)
+            (class << base; self; end).alias_method_chain :process, :fiveruns_dash_tracing
+          end
+        
+          module ClassMethods
+        
+            def process_with_fiveruns_dash_tracing(*args, &block)
+              operation = lambda { process_without_fiveruns_dash_tracing(*args, &block) }
+              params = args.first.parameters
+              # TODO/FIXME: For now, we simply look for a 'trace' parameter to select requests to trace; in the
+              #             future, we need a more advanced sampling mechanism (some operation in a recipe a
+              #             request must pass, or selection criteria returned in a response from the service)
+              trace_context = ['action', "#{params['controller'].camelize}Controller##{params['action']}"]
+              if ::Fiveruns::Dash.trace_contexts.include?(trace_context)
+                ::Fiveruns::Dash.session.trace(trace_context) do
+                  operation.call
+                end
+              else
+                operation.call
+              end
+            end
+        
+          end
+      
+          module InstanceMethods 
+                    
+            def perform_action_with_fiveruns_dash_context(*args, &block)
+              action_name = (request.parameters['action'] || 'index').to_s
+              Fiveruns::Dash::Context.set ['action', %(#{self.class.name}##{action_name})]
+              perform_action_without_fiveruns_dash_context(*args, &block)
+            end
+        
+          end
+      
+        end
+        
+        module Initializer
+          
+          def self.included(base)
+            base.send(:include, InstanceMethods)
+            base.alias_method_chain :load_application_classes, :dash
+          end
+          
+          module InstanceMethods
+            
+            def load_application_classes_with_dash
+              load_application_classes_without_dash
+              Fiveruns::Dash::Rails.dash_start_block.call
+            end            
+            
+          end
+          
+        end
+        
+      end 
+      
+    end
+    
+  end
+
+end

data/lib/fiveruns/dash/rails/startup.rb

@@ -0,0 +1,17 @@
+# AKK: remove me in favor of inlining into init
+START_FIVERUNS_DASH_RAILS = if ENV['START_FIVERUNS_DASH'] || File.basename($0) != 'irb'
+  true
+else
+  module Fiveruns
+    module Dash
+      module Rails
+        
+        def self.configure(*args, &block)
+          RAILS_DEFAULT_LOGGER.info "[FiveRuns Dash] Skipping configuration (`#{$0}' not supported for collection)"
+        end
+        
+      end
+    end
+  end
+  false
+end

data/lib/fiveruns/dash/rails/version.rb

@@ -0,0 +1,97 @@
+# (The MIT License)
+# 
+# Copyright (c) 2008 Jamis Buck <jamis@37signals.com>,
+#               with modifications by Bruce Williams <bruce@fiveruns.com>
+# 
+# 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.
+module Fiveruns
+  
+  module Dash
+    
+    module Rails
+    
+      # A class for describing the current version of a library. The version
+      # consists of three parts: the +major+ number, the +minor+ number, and the
+      # +tiny+ (or +patch+) number.
+      class Version
+      
+        include Comparable
+    
+        # A convenience method for instantiating a new Version instance with the
+        # given +major+, +minor+, and +tiny+ components.
+        def self.[](major, minor, tiny)
+          new(major, minor, tiny)
+        end
+        
+        # Borrowed from TuneUp
+        def self.rails
+          @rails ||= begin
+            # handle ::Rails::VERSION not being set
+            Version.new(::Rails::VERSION::MAJOR, ::Rails::VERSION::MINOR, ::Rails::VERSION::TINY) rescue Version.new(0,0,0)
+          end
+        end
+        
+
+        attr_reader :major, :minor, :tiny
+
+        # Create a new Version object with the given components.
+        def initialize(major, minor, tiny)
+          @major, @minor, @tiny = major, minor, tiny
+        end
+
+        # Compare this version to the given +version+ object.
+        def <=>(version)
+          to_i <=> version.to_i
+        end
+
+        # Converts this version object to a string, where each of the three
+        # version components are joined by the '.' character. E.g., 2.0.0.
+        def to_s
+          @to_s ||= [@major, @minor, @tiny].join(".")
+        end
+
+        # Converts this version to a canonical integer that may be compared
+        # against other version objects.
+        def to_i
+          @to_i ||= @major * 1_000_000 + @minor * 1_000 + @tiny
+        end
+      
+        def to_a
+          [@major, @minor, @tiny]
+        end
+
+        PARSED = YAML.load(File.read(File.dirname(__FILE__) << "/../../../../version.yml"))
+
+        MAJOR = PARSED['major']
+        MINOR = PARSED['minor']
+        TINY  = PARSED['patch']
+
+        # The current version as a Version instance
+        CURRENT = new(MAJOR, MINOR, TINY)
+        # The current version as a String
+        STRING = CURRENT.to_s
+      
+      end
+            
+    end
+    
+  end
+  
+end

data/lib/fiveruns/dash/recipes/activerecord.rb

@@ -0,0 +1,96 @@
+module Fiveruns::Dash::ActiveRecordContext
+  CLASS_METHODS = %w(find find_by_sql calculate create create! update_all destroy destroy_all delete delete_all)
+  INSTANCE_METHODS = %w(update save save! destroy)
+
+  def self.included(base)
+    class << base
+      CLASS_METHODS.each do |meth|
+        head = meth
+        tail = ''
+        head, tail = meth[0..(meth.length-2)], meth[-1..-1] if %w(? !).include? meth[-1..-1]
+        self.class_eval <<-EOM
+          def #{head}_with_dash_context#{tail}(*args, &block)
+            Fiveruns::Dash::ActiveRecordContext.with_model_context(self.name) do
+              #{head}_without_dash_context#{tail}(*args, &block)
+            end
+          end
+        EOM
+        alias_method_chain(meth.to_sym, :dash_context)
+      end
+    end
+
+    INSTANCE_METHODS.each do |meth|
+      head = meth
+      tail = ''
+      head, tail = meth[0..meth.length-2], meth[-1..-1] if %w(? !).include? meth[-1..-1]
+      base.class_eval <<-EOM
+        def #{head}_with_dash_context#{tail}(*args, &block)
+          Fiveruns::Dash::ActiveRecordContext.with_model_context(self.class.name) do
+            #{head}_without_dash_context#{tail}(*args, &block)
+          end
+        end
+      EOM
+      base.alias_method_chain(meth.to_sym, :dash_context)
+    end
+  end
+
+  def self.with_model_context(model_name)
+    ctx = Fiveruns::Dash::Context.context
+    # don't change context if model context has already been set.
+    return yield if ctx.size > 0 && ctx[-2] == 'model' && ctx[-1] == model_name
+
+    original_context = Fiveruns::Dash::Context.context.dup
+    begin
+      if ctx[-2] == 'model'
+        # Some models will internally load other models.
+        Fiveruns::Dash::Context.context.pop
+        Fiveruns::Dash::Context.context << model_name
+      else
+        Fiveruns::Dash::Context.context << 'model'
+        Fiveruns::Dash::Context.context << model_name
+      end
+      return yield
+    ensure
+      Fiveruns::Dash::Context.set original_context
+    end
+  end
+  
+  def self.all_methods
+    CLASS_METHODS.map { |m| "ActiveRecord::Base.#{m}" } + INSTANCE_METHODS.map { |m| "ActiveRecord::Base##{m}"}
+  end
+  
+end
+
+# ActiveRecord ################################################################
+
+Fiveruns::Dash.register_recipe :activerecord, :url => 'http://dash.fiveruns.com' do |recipe|
+  recipe.time :ar_time, 'ActiveRecord Time', :methods => Fiveruns::Dash::ActiveRecordContext.all_methods, :reentrant => true
+  recipe.time :db_time, 'Database Time', :methods => %w(ActiveRecord::ConnectionAdapters::AbstractAdapter#log)
+
+  # We need a way to get the total time for a request/operation so that we can
+  # calculate the relative percentage used by AR/DB.  Default to "response_time" for the Rails
+  # recipe but daemons can set this constant to provide their own total time metric.
+  total_time = recipe.options[:ar_total_time] ? recipe.options[:ar_total_time] : "response_time"
+
+  recipe.percentage :ar_util, 'ActiveRecord Utilization', :sources => ["ar_time", total_time] do |ar_time, all_time|
+    (ar_time / all_time) * 100.0
+  end
+  recipe.percentage :db_util, 'Database Utilization', :sources => ["db_time", total_time] do |db_time, all_time|
+    (db_time / all_time) * 100.0
+  end
+
+  recipe.modify :recipe_name => :activerecord, :recipe_url => 'http://dash.fiveruns.com' do |metric|
+    metric.find_context_with do |obj, *args|
+      if Fiveruns::Dash::Context.context == []
+        []
+      else
+        [[], Fiveruns::Dash::Context.context]
+      end
+    end
+  end
+
+  recipe.added do
+    ActiveRecord::Base.send(:include, Fiveruns::Dash::ActiveRecordContext)
+  end
+end
+

data/lib/fiveruns/dash/recipes/rails.rb

@@ -0,0 +1,112 @@
+module Fiveruns::Dash::Rails::Hash
+  
+  def self.clean(extended_hash = {})
+    (extended_hash || {}).keys.inject({}) do |all, key|
+      val = extended_hash[key]
+      if val.kind_of? Hash
+        val = clean(val)
+      end
+      all[key.to_s] = val
+      all
+    end
+  end
+  
+end
+
+# ActionPack ##################################################################
+Fiveruns::Dash.register_recipe :actionpack, :url => 'http://dash.fiveruns.com' do |recipe|
+  recipe.time :response_time, :method => 'ActionController::Base#perform_action'
+  recipe.counter :requests, 'Requests', :incremented_by => 'ActionController::Base#perform_action'
+  
+  targets = []
+  targets << 'ActionView::Template#render' if defined?(ActionView::Template)
+  targets << 'ActionView::PartialTemplate#render' if defined?(ActionView::PartialTemplate)
+  if !targets.empty?
+    recipe.time :render_time, :method => targets
+  else
+    Fiveruns::Dash.logger.warn 'Collection of "render_time" unsupported for this version of Rails'
+  end
+end
+
+# Rails #######################################################################
+Fiveruns::Dash.register_recipe :rails, :url => 'http://dash.fiveruns.com' do |recipe|  
+  recipe.add_recipe :activerecord, :url => 'http://dash.fiveruns.com'
+
+  recipe.add_recipe :actionpack, :url => 'http://dash.fiveruns.com'
+  recipe.modify :recipe_name => :actionpack, :recipe_url => 'http://dash.fiveruns.com' do |metric|
+    if metric.name.to_s == 'render_time'
+      metric.find_context_with do |obj, *args|
+        Fiveruns::Dash::Context.context
+      end
+    else
+      metric.find_context_with do |obj, *args|
+        [[], Fiveruns::Dash::Context.context]
+      end
+    end
+  end
+
+  recipe.add_exceptions_from 'ActionController::Base#perform_action_without_rescue' do |ex, controller|
+    session_data = nil
+    begin
+      session_data = controller.request.session.instance_variable_get("@data")
+    rescue Exception => e
+      Fiveruns::Dash.logger.warn "Could not retrieve session data for exception: #{e.message}"
+    end
+    {
+      :name => "#{ex.class.name} in #{controller.class.name}##{controller.params[:action]}", # Override the standard name 
+      :session => Fiveruns::Dash::Rails::Hash.clean(session_data).to_json,
+      :headers => Fiveruns::Dash::Rails::Hash.clean(controller.request.headers).to_json,
+      :request => { :url => controller.request.url, :params => controller.params.inspect }.to_json,
+    }
+  end
+
+  # Same classes as the exception_notification plugin
+  IGNORE = [ActiveRecord::RecordNotFound, ActionController::RoutingError, ActionController::UnknownController, ActionController::UnknownAction]
+
+  recipe.ignore_exceptions do |exc|
+    IGNORE.include? exc.class
+  end
+
+  recipe.added do
+    ActionController::Base.send(:include, Fiveruns::Dash::Rails::ActionContext)
+    ActionView::Template.send(:include, Fiveruns::Dash::Rails::TemplateContext) if defined?(ActionView::Template)
+    ActionView::InlineTemplate.send(:include, Fiveruns::Dash::Rails::TemplateContext) if defined?(ActionView::InlineTemplate)
+    ActionView::PartialTemplate.send(:include, Fiveruns::Dash::Rails::TemplateContext) if defined?(ActionView::PartialTemplate)
+
+    begin
+      if defined?(Mongrel)
+        ActiveSupport::Deprecation.silence do
+          # Unfortunately there is no known way to get direct access
+          # to the Mongrel singleton.  Wade through the Ruby heap to
+          # find it.
+          ObjectSpace.each_object do |obj|
+            if obj.class == Mongrel::HttpServer
+              Fiveruns::Dash::Rails.server = obj
+            end
+          end
+        end
+      end
+    rescue Exception => e
+      if RUBY_PLATFORM =~ /java/ && e.message =~ /ObjectSpace/
+        Fiveruns::Dash.logger.info "Cannot find Mongrel: #{e.message}"
+      else
+        raise e
+      end
+    end
+
+    # Passenger forks the Rails processes, which has the side effect of
+    # killing our reporter thread.  We need to revive the thread.
+    class ActionController::Base
+      def perform_action_with_dash_startup(*args, &block)
+        Fiveruns::Dash.session.reporter.revive!
+        perform_action_without_dash_startup(*args, &block)
+      end
+
+      alias_method_chain :perform_action, :dash_startup
+    end
+  end
+  
+  recipe.absolute :queue_size do
+    Fiveruns::Dash::Rails.queue_size || 0
+  end
+end

data/lib/fiveruns/dash/template_context.rb

@@ -0,0 +1,51 @@
+
+module Fiveruns::Dash::Rails::TemplateContext
+  
+  def self.included(base)
+    base.send(:include, InstanceMethods)
+    base.alias_method_chain(:render, :fiveruns_dash_context)
+  end
+  
+  RAILS_ROOT_RE = /\A#{Regexp.quote RAILS_ROOT}/
+
+  GEM_REs = Gem.path.map do |path|
+    /\A#{Regexp.quote path}\/gems/
+  end
+  
+  def self.sanitize_view_path(path)
+    path = if path[0..0] == '/'
+      if path =~ RAILS_ROOT_RE
+        trimmed = path.sub(RAILS_ROOT_RE, 'RAILS_ROOT')
+        trimmed
+      elsif (re = GEM_REs.find { |re| path =~ re })
+        trimmed = path.sub(re, 'GEMS')
+      else
+        path
+      end
+    else
+      path
+    end
+    # Remove extensions, if any
+    path.sub(/\.[^\/\\]*$/, '')
+  end
+
+  module InstanceMethods
+    
+    def render_with_fiveruns_dash_context(*args, &block)
+      original_context = Fiveruns::Dash::Context.context.dup
+      
+      begin
+        template = Fiveruns::Dash::Rails::TemplateContext.sanitize_view_path(path)
+        Fiveruns::Dash::Context.context << 'view'
+        Fiveruns::Dash::Context.context << template
+        result = render_without_fiveruns_dash_context(*args, &block)
+      ensure
+        Fiveruns::Dash::Context.set original_context
+      end
+      
+      result
+    end
+    
+  end
+  
+end

data/lib/fiveruns_dash_rails.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) << "/fiveruns/dash/rails/startup"
+
+if START_FIVERUNS_DASH_RAILS
+  gem 'fiveruns-dash-ruby' # Put its path first
+  require 'fiveruns/dash'
+  require 'fiveruns/dash/rails'
+  require 'fiveruns/dash/template_context'
+  require File.dirname(__FILE__) << "/../rails/init"  
+end

data/lib/tasks/dash.rake

@@ -0,0 +1,57 @@
+namespace :dash do
+  desc "Verify FiveRuns Dash connectivity and configuration"
+  task :test => :environment do
+    unless $tested
+      $tested = true
+      begin
+        puts ""
+        puts "FiveRuns Dash installation verification"
+        puts "======================================="
+        puts ""
+        RAILS_DEFAULT_LOGGER = Fiveruns::Dash.logger = Logger.new(STDOUT)
+        Fiveruns::Dash.logger.level = Logger::WARN
+        verify('FiveRuns Dash loaded',
+               'The FiveRuns Dash plugin has not been loaded.  Verify you are initializing Dash in config/initializers/dash.rb.') do
+          defined? ::Fiveruns::Dash::Rails
+        end
+        verify('FiveRuns Dash configuration',
+               "No application token was found for the #{Rails.env} environment.") do
+          Fiveruns::Dash.configuration.options[:app]
+        end
+        verify('FiveRuns Dash session running', "FiveRuns Dash session is not active") do
+          Fiveruns::Dash.session.reporter.alive?
+        end
+        verify('FiveRuns Dash network connectivity') do
+          Fiveruns::Dash.session.reporter.ping
+        end
+        puts ""
+        puts "All appears normal.  If you are experiencing a problem, please email support@fiveruns.com with details about the problem and your environment."
+        puts ""
+      rescue ArgumentError
+      end
+    end
+  end
+end
+
+def verify(test, fail=nil)
+  $test_count = ($test_count || 0) + 1
+  print "  #{$test_count}. #{test}..."
+  begin
+    result = yield
+    if result
+      puts "OK." if fail
+    else
+      if fail
+        puts "FAIL!"
+        puts fail
+      end
+      raise ArgumentError
+    end
+  rescue ArgumentError => ex
+    raise ex
+  rescue => e
+    puts "FAIL!"
+    puts fail
+    raise e
+  end
+end

data/rails/init.rb

@@ -0,0 +1,32 @@
+
+unless defined?(START_FIVERUNS_DASH_RAILS)
+  START_FIVERUNS_DASH_RAILS = if ENV['START_FIVERUNS_DASH'] || File.basename($0) != 'irb'
+    true
+  else
+    module Fiveruns
+      module Dash
+        module Rails
+        
+          def self.configure(*args, &block)
+            RAILS_DEFAULT_LOGGER.info "[FiveRuns Dash] Skipping configuration (`#{$0}' not supported for collection)"
+          end
+        
+        end
+      end
+    end
+    false
+  end
+end
+
+if START_FIVERUNS_DASH_RAILS
+
+  require 'fiveruns_dash_rails'
+  Fiveruns::Dash.logger = RAILS_DEFAULT_LOGGER
+  Fiveruns::Dash::Rails.load_recipes
+  Fiveruns::Dash.configure do |config|
+    config.add_recipe :ruby, :url => 'http://dash.fiveruns.com'
+    config.add_recipe :jruby, :url => 'http://dash.fiveruns.com' if RUBY_PLATFORM[/java/]
+    config.add_recipe :rails, :url => 'http://dash.fiveruns.com'
+  end
+
+end

data/test/activerecord_test.rb

@@ -0,0 +1,113 @@
+require File.dirname(__FILE__) << "/test_helper"
+
+class ActiverecordTest < Test::Unit::TestCase
+
+  class TestModel < ActiveRecord::Base
+  end
+
+  class TestEngine
+    def doit
+      sleep 1
+      2.times do
+        t = TestModel.create!(:name => 'foo')
+        t.destroy
+      end
+    end
+
+    def conn
+      TestModel.connection.execute("select sleep(1)")
+    end
+
+    def entry(meth)
+      send(meth)
+    end
+  end
+  
+
+  context "Metric" do
+    
+    setup do
+      ActiveRecord::Base.configurations = { 'test' => { 'database' => 'test', 'adapter' => 'mysql', 'user' => 'root', 'hostname' => 'localhost' }}
+      ActiveRecord::Base.establish_connection
+      ActiveRecord::Base.connection.execute("create table if not exists test_models (id integer PRIMARY KEY, name varchar(32) not null)")
+      ActiveRecord::Base.connection.execute("delete from test_models")
+    end
+
+    should "collect basic AR metrics" do
+      ar_scenario do
+        TestEngine.new.entry(:doit)
+
+        data = Fiveruns::Dash.session.data
+        # data.each do |hsh|
+        #   puts "#{hsh[:name]}: #{hsh[:values].inspect}"
+        # end
+
+        assert metric('test_time', data) > 1.0
+        assert metric('ar_util', data) > metric('db_util', data)
+        assert metric('db_util', data) < 5
+      end
+    end
+
+    should "collect DB metrics" do
+      ar_scenario do
+        TestEngine.new.entry(:conn)
+        
+        data = Fiveruns::Dash.session.data
+        # data.each do |hsh|
+        #   puts "#{hsh[:name]}: #{hsh[:values].inspect}"
+        # end
+
+        assert metric('test_time', data) > 1.0
+        assert metric('test_time', data) < 1.1
+        assert metric('db_time', data) > 1.0
+        assert metric('db_time', data) < 1.1
+        assert metric('db_util', data) > 90.0
+        assert metric('db_util', data) < 100.0
+      end
+    end
+  end
+
+  def ar_scenario(&block)
+    child = fork do
+      mock_activerecord!
+      yield
+    end
+    Process.wait
+    assert_equal 0, $?.exitstatus
+  end
+
+  def metric(metric, data, in_ctx=[])
+    hsh = data.detect { |hsh| hsh[:name] == metric }
+    assert hsh, "No metric named #{metric} was found in metrics payload"
+    vals = hsh[:values]
+    assert vals, "No values found for #{metric} in metrics payload"
+    val = vals.detect { |val| val[:context] == in_ctx }
+    assert val, "No value for #{metric} found for context #{in_ctx.inspect}"
+    val[:value]
+  end
+
+  def mock_activerecord!
+    require 'fiveruns/dash'
+    require 'fiveruns/dash/recipes/activerecord'
+
+    eval <<-MOCK
+      module Fiveruns::Dash
+        class Reporter
+          private
+          def run
+          end
+        end
+      end
+    MOCK
+
+    Fiveruns::Dash.register_recipe :tester, :url => 'http://dash.fiveruns.com' do |recipe|
+      recipe.time :test_time, 'Test Time', :method => 'ActiverecordTest::TestEngine#entry'
+    end
+    Fiveruns::Dash.configure :app => '666', :ar_total_time => 'test_time' do |config|
+      config.add_recipe :ruby
+      config.add_recipe :activerecord
+      config.add_recipe :tester
+    end
+    Fiveruns::Dash.session.start(true)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,30 @@
+RAILS_ENV='test'
+RAILS_ROOT=File.dirname(__FILE__)
+require 'test/unit'
+require 'logger'
+require 'rubygems'
+
+begin
+  require 'shoulda'
+  require 'flexmock/test_unit'
+  require 'fake_web'
+rescue
+  puts "Please install the Shoulda, FakeWeb and flexmock gems to run the Dash plugin tests."
+end
+
+require 'shoulda'
+require 'flexmock/test_unit'
+
+RAILS_DEFAULT_LOGGER=Logger.new(STDOUT)
+require 'active_record'
+require 'action_controller'
+require 'action_controller/test_process'
+require 'action_controller/test_case'
+require 'action_view'
+
+$:.unshift(File.dirname(__FILE__) << '/../lib')
+$:.unshift(File.dirname(__FILE__) << '/../../fiveruns_dash/lib')
+
+class Test::Unit::TestCase
+
+end

data/version.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 7
+:patch: 1

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: fiveruns-dash-rails
+version: !ruby/object:Gem::Version 
+  version: 0.7.1
+platform: ruby
+authors: 
+- FiveRuns Development Team
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-28 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: fiveruns-dash-ruby
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.7.1
+    version: 
+description: Provides an API to send metrics from Rails applications to the FiveRuns Dash service
+email: dev@fiveruns.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- Rakefile
+- version.yml
+- init.rb
+- lib/fiveruns
+- lib/fiveruns/dash
+- lib/fiveruns/dash/rails
+- lib/fiveruns/dash/rails/startup.rb
+- lib/fiveruns/dash/rails/version.rb
+- lib/fiveruns/dash/rails.rb
+- lib/fiveruns/dash/recipes
+- lib/fiveruns/dash/recipes/activerecord.rb
+- lib/fiveruns/dash/recipes/rails.rb
+- lib/fiveruns/dash/template_context.rb
+- lib/fiveruns_dash_rails.rb
+- lib/tasks
+- lib/tasks/dash.rake
+- rails/init.rb
+- test/activerecord_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/fiveruns/dash-rails
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --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: fiveruns
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: FiveRuns Dash recipe for Ruby on Rails
+test_files: []
+