time_bandits 0.4.1 → 0.5.0

data/init.rb

@@ -1,12 +0,0 @@
-# this file gets only loaded for rails2
-require 'time_bandits'
-require 'time_bandits/monkey_patches/active_record_rails2'
-require 'time_bandits/monkey_patches/action_controller_rails2'
-
-ActionController::Base.send :include, ActionController::TimeBanditry
-
-TimeBandits::TimeConsumers::GarbageCollection.heap_dumps_enabled = %w(production development).include?(RAILS_ENV)
-
-# TimeBandits.add TimeBandits::TimeConsumers::Memcached if defined?(Memcached)
-# TimeBandits.add TimeBandits::TimeConsumers::GarbageCollection.instance if GC.respond_to? :enable_stats
-# TimeBandits.add TimeBandits::TimeConsumers::JMX.instance if defined? JRUBY_VERSION

data/lib/time_bandits/monkey_patches/action_controller_rails2.rb

@@ -1,162 +0,0 @@
-# =========================================================================================================
-# IMPORTANT: the plugin changes the ActionController#process method chain
-#
-# the original rails stack looks like this:
-#
-# ActionController::SessionManagement#process_with_session_management_support
-# ActionController::Filters#process_with_filters
-# ActionController::Base#process
-# ActionController::Caching::SqlCache#perform_action_with_caching
-# ActionController::Rescue#perform_action_with_rescue
-# *** ActionController::Benchmarking#perform_action_with_benchmark ***
-# ActionController::Filters#perform_action_with_filters (==> this runs the filters)
-# ActionController::Base#perform_action (==> run the action and eventually call render)
-# ActionController::Benchmarking#render_with_benchmark (==> this is where the rendering time gets computed)
-# ActionController::Base::render
-#
-# with the plugin installed, the stack looks like this:
-#
-# ActionController::SessionManagement#process_with_session_management_support
-# ActionController::Filters#process_with_filters
-# ActionController::Base#process
-# *** ActionController::Benchmarking#perform_action_with_time_bandits ***   <=========== !!!!
-# ActionController::Caching::SqlCache#perform_action_with_caching
-# ActionController::Rescue#perform_action_with_rescue
-# ActionController::Filters#perform_action_with_filters (==> this runs the filters)
-# ActionController::Base#perform_action (==> run the action and eventually call render)
-# ActionController::Benchmarking#render_with_benchmark (==> this is where the rendering time gets computed)
-# ActionController::Base::render
-# =========================================================================================================
-
-module ActionController #:nodoc:
-
-  class Base
-    # this ugly hack is used to get the started_at and ip information into time bandits metrics
-    def request_origin
-      # this *needs* to be cached!
-      # otherwise you'd get different results if calling it more than once
-      @request_origin ||=
-        begin
-          remote_ip = request.remote_ip
-          t = Time.now
-          started_at = "#{t.to_s(:db)}.#{t.usec}"
-          request.env["time_bandits.metrics"] = {:ip => remote_ip, :started_at => started_at}
-          "#{remote_ip} at #{started_at}"
-        end
-    end
-  end
-
-  module TimeBanditry #:nodoc:
-    def self.included(base)
-      base.class_eval do
-        alias_method_chain :perform_action, :time_bandits
-        alias_method_chain :rescue_action, :time_bandits
-
-        # if timebandits are used, the default benchmarking is
-        # disabled. As alias_method_chain is unfriendly to extensions,
-        # this is done by skipping perform_action_with_benchmarks by
-        # calling perform_action_without_benchmarks at the appropriate
-        # place.
-        def perform_action_without_rescue
-          perform_action_without_benchmark
-        end
-
-        alias_method :render, :render_with_benchmark
-      end
-
-      TimeBandits.add TimeBandits::TimeConsumers::Database.instance
-    end
-
-    def render_with_benchmark(options = nil, extra_options = {}, &block)
-      if logger
-        before_rendering = TimeBandits.consumed
-
-        render_output = nil
-        @view_runtime = Benchmark::realtime { render_output = render_without_benchmark(options, extra_options, &block) }
-
-        other_time_consumed_during_rendering = TimeBandits.consumed - before_rendering
-        @view_runtime -= other_time_consumed_during_rendering
-
-        render_output
-      else
-        render_without_benchmark(options, extra_options, &block)
-      end
-    end
-
-    def perform_action_with_time_bandits
-      if logger
-        TimeBandits.reset
-
-        seconds = [ Benchmark::measure{ perform_action_without_time_bandits }.real, 0.0001 ].max
-
-        # need to call this to compute DB time/calls
-        TimeBandits.consumed
-
-        log_message  = "Completed in #{sprintf("%.3f", seconds * 1000)}ms"
-
-        log_message << " ("
-        log_message << view_runtime
-        TimeBandits.time_bandits.each do |bandit|
-          log_message << ", #{bandit.runtime}"
-        end
-        log_message << ")"
-
-        log_message << " | #{response.status}"
-        log_message << " [#{complete_request_uri rescue "unknown"}]"
-
-        logger.info(log_message)
-        response.headers["X-Runtime"] = "#{sprintf("%.0f", seconds * 1000)}ms"
-        merge_metrics(seconds)
-      else
-        perform_action_without_time_bandits
-      end
-    end
-
-    def rescue_action_with_time_bandits(exception)
-      # HACK!
-      if logger && !caller.any?{|c| c =~ /perform_action_without_time_bandits/ }
-        TimeBandits.reset
-
-        seconds = [ Benchmark::measure{ rescue_action_without_time_bandits(exception) }.real, 0.0001 ].max
-
-        # need to call this to compute DB time/calls
-        TimeBandits.consumed
-
-        log_message  = "Completed in #{sprintf("%.3f", seconds * 1000)}ms"
-
-        log_message << " ("
-        log_message << view_runtime
-        TimeBandits.time_bandits.each do |bandit|
-          log_message << ", #{bandit.runtime}"
-        end
-        log_message << ")"
-
-        log_message << " | #{response.status}"
-        log_message << " [#{complete_request_uri rescue "unknown"}]"
-
-        logger.info(log_message)
-        response.headers["X-Runtime"] = "#{sprintf("%.0f", seconds * 1000)}ms"
-        merge_metrics(seconds)
-      else
-        rescue_action_without_time_bandits(exception)
-      end
-    end
-
-    private
-
-    def merge_metrics(total_time_seconds)
-      basic_request_metrics = {
-        :total_time => total_time_seconds * 1000,
-        :view_time => (@view_runtime||0) * 1000,
-        :code => response.status.to_i,
-        :action => "#{self.class.name}\##{action_name}",
-      }
-      request.env["time_bandits.metrics"].merge!(TimeBandits.metrics).merge!(basic_request_metrics)
-    end
-
-    def view_runtime
-      "View: %.3f" % ((@view_runtime||0) * 1000)
-    end
-
-  end
-end

data/lib/time_bandits/monkey_patches/active_record_rails2.rb

@@ -1,86 +0,0 @@
-# this file monkey patches class ActiveRecord::ConnectionAdapters::AbstractAdapter
-# and the module module ActiveRecord::ConnectionAdapters::QueryCache
-# to count the number of sql statements being executed.
-# it needs to be adapted to each new rails version
-
-raise "AR abstract adapter monkey patch for custom benchmarking is not compatible with your rails version" unless
-  %w(2.3.2 2.3.3 2.3.4 2.3.8 2.3.9 2.3.10 2.3.11 2.3.12 2.3.13 2.3.14).include?(Rails::VERSION::STRING)
-
-module ActiveRecord
-  module ConnectionAdapters
-    class ConnectionPool
-      attr_reader :connections
-    end
-
-    class AbstractAdapter
-      attr_accessor :call_count, :query_cache_hits
-
-      def initialize(connection, logger = nil) #:nodoc:
-        @connection, @logger = connection, logger
-        @runtime = 0
-        @call_count = 0
-        @last_verification = 0
-        @query_cache_enabled = false
-        @query_cache_hits = 0
-      end
-
-      def reset_call_count
-        calls = @call_count
-        @call_count = 0
-        calls
-      end
-
-      def reset_query_cache_hits
-        hits = @query_cache_hits
-        @query_cache_hits = 0
-        hits
-      end
-
-      protected
-      def log(sql, name)
-        if block_given?
-          result = nil
-          seconds = Benchmark.realtime { result = yield }
-          @runtime += seconds
-          @call_count += 1
-          log_info(sql, name, seconds * 1000)
-          result
-        else
-          log_info(sql, name, 0)
-          nil
-        end
-      rescue Exception => e
-        # Log message and raise exception.
-        # Set last_verification to 0, so that connection gets verified
-        # upon reentering the request loop
-        @last_verification = 0
-        message = "#{e.class.name}: #{e.message}: #{sql}"
-        log_info(message, name, 0)
-        raise ActiveRecord::StatementInvalid, message
-      end
-    end
-
-    module QueryCache
-      private
-      def cache_sql(sql)
-        result =
-          if @query_cache.has_key?(sql)
-            @query_cache_hits += 1
-            log_info(sql, "CACHE", 0.0)
-            @query_cache[sql]
-          else
-            @query_cache[sql] = yield
-          end
-
-        if Array === result
-          result.collect { |row| row.dup }
-        else
-          result.duplicable? ? result.dup : result
-        end
-      rescue TypeError
-        result
-      end
-    end
-  end
-end
-

data/lib/time_bandits/time_consumers/database_rails2.rb

@@ -1,61 +0,0 @@
-# Database time consumer for Rails2. You need to add it via
-#
-# TimeBandits.add TimeBandits::TimeConsumers::Database.instance
-#
-
-module TimeBandits
-  module TimeConsumers
-    # provide a time consumer interface to ActiveRecord for perform_action_with_benchmark and render_with_benchmark
-    class Database
-      def initialize
-        @consumed = 0.0
-        @call_count = 0
-        @query_cache_hits = 0
-      end
-      private :initialize
-
-      def self.instance
-        @instance ||= new
-      end
-
-      def reset
-        reset_stats
-        @call_count = 0
-        @consumed = 0.0
-        @query_cache_hits = 0
-      end
-
-      def consumed
-        hits, calls, time = reset_stats
-        @query_cache_hits += hits
-        @call_count += calls
-        @consumed += time
-      end
-
-      def runtime
-        sprintf "DB: %.3f(%d,%d)", @consumed * 1000, @call_count, @query_cache_hits
-      end
-
-      def metrics
-        {
-          :db_calls => @call_count,
-          :db_sql_query_cache_hits  => @query_cache_hits,
-          :db_time => @consumed * 1000
-        }
-      end
-
-      private
-      def all_connections
-        ActiveRecord::Base.connection_handler.connection_pools.values.map{|pool| pool.connections}.flatten
-      end
-
-      def reset_stats
-        connections = all_connections
-        hits  = connections.map{|c| c.reset_query_cache_hits}.sum
-        calls = connections.map{|c| c.reset_call_count}.sum
-        time  = connections.map{|c| c.reset_runtime}.sum
-        [hits, calls, time]
-      end
-    end
-  end
-end