rack-mini-profiler 0.10.6 → 2.3.0

data/lib/mini_profiler/profiling_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   class MiniProfiler
     module ProfilingMethods
@@ -5,14 +7,21 @@ module Rack
       def record_sql(query, elapsed_ms, params = nil)
         return unless current && current.current_timer
         c = current
-        c.current_timer.add_sql(query, elapsed_ms, c.page_struct, params, c.skip_backtrace, c.full_backtrace)
+        c.current_timer.add_sql(
+          redact_sql_queries? ? nil : query,
+          elapsed_ms,
+          c.page_struct,
+          redact_sql_queries? ? nil : params,
+          c.skip_backtrace,
+          c.full_backtrace
+        )
       end
 
       def start_step(name)
         return unless current
         parent_timer          = current.current_timer
         current.current_timer = current_timer = current.current_timer.add_child(name)
-        [current_timer,parent_timer]
+        [current_timer, parent_timer]
       end
 
       def finish_step(obj)
@@ -61,7 +70,7 @@ module Rack
       end
 
       def profile_method(klass, method, type = :profile, &blk)
-        default_name = type==:counter ? method.to_s  : klass.to_s + " " + method.to_s
+        default_name = type == :counter ? method.to_s : klass.to_s + " " + method.to_s
         clean        = clean_method_name(method)
 
         with_profiling    = ("#{clean}_with_mini_profiler").intern
@@ -89,12 +98,12 @@ module Rack
           parent_timer = Rack::MiniProfiler.current.current_timer
 
           if type == :counter
-            start = Time.now
+            start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             begin
               self.send without_profiling, *args, &orig
             ensure
-              duration_ms = (Time.now - start).to_f * 1000
-              parent_timer.add_custom(name, duration_ms, Rack::MiniProfiler.current.page_struct )
+              duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start).to_f * 1000
+              parent_timer.add_custom(name, duration_ms, Rack::MiniProfiler.current.page_struct)
             end
           else
             Rack::MiniProfiler.current.current_timer = current_timer = parent_timer.add_child(name)
@@ -110,11 +119,11 @@ module Rack
       end
 
       def profile_singleton_method(klass, method, type = :profile, &blk)
-        profile_method(singleton_class(klass), method, type, &blk)
+        profile_method(klass.singleton_class, method, type, &blk)
       end
 
       def unprofile_singleton_method(klass, method)
-        unprofile_method(singleton_class(klass), method)
+        unprofile_method(klass.singleton_class, method)
       end
 
       # Add a custom timing. These are displayed similar to SQL/query time in
@@ -128,12 +137,12 @@ module Rack
       # and keeping a record of its run time.
       #
       # Returns the result of the block, or nil when no block is given.
-      def counter(type, duration_ms=nil)
+      def counter(type, duration_ms = nil)
         result = nil
         if block_given?
-          start       = Time.now
+          start       = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           result      = yield
-          duration_ms = (Time.now - start).to_f * 1000
+          duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start).to_f * 1000
         end
         return result if current.nil? || !request_authorized?
         current.current_timer.add_custom(type, duration_ms, current.page_struct)
@@ -142,10 +151,6 @@ module Rack
 
       private
 
-      def singleton_class(klass)
-        class << klass; self; end
-      end
-
       def clean_method_name(method)
         method.to_s.gsub(/[\?\!]/, "")
       end

data/lib/mini_profiler/snapshots_transporter.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+class ::Rack::MiniProfiler::SnapshotsTransporter
+  @@transported_snapshots_count = 0
+  @@successful_http_requests_count = 0
+  @@failed_http_requests_count = 0
+
+  class << self
+    def transported_snapshots_count
+      @@transported_snapshots_count
+    end
+    def successful_http_requests_count
+      @@successful_http_requests_count
+    end
+    def failed_http_requests_count
+      @@failed_http_requests_count
+    end
+
+    def transport(snapshot)
+      @transporter ||= self.new(Rack::MiniProfiler.config)
+      @transporter.ship(snapshot)
+    end
+  end
+
+  attr_reader :buffer
+  attr_accessor :max_buffer_size, :gzip_requests
+
+  def initialize(config)
+    @uri = URI(config.snapshots_transport_destination_url)
+    @auth_key = config.snapshots_transport_auth_key
+    @gzip_requests = config.snapshots_transport_gzip_requests
+    @thread = nil
+    @thread_mutex = Mutex.new
+    @buffer = []
+    @buffer_mutex = Mutex.new
+    @max_buffer_size = 100
+    @consecutive_failures_count = 0
+    @testing = false
+  end
+
+  def ship(snapshot)
+    @buffer_mutex.synchronize do
+      @buffer << snapshot
+      @buffer.shift if @buffer.size > @max_buffer_size
+    end
+    @thread_mutex.synchronize { start_thread }
+  end
+
+  def flush_buffer
+    buffer_content = @buffer_mutex.synchronize do
+      @buffer.dup if @buffer.size > 0
+    end
+    if buffer_content
+      headers = {
+        'Content-Type' => 'application/json',
+        'Mini-Profiler-Transport-Auth' => @auth_key
+      }
+      json = { snapshots: buffer_content }.to_json
+      body = if @gzip_requests
+        require 'zlib'
+        io = StringIO.new
+        gzip_writer = Zlib::GzipWriter.new(io)
+        gzip_writer.write(json)
+        gzip_writer.close
+        headers['Content-Encoding'] = 'gzip'
+        io.string
+      else
+        json
+      end
+      request = Net::HTTP::Post.new(@uri, headers)
+      request.body = body
+      http = Net::HTTP.new(@uri.hostname, @uri.port)
+      http.use_ssl = @uri.scheme == 'https'
+      res = http.request(request)
+      if res.code.to_i == 200
+        @@successful_http_requests_count += 1
+        @@transported_snapshots_count += buffer_content.size
+        @buffer_mutex.synchronize do
+          @buffer -= buffer_content
+        end
+        @consecutive_failures_count = 0
+      else
+        @@failed_http_requests_count += 1
+        @consecutive_failures_count += 1
+      end
+    end
+  end
+
+  def requests_interval
+    [30 + backoff_delay, 60 * 60].min
+  end
+
+  private
+
+  def backoff_delay
+    return 0 if @consecutive_failures_count == 0
+    2**@consecutive_failures_count
+  end
+
+  def start_thread
+    return if @thread&.alive? || @testing
+    @thread = Thread.new do
+      while true
+        sleep requests_interval
+        flush_buffer
+      end
+    end
+  end
+end

data/lib/mini_profiler/storage/abstract_store.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   class MiniProfiler
     class AbstractStore
@@ -39,6 +41,84 @@ module Rack
         raise NotImplementedError.new("allowed_tokens is not implemented")
       end
 
+      def should_take_snapshot?(period)
+        raise NotImplementedError.new("should_take_snapshot? is not implemented")
+      end
+
+      def push_snapshot(page_struct, config)
+        raise NotImplementedError.new("push_snapshot is not implemented")
+      end
+
+      def fetch_snapshots(batch_size: 200, &blk)
+        raise NotImplementedError.new("fetch_snapshots is not implemented")
+      end
+
+      def snapshot_groups_overview
+        groups = {}
+        fetch_snapshots do |batch|
+          batch.each do |snapshot|
+            group_name = default_snapshot_grouping(snapshot)
+            hash = groups[group_name] ||= {}
+            hash[:snapshots_count] ||= 0
+            hash[:snapshots_count] += 1
+            if !hash[:worst_score] || hash[:worst_score] < snapshot.duration_ms
+              groups[group_name][:worst_score] = snapshot.duration_ms
+            end
+            if !hash[:best_score] || hash[:best_score] > snapshot.duration_ms
+              groups[group_name][:best_score] = snapshot.duration_ms
+            end
+          end
+        end
+        groups = groups.to_a
+        groups.sort_by! { |name, hash| hash[:worst_score] }
+        groups.reverse!
+        groups.map! { |name, hash| hash.merge(name: name) }
+        groups
+      end
+
+      def find_snapshots_group(group_name)
+        data = []
+        fetch_snapshots do |batch|
+          batch.each do |snapshot|
+            snapshot_group_name = default_snapshot_grouping(snapshot)
+            if group_name == snapshot_group_name
+              data << {
+                id: snapshot[:id],
+                duration: snapshot.duration_ms,
+                sql_count: snapshot[:sql_count],
+                timestamp: snapshot[:started_at],
+                custom_fields: snapshot[:custom_fields]
+              }
+            end
+          end
+        end
+        data.sort_by! { |s| s[:duration] }
+        data.reverse!
+        data
+      end
+
+      def load_snapshot(id)
+        raise NotImplementedError.new("load_snapshot is not implemented")
+      end
+
+      private
+
+      def default_snapshot_grouping(snapshot)
+        group_name = rails_route_from_path(snapshot[:request_path], snapshot[:request_method])
+        group_name ||= snapshot[:request_path]
+        "#{snapshot[:request_method]} #{group_name}"
+      end
+
+      def rails_route_from_path(path, method)
+        if defined?(Rails) && defined?(ActionController::RoutingError)
+          hash = Rails.application.routes.recognize_path(path, method: method)
+          if hash && hash[:controller] && hash[:action]
+            "#{hash[:controller]}##{hash[:action]}"
+          end
+        end
+      rescue ActionController::RoutingError
+        nil
+      end
     end
   end
 end

data/lib/mini_profiler/storage/file_store.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   class MiniProfiler
     class FileStore < AbstractStore
@@ -14,25 +16,28 @@ module Rack
 
         def [](key)
           begin
-            data = ::File.open(path(key),"rb") {|f| f.read}
-            return Marshal.load data
-          rescue => e
-            return nil
+            data = ::File.open(path(key), "rb") { |f| f.read }
+            Marshal.load data
+          rescue
+            nil
           end
         end
 
-        def []=(key,val)
-          ::File.open(path(key), "wb+") {|f| f.write Marshal.dump(val)}
+        def []=(key, val)
+          ::File.open(path(key), "wb+") do |f|
+            f.sync = true
+            f.write Marshal.dump(val)
+          end
         end
 
         private
-        if RUBY_PLATFORM =~ /mswin(?!ce)|mingw|cygwin|bccwin/
+        if Gem.win_platform?
           def path(key)
-            @path + "/" + @prefix  + "_" + key.gsub(/:/, '_')
+            @path.dup << "/" << @prefix << "_" << key.gsub(/:/, '_')
           end
         else
           def path(key)
-            @path + "/" + @prefix  + "_" + key
+            @path.dup << "/" << @prefix << "_" << key
           end
         end
       end
@@ -139,10 +144,10 @@ module Rack
         @auth_token_lock.synchronize {
           token1, token2, cycle_at = @auth_token_cache[""]
 
-          unless cycle_at && (Time === cycle_at) && (cycle_at > Time.now)
+          unless cycle_at && (Float === cycle_at) && (cycle_at > Process.clock_gettime(Process::CLOCK_MONOTONIC))
             token2 = token1
             token1 = SecureRandom.hex
-            cycle_at = Time.now + Rack::MiniProfiler::AbstractStore::MAX_TOKEN_AGE
+            cycle_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) + Rack::MiniProfiler::AbstractStore::MAX_TOKEN_AGE
           end
 
           @auth_token_cache[""] = [token1, token2, cycle_at]
@@ -156,13 +161,13 @@ module Rack
         @timer_struct_lock.synchronize {
           files.each do |f|
             f = @path + '/' + f
-            ::File.delete f if ::File.basename(f) =~ /^mp_timers/ and (Time.now - ::File.mtime(f)) > @expires_in_seconds
+            ::File.delete f if ::File.basename(f) =~ (/^mp_timers/) && ((Time.now - ::File.mtime(f)) > @expires_in_seconds)
           end
         }
         @user_view_lock.synchronize {
           files.each do |f|
             f = @path + '/' + f
-            ::File.delete f if ::File.basename(f) =~ /^mp_views/ and (Time.now - ::File.mtime(f)) > @expires_in_seconds
+            ::File.delete f if ::File.basename(f) =~ (/^mp_views/) && ((Time.now - ::File.mtime(f)) > @expires_in_seconds)
           end
         }
       end

data/lib/mini_profiler/storage/memcache_store.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   class MiniProfiler
     class MemcacheStore < AbstractStore
@@ -8,8 +10,10 @@ module Rack
       def initialize(args = nil)
         require 'dalli' unless defined? Dalli
         args ||= {}
-        @prefix             = args[:prefix]     || "MPMemcacheStore"
-        @prefix             += "-#{Rack::MiniProfiler::VERSION}"
+
+        @prefix = args[:prefix] || "MPMemcacheStore"
+        @prefix += "-#{Rack::MiniProfiler::VERSION}"
+
         @client             = args[:client]     || Dalli::Client.new
         @expires_in_seconds = args[:expires_in] || EXPIRES_IN_SECONDS
       end
@@ -60,15 +64,14 @@ module Rack
         token_info = @client.get("#{@prefix}-tokens")
         key1, key2, cycle_at = nil
 
-
         if token_info
-           key1, key2, cycle_at = Marshal::load(token_info)
+          key1, key2, cycle_at = Marshal::load(token_info)
 
            key1 = nil unless key1 && key1.length == 32
            key2 = nil unless key2 && key2.length == 32
 
-           if key1 && cycle_at && (cycle_at > Time.now)
-              return [key1,key2].compact
+           if key1 && cycle_at && (cycle_at > Process.clock_gettime(Process::CLOCK_MONOTONIC))
+             return [key1, key2].compact
            end
         end
 
@@ -77,7 +80,7 @@ module Rack
         # cycle keys
         key2 = key1
         key1 = SecureRandom.hex
-        cycle_at = Time.now + timeout
+        cycle_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
 
         @client.set("#{@prefix}-tokens", Marshal::dump([key1, key2, cycle_at]))
 

data/lib/mini_profiler/storage/memory_store.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   class MiniProfiler
     class MemoryStore < AbstractStore
@@ -17,7 +19,6 @@ module Rack
           @cycle_count * @interval >= @cycle
         end
 
-
         # We don't want to hit the filesystem every 10s to clean up the cache so we need to do a bit of
         # accounting to avoid sleeping that entire time.  We don't want to sleep for the entire period because
         # it means the thread will stay live in hot deployment scenarios, keeping a potentially large memory
@@ -50,27 +51,31 @@ module Rack
         args ||= {}
         @expires_in_seconds = args.fetch(:expires_in) { EXPIRES_IN_SECONDS }
 
-        @token1, @token2, @cycle_tokens_at = nil
+        @token1, @token2, @cycle_at = nil
+        @snapshots_cycle = 0
+        @snapshots = []
 
         initialize_locks
         initialize_cleanup_thread(args)
       end
 
       def initialize_locks
-        @token_lock = Mutex.new
-        @timer_struct_lock  = Mutex.new
-        @user_view_lock     = Mutex.new
-        @timer_struct_cache = {}
-        @user_view_cache    = {}
+        @token_lock           = Mutex.new
+        @timer_struct_lock    = Mutex.new
+        @user_view_lock       = Mutex.new
+        @snapshots_cycle_lock = Mutex.new
+        @snapshots_lock       = Mutex.new
+        @timer_struct_cache   = {}
+        @user_view_cache      = {}
       end
 
       #FIXME: use weak ref, trouble it may be broken in 1.9 so need to use the 'ref' gem
-      def initialize_cleanup_thread(args={})
+      def initialize_cleanup_thread(args = {})
         cleanup_interval = args.fetch(:cleanup_interval) { CLEANUP_INTERVAL }
         cleanup_cycle    = args.fetch(:cleanup_cycle)    { CLEANUP_CYCLE }
-        t = CacheCleanupThread.new(cleanup_interval, cleanup_cycle, self) do |t|
+        t = CacheCleanupThread.new(cleanup_interval, cleanup_cycle, self) do
           until Thread.current[:should_exit] do
-            self.sleepy_run
+            t.sleepy_run
           end
         end
         at_exit { t[:should_exit] = true }
@@ -115,7 +120,7 @@ module Rack
       end
 
       def cleanup_cache
-        expire_older_than = ((Time.now.to_f - @expires_in_seconds) * 1000).to_i
+        expire_older_than = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - @expires_in_seconds) * 1000).to_i
         @timer_struct_lock.synchronize {
           @timer_struct_cache.delete_if { |k, v| v[:started] < expire_older_than }
         }
@@ -124,16 +129,61 @@ module Rack
       def allowed_tokens
         @token_lock.synchronize do
 
-          unless @cycle_at && (@cycle_at > Time.now)
+          unless @cycle_at && (@cycle_at > Process.clock_gettime(Process::CLOCK_MONOTONIC))
             @token2 = @token1
             @token1 = SecureRandom.hex
-            @cycle_at = Time.now + Rack::MiniProfiler::AbstractStore::MAX_TOKEN_AGE
+            @cycle_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) + Rack::MiniProfiler::AbstractStore::MAX_TOKEN_AGE
           end
 
           [@token1, @token2].compact
 
         end
       end
+
+      def should_take_snapshot?(period)
+        @snapshots_cycle_lock.synchronize do
+          @snapshots_cycle += 1
+          if @snapshots_cycle % period == 0
+            @snapshots_cycle = 0
+            true
+          else
+            false
+          end
+        end
+      end
+
+      def push_snapshot(page_struct, config)
+        @snapshots_lock.synchronize do
+          @snapshots << page_struct
+          @snapshots.sort_by! { |s| s.duration_ms }
+          @snapshots.reverse!
+          if @snapshots.size > config.snapshots_limit
+            @snapshots.slice!(-1)
+          end
+        end
+      end
+
+      def fetch_snapshots(batch_size: 200, &blk)
+        @snapshots_lock.synchronize do
+          @snapshots.each_slice(batch_size) do |batch|
+            blk.call(batch)
+          end
+        end
+      end
+
+      def load_snapshot(id)
+        @snapshots_lock.synchronize do
+          @snapshots.find { |s| s[:id] == id }
+        end
+      end
+
+      private
+
+      # used in tests only
+      def wipe_snapshots_data
+        @snapshots_cycle = 0
+        @snapshots = []
+      end
     end
   end
 end