rails-profiler 0.1.4

data/lib/profiler/models/sql_query.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Models
+    class SqlQuery
+      attr_reader :sql, :duration, :binds, :name, :connection, :backtrace
+
+      def initialize(sql:, duration:, binds: [], name: nil, connection: nil, backtrace: [])
+        @sql = sql
+        @duration = duration
+        @binds = binds
+        @name = name
+        @connection = connection
+        @backtrace = backtrace
+      end
+
+      def slow?(threshold = 100)
+        @duration > threshold
+      end
+
+      def cached?
+        @name == "CACHE"
+      end
+
+      def transaction?
+        @sql =~ /^(BEGIN|COMMIT|ROLLBACK)/i
+      end
+
+      def to_h
+        {
+          sql: @sql,
+          duration: @duration,
+          binds: @binds,
+          name: @name,
+          connection: @connection&.class&.name,
+          backtrace: @backtrace.map(&:to_s),
+          slow: slow?,
+          cached: cached?,
+          transaction: transaction?
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+  end
+end

data/lib/profiler/models/timeline_event.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Models
+    class TimelineEvent
+      attr_reader :name, :started_at, :finished_at, :duration, :payload, :children, :category
+
+      def initialize(name:, started_at:, finished_at:, payload: {}, category: nil)
+        @name = name
+        @started_at = started_at
+        @finished_at = finished_at
+        @duration = ((finished_at - started_at) * 1000).round(2) # milliseconds
+        @payload = payload
+        @category = category
+        @children = []
+      end
+
+      def add_child(event)
+        @children << event
+      end
+
+      def to_h
+        h = {
+          name: @name,
+          started_at: @started_at,
+          finished_at: @finished_at,
+          duration: @duration,
+          payload: @payload,
+          children: @children.map(&:to_h)
+        }
+        h[:category] = @category if @category
+        h
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+  end
+end

data/lib/profiler/railtie.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module Profiler
+  class Railtie < Rails::Railtie
+    config.profiler = ActiveSupport::OrderedOptions.new
+
+    initializer "profiler.set_configs" do |app|
+      # Set default configuration for Rails environment
+      Profiler.configure do |config|
+        config.enabled = Rails.env.development? || Rails.env.test?
+        config.storage = Rails.env.development? ? :file : :memory
+        config.storage_options = {
+          path: Rails.root.join("tmp", "profiler")
+        }
+      end
+    end
+
+    initializer "profiler.insert_middleware", before: :build_middleware_stack do |app|
+      if Profiler.configuration.enabled
+        require_relative "middleware/profiler_middleware"
+
+        # Insert CORS middleware first if enabled
+        if Profiler.configuration.extension_cors_enabled
+          require_relative "middleware/cors_middleware"
+          app.middleware.insert_before 0, Profiler::Middleware::CorsMiddleware
+        end
+
+        app.middleware.insert_before 0, Profiler::Middleware::ProfilerMiddleware
+      end
+    end
+
+    initializer "profiler.load_collectors" do
+      if Profiler.configuration.collectors.empty?
+        Profiler.configure do |config|
+          config.collectors = [
+            Profiler::Collectors::RequestCollector,
+            Profiler::Collectors::DumpCollector,
+            Profiler::Collectors::DatabaseCollector,
+            Profiler::Collectors::PerformanceCollector,
+            Profiler::Collectors::ViewCollector,
+            Profiler::Collectors::CacheCollector,
+            Profiler::Collectors::HttpCollector,
+            Profiler::Collectors::FlameGraphCollector
+          ]
+        end
+      end
+    end
+
+    initializer "profiler.setup_job_instrumentation" do
+      next unless Profiler.configuration.enabled && Profiler.configuration.track_jobs
+
+      require_relative "job_profiler"
+
+      if defined?(Sidekiq)
+        require_relative "instrumentation/sidekiq_middleware"
+        Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add Profiler::Instrumentation::SidekiqMiddleware
+          end
+        end
+      end
+
+      if defined?(ActiveJob::Base)
+        require_relative "instrumentation/active_job_instrumentation"
+        ActiveJob::Base.include Profiler::Instrumentation::ActiveJobInstrumentation
+      end
+    end
+
+    rake_tasks do
+      load "profiler/tasks/profiler.rake"
+    end
+  end
+end

data/lib/profiler/storage/base_store.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Storage
+    class BaseStore
+      def save(token, profile)
+        raise NotImplementedError, "#{self.class} must implement #save"
+      end
+
+      def load(token)
+        raise NotImplementedError, "#{self.class} must implement #load"
+      end
+
+      def list(limit: 50, offset: 0)
+        raise NotImplementedError, "#{self.class} must implement #list"
+      end
+
+      def cleanup(older_than: 24 * 60 * 60)
+        raise NotImplementedError, "#{self.class} must implement #cleanup"
+      end
+
+      def exists?(token)
+        !load(token).nil?
+      rescue
+        false
+      end
+
+      def find_by_parent(parent_token)
+        raise NotImplementedError, "#{self.class} must implement #find_by_parent"
+      end
+
+      def delete(token)
+        raise NotImplementedError, "#{self.class} must implement #delete"
+      end
+
+      def clear(type: nil)
+        raise NotImplementedError, "#{self.class} must implement #clear"
+      end
+    end
+  end
+end

data/lib/profiler/storage/blob_store.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Profiler
+  module Storage
+    class BlobStore
+      def initialize(path)
+        @path = path
+        FileUtils.mkdir_p(@path)
+      end
+
+      def write(token, collector_name, data)
+        dir = token_dir(token)
+        FileUtils.mkdir_p(dir)
+        File.write(File.join(dir, "#{collector_name}.json"), JSON.generate(data))
+      end
+
+      def read(token, collector_name)
+        file = File.join(token_dir(token), "#{collector_name}.json")
+        return nil unless File.exist?(file)
+
+        JSON.parse(File.read(file))
+      rescue => e
+        warn "BlobStore: failed to read #{token}/#{collector_name}: #{e.message}"
+        nil
+      end
+
+      def delete(token)
+        dir = token_dir(token)
+        FileUtils.rm_rf(dir) if File.directory?(dir)
+      end
+
+      def exists?(token, collector_name)
+        File.exist?(File.join(token_dir(token), "#{collector_name}.json"))
+      end
+
+      private
+
+      def token_dir(token)
+        File.join(@path, token)
+      end
+    end
+  end
+end

data/lib/profiler/storage/file_store.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require_relative "base_store"
+require_relative "../models/profile"
+
+module Profiler
+  module Storage
+    class FileStore < BaseStore
+      def initialize(options = {})
+        @path = options[:path] || default_path
+        @max_size = options[:max_size] || 100 * 1024 * 1024 # 100 MB
+        ensure_directory_exists
+      end
+
+      def save(token, profile)
+        file_path = profile_file_path(token)
+        File.write(file_path, profile.to_json)
+        cleanup_if_needed
+        token
+      end
+
+      def load(token)
+        file_path = profile_file_path(token)
+        return nil unless File.exist?(file_path)
+
+        json_data = File.read(file_path)
+        Models::Profile.from_json(json_data)
+      rescue => e
+        warn "Failed to load profile #{token}: #{e.message}"
+        nil
+      end
+
+      def list(limit: 50, offset: 0)
+        profile_files
+          .sort_by { |f| File.mtime(f) }
+          .reverse
+          .drop(offset)
+          .take(limit)
+          .map { |f| load(File.basename(f, ".json")) }
+          .compact
+      end
+
+      def cleanup(older_than: 24 * 60 * 60)
+        cutoff_time = Time.now - older_than
+        profile_files.each do |file|
+          File.delete(file) if File.mtime(file) < cutoff_time
+        rescue => e
+          warn "Failed to delete profile file #{file}: #{e.message}"
+        end
+      end
+
+      def find_by_parent(parent_token)
+        profile_files
+          .map { |f| load(File.basename(f, ".json")) }
+          .compact
+          .select { |profile| profile.parent_token == parent_token }
+          .sort_by { |profile| profile.started_at }
+      end
+
+      def delete(token)
+        file_path = profile_file_path(token)
+        File.delete(file_path) if File.exist?(file_path)
+      end
+
+      def clear(type: nil)
+        if type.nil?
+          profile_files.each { |f| File.delete(f) rescue nil }
+        else
+          profile_files.each do |f|
+            profile = load(File.basename(f, ".json"))
+            File.delete(f) if profile&.profile_type == type.to_s
+          rescue
+            nil
+          end
+        end
+      end
+
+      private
+
+      def default_path
+        if defined?(Rails)
+          Rails.root.join("tmp", "profiler")
+        else
+          File.expand_path("tmp/profiler", Dir.pwd)
+        end
+      end
+
+      def ensure_directory_exists
+        FileUtils.mkdir_p(@path) unless File.directory?(@path)
+      end
+
+      def profile_file_path(token)
+        File.join(@path, "#{token}.json")
+      end
+
+      def profile_files
+        Dir.glob(File.join(@path, "*.json"))
+      end
+
+      def cleanup_if_needed
+        total_size = profile_files.sum { |f| File.size(f) }
+        return if total_size < @max_size
+
+        # Delete oldest files until we're under the limit
+        profile_files
+          .sort_by { |f| File.mtime(f) }
+          .each do |file|
+            File.delete(file)
+            total_size -= File.size(file)
+            break if total_size < @max_size * 0.8
+          rescue => e
+            warn "Failed to delete profile file #{file}: #{e.message}"
+          end
+      end
+    end
+  end
+end

data/lib/profiler/storage/memory_store.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "concurrent-ruby"
+require_relative "base_store"
+require_relative "../models/profile"
+
+module Profiler
+  module Storage
+    class MemoryStore < BaseStore
+      def initialize(options = {})
+        @profiles = Concurrent::Hash.new
+        @max_profiles = options[:max_profiles] || Profiler.configuration.max_profiles || 100
+      end
+
+      def save(token, profile)
+        cleanup_if_needed
+        @profiles[token] = serialize_profile(profile)
+        token
+      end
+
+      def load(token)
+        data = @profiles[token]
+        return nil unless data
+
+        deserialize_profile(data)
+      end
+
+      def list(limit: 50, offset: 0)
+        @profiles.values
+                .map { |data| deserialize_profile(data) }
+                .sort_by { |p| p.started_at }
+                .reverse
+                .drop(offset)
+                .take(limit)
+      end
+
+      def cleanup(older_than: 24 * 60 * 60)
+        cutoff_time = Time.now - older_than
+        @profiles.delete_if do |_token, data|
+          profile = deserialize_profile(data)
+          profile.started_at < cutoff_time
+        end
+      end
+
+      def find_by_parent(parent_token)
+        @profiles.values
+                .map { |data| deserialize_profile(data) }
+                .select { |profile| profile.parent_token == parent_token }
+                .sort_by { |profile| profile.started_at }
+      end
+
+      def delete(token)
+        @profiles.delete(token)
+      end
+
+      def clear(type: nil)
+        if type.nil?
+          @profiles.clear
+        else
+          @profiles.delete_if do |_token, data|
+            deserialize_profile(data).profile_type == type.to_s
+          end
+        end
+      end
+
+      private
+
+      def cleanup_if_needed
+        return if @profiles.size < @max_profiles
+
+        # Remove oldest profiles until we're under the limit
+        profiles_to_remove = @profiles.size - (@max_profiles * 0.8).to_i
+        return if profiles_to_remove <= 0
+
+        sorted_tokens = @profiles.map do |token, data|
+          profile = deserialize_profile(data)
+          [token, profile.started_at]
+        end.sort_by { |_, time| time }.map(&:first)
+
+        sorted_tokens.take(profiles_to_remove).each do |token|
+          @profiles.delete(token)
+        end
+      end
+
+      def serialize_profile(profile)
+        profile.to_h
+      end
+
+      def deserialize_profile(data)
+        Models::Profile.from_hash(data)
+      end
+    end
+  end
+end

data/lib/profiler/storage/redis_store.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "redis"
+require "json"
+require_relative "base_store"
+require_relative "../models/profile"
+
+module Profiler
+  module Storage
+    class RedisStore < BaseStore
+      DEFAULT_TTL = 24 * 60 * 60 # 24 hours
+
+      def initialize(options = {})
+        @redis = options[:redis] || build_redis_client(options)
+        @ttl = options[:ttl] || DEFAULT_TTL
+        @key_prefix = options[:key_prefix] || "profiler"
+      end
+
+      def save(token, profile)
+        key = profile_key(token)
+        @redis.setex(key, @ttl, profile.to_json)
+
+        # Add to sorted set for listing
+        @redis.zadd(list_key, profile.started_at.to_f, token)
+
+        token
+      end
+
+      def load(token)
+        key = profile_key(token)
+        json_data = @redis.get(key)
+        return nil unless json_data
+
+        Models::Profile.from_json(json_data)
+      rescue => e
+        warn "Failed to load profile #{token}: #{e.message}"
+        nil
+      end
+
+      def list(limit: 50, offset: 0)
+        tokens = @redis.zrevrange(list_key, offset, offset + limit - 1)
+        tokens.map { |token| load(token) }.compact
+      end
+
+      def cleanup(older_than: 24 * 60 * 60)
+        cutoff_time = Time.now.to_f - older_than
+        @redis.zremrangebyscore(list_key, "-inf", cutoff_time)
+      end
+
+      def find_by_parent(parent_token)
+        # Get all tokens from the sorted set
+        tokens = @redis.zrange(list_key, 0, -1)
+
+        # Load each profile and filter by parent_token
+        tokens.map { |token| load(token) }
+              .compact
+              .select { |profile| profile.parent_token == parent_token }
+              .sort_by { |profile| profile.started_at }
+      end
+
+      def delete(token)
+        @redis.del(profile_key(token))
+        @redis.zrem(list_key, token)
+      end
+
+      def clear(type: nil)
+        tokens = @redis.zrange(list_key, 0, -1)
+        tokens.each do |token|
+          if type.nil?
+            @redis.del(profile_key(token))
+            @redis.zrem(list_key, token)
+          else
+            profile = load(token)
+            if profile&.profile_type == type.to_s
+              @redis.del(profile_key(token))
+              @redis.zrem(list_key, token)
+            end
+          end
+        end
+      end
+
+      private
+
+      def build_redis_client(options)
+        url = options[:url] || ENV["REDIS_URL"] || "redis://localhost:6379/0"
+        Redis.new(url: url)
+      end
+
+      def profile_key(token)
+        "#{@key_prefix}:#{token}"
+      end
+
+      def list_key
+        "#{@key_prefix}:list"
+      end
+    end
+  end
+end