tylerkovacs-custom_benchmarks 0.4.0

data/VERSION.yml

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

data/lib/adapters/memcache-client.rb

@@ -0,0 +1,134 @@
+# Add this line to your ApplicationController (app/controllers/application.rb)
+# to enable logging for memcache-client:
+# custom_benchmark {|runtime| MemCache.cache_runtime(runtime) }
+
+class MemCache
+  @@record_size = false
+  @@logger = nil
+  @@error_logger = nil
+  @@cache_latency = 0.0
+  @@cache_gets = 0
+  @@cache_sets = 0
+  @@cache_deletes = 0
+  @@cache_hits = 0
+  @@cache_misses = 0
+  @@get_data_size = 0
+  @@set_data_size = 0
+
+  cattr_accessor :record_size, :logger, :error_logger
+
+  def self.reset_benchmarks
+    @@cache_latency = 0.0
+    @@cache_gets = 0
+    @@cache_sets = 0
+    @@cache_deletes = 0
+    @@cache_hits = 0
+    @@cache_misses = 0
+    @@get_data_size = 0
+    @@set_data_size = 0
+  end
+
+  def self.get_benchmarks
+    [@@cache_latency, @@cache_gets, @@get_data_size, @@cache_sets, @@set_data_size, @@cache_deletes, @@cache_hits, @@cache_misses]
+  end
+
+  def self.cache_runtime(runtime)
+    latency,gets,gsize,sets,ssize,deletes,hits,misses = self.get_benchmarks
+
+    # Since we're using memcache store, the reset_benchmarks method call must
+    # appear at the beginning of the the request.  This is necessary before
+    # Rails saves the session to the store after the entry is written to
+    # production.log.  If you don't clear the MemCache stats at the beginning
+    # of the request, then the session save from other requests pollutes the
+    # cache stats for the subsequent requests.  Use a before_filter in
+    # application.rb:
+    #   before_filter { MemCache.reset_benchmarks }
+    # If you aren't using memcache session store then you uncomment this line:
+    # self.reset_benchmarks
+
+    " | memcache: #{sprintf("%.5f,%d,%d,%d,%d,%d,%d,%d",latency,gets,gsize,sets,ssize,deletes,hits,misses)} (#{sprintf("%d", (latency * 100) / runtime)}%)"
+  end
+
+  def rescue_no_connection
+    begin
+      yield
+    rescue MemCache::MemCacheError => err
+      @@error_logger.info([Time.now.to_s, err.message, err.backtrace].compact.join("\n")) if @@error_logger
+      if err.message != "No connection to server" and err.message !~ /^lost connection/i and ENV['RAILS_ENV'] != 'development'
+        SystemNotifier.deliver_non_controller_exception_notification(err)
+      end
+      return nil
+    end
+  end
+
+  def get_with_benchmark(key, raw=false)
+    val = nil
+    t1 = Time.now
+    val = rescue_no_connection { get_without_benchmark(key, raw) }
+    val.nil? ? (@@cache_misses += 1) : (@@cache_hits += 1)
+    @@cache_latency += Time.now - t1
+    @@cache_gets += 1
+    size = @@record_size ? (Marshal.dump(val).length rescue 0) : 0
+    @@get_data_size += size if @@record_size
+    @@logger.info("MEMCACHE GET #{key} SIZE #{size} TIME #{Time.now - t1}") if @@logger
+    val
+  end
+  alias_method :get_without_benchmark, :get
+  alias_method :get, :get_with_benchmark
+  alias [] get_with_benchmark
+
+  def get_multi_with_benchmark(*keys)
+    val = nil
+    t1 = Time.now
+    vals = rescue_no_connection { get_multi_without_benchmark(keys) }
+    @@cache_latency += Time.now - t1
+    @@cache_gets += 1
+    if @@logger or @@record_size
+      request_id = t1.to_f.to_s.last(4)
+      for key in keys
+        size = @@record_size ? (Marshal.dump(vals[key]).length rescue 0) : 0
+        @@get_data_size += size if @@record_size
+        @@logger.info("MEMCACHE GETMULTI ID #{request_id} KEY #{key} SIZE #{size} TIME #{Time.now - t1}") if @@logger
+      end
+    end
+    vals
+  end
+  alias_method :get_multi_without_benchmark, :get_multi
+  alias_method :get_multi, :get_multi_with_benchmark
+
+  def set_with_benchmark(key, val, expiry=0, raw=false)
+    t1 = Time.now
+    rescue_no_connection { set_without_benchmark(key, val, expiry, raw) }
+    @@cache_latency += Time.now - t1
+    @@cache_sets += 1
+    size = @@record_size ? (Marshal.dump(val).length rescue 0) : 0
+    @@set_data_size += size if @@record_size
+    @@logger.info("MEMCACHE SET #{key} SIZE #{size} TIME #{Time.now - t1}") if @@logger
+  end
+  alias_method :set_without_benchmark, :set
+  alias_method :set, :set_with_benchmark
+  alias []= set_with_benchmark
+
+  def add_with_benchmark(key, val, expiry=0, raw=false)
+    t1 = Time.now
+    rescue_no_connection { add_without_benchmark(key, val, expiry, raw) }
+    @@cache_latency += Time.now - t1
+    @@cache_sets += 1
+    size = @@record_size ? (Marshal.dump(val).length rescue 0) : 0
+    @@set_data_size += size if @@record_size
+    @@logger.info("MEMCACHE ADD #{key} SIZE #{size} TIME #{Time.now - t1}") if @@logger
+  end
+  alias_method :add_without_benchmark, :add
+  alias_method :add, :add_with_benchmark
+
+  def delete_with_benchmark(key, expiry=0)
+    t1 = Time.now
+    rescue_no_connection { delete_without_benchmark(key, expiry) }
+    @@cache_latency += Time.now - t1
+    @@cache_deletes += 1
+    @@logger.info("MEMCACHE DELETE #{key} TIME #{Time.now - t1}") if @@logger
+  end
+  alias_method :delete_without_benchmark, :delete
+  alias_method :delete, :delete_with_benchmark
+end
+

data/lib/custom_benchmarks.rb

@@ -0,0 +1,180 @@
+# Custom Benchmarks
+#
+# Custom Benchmarks allow you to easily log your own information to the
+# rails log at the end of each request.  The standard rails summary log
+# line looks like this:
+#
+# Completed in 5ms (View: 3, DB: 2) | 200 OK [http://zvm/]
+#
+# With custom_benchmarks, an additional line is added to the output that
+# contains as many metrics as you like for each request.  e.g.,
+#
+# Completed in 5ms (View: 3, DB: 2) | 200 OK [http://zvm/]
+# Finished WelcomeController#index in 0.08545 (11 reqs/sec) DB: 2 | PID: 30796 | Time: 1233202720 | 200 OK [http://zvm/]
+#
+# Typically, the log line includes the latency associated with executing
+# specific parts of a request.  In the example above, we have added a
+# measurement of search latency.  But you can use Custom Benchmarks to add
+# any information to the log line.  The example above also shows the ID of
+# the process (PID) that served this request.  The PID is useful when parsing
+# information from logs that contain data from multiple processes.
+#
+# Simple Example: Logging the Process ID
+#
+# To add the PID as a custom benchmark field, simply add a custom_benchmark
+# line like the following to your ApplicationController:
+#
+# class ApplicationController < ActionController::Base
+#   custom_benchmark {|runtime| " | PID: #{$$}" }
+#   ...
+# end
+#
+# Declare your custom_benchmark with a block that expects an input parameter
+# called runtime.  runtime, which isn't used in this example, contains the
+# overall latency of the entire request.  Later, we'll show you an example
+# of using runtime to calculate percentage latency below.  custom_benchmark
+# expects your block to return a string - which will be inserted in the
+# log file immediate before the status (e.g., 200 OK [http://www.zvents.com/])
+#
+# Complex Example: Logging Arbitrary Latency
+#
+# Let's say that your application includes a search function that is powered
+# by Lucene.  Like SQL calls issued to a database, calls to Lucene can take
+# a while so you want to log your search latency.
+#
+# The first step is to set up a mechanism that allows you to record your
+# search latency for each request.  You can do that with something like this:
+#
+# class MySearch
+#   @@latency = 0.0
+#   cattr_accessor :latency
+#
+#   def run_search
+#     @@latency = Benchmark::measure{
+#       # execute the call to Lucene here
+#     }.real
+#   end
+#
+#   def self.get_timing_summary(runtime)
+#     summary = " | Search: #{sprintf("%.5f",@@latency)} (#{sprintf("%d", (@@latency * 100) / runtime)}%)"
+#     @@latency = 0.0
+#     summary
+#   end
+# end
+#
+# The run_search method uses Benchmark::measure to record the latency of the
+# search.  The get_timing_summary class method, which will be invoked by
+# a custom_benchmark, returns a formatted string summarizing the search
+# latency in absolute and percentage terms.  It also resets the value
+# of @@latency to avoid affecting subsequent queries.
+#
+# Finally, we just need to add a custom_benchmark statement to the
+# ApplicationController:
+#
+# custom_benchmark {|runtime| MySearch.get_timing_summary(runtime) }
+
+module ActionController #:nodoc:
+  module CustomBenchmarking #:nodoc:
+    def self.included(base)
+      base.extend(ClassMethods)
+
+      #if ENV['RAILS_ENV'] != "test"
+        base.class_eval do
+          alias_method :perform_action_without_custom_benchmark, :perform_action
+          alias_method :perform_action, :perform_action_with_custom_benchmark
+        end
+      #end
+    end
+
+    module ClassMethods
+      def custom_benchmark(*benchmark, &block)
+        #return if ENV['RAILS_ENV'] == "test"
+
+        if block_given?
+          write_inheritable_attribute(:custom_benchmarks,
+            (read_inheritable_attribute(:custom_benchmarks) || []) << block)
+        end
+      end
+
+      def custom_benchmarks
+        @custom_benchmarks ||= read_inheritable_attribute(:custom_benchmarks) || []
+      end
+    end
+
+    def perform_action_with_custom_benchmark
+      unless logger
+        perform_action_without_custom_benchmark
+      else
+        t1 = Time.now
+        perform_action_without_custom_benchmark
+        runtime = Time.now - t1
+
+        log_message  = ["Finished #{controller_class_name}\##{action_name} in #{sprintf("%.5f", runtime)} (#{(1 / runtime).floor} reqs/sec)"]
+        if Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
+          log_message << active_record_runtime
+        end
+        log_message << rendering_runtime(runtime) if @rendering_runtime
+        self.class.custom_benchmarks.each do |benchmark|
+          log_message << benchmark.call(runtime)
+        end
+        log_message << "| Time: #{Time.now.to_i}"
+        log_message << "| #{headers["Status"]}"
+        log_message << "[#{complete_request_uri rescue "unknown"}]"
+        logger.info(log_message.join(' '))
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    class AbstractAdapter
+      def initialize(connection, logger = nil) #:nodoc:
+        @connection, @logger = connection, logger
+        @runtime = 0
+        @total_runtime = 0
+        @last_verification = 0
+      end
+
+      def reset_runtime(reset=false) #:nodoc:
+        if reset
+          rt, @runtime, @total_runtime = @total_runtime, 0, 0
+        else
+          rt, @runtime = @runtime, 0, 0
+        end
+
+        rt
+      end
+
+      protected
+        def log(sql, name)
+          if block_given?
+            if @logger and @logger.level <= Logger::INFO
+              result = nil
+              seconds = Benchmark.realtime { result = yield }
+              @runtime += seconds
+              @total_runtime += seconds
+              log_info(sql, name, seconds)
+              result
+            else
+              seconds = Benchmark.realtime { result = yield }
+              @runtime += seconds
+              @total_runtime += seconds
+              result
+            end
+          else
+            log_info(sql, name, 0)
+            nil
+          end
+        rescue Exception => e
+          # Log message and raise exception.
+          # Set last_verfication 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
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: tylerkovacs-custom_benchmarks
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+platform: ruby
+authors: 
+- tylerkovacs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-28 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Custom Benchmarks allow you to easily log your own information to the rails log at the end of each request.
+email: tyler.kovacs@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- VERSION.yml
+- lib/custom_benchmarks.rb
+- lib/adapters
+- lib/adapters/memcache-client.rb
+has_rdoc: true
+homepage: http://github.com/tylerkovacs/custom_benchmarks
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: custom_benchmarks
+test_files: []
+