rack-mini-profiler 1.0.0 → 1.0.1

data/lib/mini_profiler/timer_struct/base.rb

@@ -6,7 +6,7 @@ module Rack
       # A base class for timing structures
       class Base
 
-        def initialize(attrs={})
+        def initialize(attrs = {})
           @attributes = attrs
         end
 
@@ -26,7 +26,7 @@ module Rack
         def to_json(*a)
           # this does could take in an option hash, but the only interesting there is max_nesting.
           #   if this becomes an option we could increase
-          ::JSON.generate( @attributes, :max_nesting => 100 )
+          ::JSON.generate(@attributes, max_nesting: 100)
         end
 
         def as_json(options = nil)

data/lib/mini_profiler/timer_struct/client.rb

@@ -24,8 +24,7 @@ module Rack
           wrapped
         end
 
-
-        def initialize(env={})
+        def initialize(env = {})
           super
         end
 
@@ -62,21 +61,21 @@ module Rack
           end
 
           translated.each do |name, data|
-            h = {"Name" => name, "Start" => data[:start].to_i - baseTime}
+            h = { "Name" => name, "Start" => data[:start].to_i - baseTime }
             h["Duration"] = data[:finish].to_i - data[:start].to_i if data[:finish]
             timings.push(h)
           end
 
-          clientTimes.keys.find_all{|k| k =~ /Start$/ }.each do |k|
+          clientTimes.keys.find_all { |k| k =~ /Start$/ }.each do |k|
             start    = clientTimes[k].to_i - baseTime
             finish   = clientTimes[k.sub(/Start$/, "End")].to_i - baseTime
             duration = 0
             duration = finish - start if finish > start
-            name     = k.sub(/Start$/, "").split(/(?=[A-Z])/).map{|s| s.capitalize}.join(' ')
-            timings.push({"Name" => name, "Start" => start, "Duration" => duration}) if start >= 0
+            name     = k.sub(/Start$/, "").split(/(?=[A-Z])/).map { |s| s.capitalize }.join(' ')
+            timings.push("Name" => name, "Start" => start, "Duration" => duration) if start >= 0
           end
 
-          clientTimes.keys.find_all{|k| !(k =~ /(End|Start)$/)}.each do |k|
+          clientTimes.keys.find_all { |k| !(k =~ /(End|Start)$/) }.each do |k|
             timings.push("Name" => k, "Start" => clientTimes[k].to_i - baseTime, "Duration" => -1)
           end
 

data/lib/mini_profiler/timer_struct/custom.rb

@@ -12,10 +12,10 @@ module Rack
           @type        = type
           start_millis = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i - page[:started]) - duration_ms
           super(
-            :type                  => type,
-            :start_milliseconds    => start_millis,
-            :duration_milliseconds => duration_ms,
-            :parent_timing_id      => nil
+            type: type,
+            start_milliseconds: start_millis,
+            duration_milliseconds: duration_ms,
+            parent_timing_id: nil
           )
         end
       end

data/lib/mini_profiler/timer_struct/page.rb

@@ -17,28 +17,29 @@ module Rack
           started      = (Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i
           machine_name = env['SERVER_NAME']
           super(
-            :id                                      => timer_id,
-            :name                                    => page_name,
-            :started                                 => started,
-            :started_at                              => started_at,
-            :machine_name                            => machine_name,
-            :level                                   => 0,
-            :user                                    => "unknown user",
-            :has_user_viewed                         => false,
-            :client_timings                          => nil,
-            :duration_milliseconds                   => 0,
-            :has_trivial_timings                     => true,
-            :has_all_trivial_timings                 => false,
-            :trivial_duration_threshold_milliseconds => 2,
-            :head                                    => nil,
-            :duration_milliseconds_in_sql            => 0,
-            :has_sql_timings                         => true,
-            :has_duplicate_sql_timings               => false,
-            :executed_readers                        => 0,
-            :executed_scalars                        => 0,
-            :executed_non_queries                    => 0,
-            :custom_timing_names                     => [],
-            :custom_timing_stats                     => {}
+            id: timer_id,
+            name: page_name,
+            started: started,
+            started_at: started_at,
+            machine_name: machine_name,
+            level: 0,
+            user: "unknown user",
+            has_user_viewed: false,
+            client_timings: nil,
+            duration_milliseconds: 0,
+            has_trivial_timings: true,
+            has_all_trivial_timings: false,
+            trivial_duration_threshold_milliseconds: 2,
+            head: nil,
+            sql_count: 0,
+            duration_milliseconds_in_sql: 0,
+            has_sql_timings: true,
+            has_duplicate_sql_timings: false,
+            executed_readers: 0,
+            executed_scalars: 0,
+            executed_non_queries: 0,
+            custom_timing_names: [],
+            custom_timing_stats: {}
           )
           name = "#{env['REQUEST_METHOD']} http://#{env['SERVER_NAME']}:#{env['SERVER_PORT']}#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
           self[:root] = TimerStruct::Request.createRoot(name, self)
@@ -70,9 +71,9 @@ module Rack
 
         def extra_json
           {
-            :started               => '/Date(%d)/' % @attributes.delete(:started_at),
-            :duration_milliseconds => @attributes[:root][:duration_milliseconds],
-            :custom_timing_names   => @attributes[:custom_timing_stats].keys.sort
+            started: '/Date(%d)/' % @attributes[:started_at],
+            duration_milliseconds: @attributes[:root][:duration_milliseconds],
+            custom_timing_names: @attributes[:custom_timing_stats].keys.sort
           }
         end
       end

data/lib/mini_profiler/timer_struct/request.rb

@@ -17,28 +17,28 @@ module Rack
           start_millis = (Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i - page[:started]
           depth        = parent ? parent.depth + 1 : 0
           super(
-            :id                                      => MiniProfiler.generate_id,
-            :name                                    => name,
-            :duration_milliseconds                   => 0,
-            :duration_without_children_milliseconds  => 0,
-            :start_milliseconds                      => start_millis,
-            :parent_timing_id                        => nil,
-            :children                                => [],
-            :has_children                            => false,
-            :key_values                              => nil,
-            :has_sql_timings                         => false,
-            :has_duplicate_sql_timings               => false,
-            :trivial_duration_threshold_milliseconds => 2,
-            :sql_timings                             => [],
-            :sql_timings_duration_milliseconds       => 0,
-            :is_trivial                              => false,
-            :is_root                                 => false,
-            :depth                                   => depth,
-            :executed_readers                        => 0,
-            :executed_scalars                        => 0,
-            :executed_non_queries                    => 0,
-            :custom_timing_stats                     => {},
-            :custom_timings                          => {}
+            id: MiniProfiler.generate_id,
+            name: name,
+            duration_milliseconds: 0,
+            duration_without_children_milliseconds: 0,
+            start_milliseconds: start_millis,
+            parent_timing_id: nil,
+            children: [],
+            has_children: false,
+            key_values: nil,
+            has_sql_timings: false,
+            has_duplicate_sql_timings: false,
+            trivial_duration_threshold_milliseconds: 2,
+            sql_timings: [],
+            sql_timings_duration_milliseconds: 0,
+            is_trivial: false,
+            is_root: false,
+            depth: depth,
+            executed_readers: 0,
+            executed_scalars: 0,
+            executed_non_queries: 0,
+            custom_timing_stats: {},
+            custom_timings: {}
           )
           @children_duration = 0
           @start             = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -98,6 +98,7 @@ module Rack
             self[:has_sql_timings]   = true
             self[:sql_timings_duration_milliseconds] += elapsed_ms
             page[:duration_milliseconds_in_sql]      += elapsed_ms
+            page[:sql_count] += 1
           end
         end
 
@@ -108,11 +109,11 @@ module Rack
             self[:custom_timings][type] ||= []
             self[:custom_timings][type].push(timer)
 
-            self[:custom_timing_stats][type] ||= {:count => 0, :duration => 0.0}
+            self[:custom_timing_stats][type] ||= { count: 0, duration: 0.0 }
             self[:custom_timing_stats][type][:count]    += 1
             self[:custom_timing_stats][type][:duration] += elapsed_ms
 
-            page[:custom_timing_stats][type] ||= {:count => 0, :duration => 0.0}
+            page[:custom_timing_stats][type] ||= { count: 0, duration: 0.0 }
             page[:custom_timing_stats][type][:count]    += 1
             page[:custom_timing_stats][type][:duration] += elapsed_ms
           end

data/lib/mini_profiler/timer_struct/sql.rb

@@ -12,18 +12,18 @@ module Rack
           unless skip_backtrace || duration_ms < Rack::MiniProfiler.config.backtrace_threshold_ms
             # Allow us to filter the stack trace
             stack_trace = "".dup
-             # Clean up the stack trace if there are options to do so
+            # Clean up the stack trace if there are options to do so
             Kernel.caller.each do |ln|
-              ln.gsub!(Rack::MiniProfiler.config.backtrace_remove, '') if Rack::MiniProfiler.config.backtrace_remove and !full_backtrace
-              if    full_backtrace or
+              ln.gsub!(Rack::MiniProfiler.config.backtrace_remove, '') if Rack::MiniProfiler.config.backtrace_remove && !full_backtrace
+              if    full_backtrace ||
                     (
                       (
-                        Rack::MiniProfiler.config.backtrace_includes.nil? or
-                        Rack::MiniProfiler.config.backtrace_includes.any?{|regex| ln =~ regex}
-                      ) and
+                        Rack::MiniProfiler.config.backtrace_includes.nil? ||
+                        Rack::MiniProfiler.config.backtrace_includes.any? { |regex| ln =~ regex }
+                      ) &&
                       (
-                        Rack::MiniProfiler.config.backtrace_ignores.nil? or
-                        Rack::MiniProfiler.config.backtrace_ignores.none?{|regex| ln =~ regex}
+                        Rack::MiniProfiler.config.backtrace_ignores.nil? ||
+                        Rack::MiniProfiler.config.backtrace_ignores.none? { |regex| ln =~ regex }
                       )
                     )
                 stack_trace << ln << "\n"
@@ -35,15 +35,15 @@ module Rack
           @page        = page
           start_millis = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i - page[:started]) - duration_ms
           super(
-            :execute_type                      => 3, # TODO
-            :formatted_command_string          => query,
-            :stack_trace_snippet               => stack_trace,
-            :start_milliseconds                => start_millis,
-            :duration_milliseconds             => duration_ms,
-            :first_fetch_duration_milliseconds => duration_ms,
-            :parameters                        => trim_binds(params),
-            :parent_timing_id                  => nil,
-            :is_duplicate                      => false
+            execute_type: 3, # TODO
+            formatted_command_string: query,
+            stack_trace_snippet: stack_trace,
+            start_milliseconds: start_millis,
+            duration_milliseconds: duration_ms,
+            first_fetch_duration_milliseconds: duration_ms,
+            parameters: trim_binds(params),
+            parent_timing_id: nil,
+            is_duplicate: false
           )
         end
 
@@ -58,18 +58,18 @@ module Rack
         def trim_binds(binds)
           max_len = Rack::MiniProfiler.config.max_sql_param_length
           return if binds.nil? || max_len == 0
-          return binds.map{|(name, val)| [name, val]} if max_len.nil?
+          return binds.map { |(name, val)| [name, val] } if max_len.nil?
           binds.map do |(name, val)|
             val ||= name
             if val.nil? || val == true || val == false || val.kind_of?(Numeric)
               # keep these parameters as is
             elsif val.kind_of?(String)
-              val = val[0...max_len]+(max_len < val.length ? '...' : '') if max_len
+              val = val[0...max_len] + (max_len < val.length ? '...' : '') if max_len
             else
               val = val.class.name
             end
             if name.kind_of?(String)
-              name = name[0...max_len]+(max_len < name.length ? '...' : '') if max_len
+              name = name[0...max_len] + (max_len < name.length ? '...' : '') if max_len
             end
             [name, val]
           end

data/lib/mini_profiler/version.rb

@@ -2,6 +2,6 @@
 
 module Rack
   class MiniProfiler
-    VERSION = '1.0.0'
+    VERSION = '1.0.1'
   end
 end

data/lib/mini_profiler_rails/railtie.rb

@@ -44,7 +44,7 @@ module Rack::MiniProfilerRails
       base_path = Rails.application.config.paths['tmp'].first rescue "#{Rails.root}/tmp"
       tmp       = base_path + '/miniprofiler'
 
-      c.storage_options = {:path => tmp}
+      c.storage_options = { path: tmp }
       c.storage = Rack::MiniProfiler::FileStore
     end
 
@@ -58,10 +58,10 @@ module Rack::MiniProfilerRails
 
     # Attach to various Rails methods
     ActiveSupport.on_load(:action_controller) do
-      ::Rack::MiniProfiler.profile_method(ActionController::Base, :process) {|action| "Executing action: #{action}"}
+      ::Rack::MiniProfiler.profile_method(ActionController::Base, :process) { |action| "Executing action: #{action}" }
     end
     ActiveSupport.on_load(:action_view) do
-      ::Rack::MiniProfiler.profile_method(ActionView::Template, :render) {|x,y| "Rendering: #{@virtual_path}"}
+      ::Rack::MiniProfiler.profile_method(ActionView::Template, :render) { |x, y| "Rendering: #{@virtual_path}" }
     end
 
     @already_initialized = true

data/lib/patches/db/activerecord.rb

@@ -20,7 +20,7 @@ module Rack
         # map ActiveRecord::Relation::QueryAttribute to [name, value]
         params = binds.map { |c| c.kind_of?(Array) ? [c.first, c.last] : [c.name, c.value] }
         if (skip = Rack::MiniProfiler.config.skip_sql_param_names)
-          params.map { |(n,v)| n =~ skip ? [n, nil] : [n, v] }
+          params.map { |(n, v)| n =~ skip ? [n, nil] : [n, v] }
         else
           params
         end
@@ -34,7 +34,7 @@ module Rack
         rval             = log_without_miniprofiler(*args, &block)
 
         # Don't log schema queries if the option is set
-        return rval if Rack::MiniProfiler.config.skip_schema_queries and name =~ /SCHEMA/
+        return rval if Rack::MiniProfiler.config.skip_schema_queries && name =~ (/SCHEMA/)
 
         elapsed_time = SqlPatches.elapsed_time(start)
         Rack::MiniProfiler.record_sql(sql, elapsed_time, binds_to_params(binds))

data/lib/patches/db/moped.rb

@@ -3,8 +3,8 @@
 # Mongoid 3 patches
 class Moped::Node
   alias_method :process_without_profiling, :process
-  def process(*args,&blk)
-    return process_without_profiling(*args,&blk) unless SqlPatches.should_measure?
+  def process(*args, &blk)
+    return process_without_profiling(*args, &blk) unless SqlPatches.should_measure?
 
     result, _record = SqlPatches.record_sql(args[0].log_inspect) do
       process_without_profiling(*args, &blk)

data/lib/patches/db/mysql2.rb

@@ -8,7 +8,7 @@ class Mysql2::Result
     return each_without_profiling(*args, &blk) unless defined?(@miniprofiler_sql_id)
 
     start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    result       = each_without_profiling(*args,&blk)
+    result       = each_without_profiling(*args, &blk)
     elapsed_time = SqlPatches.elapsed_time(start)
 
     @miniprofiler_sql_id.report_reader_duration(elapsed_time)
@@ -18,11 +18,11 @@ end
 
 class Mysql2::Client
   alias_method :query_without_profiling, :query
-  def query(*args,&blk)
-    return query_without_profiling(*args,&blk) unless SqlPatches.should_measure?
+  def query(*args, &blk)
+    return query_without_profiling(*args, &blk) unless SqlPatches.should_measure?
 
-    result, record = SqlPatches.record_sql( args[0] ) do
-      query_without_profiling(*args,&blk)
+    result, record = SqlPatches.record_sql(args[0]) do
+      query_without_profiling(*args, &blk)
     end
     result.instance_variable_set("@miniprofiler_sql_id", record) if result
     result

data/lib/patches/db/nobrainer.rb

@@ -17,7 +17,7 @@ class Rack::MiniProfiler::NoBrainerProfiler
       # query << "(#{NoBrainer::RQL.type_of(env[:query]).to_s}) "
 
       query << "NOT USING INDEX: " if not_indexed
-      query << env[:query].inspect.gsub(/\n/, '').gsub(/ +/, ' ') + " "
+      query << env[:query].inspect.delete("\n").gsub(/ +/, ' ') + " "
 
       if env[:exception]
         query << "exception: #{env[:exception].class} #{env[:exception].message.split("\n").first} "

data/lib/patches/db/pg.rb

@@ -8,7 +8,7 @@ class PG::Result
   def values(*args, &blk)
     return values_without_profiling(*args, &blk) unless defined?(@miniprofiler_sql_id)
     mp_report_sql do
-      values_without_profiling(*args ,&blk)
+      values_without_profiling(*args , &blk)
     end
   end
 
@@ -35,7 +35,11 @@ class PG::Connection
   alias_method :send_query_prepared_without_profiling, :send_query_prepared
   alias_method :prepare_without_profiling, :prepare
 
-  def prepare(*args,&blk)
+  if Gem::Version.new(PG::VERSION) >= Gem::Version.new("1.1.0")
+    alias_method :exec_params_without_profiling, :exec_params
+  end
+
+  def prepare(*args, &blk)
     # we have no choice but to do this here,
     # if we do the check for profiling first, our cache may miss critical stuff
 
@@ -44,15 +48,15 @@ class PG::Connection
     # dont leak more than 10k ever
     @prepare_map = {} if @prepare_map.length > 1000
 
-    return prepare_without_profiling(*args,&blk) unless SqlPatches.should_measure?
-    prepare_without_profiling(*args,&blk)
+    return prepare_without_profiling(*args, &blk) unless SqlPatches.should_measure?
+    prepare_without_profiling(*args, &blk)
   end
 
-  def exec(*args,&blk)
-    return exec_without_profiling(*args,&blk) unless SqlPatches.should_measure?
+  def exec(*args, &blk)
+    return exec_without_profiling(*args, &blk) unless SqlPatches.should_measure?
 
     start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    result       = exec_without_profiling(*args,&blk)
+    result       = exec_without_profiling(*args, &blk)
     elapsed_time = SqlPatches.elapsed_time(start)
     record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
     result.instance_variable_set("@miniprofiler_sql_id", record) if result
@@ -60,11 +64,25 @@ class PG::Connection
     result
   end
 
-  def exec_prepared(*args,&blk)
-    return exec_prepared_without_profiling(*args,&blk) unless SqlPatches.should_measure?
+  if Gem::Version.new(PG::VERSION) >= Gem::Version.new("1.1.0")
+    def exec_params(*args, &blk)
+      return exec_params_without_profiling(*args, &blk) unless SqlPatches.should_measure?
+
+      start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result       = exec_params_without_profiling(*args, &blk)
+      elapsed_time = SqlPatches.elapsed_time(start)
+      record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
+      result.instance_variable_set("@miniprofiler_sql_id", record) if result
+
+      result
+    end
+  end
+
+  def exec_prepared(*args, &blk)
+    return exec_prepared_without_profiling(*args, &blk) unless SqlPatches.should_measure?
 
     start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    result       = exec_prepared_without_profiling(*args,&blk)
+    result       = exec_prepared_without_profiling(*args, &blk)
     elapsed_time = SqlPatches.elapsed_time(start)
     mapped       = args[0]
     mapped       = @prepare_map[mapped] || args[0] if @prepare_map
@@ -74,11 +92,11 @@ class PG::Connection
     result
   end
 
-  def send_query_prepared(*args,&blk)
-    return send_query_prepared_without_profiling(*args,&blk) unless SqlPatches.should_measure?
+  def send_query_prepared(*args, &blk)
+    return send_query_prepared_without_profiling(*args, &blk) unless SqlPatches.should_measure?
 
     start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    result       = send_query_prepared_without_profiling(*args,&blk)
+    result       = send_query_prepared_without_profiling(*args, &blk)
     elapsed_time = SqlPatches.elapsed_time(start)
     mapped       = args[0]
     mapped       = @prepare_map[mapped] || args[0] if @prepare_map
@@ -88,11 +106,11 @@ class PG::Connection
     result
   end
 
-  def async_exec(*args,&blk)
-    return async_exec_without_profiling(*args,&blk) unless SqlPatches.should_measure?
+  def async_exec(*args, &blk)
+    return async_exec_without_profiling(*args, &blk) unless SqlPatches.should_measure?
 
     start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    result       = exec_without_profiling(*args,&blk)
+    result       = exec_without_profiling(*args, &blk)
     elapsed_time = SqlPatches.elapsed_time(start)
     record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
     result.instance_variable_set("@miniprofiler_sql_id", record) if result