piko-sharp-kit 0.0.1

data/rack-mini-profiler-4.0.1/lib/mini_profiler/profiling_methods.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Rack
+  class MiniProfiler
+    module ProfilingMethods
+
+      def record_sql(query, elapsed_ms, params = nil, cached = nil)
+        return unless current && current.current_timer
+        c = current
+        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,
+          cached
+        )
+      end
+
+      def report_reader_duration(elapsed_ms, row_count = nil, class_name = nil)
+        current&.current_timer&.report_reader_duration(elapsed_ms, row_count, class_name)
+      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]
+      end
+
+      def finish_step(obj)
+        return unless obj && current
+        current_timer, parent_timer = obj
+        current_timer.record_time
+        current.current_timer = parent_timer
+      end
+
+      # perform a profiling step on given block
+      def step(name, opts = nil)
+        if current
+          parent_timer          = current.current_timer
+          current.current_timer = current_timer = current.current_timer.add_child(name)
+          begin
+            yield if block_given?
+          ensure
+            current_timer.record_time
+            current.current_timer = parent_timer
+          end
+        else
+          yield if block_given?
+        end
+      end
+
+      def unprofile_method(klass, method)
+
+        clean = clean_method_name(method)
+
+        with_profiling = ("#{clean}_with_mini_profiler").intern
+        without_profiling = ("#{clean}_without_mini_profiler").intern
+
+        if klass.send :method_defined?, with_profiling
+          klass.send :alias_method, method, without_profiling
+          klass.send :remove_method, with_profiling
+          klass.send :remove_method, without_profiling
+        end
+      end
+
+      def counter_method(klass, method, &blk)
+        self.profile_method(klass, method, :counter, &blk)
+      end
+
+      def uncounter_method(klass, method)
+        self.unprofile_method(klass, method)
+      end
+
+      def profile_method(klass, method, type = :profile, &blk)
+        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
+        without_profiling = ("#{clean}_without_mini_profiler").intern
+
+        if klass.send :method_defined?, with_profiling
+          return # dont double profile
+        end
+
+        klass.send :alias_method, without_profiling, method
+        klass.send :define_method, with_profiling do |*args, &orig|
+          return self.send without_profiling, *args, &orig unless Rack::MiniProfiler.current
+
+          name = default_name
+          if blk
+            name =
+              if respond_to?(:instance_exec)
+                instance_exec(*args, &blk)
+              else
+                # deprecated in Rails 4.x
+                blk.bind(self).call(*args)
+              end
+          end
+
+          parent_timer = Rack::MiniProfiler.current.current_timer
+
+          if type == :counter
+            start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            begin
+              self.send without_profiling, *args, &orig
+            ensure
+              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)
+            begin
+              self.send without_profiling, *args, &orig
+            ensure
+              current_timer.record_time
+              Rack::MiniProfiler.current.current_timer = parent_timer
+            end
+          end
+        end
+        if klass.respond_to?(:ruby2_keywords, true)
+          klass.send(:ruby2_keywords, with_profiling)
+        end
+        klass.send :alias_method, method, with_profiling
+      end
+
+      def profile_singleton_method(klass, method, type = :profile, &blk)
+        profile_method(klass.singleton_class, method, type, &blk)
+      end
+
+      def unprofile_singleton_method(klass, method)
+        unprofile_method(klass.singleton_class, method)
+      end
+
+      # Add a custom timing. These are displayed similar to SQL/query time in
+      # columns expanding to the right.
+      #
+      # type        - String counter type. Each distinct type gets its own column.
+      # duration_ms - Duration of the call in ms. Either this or a block must be
+      #               given but not both.
+      #
+      # When a block is given, calculate the duration by yielding to the block
+      # 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)
+        result = nil
+        if block_given?
+          start       = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          result      = yield
+          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)
+        result
+      end
+
+      private
+
+      def clean_method_name(method)
+        method.to_s.gsub(/[\?\!]/, "")
+      end
+    end
+  end
+end

data/rack-mini-profiler-4.0.1/lib/mini_profiler/snapshots_transporter.rb

@@ -0,0 +1,111 @@
+# 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/rack-mini-profiler-4.0.1/lib/mini_profiler/storage/abstract_store.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Rack
+  class MiniProfiler
+    class AbstractStore
+
+      # maximum age of allowed tokens before cycling in seconds
+      MAX_TOKEN_AGE = 1800
+
+      def save(page_struct)
+        raise NotImplementedError.new("save is not implemented")
+      end
+
+      def load(id)
+        raise NotImplementedError.new("load is not implemented")
+      end
+
+      def set_unviewed(user, id)
+        raise NotImplementedError.new("set_unviewed is not implemented")
+      end
+
+      def set_viewed(user, id)
+        raise NotImplementedError.new("set_viewed is not implemented")
+      end
+
+      def set_all_unviewed(user, ids)
+        raise NotImplementedError.new("set_all_unviewed is not implemented")
+      end
+
+      def get_unviewed_ids(user)
+        raise NotImplementedError.new("get_unviewed_ids is not implemented")
+      end
+
+      def diagnostics(user)
+        # this is opt in, no need to explode if not implemented
+        ""
+      end
+
+      # a list of tokens that are permitted to access profiler in explicit mode
+      def allowed_tokens
+        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, group_name, config)
+        raise NotImplementedError.new("push_snapshot is not implemented")
+      end
+
+      # returns a hash where the keys are group names and the values
+      # are hashes that contain 3 keys:
+      #   1. `:worst_score` => the duration of the worst/slowest snapshot in the group (float)
+      #   2. `:best_score` => the duration of the best/fastest snapshot in the group (float)
+      #   3. `:snapshots_count` => the number of snapshots in the group (integer)
+      def fetch_snapshots_overview
+        raise NotImplementedError.new("fetch_snapshots_overview is not implemented")
+      end
+
+      # @param group_name [String]
+      # @return [Array<Rack::MiniProfiler::TimerStruct::Page>] list of snapshots of the group. Blank array if the group doesn't exist.
+      def fetch_snapshots_group(group_name)
+        raise NotImplementedError.new("fetch_snapshots_group is not implemented")
+      end
+
+      def load_snapshot(id, group_name)
+        raise NotImplementedError.new("load_snapshot is not implemented")
+      end
+
+      def snapshots_overview
+        groups = fetch_snapshots_overview.to_a
+        groups.sort_by! { |name, hash| hash[:worst_score] }
+        groups.reverse!
+        groups.map! { |name, hash| hash.merge(name: name) }
+        groups
+      end
+
+      def snapshots_group(group_name)
+        snapshots = fetch_snapshots_group(group_name)
+        data = []
+        snapshots.each do |snapshot|
+          data << {
+            id: snapshot[:id],
+            duration: snapshot.duration_ms,
+            sql_count: snapshot[:sql_count],
+            timestamp: snapshot[:started_at],
+            custom_fields: snapshot[:custom_fields]
+          }
+        end
+        data.sort_by! { |s| s[:duration] }
+        data.reverse!
+        data
+      end
+    end
+  end
+end

data/rack-mini-profiler-4.0.1/lib/mini_profiler/storage/file_store.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Rack
+  class MiniProfiler
+    class FileStore < AbstractStore
+
+      # Sub-class thread so we have a named thread (useful for debugging in Thread.list).
+      class CacheCleanupThread < Thread
+      end
+
+      class FileCache
+        def initialize(path, prefix)
+          @path = path
+          @prefix = prefix
+        end
+
+        def [](key)
+          begin
+            data = ::File.open(path(key), "rb") { |f| f.read }
+            # rubocop:disable Security/MarshalLoad
+            Marshal.load data
+            # rubocop:enable Security/MarshalLoad
+          rescue
+            nil
+          end
+        end
+
+        def []=(key, val)
+          ::File.open(path(key), "wb+") do |f|
+            f.sync = true
+            f.write Marshal.dump(val)
+          end
+        end
+
+        private
+        if Gem.win_platform?
+          def path(key)
+            @path.dup << "/" << @prefix << "_" << key.gsub(/:/, '_')
+          end
+        else
+          def path(key)
+            @path.dup << "/" << @prefix << "_" << key
+          end
+        end
+      end
+
+      EXPIRES_IN_SECONDS = 60 * 60 * 24
+
+      def initialize(args = nil)
+        args ||= {}
+        @path = args[:path]
+        @expires_in_seconds = args[:expires_in] || EXPIRES_IN_SECONDS
+        raise ArgumentError.new :path unless @path
+        FileUtils.mkdir_p(@path) unless ::File.exist?(@path)
+
+        @timer_struct_cache = FileCache.new(@path, "mp_timers")
+        @timer_struct_lock  = Mutex.new
+        @user_view_cache    = FileCache.new(@path, "mp_views")
+        @user_view_lock     = Mutex.new
+
+        @auth_token_cache    = FileCache.new(@path, "tokens")
+        @auth_token_lock     = Mutex.new
+
+        me = self
+        t = CacheCleanupThread.new do
+          interval = 10
+          cleanup_cache_cycle = 3600
+          cycle_count = 1
+
+          begin
+            until Thread.current[:should_exit] do
+              # TODO: a sane retry count before bailing
+
+              # 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
+              # graph from being garbage collected upon undeploy.
+              if cycle_count * interval >= cleanup_cache_cycle
+                cycle_count = 1
+                me.cleanup_cache
+              end
+
+              sleep(interval)
+              cycle_count += 1
+            end
+          rescue
+            # don't crash the thread, we can clean up next time
+          end
+        end
+
+        at_exit { t[:should_exit] = true }
+      end
+
+      def save(page_struct)
+        @timer_struct_lock.synchronize {
+          @timer_struct_cache[page_struct[:id]] = page_struct
+        }
+      end
+
+      def load(id)
+        @timer_struct_lock.synchronize {
+          @timer_struct_cache[id]
+        }
+      end
+
+      def set_unviewed(user, id)
+        @user_view_lock.synchronize {
+          current = @user_view_cache[user]
+          current = [] unless Array === current
+          current << id
+          @user_view_cache[user] = current.uniq
+        }
+      end
+
+      def set_viewed(user, id)
+        @user_view_lock.synchronize {
+          @user_view_cache[user] ||= []
+          current = @user_view_cache[user]
+          current = [] unless Array === current
+          current.delete(id)
+          @user_view_cache[user] = current.uniq
+        }
+      end
+
+      def set_all_unviewed(user, ids)
+        @user_view_lock.synchronize {
+          @user_view_cache[user] = ids.uniq
+        }
+      end
+
+      def get_unviewed_ids(user)
+        @user_view_lock.synchronize {
+          @user_view_cache[user]
+        }
+      end
+
+      def flush_tokens
+        @auth_token_lock.synchronize {
+          @auth_token_cache[""] = nil
+        }
+      end
+
+      def allowed_tokens
+        @auth_token_lock.synchronize {
+          token1, token2, cycle_at = @auth_token_cache[""]
+
+          unless cycle_at && (Float === cycle_at) && (cycle_at > Process.clock_gettime(Process::CLOCK_MONOTONIC))
+            token2 = token1
+            token1 = SecureRandom.hex
+            cycle_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) + Rack::MiniProfiler::AbstractStore::MAX_TOKEN_AGE
+          end
+
+          @auth_token_cache[""] = [token1, token2, cycle_at]
+
+          [token1, token2].compact
+        }
+      end
+
+      def cleanup_cache
+        files = Dir.entries(@path)
+        @timer_struct_lock.synchronize {
+          files.each do |f|
+            f = @path + '/' + f
+            ::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/) && ((Time.now - ::File.mtime(f)) > @expires_in_seconds)
+          end
+        }
+      end
+
+    end
+  end
+end

data/rack-mini-profiler-4.0.1/lib/mini_profiler/storage/memcache_store.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Rack
+  class MiniProfiler
+    class MemcacheStore < AbstractStore
+
+      EXPIRES_IN_SECONDS = 60 * 60 * 24
+      MAX_RETRIES        = 10
+
+      def initialize(args = nil)
+        require 'dalli' unless defined? Dalli
+        args ||= {}
+
+        @prefix = args[:prefix] || "MPMemcacheStore"
+        @prefix += "-#{Rack::MiniProfiler::VERSION}"
+
+        @client             = args[:client]     || Dalli::Client.new
+        @expires_in_seconds = args[:expires_in] || EXPIRES_IN_SECONDS
+      end
+
+      def alive?
+        begin
+          @client.alive!
+          true
+        rescue Dalli::RingError
+          false
+        end
+      end
+
+      def save(page_struct)
+        @client.set("#{@prefix}#{page_struct[:id]}", Marshal::dump(page_struct), @expires_in_seconds)
+      end
+
+      def load(id)
+        raw = @client.get("#{@prefix}#{id}")
+        # rubocop:disable Security/MarshalLoad
+        Marshal.load(raw) if raw
+        # rubocop:enable Security/MarshalLoad
+      end
+
+      def set_unviewed(user, id)
+        @client.add("#{@prefix}-#{user}-v", [], @expires_in_seconds)
+        MAX_RETRIES.times do
+          break if @client.cas("#{@prefix}-#{user}-v", @expires_in_seconds) do |ids|
+            ids << id if !ids.include?(id)
+            ids
+          end
+        end
+      end
+
+      def set_viewed(user, id)
+        @client.add("#{@prefix}-#{user}-v", [], @expires_in_seconds)
+        MAX_RETRIES.times do
+          break if @client.cas("#{@prefix}-#{user}-v", @expires_in_seconds) do |ids|
+            ids.delete id
+            ids
+          end
+        end
+      end
+
+      def set_all_unviewed(user, ids)
+        @client.set("#{@prefix}-#{user}-v", ids, @expires_in_seconds)
+      end
+
+      def get_unviewed_ids(user)
+        @client.get("#{@prefix}-#{user}-v") || []
+      end
+
+      def flush_tokens
+        @client.set("#{@prefix}-tokens", nil)
+      end
+
+      def allowed_tokens
+
+        token_info = @client.get("#{@prefix}-tokens")
+        key1, key2, cycle_at = nil
+
+        if token_info
+          # rubocop:disable Security/MarshalLoad
+          key1, key2, cycle_at = Marshal.load(token_info)
+          # rubocop:enable Security/MarshalLoad
+
+          key1 = nil unless key1 && key1.length == 32
+          key2 = nil unless key2 && key2.length == 32
+
+          if key1 && cycle_at && (cycle_at > Process.clock_gettime(Process::CLOCK_MONOTONIC))
+            return [key1, key2].compact
+          end
+        end
+
+        timeout = Rack::MiniProfiler::AbstractStore::MAX_TOKEN_AGE
+
+        # cycle keys
+        key2 = key1
+        key1 = SecureRandom.hex
+        cycle_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+
+        @client.set("#{@prefix}-tokens", Marshal::dump([key1, key2, cycle_at]))
+
+        [key1, key2].compact
+      end
+
+    end
+  end
+end