time_bandits 0.0.4 → 0.0.5

data/README.rdoc

@@ -9,13 +9,13 @@ Time Bandits is a plugin which enhances Rails' controller/view/db benchmark logg
 Without configuration, the standard Rails 'Completed line' will change
 from its default format
 
-    Completed in 56ms (View: 28, DB: 5) | 200 OK [http://127.0.0.1/jobs/info]
+    Completed 200 OK in 56ms (Views: 28.5ms, ActiveRecord: 5.1ms)
 
 to:
 
-    Completed in 56.278ms (View: 28.488, DB: 5.111(2,0)) | 200 OK [http://127.0.0.1/jobs/info]
+    Completed 200 OK in 56.278ms (Views: 28.488ms, ActiveRecord: 5.111ms(2q,0h))
 
-Here "DB: 5.111(2,0)" means that 2 DB queries were executed and there were 0 SQL query cache hits.
+"ActiveRecord: 5.111ms(2q,0h)" means that 2 SQL queries were executed and there were 0 SQL query cache hits.
 
 However, non-trivial applications also rather often use external services, which consume time that adds
 to your total response time, and sometimes these external services are not under your control. In these
@@ -30,50 +30,58 @@ Example:
     TimeBandits.add TimeBandits::TimeConsumers::Memcached
     TimeBandits.add TimeBandits::TimeConsumers::GarbageCollection.instance if GC.respond_to? :enable_stats
 
-Here we've added two additional consumers, which are already provided with the plugin. (Note that GC
-information requires a patched ruby, (e.g. http://github.com/skaes/matzruby, branch ruby187pl202patched
-or Ruby Enterprise Edition).
+Here we've added two additional consumers, which are already provided with the
+plugin. (Note that GC information requires a patched ruby, see prerequistes below.)
+
+Note: if you run a multithreaded program, the numbers reported for garbage collections and
+heap usage are partially misleading, because the Ruby interpreter collects stats in global
+variables shared by all threads.
 
 With these two new time consumers, the log line changes to
 
-    Completed in 680.378ms (View: 28.488, DB: 5.111(2,0), MC: 5.382(6r,0m), GC: 120.100(1), HP: 0(2000000,546468,18682541,934967)) | 200 OK [http://127.0.0.1/jobs/info]
+    Completed 200 OK in 680.378ms (Views: 28.488ms, ActiveRecord: 5.111ms(2q,0h), MC: 5.382(6r,0m), GC: 120.100(1), HP: 0(2000000,546468,18682541,934967))
 
 "MC: 5.382(6r,0m)" means that 6 memcache reads were performed and all keys were found in the cache (0 misses).
 
 "GC: 120.100(1)" tells us that 1 garbage collection was triggered during the request, taking 120.100 milliseconds.
 
-"HP: 0(2000000,546468,18682541,934967)" shows statistics on heap usage. The format is g(s,a,m,l), where
+"HP: 0(2000000,546468,18682541,934967)" shows statistics on heap usage. The format is g(s,a,b,l), where
 
    g: heap growth during the request (#slots)
    s: size of the heap after request processing was completed (#slots)
    a: number of object allocations during the request (#slots)
-   m: number of bytes allocated by the ruby x_malloc call (#bytes)
+   b: number of bytes allocated by the ruby x_malloc call (#bytes)
    l: live data set size after last GC (#slots)
 
+Sidenote for Germans: you can use the word "Gesabbel" (eng: drivel) as a mnemonic here ;-)
+
 It's pretty easy to write additional time consumers; please refer to the source code.
 
 
 == Prerequisites
 
-Rails 2.3.2, 2.3.3 or 2.3.4 The plugin will raise an error if you try
-to use it with a different version.
+Rails 3.x is required. The plugin will raise an error if you try to use it with a
+different version.
+
+You'll need a ruby with the railsexpress GC patches applied, if you want to include GC and
+heap size information in the completed line. This is very useful, especially if you want
+to analyze your rails logs using logjam (see http://github.com/alpinegizmo/logjam/).
 
-A ruby with the railsbench GC patches applied, if you want to include
-GC and heap size information in the completed line. This is very
-useful, especially if you want to analyze your rails logs using logjam
-(see http://github.com/alpinegizmo/logjam/).
+Ruby Enterprise Edition contains a subset of the railsexpress patches. To get the full
+monty, you can use for example rvm and the railsexpress rvm patchsets (see
+https://github.com/skaes/rvm-patchsets).
 
 
 == History
 
-This plugin started from the code of the 'custom_benchmark' plugin
-written by tylerkovacs. However, we changed so much of the code that
-is is practically a full rewrite, hence we changed the name.
+This plugin started from the code of the 'custom_benchmark' plugin written by
+tylerkovacs. However, we changed so much of the code that is is practically a full
+rewrite, hence we changed the name.
 
 
 == License
 
-Copyright (c) 2009 Stefan Kaes <skaes@railsexpress.de>
+Copyright (c) 2009,2011 Stefan Kaes <skaes@railsexpress.de>
 
 Some portions Copyright (c) 2008 tylerkovacs
 

data/TODO

@@ -0,0 +1,3 @@
+* make memcache consumers thread safe
+* test memcache consumers against a rails 3 app
+* maybe use ActiveSupport::Notifications everywhere?

data/lib/time_bandits/monkey_patches/action_controller.rb

@@ -58,6 +58,14 @@ module ActionController #:nodoc:
       consumed_during_rendering = TimeBandits.consumed - consumed_before_rendering
       runtime - consumed_during_rendering
     end
+
+    module ClassMethods
+      def log_process_action(payload) #:nodoc:
+        messages, view_runtime = [], payload[:view_runtime]
+        messages << ("Views: %.3fms" % view_runtime.to_f) if view_runtime
+        messages
+      end
+    end
   end
 
   class LogSubscriber

data/lib/time_bandits/monkey_patches/active_record.rb

@@ -0,0 +1,76 @@
+# this file monkey patches class ActiveRecord::LogSubscriber
+# to count the number of sql statements being executed
+# and the number of query cache hits
+# it needs to be adapted to each new rails version
+
+raise "AR log subscriber monkey patch for custom benchmarking is not compatible with your rails version" unless
+  (Rails::VERSION::STRING > "3.0" && Rails::VERSION::STRING < "3.1")
+
+require "active_record/log_subscriber"
+
+module ActiveRecord
+  class LogSubscriber
+
+    def self.call_count=(value)
+      Thread.current["active_record_sql_call_count"] = value
+    end
+
+    def self.call_count
+      Thread.current["active_record_sql_call_count"] ||= 0
+    end
+
+    def self.query_cache_hits=(value)
+      Thread.current["active_record_sql_query_cache_hits"] = value
+    end
+
+    def self.query_cache_hits
+      Thread.current["active_record_sql_query_cache_hits"] ||= 0
+    end
+
+    def self.reset_call_count
+      calls = call_count
+      self.call_count = 0
+      calls
+    end
+
+    def self.reset_query_cache_hits
+      hits = query_cache_hits
+      self.query_cache_hits = 0
+      hits
+    end
+
+    def sql(event)
+      self.class.runtime += event.duration
+      self.class.call_count += 1
+      self.class.query_cache_hits += 1 if event.payload[:name] == "CACHE"
+
+      return unless logger.debug?
+
+      name = '%s (%.1fms)' % [event.payload[:name], event.duration]
+      sql  = event.payload[:sql].squeeze(' ')
+
+      if odd?
+        name = color(name, CYAN, true)
+        sql  = color(sql, nil, true)
+      else
+        name = color(name, MAGENTA, true)
+      end
+
+      debug "  #{name}  #{sql}"
+    end
+  end
+
+  module Railties
+    module ControllerRuntime
+      def cleanup_view_runtime
+        super
+      end
+      module ClassMethods
+        def log_process_action(payload)
+          super
+        end
+      end
+    end
+  end
+end
+

data/lib/time_bandits/railtie.rb

@@ -9,8 +9,8 @@ module TimeBandits
       end
 
       ActiveSupport.on_load(:active_record) do
-        require 'time_bandits/monkey_patches/activerecord_adapter'
-        TimeBandits.add TimeBandits::TimeConsumers::Database.instance
+        require 'time_bandits/monkey_patches/active_record'
+        TimeBandits.add TimeBandits::TimeConsumers::Database
       end
     end
 

data/lib/time_bandits/time_consumers/database.rb

@@ -1,54 +1,49 @@
 # this consumer gets installed automatically by the plugin
 # if this were not so
 #
-#   time_bandit TimeBandits::TimeConsumers::Database.new
+#   TimeBandit.add TimeBandits::TimeConsumers::Database
 #
 # would do the job
 
 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
+    # provide a time consumer interface to ActiveRecord
+    module Database
+      extend self
+
+      def info
+        Thread.current[:time_bandits_database_info] ||= [0.0, 0, 0]
       end
-      private :initialize
 
-      def self.instance
-        @instance ||= new
+      def info=(info)
+        Thread.current[:time_bandits_database_info] = info
       end
 
       def reset
         reset_stats
-        @call_count = 0
-        @consumed = 0.0
-        @query_cache_hits = 0
+        self.info = [0.0, 0, 0]
       end
 
       def consumed
-        hits, calls, time = reset_stats
-        @query_cache_hits += hits
-        @call_count += calls
-        @consumed += time
+        time, calls, hits = reset_stats
+        i = self.info
+        i[2] += hits
+        i[1] += calls
+        i[0] += time
       end
 
       def runtime
-        sprintf "DB: %.3f(%d,%d)", @consumed * 1000, @call_count, @query_cache_hits
+        sprintf "ActiveRecord: %.3fms(%dq,%dh)", *info
       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]
+        s = ActiveRecord::LogSubscriber
+        hits  = s.reset_query_cache_hits
+        calls = s.reset_call_count
+        time  = s.reset_runtime
+        [time, calls, hits]
       end
     end
   end

data/lib/time_bandits/version.rb

@@ -1,3 +1,3 @@
 module TimeBandits
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: time_bandits
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: 
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Stefan Kaes
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-31 00:00:00 +02:00
+date: 2011-04-03 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -47,9 +47,10 @@ files:
 - Gemfile
 - README.rdoc
 - Rakefile
+- TODO
 - lib/time_bandits.rb
 - lib/time_bandits/monkey_patches/action_controller.rb
-- lib/time_bandits/monkey_patches/activerecord_adapter.rb
+- lib/time_bandits/monkey_patches/active_record.rb
 - lib/time_bandits/monkey_patches/memcache-client.rb
 - lib/time_bandits/monkey_patches/memcached.rb
 - lib/time_bandits/monkey_patches/rails_rack_logger.rb
@@ -91,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: time_bandits
-rubygems_version: 1.6.2
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: Custom performance logging for Rails

data/lib/time_bandits/monkey_patches/activerecord_adapter.rb

@@ -1,85 +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).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
-