time_bandits 0.10.9 → 0.12.0

data/lib/time_bandits/monkey_patches/active_record.rb

@@ -3,9 +3,6 @@
 # and the number of query cache hits
 # it needs to be adapted to each new rails version
 
-raise "time_bandits ActiveRecord monkey patch is not compatible with your rails version" unless
-  Rails::VERSION::STRING =~ /^(3\.[012]|4\.[012])|5\.[01]/
-
 require "active_record/log_subscriber"
 
 module ActiveRecord
@@ -42,119 +39,39 @@ module ActiveRecord
       hits
     end
 
-    # Rails 4.1 uses method_added to automatically subscribe newly
-    # added methods. Since :render_bind and :sql are already defined,
-    # the net effect is that sql gets called twice. Therefore, we
-    # temporarily switch to protected mode and change it back later to
-    # public.
-
-    # Note that render_bind was added for Rails 4.0, and the implementation
-    # has changed since then, so we are careful to only redefine it if necessary.
-    unless instance_methods.include?(:render_bind)
-      protected
-      def render_bind(column, value)
-        if column
-          if column.type == :binary
-            value = "<#{value.bytesize} bytes of binary data>"
-          end
-          [column.name, value]
-        else
-          [nil, value]
-        end
-      end
-      public :render_bind
-      public
-    end
-
-    protected
+    remove_method :sql
     def sql(event)
+      payload = event.payload
+
       self.class.runtime += event.duration
       self.class.call_count += 1
-      self.class.query_cache_hits += 1 if payload[:cached] || event.payload[:name] == "CACHE"
+      self.class.query_cache_hits += 1 if payload[:cached] || payload[:name] == "CACHE"
 
       return unless logger.debug?
 
-      payload = event.payload
-
       return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
 
       log_sql_statement(payload, event)
     end
-    public :sql
-    public
 
     private
-    if Rails::VERSION::STRING >= "5.1.5"
-      def log_sql_statement(payload, event)
-        name  = "#{payload[:name]} (#{event.duration.round(1)}ms)"
-        name  = "CACHE #{name}" if payload[:cached]
-        sql   = payload[:sql]
-        binds = nil
-
-        unless (payload[:binds] || []).empty?
-          casted_params = type_casted_binds(payload[:type_casted_binds])
-          binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
-            render_bind(attr, value)
-          }.inspect
-        end
-
-        name = colorize_payload_name(name, payload[:name])
-        sql  = color(sql, sql_color(sql), true)
-
-        debug "  #{name}  #{sql}#{binds}"
+    def log_sql_statement(payload, event)
+      name  = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+      name  = "CACHE #{name}" if payload[:cached]
+      sql   = payload[:sql]
+      binds = nil
+
+      unless (payload[:binds] || []).empty?
+        casted_params = type_casted_binds(payload[:type_casted_binds])
+        binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
+          render_bind(attr, value)
+        }.inspect
       end
-    elsif Rails::VERSION::STRING >= "5.0.3"
-      def log_sql_statement(payload, event)
-        name = '%s (%.1fms)' % [payload[:name], event.duration]
-        sql  = payload[:sql].squeeze(' ')
-        binds = nil
-
-        unless (payload[:binds] || []).empty?
-          casted_params = type_casted_binds(payload[:binds], payload[:type_casted_binds])
-          binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
-            render_bind(attr, value)
-          }.inspect
-        end
-
-        name = colorize_payload_name(name, payload[:name])
-        sql  = color(sql, sql_color(sql), true)
-
-        debug "  #{name}  #{sql}#{binds}"
-      end
-    elsif Rails::VERSION::STRING >= "5.0"
-      def log_sql_statement(payload, event)
-        name = '%s (%.1fms)' % [payload[:name], event.duration]
-        sql  = payload[:sql].squeeze(' ')
-        binds = nil
-
-        unless (payload[:binds] || []).empty?
-          binds = "  " + payload[:binds].map { |attr| render_bind(attr) }.inspect
-        end
 
-        name = colorize_payload_name(name, payload[:name])
-        sql  = color(sql, sql_color(sql), true)
+      name = colorize_payload_name(name, payload[:name])
+      sql  = color(sql, sql_color(sql), true)
 
-        debug "  #{name}  #{sql}#{binds}"
-      end
-    else
-      def log_sql_statement(payload, event)
-        name  = "#{payload[:name]} (#{event.duration.round(1)}ms)"
-        sql   = payload[:sql]
-        binds = nil
-
-        unless (payload[:binds] || []).empty?
-          binds = "  " + payload[:binds].map { |col,v| render_bind(col, v) }.inspect
-        end
-
-        if odd?
-          name = color(name, CYAN, true)
-          sql  = color(sql, nil, true)
-        else
-          name = color(name, MAGENTA, true)
-        end
-
-        debug "  #{name}  #{sql}#{binds}"
-      end
+      debug "  #{name}  #{sql}#{binds}"
     end
   end
 
@@ -162,11 +79,13 @@ module ActiveRecord
 
   module Railties
     module ControllerRuntime
+      remove_method :cleanup_view_runtime
       def cleanup_view_runtime
         # this method has been redefined to do nothing for activerecord on purpose
         super
       end
 
+      remove_method :append_info_to_payload
       def append_info_to_payload(payload)
         super
         if ActiveRecord::Base.connected?
@@ -176,6 +95,7 @@ module ActiveRecord
 
       module ClassMethods
         # this method has been redefined to do nothing for activerecord on purpose
+        remove_method :log_process_action
         def log_process_action(payload)
           super
         end

data/lib/time_bandits/rack/logger.rb

@@ -1,9 +1,17 @@
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/object/blank'
+require 'active_support/log_subscriber'
+require 'action_dispatch/http/request'
+require 'rack/body_proxy'
+
 module TimeBandits
   module Rack
+    # Sets log tags, logs the request, calls the app, and flushes the logs.
     class Logger < ActiveSupport::LogSubscriber
-      def initialize(app, taggers=nil)
-        @app = app
-        @taggers = taggers || Rails.application.config.log_tags || []
+      def initialize(app, taggers = nil)
+        @app          = app
+        @taggers      = taggers || Rails.application.config.log_tags || []
+        @instrumenter = ActiveSupport::Notifications.instrumenter
       end
 
       def call(env)
@@ -16,15 +24,29 @@ module TimeBandits
         end
       end
 
-      protected
+    protected
 
       def call_app(request, env)
         start_time = Time.now
-        before_dispatch(request, env, start_time)
-        result = @app.call(env)
+        start(request, start_time)
+        resp = @app.call(env)
+        resp[2] = ::Rack::BodyProxy.new(resp[2]) { finish(request) }
+        resp
+      rescue
+        finish(request)
+        raise
       ensure
-        run_time = Time.now - start_time
-        after_dispatch(env, result, run_time)
+        completed(request, (Time.now - start_time) * 1000, resp)
+        ActiveSupport::LogSubscriber.flush_all!
+      end
+
+      # Started GET "/session/new" for 127.0.0.1 at 2012-09-26 14:51:42 -0700
+      def started_request_message(request, start_time=Time.now)
+        'Started %s "%s" for %s at %s' % [
+          request.request_method,
+          request.filtered_path,
+          request.ip,
+          start_time.to_default_s ]
       end
 
       def compute_tags(request)
@@ -40,28 +62,33 @@ module TimeBandits
         end
       end
 
-      def before_dispatch(request, env, start_time)
+      private
+
+      def start(request, start_time)
         TimeBandits.reset
         Thread.current.thread_variable_set(:time_bandits_completed_info, nil)
+        @instrumenter.start 'action_dispatch.request', request: request
 
-        path = request.filtered_path
-
-        debug ""
-        info "Started #{request.request_method} \"#{path}\" for #{request.ip} at #{start_time.to_default_s}"
+        logger.debug ""
+        logger.info started_request_message(request, start_time)
       end
 
-      def after_dispatch(env, result, run_time)
-        status = result ? result.first.to_i : 500
+      def completed(request, run_time, resp)
+        status = resp ? resp.first.to_i : 500
         completed_info = Thread.current.thread_variable_get(:time_bandits_completed_info)
         additions = completed_info[1] if completed_info
-
         message = "Completed #{status} #{::Rack::Utils::HTTP_STATUS_CODES[status]} in %.1fms" % run_time
         message << " (#{additions.join(' | ')})" unless additions.blank?
-        info message
-      ensure
-        ActiveSupport::LogSubscriber.flush_all!
+        logger.info message
       end
 
+      def finish(request)
+        @instrumenter.finish 'action_dispatch.request', request: request
+      end
+
+      def logger
+        @logger ||= Rails.logger
+      end
     end
   end
 end

data/lib/time_bandits/railtie.rb

@@ -1,11 +1,7 @@
 module TimeBandits
 
   module Rack
-    if Rails::VERSION::STRING >= "4.0"
-      autoload :Logger, 'time_bandits/rack/logger40'
-    else
-      autoload :Logger, 'time_bandits/rack/logger'
-    end
+    autoload :Logger, 'time_bandits/rack/logger'
   end
 
   class Railtie < Rails::Railtie
@@ -19,7 +15,7 @@ module TimeBandits
         # Rails 5 may trigger the on_load event several times.
         next if included_modules.include?(ActionController::TimeBanditry)
         # For some magic reason, the test above is always false, but I'll leave it in
-        # here, should rails every decide to change this behavior.
+        # here, should the Rails team ever decide to change this behavior.
 
         include ActionController::TimeBanditry
 

data/lib/time_bandits/time_consumers/dalli.rb

@@ -1,21 +1,9 @@
-if Rails::VERSION::STRING =~ /\A4.[0123]/
-  require "time_bandits/monkey_patches/active_support_cache_store"
-end
-
 module TimeBandits::TimeConsumers
   class Dalli < BaseConsumer
     prefix :memcache
     fields :time, :calls, :misses, :reads, :writes
     format "Dalli: %.3f(%dr,%dm,%dw,%dc)", :time, :reads, :misses, :writes, :calls
 
-    if Rails::VERSION::STRING >= "4.0" && Rails::VERSION::STRING < "4.2" && Rails.cache.class.respond_to?(:instrument=)
-      # Rails 4 mem_cache_store (which uses dalli internally), unlike dalli_store, is not instrumented by default
-      def reset
-        Rails.cache.class.instrument = true
-        super
-      end
-    end
-
     class Subscriber < ActiveSupport::LogSubscriber
       # cache events are: read write fetch_hit generate delete read_multi increment decrement clear
       def cache_read(event)

data/lib/time_bandits/time_consumers/garbage_collection.rb

@@ -33,27 +33,11 @@ module TimeBandits
         def _get_gc_time; 0; end
       end
 
-      if GC.respond_to?(:collections)
-        def _get_collections; GC.collections; end
-      elsif GC.respond_to?(:count)
-        def _get_collections; GC.count; end
-      else
-        def _get_collections; 0; end
-      end
+      def _get_collections; GC.count; end
 
-      if ObjectSpace.respond_to?(:allocated_objects)
-        def _get_allocated_objects; ObjectSpace.allocated_objects; end
-      elsif GC.respond_to?(:stat) && RUBY_VERSION >= "2.2.0"
-        def _get_allocated_objects; GC.stat(:total_allocated_objects); end
-      elsif GC.respond_to?(:stat) && RUBY_VERSION >= "2.1.0"
-        def _get_allocated_objects; GC.stat(:total_allocated_object); end
-      else
-        def _get_allocated_objects; 0; end
-      end
+      def _get_allocated_objects; GC.stat(:total_allocated_objects); end
 
-      if GC.respond_to?(:allocated_size)
-        def _get_allocated_size; GC.allocated_size; end
-      elsif GC.respond_to?(:total_malloced_bytes)
+      if GC.respond_to?(:total_malloced_bytes)
         def _get_allocated_size; GC.total_malloced_bytes; end
       else
         def _get_allocated_size; 0; end
@@ -61,22 +45,14 @@ module TimeBandits
 
       if GC.respond_to?(:heap_slots)
         def _get_heap_slots; GC.heap_slots; end
-      elsif GC.respond_to?(:stat) && RUBY_VERSION >= "2.2.0"
-        def _get_heap_slots; GC.stat(:heap_live_slots) + GC.stat(:heap_free_slots) + GC.stat(:heap_final_slots); end
-      elsif GC.respond_to?(:stat) && RUBY_VERSION >= "2.1.0"
-        def _get_heap_slots; GC.stat(:heap_live_slot) + GC.stat(:heap_free_slot) + GC.stat(:heap_final_slot); end
       else
-        def _get_heap_slots; 0; end
+        def _get_heap_slots; GC.stat(:heap_live_slots) + GC.stat(:heap_free_slots) + GC.stat(:heap_final_slots); end
       end
 
       if GC.respond_to?(:heap_slots_live_after_last_gc)
         def live_data_set_size; GC.heap_slots_live_after_last_gc; end
-      elsif GC.respond_to?(:stat) && RUBY_VERSION >= "2.2.0"
-        def live_data_set_size; GC.stat(:heap_live_slots); end
-      elsif GC.respond_to?(:stat) && RUBY_VERSION >= "2.1.0"
-        def live_data_set_size; GC.stat(:heap_live_slot); end
       else
-        def live_data_set_size; 0; end
+        def live_data_set_size; GC.stat(:heap_live_slots); end
       end
 
       def reset

data/lib/time_bandits/version.rb

@@ -1,3 +1,3 @@
 module TimeBandits
-  VERSION = "0.10.9"
+  VERSION = "0.12.0"
 end

data/test/test_helper.rb

@@ -1,5 +1,5 @@
 require 'minitest'
-require 'mocha/setup'
+require 'mocha/minitest'
 require 'minitest/pride'
 require 'minitest/autorun'
 
@@ -18,20 +18,15 @@ end
 require_relative '../lib/time_bandits'
 require "byebug"
 
-ActiveSupport::LogSubscriber.class_eval do
-  # need a logger, otherwise no data will be collected
-  def logger
-    @logger ||= ::Logger.new("/dev/null")
-  end
-end
+ActiveSupport::LogSubscriber.logger =::Logger.new("/dev/null")
 
 # fake Rails
 module Rails
   extend self
-  module VERSION
-    STRING = ActiveSupport::VERSION::STRING
-  end
   def cache
     @cache ||= ActiveSupport::Cache.lookup_store(:mem_cache_store)
   end
+  def env
+    "test"
+  end
 end

data/test/unit/database_test.rb

@@ -3,10 +3,17 @@ require 'active_record'
 require 'time_bandits/monkey_patches/active_record'
 
 class DatabaseTest < Test::Unit::TestCase
+
   def setup
     TimeBandits.time_bandits = []
     TimeBandits.add TimeBandits::TimeConsumers::Database
     TimeBandits.reset
+    @old_logger = ActiveRecord::Base.logger
+    ActiveRecord::Base.logger = Logger.new($stdout)
+  end
+
+  def teardown
+    ActiveRecord::Base.logger = @old_logger
   end
 
   test "getting metrics" do
@@ -37,6 +44,14 @@ class DatabaseTest < Test::Unit::TestCase
     assert_equal "ActiveRecord: 1.234ms(0q,0h)", TimeBandits.runtime
   end
 
+  test "sql can be executed" do
+    event = mock('event')
+    event.stubs(:payload).returns({name: "MURKS", sql: "SELECT 1"})
+    event.stubs(:duration).returns(0.1)
+    ActiveRecord::Base.logger.expects(:debug)
+    assert_nil log_subscriber.new.sql(event)
+  end
+
   private
 
   def bandit

data/test/unit/gc_consumer_test.rb

@@ -49,11 +49,10 @@ class GCConsumerTest < Test::Unit::TestCase
   def check_work
     GC.start
     m = TimeBandits.metrics
-    number_class = RUBY_VERSION >= "2.4.0" ? Integer : Fixnum
     if GC.respond_to?(:time)
       assert_operator 0, :<,  m[:gc_calls]
       assert_operator 0, :<,  m[:gc_time]
-      assert_instance_of number_class, m[:heap_growth]
+      assert_instance_of Integer, m[:heap_growth]
       assert_operator 0, :<,  m[:heap_size]
       assert_operator 0, :<,  m[:allocated_objects]
       assert_operator 0, :<,  m[:allocated_bytes]
@@ -61,7 +60,7 @@ class GCConsumerTest < Test::Unit::TestCase
     else
       assert_operator 0, :<,  m[:gc_calls]
       assert_operator 0, :<=, m[:gc_time]
-      assert_instance_of number_class, m[:heap_growth]
+      assert_instance_of Integer, m[:heap_growth]
       assert_operator 0, :<,  m[:heap_size]
       assert_operator 0, :<,  m[:allocated_objects]
       assert_operator 0, :<=, m[:allocated_bytes]