time_bandits 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+rdoc
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in time_bandits.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,98 @@
+= Time Bandits
+
+== About
+
+Time Bandits is a plugin which enhances Rails' controller/view/db benchmark logging.
+
+== Usage
+
+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]
+
+to:
+
+    Completed in 56.278ms (View: 28.488, DB: 5.111(2,0)) | 200 OK [http://127.0.0.1/jobs/info]
+
+Here "DB: 5.111(2,0)" means that 2 DB 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
+cases, it's very helpful to have an entry in your log file that records the time spent in the exterrnal
+service (so that you can prove that it wasn't your rails app that slowed down during your slashdotting,
+for example ;-).
+
+Additional TimeConsumers can be added to the log using the "Timebandits.add" method.
+
+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).
+
+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]
+
+"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
+
+   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)
+   l: live data set size after last GC (#slots)
+
+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.
+
+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/).
+
+
+== 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.
+
+
+== License
+
+Copyright (c) 2009 Stefan Kaes <skaes@railsexpress.de>
+
+Some portions Copyright (c) 2008 tylerkovacs
+
+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,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/time_bandits.rb

@@ -0,0 +1,50 @@
+require 'active_support/core_ext'
+
+module TimeBandits
+
+  module TimeConsumers
+    autoload :Database,          'time_bandits/time_consumers/database'
+    autoload :GarbageCollection, 'time_bandits/time_consumers/garbage_collection'
+    autoload :JMX,               'time_bandits/time_consumers/jmx'
+    autoload :MemCache,          'time_bandits/time_consumers/mem_cache'
+    autoload :Memcached,         'time_bandits/time_consumers/memcached'
+  end
+
+  require 'time_bandits/railtie' if defined?(Rails)
+
+  mattr_accessor :time_bandits
+  self.time_bandits = []
+  def self.add(bandit)
+    self.time_bandits << bandit unless self.time_bandits.include?(bandit)
+  end
+
+  def self.reset
+    time_bandits.each{|b| b.reset}
+  end
+
+  def self.consumed
+    time_bandits.map{|b| b.consumed}.sum
+  end
+
+  def self.runtime
+    time_bandits.map{|b| b.runtime}.join(", ")
+  end
+
+  def self.benchmark(title="Completed in", logger=Rails.logger)
+    reset
+    result = nil
+    e = nil
+    seconds = Benchmark.realtime do
+      begin
+        result = yield
+      rescue Exception => e
+        logger.error "Exception: #{e}"
+      end
+    end
+    consumed # needs to be called for DB time consumer
+    rc = e ? "500 Internal Server Error" : "200 OK"
+    logger.info "#{title} #{sprintf("%.3f", seconds * 1000)}ms (#{runtime}) | #{rc}"
+    raise e if e
+    result
+  end
+end

data/lib/time_bandits/monkey_patches/action_controller.rb

@@ -0,0 +1,85 @@
+require 'action_controller/metal/instrumentation'
+require 'action_controller/log_subscriber'
+
+module ActionController #:nodoc:
+
+  module Instrumentation
+
+    # patch to ensure that the completed line is always written to the log
+    def process_action(action, *args)
+      TimeBandits.reset
+
+      raw_payload = {
+        :controller => self.class.name,
+        :action     => self.action_name,
+        :params     => request.filtered_parameters,
+        :formats    => request.formats.map(&:to_sym),
+        :method     => request.method,
+        :path       => (request.fullpath rescue "unknown")
+      }
+
+      ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup)
+
+      exception = nil
+      result = ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
+        begin
+          super
+        rescue Exception => exception
+          response.status = 500
+          nil
+        ensure
+          payload[:status] = response.status
+          append_info_to_payload(payload)
+        end
+      end
+      raise exception if exception
+      result
+    end
+
+    # patch to ensure that render times are always recorded in the log
+    def render(*args)
+      render_output = nil
+      exception = nil
+      self.view_runtime = cleanup_view_runtime do
+        Benchmark.ms do
+          begin
+            render_output = super
+          rescue Exception => exception
+          end
+        end
+      end
+      raise exception if exception
+      render_output
+    end
+
+    def cleanup_view_runtime #:nodoc:
+      consumed_before_rendering = TimeBandits.consumed
+      runtime = yield
+      consumed_during_rendering = TimeBandits.consumed - consumed_before_rendering
+      runtime - consumed_during_rendering
+    end
+  end
+
+  class LogSubscriber
+    def process_action(event)
+      payload   = event.payload
+      additions = ActionController::Base.log_process_action(payload)
+      Thread.current[:time_bandits_completed_info] = [event.duration, additions]
+    end
+  end
+
+  module TimeBanditry #:nodoc:
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def log_process_action(payload) #:nodoc:
+        messages = super
+        TimeBandits.time_bandits.each do |bandit|
+          messages << bandit.runtime
+        end
+        messages
+      end
+    end
+
+  end
+end

data/lib/time_bandits/monkey_patches/activerecord_adapter.rb

@@ -0,0 +1,85 @@
+# 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
+

data/lib/time_bandits/monkey_patches/memcache-client.rb

@@ -0,0 +1,48 @@
+# Add this line to your ApplicationController (app/controllers/application.rb)
+# to enable logging for memcache-client:
+# time_bandit MemCache
+
+require 'memcache'
+raise "MemCache needs to be loaded before monkey patching it" unless defined?(MemCache)
+
+class MemCache
+  @@cache_latency = 0.0
+  @@cache_touches = 0
+  @@cache_misses = 0
+
+  def self.reset_benchmarks
+    @@cache_latency = 0.0
+    @@cache_touches = 0
+    @@cache_misses = 0
+  end
+
+  def self.get_benchmarks
+    [@@cache_latency, @@cache_touches, @@cache_misses]
+  end
+
+  def self.cache_runtime
+    sprintf "MC: %.3f(%dr,%dm)", @@cache_latency * 1000, @@cache_touches, @@cache_misses
+  end
+
+  def get_with_benchmark(key, raw = false)
+    val = nil
+    @@cache_latency += Benchmark.realtime{ val=get_without_benchmark(key, raw) }
+    @@cache_touches += 1
+    @@cache_misses += 1 if val.nil?
+    val
+  end
+  alias_method :get_without_benchmark, :get
+  alias_method :get, :get_with_benchmark
+
+  def get_multi_with_benchmark(*keys)
+    results = nil
+    @@cache_latency += Benchmark.realtime{ results=get_multi_without_benchmark(*keys) }
+    @@cache_touches += 1
+    @@cache_misses += keys.size - results.size
+    results
+  end
+  alias_method :get_multi_without_benchmark, :get_multi
+  alias_method :get_multi, :get_multi_with_benchmark
+
+end
+

data/lib/time_bandits/monkey_patches/memcached.rb

@@ -0,0 +1,55 @@
+# Add this line to your ApplicationController (app/controllers/application_controller.rb)
+# to enable logging for memcached:
+# time_bandit TimeBandits::TimeConsumers::Memcached
+
+require 'memcached'
+raise "Memcached needs to be loaded before monkey patching it" unless defined?(Memcached)
+
+class Memcached
+  @@cache_latency = 0.0
+  @@cache_touches = 0
+  @@cache_misses = 0
+
+  def self.reset_benchmarks
+    @@cache_latency = 0.0
+    @@cache_touches = 0
+    @@cache_misses = 0
+  end
+
+  def self.get_benchmarks
+    [@@cache_latency, @@cache_touches, @@cache_misses]
+  end
+
+  def self.cache_runtime
+    sprintf "MC: %.3f(%dr,%dm)", @@cache_latency * 1000, @@cache_touches, @@cache_misses
+  end
+
+  def get_with_benchmark(key, marshal = true)
+    @@cache_touches += 1
+    if key.is_a?(Array)
+      results = []
+      @@cache_latency += Benchmark.realtime do
+        begin
+          results = get_without_benchmark(key, marshal)
+        rescue Memcached::NotFound
+        end
+      end
+      @@cache_misses += key.size - results.size
+      results
+    else
+      val = nil
+      @@cache_latency += Benchmark.realtime do
+        begin
+          val = get_without_benchmark(key, marshal)
+        rescue Memcached::NotFound
+        end
+      end
+      @@cache_misses += 1 if val.nil?
+      val
+    end
+  end
+  alias_method :get_without_benchmark, :get
+  alias_method :get, :get_with_benchmark
+
+end
+

data/lib/time_bandits/monkey_patches/rails_rack_logger.rb

@@ -0,0 +1,36 @@
+require 'rails/rack/logger'
+
+module Rails
+  module Rack
+    class Logger
+
+      def call(env)
+        Thread.current[:time_bandits_completed_info] = nil
+        start_time = before_dispatch(env)
+        result = @app.call(env)
+      ensure
+        run_time = Time.now - start_time
+        status = result.first
+        duration, additions = Thread.current[:time_bandits_completed_info]
+        (additions ||= []).insert(0, "Controller: %.1fms" % duration)
+
+        message = "Completed #{status} #{::Rack::Utils::HTTP_STATUS_CODES[status]} in %.1fms (#{additions.join(' | ')})" % (run_time*1000)
+        info message
+
+        after_dispatch(env)
+      end
+
+      protected
+      def before_dispatch(env)
+        start_time = Time.now
+        request = ActionDispatch::Request.new(env)
+        path = request.fullpath
+
+        info "\n\nStarted #{request.request_method} \"#{path}\" " \
+             "for #{request.ip} at #{start_time.to_default_s}"
+        start_time
+      end
+
+    end
+  end
+end

data/lib/time_bandits/railtie.rb

@@ -0,0 +1,18 @@
+module TimeBandits
+  class Railtie < Rails::Railtie
+
+    initializer "time_bandits" do
+      ActiveSupport.on_load(:action_controller) do
+        require 'time_bandits/monkey_patches/rails_rack_logger'
+        require 'time_bandits/monkey_patches/action_controller'
+        include ActionController::TimeBanditry
+      end
+
+      ActiveSupport.on_load(:active_record) do
+        require 'time_bandits/monkey_patches/activerecord_adapter'
+        TimeBandits.add TimeBandits::TimeConsumers::Database.instance
+      end
+    end
+
+  end
+end

data/lib/time_bandits/time_consumers/database.rb

@@ -0,0 +1,55 @@
+# this consumer gets installed automatically by the plugin
+# if this were not so
+#
+#   time_bandit TimeBandits::TimeConsumers::Database.new
+#
+# 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
+      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
+
+      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

data/lib/time_bandits/time_consumers/garbage_collection.rb

@@ -0,0 +1,94 @@
+# a time consumer implementation for garbage collection
+module TimeBandits
+  module TimeConsumers
+    class GarbageCollection
+      @@heap_dumps_enabled = false
+      def self.heap_dumps_enabled=(v)
+        @@heap_dumps_enabled = v
+      end
+
+      def initialize
+        GC.enable_stats
+        reset
+      end
+      private :initialize
+
+      def self.instance
+        @instance ||= new
+      end
+
+      if GC.respond_to? :heap_slots
+
+        def reset
+          @consumed = GC.time
+          @collections = GC.collections
+          @allocated_objects = ObjectSpace.allocated_objects
+          @allocated_size = GC.allocated_size
+          @heap_slots = GC.heap_slots
+        end
+
+      else
+
+        def reset
+          @consumed = GC.time
+          @collections = GC.collections
+        end
+
+      end
+
+      def consumed
+        0.0
+      end
+
+      def consumed_gc_time
+        (GC.time - @consumed).to_f / 1_000_000
+      end
+
+      def collections
+        GC.collections - @collections
+      end
+
+      if GC.respond_to? :heap_slots
+
+        def allocated_objects
+          ObjectSpace.allocated_objects - @allocated_objects
+        end
+
+        def allocated_size
+          GC.allocated_size - @allocated_size
+        end
+
+        def heap_growth
+          GC.heap_slots - @heap_slots
+        end
+
+        if GC.respond_to? :heap_slots_live_after_last_gc
+          def live_data_set_size
+            GC.heap_slots_live_after_last_gc
+          end
+        else
+          def live_data_set_size
+            0
+          end
+        end
+
+        def runtime
+          heap_slots = GC.heap_slots
+          heap_growth = self.heap_growth
+          allocated_objects = self.allocated_objects
+          allocated_size = self.allocated_size
+          GCHacks.heap_dump if heap_growth > 0 && @@heap_dumps_enabled
+          "GC: %.3f(%d) | HP: %d(%d,%d,%d,%d)" %
+            [consumed_gc_time * 1000, collections, heap_growth, heap_slots, allocated_objects, allocated_size, live_data_set_size]
+        end
+
+      else
+
+        def runtime
+          "GC: %.3f(%d)" % [consumed_gc_time * 1000, collections]
+        end
+
+      end
+    end
+  end
+end

data/lib/time_bandits/time_consumers/jmx.rb

@@ -0,0 +1,77 @@
+# a time consumer implementation for jruby, using jxm
+#
+# the gc counts and times reported are summed over all the garbage collectors
+# heap_growth reflects changes in the committed size of the java heap
+# heap_size is the committed size of the java heap
+# allocated_size reflects changes in the active (used) part of the java heap
+# java non-heap memory is not reported
+
+module TimeBandits
+  module TimeConsumers
+    class JMX
+      def initialize
+        @server = ::JMX::MBeanServer.new
+        @memory_bean = @server["java.lang:type=Memory"]
+        @collectors = @server.query_names "java.lang:type=GarbageCollector,*"
+        reset
+      end
+      private :initialize
+
+      def self.instance
+        @instance ||= new
+      end
+
+      def consumed
+        0.0
+      end
+
+      def gc_time
+        @collectors.to_array.map {|gc| @server[gc].collection_time}.sum
+      end
+      
+      def gc_collections
+        @collectors.to_array.map {|gc| @server[gc].collection_count}.sum
+      end
+
+      def heap_size
+        @memory_bean.heap_memory_usage.committed
+      end
+      
+      def heap_usage
+        @memory_bean.heap_memory_usage.used
+      end
+
+      def reset
+        @consumed = gc_time
+        @collections = gc_collections
+        @heap_committed = heap_size
+        @heap_used = heap_usage
+      end
+      
+      def collections_delta
+        gc_collections - @collections
+      end
+
+      def gc_time_delta
+        (gc_time - @consumed).to_f
+      end
+
+      def heap_growth
+        heap_size - @heap_committed
+      end
+
+      def usage_growth
+        heap_usage - @heap_used
+      end
+      
+      def allocated_objects
+        0
+      end
+
+      def runtime
+        "GC: %.3f(%d), HP: %d(%d,%d,%d)" % [gc_time_delta, collections_delta, heap_growth, heap_size, allocated_objects, usage_growth]
+      end
+
+    end
+  end
+end

data/lib/time_bandits/time_consumers/mem_cache.rb

@@ -0,0 +1,25 @@
+# a time consumer implementation for memchache
+# install into application_controller.rb with the line
+#
+#   time_bandit TimeBandits::TimeConsumers::MemCache
+#
+require 'time_bandits/monkey_patches/memcache-client'
+module TimeBandits
+  module TimeConsumers
+    class MemCache
+      class << self
+        def reset
+          ::MemCache.reset_benchmarks
+        end
+
+        def consumed
+          ::MemCache.get_benchmarks.first
+        end
+
+        def runtime
+          ::MemCache.cache_runtime
+        end
+      end
+    end
+  end
+end

data/lib/time_bandits/time_consumers/memcached.rb

@@ -0,0 +1,25 @@
+# a time consumer implementation for memchached
+# install into application_controller.rb with the line
+#
+#   time_bandit TimeBandits::TimeConsumers::Memcached
+#
+require 'time_bandits/monkey_patches/memcached'
+module TimeBandits
+  module TimeConsumers
+    class Memcached
+      class << self
+        def reset
+          ::Memcached.reset_benchmarks
+        end
+
+        def consumed
+          ::Memcached.get_benchmarks.first
+        end
+
+        def runtime
+          ::Memcached.cache_runtime
+        end
+      end
+    end
+  end
+end

data/lib/time_bandits/version.rb

@@ -0,0 +1,3 @@
+module TimeBandits
+  VERSION = "0.0.1"
+end

data/time_bandits.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "time_bandits/version"
+
+Gem::Specification.new do |s|
+  s.name        = "time_bandits"
+  s.version     = TimeBandits::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Stefan Kaes"]
+  s.email       = ["skaes@railsexpress.de"]
+  s.homepage    = "https://github.com/skaes/time_bandits"
+  s.summary     = %q{Custom performance logging for Rails}
+  s.description = %q{Enables customizable performance logging for Rails applications}
+
+  s.rubyforge_project = "time_bandits"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency("activesupport",         ["~> 3.0"])
+end
+

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: time_bandits
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Stefan Kaes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-29 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+description: Enables customizable performance logging for Rails applications
+email: 
+- skaes@railsexpress.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- 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/memcache-client.rb
+- lib/time_bandits/monkey_patches/memcached.rb
+- lib/time_bandits/monkey_patches/rails_rack_logger.rb
+- lib/time_bandits/railtie.rb
+- lib/time_bandits/time_consumers/database.rb
+- lib/time_bandits/time_consumers/garbage_collection.rb
+- lib/time_bandits/time_consumers/jmx.rb
+- lib/time_bandits/time_consumers/mem_cache.rb
+- lib/time_bandits/time_consumers/memcached.rb
+- lib/time_bandits/version.rb
+- time_bandits.gemspec
+has_rdoc: true
+homepage: https://github.com/skaes/time_bandits
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: time_bandits
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Custom performance logging for Rails
+test_files: []
+