revolutionhealth-metrics 0.0.9

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2007 Revolution Health Group LLC
+
+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

@@ -0,0 +1,71 @@
+== Introduction
+
+This gem provides a metrics collecting for controllers, database queries, 
+and specific blocks of code or methods.  It is designed to be light-weight 
+and have minimal impact on production builds while providing preformance 
+indicators of the running application.
+
+== Disclaimer
+
+
+This software is released to be used at your own risk.
+For feedback please drop us a line at rails-trunk [ at ] revolution DOT com.
+
+Using this plugin should not be your first step in application 
+optimization/scaling or even the second one. 
+
+== Example
+
+class SomeClassToTest
+  collect_metrics_on :my_method
+
+  def my_method(blah = nil)
+    true
+  end
+end
+
+for more samples and test cases see:  test/metrics_test.rb 
+
+=== Usage
+
+The metrics are written to:  logs/<environment>_metrics.log
+
+Configuration can be updated in: metrics/config/metrics.yml, you may
+copy this file to your RAILS_ROOT/config/metrics.yml and customize for 
+your application, the RAILS_ROOT will be checked first.
+
+
+
+=== Sample Output
+
+[ERROR] [2007-06-21 23:21:19] [trunk] [Metrics]|[76716]|[MysqlAdapter.log]|0.012727|args=["root localhost trunk_test", "CREATE DATABASE `trunk_test`"]
+
+[ERROR] [2007-06-21 23:19:56] [trunk] [Metrics]|[35158]|[Request to [Test::SomeControllerWithMetricsId]]|0.001373|action = index|path = /some?
+
+[ERROR] [2007-06-21 23:19:56] [trunk] [Metrics]|[33676]|[SomeClassToUseModuleMixin.another_method]|0.000020|args=["also"]
+
+=== Controlling Output
+
+By setting the constant METRICS_LOGGER in your <RAILS_ROOT>/config/environment.rb to either a specific Logger or Log4r instance, otherwise the RAILS_DEFAULT_LOGGER will be used.
+
+
+
+
+== Installation
+
+sudo gem install revolutionhealth-metrics -s http://gems.github.com
+
+== Source
+
+http://github.com/revolutionhealth/metrics/tree/master
+
+== License
+
+metrics is released under the MIT license.
+
+
+== Support
+
+The plugin RubyForge page is http://rubyforge.org/projects/metrics
+
+

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+
+GEM = "metrics"
+GEM_VERSION = "0.0.9"
+AUTHOR = "Revolution Health"
+EMAIL = "rails-trunk@revolutionhealth.com"
+HOMEPAGE = %q{http://github.com/revolutionhealth/metrics}
+SUMMARY = "metrics allows one to track the performance of particular controllers, database calls, and other methods"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = false
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  
+  # Uncomment this to add a dependency
+  # s.add_dependency "foo"
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs,test,config}/**/*") + ['init.rb']
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+require 'test/unit'
+ 
+task :test do
+ runner = Test::Unit::AutoRunner.new(true)
+ runner.to_run << 'test'
+ runner.pattern = [/_test.rb$/]
+ exit if !runner.run
+end
+ 
+task :default => [:test, :package] do
+end

data/TODO

@@ -0,0 +1,4 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/<%= name %>.rb

data/config/metrics.yml

@@ -0,0 +1,13 @@
+---
+production:
+  min_real_time_threshold: 1.0
+  single_line_output: true
+
+test:
+  min_real_time_threshold: 2.0
+  single_line_output: false
+    
+development:
+  min_real_time_threshold: 0.0
+  single_line_output: false
+  care_providers/search_controller: 0.0

data/init.rb

@@ -0,0 +1,4 @@
+# CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+
+require 'metrics'
+

data/lib/metrics/collector.rb

@@ -0,0 +1,20 @@
+# CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+
+class Metrics::Collector
+  def begin_metric()
+    @metric_begin_measurement = Process.times
+    @metric_begin_measurement_time = Time.now
+  end
+    
+  def end_metric(metric_label)
+    end_metric_measurement = Process.times
+    end_metric_measurement_time = Time.now
+
+    result = Benchmark::Tms.new(end_metric_measurement.utime - @metric_begin_measurement.utime,
+                                end_metric_measurement.stime - @metric_begin_measurement.stime,
+                                end_metric_measurement.cutime - @metric_begin_measurement.cutime,
+                                end_metric_measurement.cstime - @metric_begin_measurement.cstime,
+                                end_metric_measurement_time.to_f - @metric_begin_measurement_time.to_f,
+                                metric_label)
+  end
+end

data/lib/metrics/config.rb

@@ -0,0 +1,52 @@
+# CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+
+require 'singleton'
+
+module Metrics
+  class Config
+    include Singleton
+    
+    def initialize
+      default_values = { :min_real_time_threshold => 0.1,
+                         :log_delimiter => "|",
+                         :enhanced_active_record_metrics => false,
+                         :single_line_output => false,
+                         :metrics_tracking_id => true }
+      
+      @cfg = default_values.merge(cfg)
+    end
+    
+    def self.[](key)
+      Metrics::Config.instance.cfg[key]
+    end
+    
+    def self.[]=(key, value)
+      Metrics::Config.instance.cfg[key] = value
+    end
+    
+    
+    def cfg
+      @cfg ||= load_config
+    end
+
+    private
+    
+    def load_config
+      loaded_config = {}
+      if defined? ConfigLoader
+        loaded_config = ConfigLoader.load_section('metrics.yml')
+      else
+        config = ""
+        config = File.join(RAILS_ROOT, 'config/metrics.yml') if defined?(RAILS_ROOT)
+        config = File.join(File.dirname(__FILE__), '../../config/metrics.yml') if not File.exist?(config)
+        File.open( config ) { |yf| loaded_config = YAML.load(yf) }
+        if defined?(RAILS_ENV)
+          loaded_config = loaded_config[RAILS_ENV] || {}
+        else
+          loaded_config = {}
+        end
+      end
+      loaded_config.symbolize_keys!
+    end
+  end
+end

data/lib/metrics/logger.rb

@@ -0,0 +1,15 @@
+
+module Metrics
+  module Logger
+    extend self
+    
+    def enabled?
+      METRICS_LOGGER.error?
+    end
+    
+    def log(msg)
+      METRICS_LOGGER.error(msg)
+    end
+    
+  end
+end

data/lib/metrics.rb

@@ -0,0 +1,128 @@
+# CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+require 'metrics/config'
+require 'metrics/collector'
+require 'benchmark'
+
+if not defined?(METRICS_LOGGER)
+  if defined?(RAILS_DEFAULT_LOGGER)  
+    METRICS_LOGGER = RAILS_DEFAULT_LOGGER 
+    METRICS_LOGGER.warn("METRICS_LOGGER is using RAILS_DEFAULT_LOGGER") if METRICS_LOGGER.warn?
+  else
+    require 'logger'
+    METRICS_LOGGER = Logger.new(STDOUT)
+  end
+end
+require 'metrics/logger'
+
+module Metrics
+  extend self
+    
+  def collect_metrics(label = nil, *args)
+    reset_metrics_id = false
+    collector = nil
+    if Metrics::Logger.enabled?
+      @@_metrics_id ||= nil
+      if @@_metrics_id.nil?
+        reset_metrics_id = true
+        @@_metrics_id = rand(99999)
+      end
+      collector = Metrics::Collector.new
+      collector.begin_metric()
+    end
+    
+    result = yield
+
+    log_metrics(collector.end_metric(label || metric_label), args) if Metrics::Logger.enabled?
+    @@_metrics_id = nil if reset_metrics_id
+    result
+  end
+
+  protected
+  def disable_metrics(disable = true)
+    if disable && !respond_to?(:orig_begin_metric)
+      alias :orig_end_metric :end_metric
+      alias :end_metric :disabled_metric
+      alias :orig_begin_metric :begin_metric
+      alias :begin_metric :disabled_metric
+    elsif !disable && respond_to?(:orig_begin_metric)
+      alias :end_metric :orig_end_metric
+      alias :begin_metric :orig_begin_metric 
+    end
+  end
+  
+  private
+  def begin_metric()
+    if Metrics::Logger.enabled?
+      @@_metrics_id = rand(99999)
+      @collector = Metrics::Collector.new
+      @collector.begin_metric() if @collector != nil
+    end
+  end
+  
+  def end_metric()
+    if Metrics::Logger.enabled? and @collector != nil
+      result = @collector.end_metric(metric_label) 
+      log_metrics(result)
+    end
+  end
+    
+  
+  METRICS_CAPTION = Benchmark::Tms::CAPTION.delete("\n")
+  METRICS_FMTSTR = "%10.6r"
+  METRICS_LABEL = "[Metrics]"
+  
+  def log_metrics(result, *args)
+    threshold = Metrics::Config[self.class.name.underscore.to_sym] rescue Metrics::Config[:min_real_time_threshold]
+    threshold ||= Metrics::Config[:min_real_time_threshold]
+
+    if result != nil && (result.real > threshold)
+      if Metrics::Config[:single_line_output]
+        delimiter = Metrics::Config[:log_delimiter]
+        output = METRICS_LABEL
+        output += delimiter + "[#{@@_metrics_id}]" if Metrics::Config[:metrics_tracking_id]
+        output += delimiter + "[#{result.label}]"
+        output += delimiter + real_time(result).strip
+        output += delimiter + controller_args if respond_to?(:controller_name)
+        output += delimiter + "args=#{args[0].inspect}" if (args != nil) and (args.size > 0)
+        Metrics::Logger.log(output)
+      else
+        Metrics::Logger.log("#{METRICS_LABEL} #{result.label}")
+        Metrics::Logger.log("#{METRICS_LABEL} Metrics Id=#{@@_metrics_id}") if Metrics::Config[:metrics_tracking_id]
+        Metrics::Logger.log("#{METRICS_LABEL} args=#{args[0].inspect}") if (args != nil) and (args.size > 0)
+        Metrics::Logger.log("#{METRICS_LABEL} #{METRICS_CAPTION}")
+        result_str = result.to_s.delete("\n")
+        Metrics::Logger.log("#{METRICS_LABEL} #{result_str}")
+      end
+    end
+  end
+  
+  def real_time(result)
+    METRICS_FMTSTR.gsub(/(%[-+\.\d]*)r/){"#{$1}f" % result.real}
+  end
+  
+  def metric_label
+    if respond_to?(:controller_name)
+      action = action_name 
+    	label = "Request to [#{self.class.name}]" 
+    else
+      label = "#{self.class.name}"
+    end
+  end
+  
+  def controller_args
+    "action = #{action_name }" + Metrics::Config[:log_delimiter] + "path = #{request.path}?#{request.env['QUERY_STRING']}"
+  end
+
+  def self.included(klass)
+    klass.send(:extend, Metrics)
+  end
+  
+  def disabled_metric
+  end
+end
+
+require 'rails/controller_metrics'
+require 'ruby/metric_extensions'
+require 'rails/activerecord_enhanced_metrics'
+require 'ruby/http_metrics'
+

data/lib/rails/activerecord_enhanced_metrics.rb

@@ -0,0 +1,27 @@
+
+if defined?(RAILS_ROOT)
+  class ActiveRecord::ConnectionAdapters::AbstractAdapter
+
+
+    protected
+    alias_method :non_metrics_log, :log
+    def log(sql, name, &block)
+      if @config
+        host = @config[:host].sub(/\..*/, '') if @config[:host]
+        host = @config[:host] if host.nil? || !host.scan(/^\d+$/).empty?
+        connection_info = "#{@config[:username]} #{host} #{@config[:database]}"
+      else
+        connection_info = "localhost"
+      end
+      label = "#{self.class.name.sub(/.*\:\:/, '')}.log"
+      result = nil
+      Metrics.collect_metrics(label, connection_info ||= "no db config", sql) do
+        result = non_metrics_log(sql, name, &block)
+      end
+      result
+    end
+  end
+end
+
+# CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+

data/lib/rails/activerecord_metrics.rb

@@ -0,0 +1,13 @@
+
+module Metrics::ActiveRecordMetrics
+  def self.append_features(klass)
+    super
+    klass.collect_metrics_on(:log)
+  end
+
+end
+
+ActiveRecord::ConnectionAdapters::AbstractAdapter.send :include, Metrics::ActiveRecordMetrics
+
+# CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+

data/lib/rails/controller_metrics.rb

@@ -0,0 +1,15 @@
+# CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+
+if defined?(RAILS_ROOT)
+  module ActionController
+    class Base
+      include Metrics
+
+      prepend_before_filter :begin_metric
+      append_after_filter :end_metric
+
+
+    end
+
+  end
+end

data/lib/ruby/http_metrics.rb

@@ -0,0 +1,13 @@
+# CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+require 'net/http'
+
+module Net
+  class HTTPGenericRequest
+    alias_method :__non_metrics_exec, :exec
+    def exec(sock, ver, path, &block)
+      Metrics.collect_metrics("#{self.class.name}.exec", "HTTP/#{ver}", "path= #{path}") do
+        __non_metrics_exec(sock, ver, path, &block)
+      end
+    end
+  end
+end

data/lib/ruby/metric_extensions.rb

@@ -0,0 +1,44 @@
+# CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+
+class Module
+  def collect_metrics_on(*syms)
+    syms.flatten.each do |sym|
+      interpose = lambda do |sym|
+        alias_method "__metrics_#{sym}__".to_sym, sym
+        protected "__metrics_#{sym}__".to_sym
+        class_eval <<-EOS
+          def #{sym}(*args, &block)
+            result = nil
+            Metrics.collect_metrics("#{self.name}.#{sym}", *args) do
+              result = __metrics_#{sym}__(*args, &block)
+            end
+            result
+          end
+        EOS
+      end
+
+      if method_defined? sym and (!method_defined?("__metrics_#{sym}__".to_sym))
+        class_eval { interpose.call(sym) }
+      else
+        _metrics_interpose[sym.to_sym] = interpose
+      end
+    end
+    
+    if not singleton_methods(false).include?('method_added')
+      instance_eval do
+        def method_added(method_sym)
+            if interpose = _metrics_interpose[method_sym]
+              _metrics_interpose.delete method_sym
+              class_eval { interpose.call(method_sym) }
+            end
+            super
+        end
+      end
+    end
+  end
+  
+  def _metrics_interpose
+    @metrics_interpose ||= {}
+  end
+end
+

data/test/metrics_test.rb

@@ -0,0 +1,527 @@
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))
+RAILS_ENV='test'
+RAILS_ROOT=File.expand_path(File.join(File.dirname(__FILE__), '..'))
+require 'rubygems'
+require 'actionpack'
+require 'action_controller'
+require 'action_controller/test_process'
+require 'active_record'
+
+require 'metrics'
+require File.dirname(__FILE__) + '/metrics_test_class'
+require 'resolv'
+require 'ipaddr'
+
+class SomeClassToTest
+  collect_metrics_on :my_method
+  
+  def my_method(blah = nil)
+    print "blah = #{blah}\n" if blah != nil
+    true
+  end
+
+  def my_non_metric_method(blah = nil)
+    print "blah = #{blah}\n" if blah != nil
+    true
+  end
+end
+
+class SomeClassToTestWithoutCollection
+  
+  def my_method(blah = nil)
+    print "blah = #{blah}\n" if blah != nil
+    true
+  end
+
+  def my_non_metric_method(blah = nil)
+    print "blah = #{blah}\n" if blah != nil
+    true
+  end
+end
+
+module SomeModuleToTest
+  collect_metrics_on :the_method
+  def the_method(blah)
+    print "in the_method(#{blah})\n"
+    true
+  end
+  
+  def another_method(blah)
+    print "in another_method(#{blah})\n"
+    true
+  end
+end
+
+class SomeClassToUseModuleMixin
+  include SomeModuleToTest
+  collect_metrics_on :another_method
+end
+
+class SomeController < ActionController::Base
+  def index
+    print "!!!!!!!!!!!!!! HERE\n"
+    render :text => "hello world"
+  end
+end
+
+class Test::SomeControllerThreshold < ActionController::Base
+  def index
+    print "!!!!!!!!!!!!!! HERE\n"
+    render :text => "hello world"
+  end
+end
+
+class Test::SomeControllerWithMetricsId < ActionController::Base
+  def index
+    Metrics.collect_metrics { print "!!!!!!!!!!!!!! HERE\n" }
+    render :text => "hello world"
+  end
+end
+
+class MockSocket < StringIO
+  def readline; "HTTP 200 OK"; end
+  def readuntil(a, b); ""; end
+  def read_all(a); ""; end
+end
+
+class MetricsTest < Test::Unit::TestCase
+  def setup
+    ActiveRecord::Base.configurations = {'test' => {'adapter' => "sqlite3", "dbfile" => ":memory:"}}
+    Metrics::Config[:min_real_time_threshold] = 0.0 # artifically lower the threshold so we catch everything for our tests
+    start_logging()
+  end
+  
+  def teardown
+    stop_logging()
+  end
+  
+  def test_http_metrics_log
+    http = Net::HTTP.new("www.revolutionhealth.com", "80")
+    http_output = MockSocket.new
+    http_output.print "empty\nasdf\n\n"
+    http_output.rewind
+    http.instance_eval { @socket = http_output; @started = true }
+    
+    
+    http.request_get("/test", { 'accept' => "text/plain"} )
+    assert output.string =~ /.*Metrics.*Net::HTTP::Get.exec.*test/
+    output.string.gsub!(/.*/, '')
+
+    http.request_post("/test", "body", { 'accept' => "text/plain"} )
+    assert output.string =~ /.*Metrics.*Net::HTTP::Post.exec.*test/
+    output.string.gsub!(/.*/, '')
+
+
+    http.send(:post, "/test", "body", { 'accept' => "text/plain"} )
+    assert output.string =~ /.*Metrics.*Net::HTTP::Post.exec.*test/
+    output.string.gsub!(/.*/, '')
+
+  end
+
+  def test_metrics_log_capture
+    METRICS_LOGGER.error { "BLAH" }
+    assert output.string =~ /.*BLAH\n/
+  end
+  
+  def test_metrics_config
+    default = Metrics::Config[:min_real_time_threshold]
+    Metrics::Config[:min_real_time_threshold] = 0.5
+    assert_equal 0.5, Metrics::Config[:min_real_time_threshold]
+    assert_equal Metrics::Config[:min_real_time_threshold], Metrics::Config.instance.cfg[:min_real_time_threshold]
+    Metrics::Config[:min_real_time_threshold] = default
+    
+    assert_equal "|", Metrics::Config[:log_delimiter]
+  end
+  
+  def test_class_threshold    
+    test_controller = Test::SomeControllerThreshold.new
+    test_request = ActionController::TestRequest.new
+    test_request.path = '/some'
+    test_request.action = 'index'
+    
+    original_threshold = Metrics::Config[:min_real_time_threshold]
+    Metrics::Config[:min_real_time_threshold] = 2.0 # adjust it
+    begin
+      response = test_controller.process_test(test_request)
+    ensure
+      Metrics::Config[:min_real_time_threshold] = original_threshold
+    end
+    
+    assert_equal response.body, "hello world"
+    assert_nil output.string =~ /\[Metrics\]/    
+    output.string.gsub!(/.*/, '')
+  end
+  
+  
+  def test_metrics_id
+    test_controller = Test::SomeControllerWithMetricsId.new
+    test_request = ActionController::TestRequest.new
+    test_request.path = '/some'
+    test_request.action = 'index'
+    response = test_controller.process_test(test_request)
+    assert_equal response.body, "hello world"
+
+    test1 = output.string.scan(/.*\[Metrics\]\|\[(\d*)\]/).flatten
+
+    assert_equal 2, test1.size
+    assert_equal test1[0], test1[1]
+
+
+    output.string.gsub!(/.*/, '')
+    test_controller = SomeController.new
+    response = test_controller.process_test(test_request) 
+    assert_equal response.body, "hello world"
+
+    test2 = output.string.scan(/.*\[Metrics\]\|\[(\d*)\]/).flatten
+    assert_equal 1, test2.size
+    assert_not_nil test2[0]
+    
+    assert_not_equal test1[0], test2[0]
+    
+    output.string.gsub!(/.*/, '')    
+  end
+  
+
+  def test_ar_enhanced_metrics
+    assert output.string.empty?
+    ActiveRecord::Base.establish_connection
+    not_nil_checker = nil
+    
+    ActiveRecord::Base.connection.instance_eval <<-EOS
+      log("select count(1);", "test") { not_nil_checker = true }
+    EOS
+    assert_equal false, output.string.empty?
+    output.string.gsub!(/.*/, '')
+
+    ActiveRecord::Base.connection.instance_eval <<-EOS
+      log("select count(1);", "test")
+    EOS
+    assert_equal false, output.string.empty?
+
+    assert_not_nil not_nil_checker
+    output.string.gsub!(/.*/, '')
+
+    ar_conf = ActiveRecord::Base.configurations['test'].merge({'host' => 'localhost.revolutionhealth.com', 
+                                                               'username' => 'none', 'database' => 'test'})
+    ar_conf.symbolize_keys!
+    ActiveRecord::Base.connection.instance_eval { @config = ar_conf if @config.nil? }
+    ActiveRecord::Base.connection.execute("select count(1);")
+    
+    print output.string + "\n\n"
+    assert_equal false, output.string.blank?
+    config = {'adapter' => "sqlite3", 
+              'host' => 'localhost.revolutionhealth.com',
+              'username' => 'none', 'database' => 'test'
+             }
+    config.symbolize_keys!
+    
+    host = config[:host].sub(/\..*/, '')
+    assert_match /.*args\=\[\"#{config[:username]} #{host} #{config[:database]}\"\, \"select count\(1\)\;\"\].*/, output.string
+
+
+    output.string.gsub!(/.*/, '')
+
+    host_ip = nil
+    Resolv.getaddresses(config[:host]).each { |x| host_ip = x if IPAddr.new(x).ipv4? }
+
+    if host_ip != nil
+      config[:host] = host_ip
+      ActiveRecord::Base.connection.instance_variable_set("@config", config)
+      ActiveRecord::Base.connection.execute("select count(1);")
+  
+      print output.string  
+      print "\n\n"
+      assert_equal false, output.string.blank?
+      config = ActiveRecord::Base.connection.instance_variable_get("@config")
+
+      host = config[:host].sub(/\..*/, '')
+      host = config[:host] if not host.scan(/\d+/).empty?
+      assert_match /.*args\=\[\"#{config[:username]} #{host} #{config[:database]}\"\, \"select count\(1\)\;\"\].*/, output.string
+    end
+
+    output.string.gsub!(/.*/, '')
+
+
+    
+    ActiveRecord::Base.connection.instance_eval <<-EOS
+      def execute(sql, name = nil, retries = 2) #:nodoc:
+        log(sql, name) { sleep(2) }
+      rescue ActiveRecord::StatementInvalid => exception
+        if exception.message.split(":").first =~ /Packets out of order/
+          raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information.  If you're on Windows, use the Instant Rails installer to get the updated mysql bindings."
+        else
+          raise
+        end
+      end
+    EOS
+
+    ActiveRecord::Base.connection.execute("SLEEP TEST")
+    assert_equal false, output.string.empty?
+  end
+
+  def test_metrics_collection2
+    tmp = RHG::MetricsTestClass.new.my_method("hi")
+    assert_equal true, tmp
+    assert SomeClassToTest.method_defined?(:__metrics_my_method__)
+
+    test_obj = RHG::MetricsTestClass.new
+    tmp2 = test_obj.my_method("hi")
+    assert_equal true, tmp2
+    assert SomeClassToTest.method_defined?(:__metrics_my_method__)
+    
+    tmp3 = test_obj.my_method("hi")
+    assert_equal true, tmp3
+    assert SomeClassToTest.method_defined?(:__metrics_my_method__)
+  end
+
+  def test_metrics_collection
+    tmp = SomeClassToTest.new.my_method("hi")
+    assert_equal true, tmp
+    assert SomeClassToTest.method_defined?(:__metrics_my_method__)
+  end
+  
+  def test_explicit_collection
+    assert_equal "123", collect_result_test()
+    assert_equal "321", collect_result_test(false)
+  end
+  
+  def test_module_metrics
+    tmp = Object.new.extend(SomeModuleToTest)
+    result = tmp.the_method("here")
+    assert_equal true, result
+    assert SomeModuleToTest.method_defined?(:__metrics_the_method__)
+    
+    tmp2 = SomeClassToUseModuleMixin.new
+    assert_equal true, tmp2.the_method("here")
+    assert_equal true, tmp2.another_method("also")
+    assert SomeClassToUseModuleMixin.method_defined?(:__metrics_the_method__)
+    assert SomeClassToUseModuleMixin.method_defined?(:__metrics_another_method__)
+    
+  end
+  
+  def test_an_output
+    some_class_instance = SomeClassToTest.new
+    some_class_instance.my_method
+    some_class_instance.my_method("HI")
+    collect_result_test()
+    collect_result_test2()
+        
+    METRICS_LOGGER.error("--------------- END TEST 1 -------------\n")
+    
+    Metrics::Config[:single_line_output] = true
+    
+    some_class_instance = SomeClassToTest.new
+    some_class_instance.my_method
+    some_class_instance.my_method("THAR")
+    collect_result_test()
+    collect_result_test2()
+    
+    test_controller = SomeController.new
+    test_request = ActionController::TestRequest.new
+    test_request.path = '/some'
+    test_request.action = 'index'
+    response = test_controller.process_test(test_request)
+    #assert response.body == "hello world"
+    METRICS_LOGGER.error("--------------- END TEST 2 -------------\n")
+
+    
+    print output.string  
+    print "\n\n"
+    assert_equal false, output.string.blank?
+    
+    output.string.gsub!(/.*/, '')
+    
+    old_level = METRICS_LOGGER.level
+    METRICS_LOGGER.level = fatal_level
+    collect_result_test2()
+    assert_equal true, output.string.blank?
+    
+    METRICS_LOGGER.level = old_level
+  end
+
+  def test_empty_config
+    orig_rails_env = Object.const_get('RAILS_ENV')
+    Object.const_set('RAILS_ENV', 'staging')
+    assert_nothing_raised { Metrics::Config.instance.send(:load_config) }
+    Object.const_set('RAILS_ENV', orig_rails_env)
+  end
+  
+  def test_benchmark
+    
+    Benchmark.bmbm do |x|
+      x.report("new with metrics") do 
+        SomeClassToTest.new
+      end
+      x.report("new without metrics") do 
+        SomeClassToTestWithoutCollection.new
+      end
+      
+      some_class_instance = SomeClassToTest.new
+      x.report("method call with metrics") do 
+        some_class_instance.my_method
+      end
+      x.report("method call without metrics") do 
+        some_class_instance.my_non_metric_method
+      end
+      
+      x.report("multiple method calls (1000) with metrics") do 
+        1000.times { some_class_instance.my_method }
+      end
+      x.report("multiple method calls (1000) without metrics") do 
+        1000.times { some_class_instance.my_non_metric_method }
+      end
+      
+      x.report("args inspector") do 
+        args_inspector("nothing")
+      end
+      
+      x.report("random id 100") do
+        100.times { rand(99999) }
+      end
+
+      x.report("random id 1") do
+         rand(99999)
+      end
+
+    end
+  end
+  
+  def test_no_logging
+    disable_logging = lambda do
+      Metrics.module_eval <<-EOS
+        def log_metrics(result, args); end
+      EOS
+    end
+    
+    disable_logging.call()
+    
+    some_class_instance = SomeClassToTest.new
+    Benchmark.bmbm do |x|
+      x.report("multiple method calls with metrics and no logging") do 
+        100.times { some_class_instance.my_method }
+      end
+      x.report("multiple method calls without metrics and no logging") do 
+        100.times { some_class_instance.my_non_metric_method }
+      end
+    end
+  end
+  
+  ITER_TIMES = 10000
+  
+  def test_logging_debug
+    test_args = {:test => "to this", :another_key => "and this stuff"}
+    default_level = METRICS_LOGGER.level
+    METRICS_LOGGER.level = debug_level
+    
+    Benchmark.bmbm do |x|
+      x.report("DEBUG MODE - test with debug on and in a block") do
+        ITER_TIMES.times { METRICS_LOGGER.debug {"dm 1 - do something #{test_args.inspect}"} }
+      end
+      
+      x.report("DEBUG MODE - test with debug on and a string") do
+        ITER_TIMES.times { METRICS_LOGGER.debug "dm 2 - do something #{test_args.inspect}" } 
+      end
+      
+      x.report("DEBUG MODE - test with debug on and a string and with if test") do
+        ITER_TIMES.times { METRICS_LOGGER.debug "dm 3 - do something #{test_args.inspect}" if METRICS_LOGGER.debug? }
+      end
+    end
+    
+    METRICS_LOGGER.level = fatal_level
+    
+    Benchmark.bmbm do |x|
+      x.report("FATAL MODE - test with debug on and in a block") do
+        ITER_TIMES.times { METRICS_LOGGER.debug {"fm 1 - do something #{test_args.inspect}"} }
+      end
+      
+      x.report("FATAL MODE - test with debug on and a string") do
+        ITER_TIMES.times { METRICS_LOGGER.debug "fm 2 - do something #{test_args.inspect}" }
+      end
+      
+      x.report("FATAL MODE - test with debug on and a string and with if test") do
+        ITER_TIMES.times { METRICS_LOGGER.debug "fm 3 - do something #{test_args.inspect}" if METRICS_LOGGER.debug? }
+      end
+    end
+    
+    METRICS_LOGGER.level = default_level
+  end
+  
+  
+private
+
+  def args_inspector(*args)
+    args_str = args.inspect
+  end
+  
+  def collect_result_test(testing_a = true)
+    Metrics.collect_metrics("[acts_as_rhg_rateable] - associate_rating_template") do
+      if (testing_a)
+        "123"
+      else
+        "321"
+      end
+    end
+  end
+  
+  def collect_result_test2(testing_a = true)
+    Metrics.collect_metrics("[acts_as_rhg_rateable2] - associate_rating_template", testing_a, "something else") do
+      if (testing_a)
+        "123"
+      else
+        "321"
+      end
+    end
+  end
+
+  def fatal_level
+    if defined?(Log4r)
+      Log4r::FATAL
+    else
+      Logger::FATAL
+    end
+  end
+  
+  def debug_level
+    if defined?(Log4r)
+      Log4r::DEBUG
+    else
+      Logger::DEBUG
+    end
+  end
+  
+  
+  def string_outputter
+    @string_outputter
+  end
+  
+  def output
+    @output
+  end
+  
+  def start_logging
+    @output = StringIO.new
+    if defined?(Log4r)
+      @string_outputter = Log4r::IOOutputter.new("metrics_log", output)
+      @string_outputter.formatter = METRICS_LOGGER.outputters[0].formatter
+      METRICS_LOGGER.add(@string_outputter)
+    else
+      string_outputdev = Logger::LogDevice.new(@output, :shift_age => 0, :shift_size => 1048576)
+      METRICS_LOGGER.instance_variable_set('@logdev', string_outputdev)
+    end
+    nowhere_log = Logger.new(StringIO.new)
+    ActiveRecord::Base.logger =  nowhere_log # send AR logging off to no where
+    ActionController::Base.logger =  nowhere_log # send AR logging off to no where
+  end
+  
+  def stop_logging
+    if defined?(Log4r)
+      @string_outputter.close
+      METRICS_LOGGER.remove(@string_outputter)
+      @string_outputter = nil
+      @output = nil
+    end
+  end
+end
+
+# CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+# This source code may not be disclosed to others, used or reproduced without the written permission of Revolution Health Group.

data/test/metrics_test_class.rb

@@ -0,0 +1,51 @@
+module RHG
+
+if defined?(RHG::ServiceConfig)
+
+  class MetricsTestClass < RHG::Facade::Base
+    backend_instance_method :my_method
+  
+    def self.backend
+      @backend || reset_backend(Metrics::MetricsBackendClass)
+    end
+  end
+
+  class Metrics::MetricsBackendClass
+    include RHG::ServiceConfig
+    collect_metrics_on :my_method
+  
+    def my_method(blah = nil)
+      print "blah = #{blah}\n" if blah != nil
+      true
+    end
+
+    def my_non_metric_method(blah = nil)
+      print "blah = #{blah}\n" if blah != nil
+      true
+    end
+  
+    collect_metrics_on :my_method
+  end
+
+else # if not defined ServiceConfig
+
+  class MetricsTestClass
+    collect_metrics_on :my_method
+  
+    def my_method(blah = nil)
+      print "blah = #{blah}\n" if blah != nil
+      true
+    end
+
+    def my_non_metric_method(blah = nil)
+      print "blah = #{blah}\n" if blah != nil
+      true
+    end
+  
+    collect_metrics_on :my_method
+  end
+end # end if defined?
+
+end
+# CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+# This source code may not be disclosed to others, used or reproduced without the written permission of Revolution Health Group.

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: revolutionhealth-metrics
+version: !ruby/object:Gem::Version 
+  version: 0.0.9
+platform: ruby
+authors: 
+- Revolution Health
+autorequire: metrics
+bindir: bin
+cert_chain: []
+
+date: 2008-06-27 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: metrics allows one to track the performance of particular controllers, database calls, and other methods
+email: rails-trunk@revolutionhealth.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/metrics
+- lib/metrics/collector.rb
+- lib/metrics/config.rb
+- lib/metrics/logger.rb
+- lib/metrics.rb
+- lib/rails
+- lib/rails/activerecord_enhanced_metrics.rb
+- lib/rails/activerecord_metrics.rb
+- lib/rails/controller_metrics.rb
+- lib/ruby
+- lib/ruby/http_metrics.rb
+- lib/ruby/metric_extensions.rb
+- test/metrics_test.rb
+- test/metrics_test_class.rb
+- config/metrics.yml
+- init.rb
+has_rdoc: false
+homepage: http://github.com/revolutionhealth/metrics
+post_install_message: 
+rdoc_options: []
+
+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.2.0
+signing_key: 
+specification_version: 2
+summary: metrics allows one to track the performance of particular controllers, database calls, and other methods
+test_files: []
+