rack-dev_insight 0.2.2-aarch64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5411e06db8ab18bc1e25d58588e78b9d9f9c7a638ccdfdd7ee2e1d37cb1f1d1a
+  data.tar.gz: 2aa69dbea53b9f1d3e2e8e7cb5aa85dc1fa7749f207141d5ce5669b3eb5ef213
+SHA512:
+  metadata.gz: 84c68f5fe18dd737bd467ae0d12cf595bf1eab4b643da0d64ad364ef2b924c906b2b54f4c0d7c7623e6e051268852299dabd9018bafa5ba5fc3d29be9fcc42e0
+  data.tar.gz: 3f3118a8c28003beacd648489f8e3bac041b3253fb229e09dc5242dc071dfb97368e9718d675a8089d4e6b25117de8c5d6abee98eb7436f925f12515ec06766b

data/lib/rack/dev_insight/config.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    class Config
+      attr_accessor :storage_type,
+                    :memory_store_size,
+                    :file_store_pool_size,
+                    :file_store_dir_path,
+                    :skip_paths,
+                    :backtrace_exclusion_patterns,
+                    :backtrace_depth,
+                    :prepared_statement_limit,
+                    :skip_cached_sql,
+                    :detected_dialect
+
+      def initialize
+        @storage_type = :memory
+        @memory_store_size = 32 * 1024 * 1024
+        @file_store_pool_size = 100
+        @file_store_dir_path = 'tmp/rack-dev_insight'
+        @skip_paths = []
+        @backtrace_depth = 5
+        @backtrace_exclusion_patterns = [%r{/gems/}]
+        @prepared_statement_limit = 1000
+        @skip_cached_sql = true
+      end
+
+      def storage_instance
+        case storage_type.to_sym
+        when :memory
+          MemoryStore.new
+        when :file
+          FileStore.new
+        else
+          warn "warning: Unknown storage type: #{storage_type} in Rack::DevInsight::Config. " \
+                 'Available types are :memory and :file. Falling back to :memory.'
+          MemoryStore.new
+        end
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/context.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    class Context
+      class << self
+        def current
+          Thread.current[:rack_dev_insight_context]
+        end
+
+        def create_current(id)
+          Thread.current[:rack_dev_insight_context] = new(id)
+        end
+      end
+
+      attr_reader :id, :result
+
+      private
+
+      def initialize(id)
+        @id = id
+        @result = Result.new(id)
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/disable_net_http_patch.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    DISABLE_NET_HTTP_PATCH = true
+  end
+end

data/lib/rack/dev_insight/enable_sql_patch.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    ENABLE_SQL_PATCH = true
+    DISABLE_SQL_SUBSCRIPTION = true
+  end
+end

data/lib/rack/dev_insight/errors.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    # Definitions must be synced with ext/rack_dev_insight/src/errors.rs
+    class Error < StandardError
+    end
+    class ExtError < Error
+    end
+    class ParserError < ExtError
+    end
+  end
+end

data/lib/rack/dev_insight/ext/extractor.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    module Extractor
+      class CrudTables
+        class << self
+          def extract(dialect_name, statement)
+            crud_tables = _extract(dialect_name, statement)
+            {
+              'CREATE' => crud_tables._create_tables,
+              'READ' => crud_tables._read_tables,
+              'UPDATE' => crud_tables._update_tables,
+              'DELETE' => crud_tables._delete_tables,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/ext/normalizer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    module Normalizer
+      class << self
+        def normalize(dialect_name, statement)
+          _normalize(dialect_name, statement)
+        end
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/patches/api/net_http.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+if defined?(Net) && defined?(Net::HTTP)
+  module Net
+    class HTTP
+      module RackDevInsight
+        def request(request, *args, &block)
+          Rack::DevInsight::ApiRecorder.new.record(net_http: self, request: request) { super }
+        end
+      end
+
+      prepend RackDevInsight
+    end
+  end
+end

data/lib/rack/dev_insight/patches/sql/mysql2.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+if defined?(Mysql2::Client)
+  module Mysql2
+    class Client
+      module RackDevInsight
+        def query(*args, &block)
+          sql = args[0]
+          Rack::DevInsight::SqlRecorder
+            .new
+            .record_sql(dialect: Rack::DevInsight::SqlDialects::MYSQL, statement: sql) { super }
+        end
+
+        def prepare(*args, &block)
+          sql = args[0]
+          statement = super
+          statement.instance_variable_set(:@_rack_dev_insight_sql, sql)
+          statement
+        end
+      end
+
+      prepend RackDevInsight
+    end
+  end
+end
+
+if defined?(Mysql2::Statement)
+  module Mysql2
+    class Statement
+      module RackDevInsight
+        def execute(*args, **kwargs)
+          params = args
+          Rack::DevInsight::SqlRecorder
+            .new
+            .record_sql(
+              dialect: Rack::DevInsight::SqlDialects::MYSQL,
+              statement: @_rack_dev_insight_sql || 'Missing prepared statement',
+              binds: params,
+            ) { super }
+        end
+      end
+
+      prepend RackDevInsight
+    end
+  end
+end

data/lib/rack/dev_insight/patches/sql/pg.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+if defined?(PG::Connection)
+  module PG
+    class Connection
+      module RackDevInsight
+        %i[exec sync_exec async_exec async_query send_query].each do |method_name|
+          define_method(method_name) do |*args, &block|
+            sql = args[0]
+            Rack::DevInsight::SqlRecorder
+              .new
+              .record_sql(dialect: Rack::DevInsight::SqlDialects::POSTGRESQL, statement: sql) { super(*args, &block) }
+          end
+        end
+
+        %i[exec_params sync_exec_params async_exec_params send_query_params].each do |method_name|
+          define_method(method_name) do |*args, &block|
+            sql = args[0]
+            params = args[1]
+            Rack::DevInsight::SqlRecorder
+              .new
+              .record_sql(dialect: Rack::DevInsight::SqlDialects::POSTGRESQL, statement: sql, binds: params) do
+                super(*args, &block)
+              end
+          end
+        end
+
+        %i[prepare sync_prepare async_prepare send_prepare].each do |method_name|
+          define_method(method_name) do |*args, &block|
+            name = args[0]
+            sql = args[1]
+            @_rack_dev_insight_prepared_statements ||= {}
+            # Remove the oldest prepared statement if limit is reached
+            while Rack::DevInsight.config.prepared_statement_limit <= @_rack_dev_insight_prepared_statements.size
+              @_rack_dev_insight_prepared_statements.shift
+            end
+            @_rack_dev_insight_prepared_statements[name] = sql
+            super(*args, &block)
+          end
+        end
+
+        # Assume one of the above prepare methods was called before
+        %i[exec_prepared sync_exec_prepared async_exec_prepared send_query_prepared].each do |method_name|
+          define_method(method_name) do |*args, &block|
+            name = args[0]
+            params = args[1]
+            sql = @_rack_dev_insight_prepared_statements&.[](name) || missing_statement_message(name)
+            Rack::DevInsight::SqlRecorder
+              .new
+              .record_sql(dialect: Rack::DevInsight::SqlDialects::POSTGRESQL, statement: sql, binds: params) do
+                super(*args, &block)
+              end
+          end
+        end
+
+        private
+
+        def missing_statement_message(name)
+          "Missing prepared statement name: #{name}"
+        end
+      end
+
+      prepend RackDevInsight
+    end
+  end
+end

data/lib/rack/dev_insight/railtie.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'sql_notifications'
+
+module Rack
+  class DevInsight
+    class Railtie < ::Rails::Railtie
+      initializer 'rack_dev_insight.middlewares' do |app|
+        app.middleware.use(Rack::DevInsight)
+      end
+
+      initializer 'rack_dev_insight.subscribe_events' do
+        unless defined?(DISABLE_SQL_SUBSCRIPTION)
+          DevInsight.config.detected_dialect = SqlDialects.detect_dialect
+          SqlNotifications.subscribe_events
+        end
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/recorder/api_recorder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'base_recorder'
+
+module Rack
+  class DevInsight
+    class ApiRecorder < BaseRecorder
+      def record(net_http:, request:)
+        return yield if Context.current.nil?
+
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        response = yield
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        Context.current.result.add_api(
+          method: request.method,
+          url: request.uri || "#{net_http.address}:#{net_http.port}#{request.path}",
+          request_headers: request.each_header.map { |field, value| Result.build_header(field, value) },
+          request_body: request.body,
+          status: response.code.to_i,
+          response_headers: response.each_header.map { |field, value| Result.build_header(field, value) },
+          response_body: response.body,
+          backtrace: get_backtrace,
+          duration: format('%.2f', duration * 1000).to_f,
+        )
+        response
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/recorder/base_recorder.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    class BaseRecorder
+      private
+
+      def format_binds(binds)
+        if binds.nil? || binds.empty? || (binds.is_a?(Array) && binds.all? { _1.respond_to?(:empty?) && _1.empty? })
+          ''
+        else
+          binds.to_s
+        end
+      end
+
+      def get_backtrace
+        Kernel
+          .caller
+          .reject { |line| DevInsight.config.backtrace_exclusion_patterns.any? { |regex| line =~ regex } }
+          .first(DevInsight.config.backtrace_depth)
+          .map do |line|
+            if (match = line.match(/(?<path>.*):(?<line>\d+)/))
+              Result.build_backtrace_item(line, match[:path], match[:line].to_i)
+            end
+          end
+          .compact
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/recorder/request_recorder.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'base_recorder'
+
+module Rack
+  class DevInsight
+    class RequestRecorder < BaseRecorder
+      def record(http_method:, path:)
+        return yield if Context.current.nil?
+
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        status, headers, body = yield
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        Context.current.result.set_request(
+          status: status,
+          http_method: http_method,
+          path: path,
+          duration: format('%.2f', duration * 1000).to_f,
+        )
+        [status, headers, body]
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/recorder/sql_recorder.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'base_recorder'
+
+module Rack
+  class DevInsight
+    class SqlRecorder < BaseRecorder
+      class << self
+        # @param [String] dialect 'mysql', 'postgresql' or 'sqlite' are supported
+        # @param [String] statement SQL statement
+        # @param [Array] binds SQL statement binds
+        # @param [Float] duration milliseconds of SQL execution time
+        # @return [nil]
+        def record(dialect:, statement:, binds: [], duration: 0.0)
+          new.record(dialect: dialect, statement: statement, binds: binds, duration: duration)
+        end
+      end
+
+      def record(dialect:, statement:, binds: [], duration: 0.0)
+        SqlDialects.validate!(dialect, ArgumentError)
+        return if Context.current.nil?
+
+        Context.current.result.add_sql(
+          dialect: dialect,
+          statement: statement,
+          binds: format_binds(binds),
+          backtrace: get_backtrace,
+          duration: format('%.2f', duration).to_f,
+        )
+        nil
+      end
+
+      def record_sql(dialect:, statement:, binds: [])
+        return yield if Context.current.nil?
+
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        res = yield
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+
+        Context.current.result.add_sql(
+          dialect: dialect,
+          statement: statement,
+          binds: format_binds(binds),
+          backtrace: get_backtrace,
+          duration: format('%.2f', duration * 1000).to_f,
+        )
+        res
+      end
+
+      def record_from_event(started:, finished:, statement:, binds:, cached:)
+        return if Context.current.nil?
+        return if DevInsight.config.detected_dialect.nil?
+        return if DevInsight.config.skip_cached_sql && cached
+
+        Context.current.result.add_sql(
+          dialect: DevInsight.config.detected_dialect,
+          statement: statement,
+          binds: format_binds(binds),
+          backtrace: get_backtrace,
+          duration: format('%.2f', (finished - started) * 1000).to_f,
+        )
+        nil
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/result/apis.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    class Result
+      class Apis
+        Api =
+          Struct.new(
+            :id,
+            :method, # rubocop:disable Lint/StructNewOverride
+            :url,
+            :request_headers,
+            :request_body,
+            :status,
+            :response_headers,
+            :response_body,
+            :backtrace,
+            :duration,
+          )
+        Header = Struct.new(:field, :value)
+
+        def initialize
+          @id = 0
+          @data = []
+        end
+
+        def add(
+          method,
+          url,
+          request_headers,
+          request_body,
+          status,
+          response_headers,
+          response_body,
+          backtrace,
+          duration
+        )
+          @data << Api.new(
+            @id += 1,
+            method,
+            url,
+            request_headers.map(&:to_h),
+            request_body,
+            status,
+            response_headers.map(&:to_h),
+            response_body,
+            backtrace.map(&:to_h),
+            duration,
+          )
+        end
+
+        def attributes
+          @data.map(&:to_h)
+        end
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/result/sql/crud_aggregations.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    class Result
+      class Sql
+        class CrudAggregations
+          CrudAggregation = Struct.new(:id, :type, :table, :count, :duration, :query_ids) # rubocop:disable Lint/StructNewOverride
+
+          def initialize
+            @id = 0
+            @cached_data = {}
+          end
+
+          def add(dialect_name, statement, duration, query_id)
+            crud_tables = Extractor::CrudTables.extract(dialect_name, statement)
+
+            crud_tables.each do |type, tables|
+              tables.each do |table|
+                key = "#{type}_#{table.downcase}"
+                data = @cached_data[key] ||= CrudAggregation.new(@id += 1, type, table, 0, 0, [])
+                data.count += 1
+                data.duration += duration
+                data.query_ids << query_id
+              end
+            end
+          end
+
+          def attributes
+            @cached_data.values.map do |data|
+              data.duration = format('%.2f', data.duration).to_f
+              data.to_h
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/result/sql/errored_queries.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    class Result
+      class Sql
+        class ErroredQueries
+          ErroredQuery = Struct.new(:id, :message, :statement, :backtrace, :duration)
+
+          def initialize
+            @data = []
+          end
+
+          def add(id, message, statement, backtrace, duration)
+            @data << ErroredQuery.new(id, message, statement, backtrace, duration)
+          end
+
+          def attributes
+            @data.map(&:to_h)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/result/sql/normalized_aggregations.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    class Result
+      class Sql
+        class NormalizedAggregations
+          NormalizedAggregation = Struct.new(:id, :statement, :count, :duration, :query_ids) # rubocop:disable Lint/StructNewOverride
+
+          def initialize
+            @id = 0
+            @cached_data = {}
+          end
+
+          def add(dialect_name, statement, duration, query_id)
+            normalized_statements = Normalizer.normalize(dialect_name, statement)
+            normalized_statement = normalized_statements.join('; ')
+
+            data =
+              @cached_data[normalized_statement] ||= NormalizedAggregation.new(@id += 1, normalized_statement, 0, 0, [])
+            data.count += 1
+            data.duration += duration
+            data.query_ids << query_id
+          end
+
+          def attributes
+            @cached_data.values.map do |data|
+              data.duration = format('%.2f', data.duration).to_f
+              data.to_h
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/result/sql/queries.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    class Result
+      class Sql
+        class Queries
+          Query = Struct.new(:id, :statement, :binds, :backtrace, :duration)
+          TraceInfo = Struct.new(:original, :path, :line)
+
+          attr_reader :id
+
+          def initialize
+            @id = 0
+            @data = []
+          end
+
+          def add(statement, binds, backtrace, duration)
+            @data << Query.new(@id += 1, statement, binds, backtrace.map(&:to_h), duration)
+          end
+
+          def attributes
+            @data.map(&:to_h)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/result/sql.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    class Result
+      class Sql
+        def initialize
+          @crud_aggregations = CrudAggregations.new
+          @normalized_aggregations = NormalizedAggregations.new
+          @errored_queries = ErroredQueries.new
+          @queries = Queries.new
+        end
+
+        def add(dialect, statement, binds, backtrace, duration)
+          @queries.add(statement, binds, backtrace, duration)
+          @crud_aggregations.add(dialect, statement, duration, @queries.id)
+          @normalized_aggregations.add(dialect, statement, duration, @queries.id)
+        rescue ExtError => e
+          @errored_queries.add(@queries.id, e.message, statement, backtrace, duration)
+        end
+
+        def attributes
+          {
+            crud_aggregations: @crud_aggregations.attributes,
+            normalized_aggregations: @normalized_aggregations.attributes,
+            errored_queries: @errored_queries.attributes,
+            queries: @queries.attributes,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/result.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Rack
+  class DevInsight
+    class Result
+      Request = Struct.new(:status, :http_method, :path, :duration)
+
+      class << self
+        def build_backtrace_item(original, path, line)
+          Sql::Queries::TraceInfo.new(original, path, line)
+        end
+
+        def build_header(field, value)
+          Apis::Header.new(field, value)
+        end
+      end
+
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+        @request = Request.new
+        @sql = Sql.new
+        @apis = Apis.new
+      end
+
+      def set_request(status:, http_method:, path:, duration:)
+        @request = Request.new(status, http_method, path, duration)
+      end
+
+      def add_sql(dialect:, statement:, binds:, backtrace:, duration:)
+        @sql.add(dialect, statement, binds, backtrace, duration)
+      end
+
+      def add_api(
+        method:,
+        url:,
+        request_headers:,
+        request_body:,
+        status:,
+        response_headers:,
+        response_body:,
+        backtrace:,
+        duration:
+      )
+        @apis.add(
+          method,
+          url,
+          request_headers,
+          request_body,
+          status,
+          response_headers,
+          response_body,
+          backtrace,
+          duration,
+        )
+      end
+
+      def attributes
+        {
+          id: @id,
+          status: @request.status,
+          method: @request.http_method,
+          path: @request.path,
+          duration: @request.duration,
+          sql: @sql.attributes,
+          apis: @apis.attributes,
+        }
+      end
+
+      def to_response_json
+        Camelizer.camelize_keys(attributes).to_json
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/sql_dialects.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    module SqlDialects
+      MYSQL = 'mysql'
+      POSTGRESQL = 'postgresql'
+      SQLITE = 'sqlite'
+      DIALECTS = [MYSQL, POSTGRESQL, SQLITE].freeze
+
+      class << self
+        def detect_dialect
+          if defined?(Mysql2)
+            MYSQL
+          elsif defined?(PG)
+            POSTGRESQL
+          elsif defined?(SQLite3)
+            SQLITE
+          end
+        end
+
+        def validate!(dialect, error_klass)
+          return if DIALECTS.include?(dialect)
+
+          raise error_klass, "Unsupported SQL dialect: #{dialect}. Supported dialects are: #{DIALECTS.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/sql_notifications.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    class SqlNotifications
+      DEFAULT_EVENT_NAMES = %w[sql.active_record sql.rom sql.sequel].freeze
+
+      class << self
+        def subscribe_events(event_names = DEFAULT_EVENT_NAMES)
+          event_names.each { |event_name| subscribe(event_name) }
+        end
+
+        # @param [String] event_name
+        def subscribe(event_name)
+          ActiveSupport::Notifications.subscribe(event_name, &new)
+        end
+      end
+
+      def to_proc
+        method(:call).to_proc
+      end
+
+      def call(*args)
+        _name, started, finished, _unique_id, data = args
+        SqlRecorder.new.record_from_event(
+          started: started,
+          finished: finished,
+          statement: data[:sql],
+          binds: data[:type_casted_binds].try(:call) || data[:type_casted_binds],
+          cached: data[:cached],
+        )
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/storage/file_store.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    class FileStore
+      def initialize
+        @dir_path = DevInsight.config.file_store_dir_path
+        @pool_size = DevInsight.config.file_store_pool_size
+      end
+
+      def write(result)
+        ::File.open(file_path(result.id), 'wb+') do |f|
+          f.sync = true
+          f.write Marshal.dump(result)
+        end
+        reap_excess_files
+      end
+
+      def read(id)
+        return nil unless ::File.exist?(file_path(id))
+
+        Marshal.load(::File.binread(file_path(id))) # rubocop:disable Security/MarshalLoad
+      end
+
+      private
+
+      def file_path(id)
+        FileUtils.mkdir_p(@dir_path)
+        Pathname.new(@dir_path).join(id.to_s).to_s
+      end
+
+      def reap_excess_files
+        files = Dir.glob(::File.join(@dir_path, '*')).sort_by { |f| ::File.mtime(f) }
+        files[0..-(@pool_size + 1)].each { |old_file| ::File.delete(old_file) }
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/storage/memory_store.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    class MemoryStore
+      MAX_REAP_SEC = 2
+
+      def initialize
+        @lock = Mutex.new
+        @cache = {}
+        @memory_size = DevInsight.config.memory_store_size
+      end
+
+      def write(result)
+        @lock.synchronize do
+          @cache[result.id] = result
+          reap_excess_memory
+        end
+      end
+
+      def read(id)
+        @lock.synchronize { @cache[id] }
+      end
+
+      private
+
+      def reap_excess_memory
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @cache.delete(@cache.keys.first) while memory_excess? && within_reap_time?(start_time)
+      end
+
+      def memory_excess?
+        bytesize(@cache) > @memory_size
+      end
+
+      def within_reap_time?(start_time)
+        Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time < MAX_REAP_SEC
+      end
+
+      def bytesize(data)
+        Marshal.dump(data).bytesize
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/utils/camelizer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    module Camelizer
+      module_function
+
+      def camelize_keys(value)
+        case value
+        when Array
+          value.map { |v| camelize_keys(v) }
+        when Hash
+          value.transform_keys { |key| to_camel_case(key.to_s) }.transform_values { |v| camelize_keys(v) }
+        else
+          value
+        end
+      end
+
+      def to_camel_case(str)
+        str.gsub(/_([a-z])/) { ::Regexp.last_match(1).upcase }
+      end
+    end
+  end
+end

data/lib/rack/dev_insight/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rack
+  class DevInsight
+    VERSION = '0.2.2'
+  end
+end

data/lib/rack/dev_insight.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative 'dev_insight/ext/extractor'
+require_relative 'dev_insight/ext/normalizer'
+require_relative 'dev_insight/recorder/api_recorder'
+require_relative 'dev_insight/recorder/request_recorder'
+require_relative 'dev_insight/recorder/sql_recorder'
+require_relative 'dev_insight/result'
+require_relative 'dev_insight/result/apis'
+require_relative 'dev_insight/result/sql'
+require_relative 'dev_insight/result/sql/crud_aggregations'
+require_relative 'dev_insight/result/sql/errored_queries'
+require_relative 'dev_insight/result/sql/normalized_aggregations'
+require_relative 'dev_insight/result/sql/queries'
+require_relative 'dev_insight/storage/file_store'
+require_relative 'dev_insight/storage/memory_store'
+require_relative 'dev_insight/utils/camelizer'
+require_relative 'dev_insight/config'
+require_relative 'dev_insight/context'
+require_relative 'dev_insight/errors'
+require_relative 'dev_insight/sql_dialects'
+require_relative 'dev_insight/version'
+
+# https://github.com/rake-compiler/rake-compiler/blob/master/README.md
+# Technique to lookup the fat binaries first, and then lookup the gems compiled by the end user.
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require_relative "dev_insight/#{Regexp.last_match(1)}/rack_dev_insight"
+rescue LoadError
+  require_relative 'dev_insight/rack_dev_insight'
+end
+# Railtie
+require_relative 'dev_insight/railtie' if defined?(Rails)
+# Patches
+if defined?(Rack::DevInsight::ENABLE_SQL_PATCH)
+  require_relative 'dev_insight/patches/sql/mysql2'
+  require_relative 'dev_insight/patches/sql/pg'
+end
+require_relative 'dev_insight/patches/api/net_http' unless defined?(Rack::DevInsight::DISABLE_NET_HTTP_PATCH)
+
+module Rack
+  class DevInsight
+    class << self
+      def configure
+        yield config
+      end
+
+      def config
+        @config ||= Config.new
+      end
+    end
+
+    def initialize(app)
+      @app = app
+      @storage = DevInsight.config.storage_instance
+    end
+
+    def call(env)
+      if (id = get_id_from_path(env))
+        fetch_analyzed(id)
+      else
+        analyze(env)
+      end
+    end
+
+    private
+
+    def get_id_from_path(env)
+      env['PATH_INFO'][%r{/rack-dev-insight-results/(.+)$}, 1]
+    end
+
+    def fetch_analyzed(id)
+      header = { 'Content-Type' => 'application/json' }
+      if (result = @storage.read(id))
+        [200, header, [result.to_response_json]]
+      else
+        [404, header, [{ status: 404, message: "id: #{id} is not found" }.to_json]]
+      end
+    rescue StandardError => e
+      [500, header, [{ status: 500, message: e.inspect }.to_json]]
+    end
+
+    def analyze(env)
+      return @app.call(env) if skip_path?(env)
+
+      Context.create_current(SecureRandom.uuid)
+      request = Rack::Request.new(env)
+      status, headers, body =
+        RequestRecorder.new.record(http_method: request.request_method, path: request.fullpath) { @app.call(env) }
+      @storage.write(Context.current.result)
+      headers['X-Rack-Dev-Insight-Id'] = Context.current.id
+
+      [status, headers, body]
+    end
+
+    def skip_path?(env)
+      DevInsight.config.skip_paths.any? { |path| env['PATH_INFO'] =~ path }
+    end
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: rack-dev_insight
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: aarch64-linux
+authors:
+- Takahiro Ebato
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-01-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A rack middleware for analyzing SQL queries and HTTP request / response
+  data. Chrome extension is needed to display the analysis result.
+email:
+- takahiro.ebato@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rack/dev_insight.rb
+- lib/rack/dev_insight/3.0/rack_dev_insight.so
+- lib/rack/dev_insight/3.1/rack_dev_insight.so
+- lib/rack/dev_insight/3.2/rack_dev_insight.so
+- lib/rack/dev_insight/config.rb
+- lib/rack/dev_insight/context.rb
+- lib/rack/dev_insight/disable_net_http_patch.rb
+- lib/rack/dev_insight/enable_sql_patch.rb
+- lib/rack/dev_insight/errors.rb
+- lib/rack/dev_insight/ext/extractor.rb
+- lib/rack/dev_insight/ext/normalizer.rb
+- lib/rack/dev_insight/patches/api/net_http.rb
+- lib/rack/dev_insight/patches/sql/mysql2.rb
+- lib/rack/dev_insight/patches/sql/pg.rb
+- lib/rack/dev_insight/railtie.rb
+- lib/rack/dev_insight/recorder/api_recorder.rb
+- lib/rack/dev_insight/recorder/base_recorder.rb
+- lib/rack/dev_insight/recorder/request_recorder.rb
+- lib/rack/dev_insight/recorder/sql_recorder.rb
+- lib/rack/dev_insight/result.rb
+- lib/rack/dev_insight/result/apis.rb
+- lib/rack/dev_insight/result/sql.rb
+- lib/rack/dev_insight/result/sql/crud_aggregations.rb
+- lib/rack/dev_insight/result/sql/errored_queries.rb
+- lib/rack/dev_insight/result/sql/normalized_aggregations.rb
+- lib/rack/dev_insight/result/sql/queries.rb
+- lib/rack/dev_insight/sql_dialects.rb
+- lib/rack/dev_insight/sql_notifications.rb
+- lib/rack/dev_insight/storage/file_store.rb
+- lib/rack/dev_insight/storage/memory_store.rb
+- lib/rack/dev_insight/utils/camelizer.rb
+- lib/rack/dev_insight/version.rb
+homepage: https://github.com/takaebato/rack-dev_insight
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/takaebato/rack-dev_insight
+  changelog_uri: https://github.com/takaebato/rack-dev_insight/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.3.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.22
+requirements: []
+rubygems_version: 3.4.4
+signing_key: 
+specification_version: 4
+summary: A rack middleware for analyzing SQL queries and HTTP request / response data.
+test_files: []