jpie 1.5.1 → 2.0.1

data/lib/json_api/support/correlation_id.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    module CorrelationId
+      def self.resolve
+        resolver = JSONAPI.configuration.correlation_id_resolver
+        return nil unless resolver.respond_to?(:call)
+
+        resolver.call
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/json_api/support/filter_parsing.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    module FilterParsing
+      module_function
+
+      def parse_column_filter(filter_name)
+        m = filter_name.to_s.match(/\A(.+)_(eq|match|lt|lte|gt|gte)\z/)
+        m ? { column: m[1], operator: m[2].to_sym } : nil
+      end
+
+      def empty_filter_value?(filter_value)
+        filter_value.respond_to?(:empty?) ? filter_value.empty? : filter_value.nil?
+      end
+    end
+  end
+end

data/lib/json_api/support/header_warning_subscriber.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    class HeaderWarningSubscriber
+      HEADER_EVENTS = %w[jpie.n1_detected jpie.slow_query_detected].freeze
+
+      def emit(event)
+        ev = event.is_a?(Hash) ? event : event.to_h
+        return unless HEADER_EVENTS.include?(ev[:name])
+
+        Thread.current[:jpie_warnings] ||= []
+        Thread.current[:jpie_warnings] << (ev[:name] == "jpie.n1_detected" ? "n1" : "slow_query")
+      end
+    end
+  end
+end

data/lib/json_api/support/n1_log_subscriber.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    class N1LogSubscriber
+      def emit(event)
+        ev = event.is_a?(Hash) ? event : event.to_h
+        return unless ev[:name] == "jpie.n1_detected"
+
+        payload = ev[:payload] || {}
+        log_warn(build_message(payload), payload[:correlation_id])
+      end
+
+      private
+
+      def log_warn(msg, cid)
+        if cid.present?
+          Rails.logger.tagged("JPie", "CID(#{cid})") { Rails.logger.warn(msg) }
+        else
+          Rails.logger.warn("[JPie] #{msg}")
+        end
+      end
+
+      def build_message(payload)
+        msg = "N+1 detected #{payload[:method]} #{payload[:path]}"
+        if payload[:resource_type].present?
+          rt = payload[:resource_type]
+          rid = payload[:resource_id]
+          resource = rid.present? ? "#{rt}/#{rid}" : rt
+          msg += " resource=#{resource}"
+        end
+        msg += " include=#{payload[:include]}" if payload[:include].present?
+        msg += " query=#{payload[:n1_query]}" if payload[:n1_query].present?
+        msg
+      end
+    end
+  end
+end

data/lib/json_api/support/param_helpers.rb

@@ -50,5 +50,9 @@ module JSONAPI
     def esc(val)
       CGI.escape(val.to_s)
     end
+
+    def empty_array?(data)
+      data.is_a?(Array) && data.empty?
+    end
   end
 end

data/lib/json_api/support/prosopite_instrumentation_logger.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    class ProsopiteInstrumentationLogger
+      def warn(progname = nil, &)
+        n1_details = block_given? ? yield : progname.to_s
+        return if n1_details.nil? || n1_details.empty?
+
+        env = Thread.current[:jpie_request_env]
+        payload = build_payload(env, n1_details)
+
+        return unless defined?(Rails) && Rails.respond_to?(:event)
+
+        Rails.event.tagged("jsonapi", "n1") do
+          Rails.event.notify("jpie.n1_detected", payload)
+        end
+      end
+
+      private
+
+      def build_payload(env, n1_details)
+        base = { n1_details: n1_details, n1_query: extract_first_query(n1_details) }
+        result = if env.nil?
+                   base
+                 else
+                   request_payload(ActionDispatch::Request.new(env), n1_details).merge(n1_query: base[:n1_query])
+                 end
+        result.merge(correlation_id: JSONAPI::Support::CorrelationId.resolve)
+      end
+
+      def extract_first_query(n1_details)
+        return nil if n1_details.nil? || n1_details.empty?
+
+        parts = n1_details.split("Call stack:")
+        return nil if parts.size < 2
+
+        query_section = parts[0].sub(/\AN\+1 queries detected:\n?/, "")
+        first_line = query_section.each_line.map(&:strip).reject(&:empty?).first
+        first_line.presence
+      end
+
+      def request_payload(req, n1_details)
+        params = req.params
+        {
+          path: req.path,
+          method: req.request_method,
+          include: params[:include],
+          resource_type: params[:resource_type],
+          resource_id: params[:id],
+          n1_details: n1_details,
+        }
+      end
+    end
+  end
+end

data/lib/json_api/support/query_tracking_log_subscriber.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    class QueryTrackingLogSubscriber
+      QUERY_TRACKING_EVENTS = %w[jpie.slow_query_detected jpie.excessive_queries_detected].freeze
+
+      def emit(event)
+        ev = event.is_a?(Hash) ? event : event.to_h
+        name = ev[:name]
+        return unless QUERY_TRACKING_EVENTS.include?(name)
+
+        payload = ev[:payload] || {}
+        msg = if name == "jpie.slow_query_detected"
+                build_slow_query_message(payload)
+              else
+                build_excessive_queries_message(payload)
+              end
+        log_warn(msg, payload[:correlation_id])
+      end
+
+      private
+
+      def log_warn(msg, cid)
+        if cid.present?
+          Rails.logger.tagged("JPie", "CID(#{cid})") { Rails.logger.warn(msg) }
+        else
+          Rails.logger.warn("[JPie] #{msg}")
+        end
+      end
+
+      def build_slow_query_message(payload)
+        msg = "Slow query detected #{payload[:method]} #{payload[:path]}"
+        msg += " resource=#{resource_str(payload)}" if payload[:resource_type].present?
+        msg += " include=#{payload[:include]}" if payload[:include].present?
+        msg += " duration_ms=#{payload[:duration_ms]}" if payload[:duration_ms].present?
+        msg += " sql=#{payload[:sql]}" if payload[:sql].present?
+        msg
+      end
+
+      def build_excessive_queries_message(payload)
+        msg = "Excessive queries detected #{payload[:method]} #{payload[:path]}"
+        msg += " resource=#{resource_str(payload)}" if payload[:resource_type].present?
+        msg += " include=#{payload[:include]}" if payload[:include].present?
+        msg += " query_count=#{payload[:query_count]}" if payload[:query_count].present?
+        msg += " queries=#{payload[:queries].inspect}" if payload[:queries].present?
+        msg
+      end
+
+      def resource_str(payload)
+        rt = payload[:resource_type]
+        rid = payload[:resource_id]
+        rid.present? ? "#{rt}/#{rid}" : rt
+      end
+    end
+  end
+end

data/lib/json_api/support/query_tracking_subscriber.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Support
+    class QueryTrackingSubscriber
+      SKIP_PATTERNS = [
+        /\A\s*(BEGIN|COMMIT|ROLLBACK|SAVEPOINT|RELEASE\s+SAVEPOINT)\b/i,
+        /\A\s*(CREATE|ALTER|DROP)\s+(TABLE|INDEX|DATABASE)/i,
+        /\APRAGMA\b/i,
+        /sqlite_master|sqlite_temp_master/i,
+        /\bFROM\s+pg_/i,
+        /\A\s*(SET|SHOW)\s/i,
+      ].freeze
+
+      def call(name, start, finish, id, payload)
+        tracking = Thread.current[:jpie_query_tracking]
+        return if tracking.nil?
+
+        sql = payload[:sql]
+        return unless count_query?(sql)
+
+        tracking[:count] += 1
+        tracking[:queries] << sql
+
+        maybe_emit_slow_query(tracking, sql, name, start, finish, id, payload)
+      end
+
+      private
+
+      def count_query?(sql)
+        return false if sql.nil?
+
+        SKIP_PATTERNS.none? { |pattern| pattern.match?(sql) }
+      end
+
+      def maybe_emit_slow_query(tracking, sql, name, start, finish, id, payload) # rubocop:disable Metrics/ParameterLists
+        return unless defined?(Rails) && Rails.respond_to?(:event)
+
+        duration_ms = ActiveSupport::Notifications::Event.new(name, start, finish, id, payload).duration
+        threshold_ms = JSONAPI.configuration.slow_query_threshold_ms
+        return if duration_ms < threshold_ms
+
+        emit_slow_query_detected(tracking, sql, duration_ms, threshold_ms)
+      end
+
+      def emit_slow_query_detected(tracking, sql, duration_ms, threshold_ms)
+        event_payload = build_payload(tracking[:env]).merge(
+          sql: sql,
+          duration_ms: duration_ms,
+          threshold_ms: threshold_ms,
+        )
+
+        Rails.event.tagged("jsonapi", "slow_query") do
+          Rails.event.notify("jpie.slow_query_detected", event_payload)
+        end
+      end
+
+      def build_payload(env)
+        base = env.nil? ? {} : request_payload_from_env(env)
+        base.merge(correlation_id: JSONAPI::Support::CorrelationId.resolve)
+      end
+
+      def request_payload_from_env(env)
+        req = ActionDispatch::Request.new(env)
+        params = req.params
+        {
+          path: req.path,
+          method: req.request_method,
+          include: params[:include],
+          resource_type: params[:resource_type],
+          resource_id: params[:id],
+        }
+      end
+    end
+  end
+end

data/lib/json_api/support/relationship_guard.rb

@@ -10,7 +10,7 @@ module JSONAPI
       return unless association
       return unless readonly
 
-      raise JSONAPI::Exceptions::ParameterNotAllowed, [error_target]
+      raise JSONAPI::Errors::ParameterNotAllowed, [error_target]
     end
   end
 end

data/lib/json_api/support/resource_identifier.rb

@@ -58,7 +58,8 @@ module JSONAPI
 
     def find_related_record(type, id, association, is_polymorphic)
       related_model_class = resolve_related_model_class(type, association, is_polymorphic)
-      related_model_class.find(id)
+      resource_class = JSONAPI::ResourceLoader.find_for_model(related_model_class)
+      resource_class.records.find(id)
     rescue ActiveRecord::RecordNotFound
       raise ArgumentError, "Related resource not found: #{type} with id #{id}"
     rescue NameError

data/lib/json_api/support/responders.rb

@@ -94,7 +94,7 @@ module JSONAPI
     def status_code_for(status)
       return status if status.is_a?(String) && status.match?(/\A\d+\z/)
 
-      Rack::Utils::SYMBOL_TO_STATUS_CODE.fetch(status, status).to_s
+      ::Rack::Utils::SYMBOL_TO_STATUS_CODE.fetch(status, status).to_s
     end
   end
 end

data/lib/json_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSONAPI
-  VERSION = "1.5.1"
+  VERSION = "2.0.1"
 end

data/lib/json_api.rb

@@ -29,17 +29,25 @@ require "json_api/support/sort_parsing"
 require "json_api/support/resource_identifier"
 require "json_api/support/relationship_helpers"
 require "json_api/support/param_helpers"
+require "json_api/support/correlation_id"
 require "json_api/active_storage/detection"
 require "json_api/active_storage/serialization"
 require "json_api/active_storage/deserialization"
 require "json_api/support/active_storage_support"
+require "json_api/support/filter_parsing"
 require "json_api/support/collection_query"
+require "json_api/support/prosopite_instrumentation_logger"
+require "json_api/support/n1_log_subscriber"
+require "json_api/support/header_warning_subscriber"
+require "json_api/rack/n1_detection"
+require "json_api/support/query_tracking_subscriber"
+require "json_api/support/query_tracking_log_subscriber"
+require "json_api/rack/query_tracking"
 require "json_api/routing"
 require "json_api/support/responders"
 require "json_api/support/instrumentation"
 require "json_api/serialization/serializer"
 require "json_api/serialization/deserializer"
-require "json_api/support/response_helpers"
 require "json_api/controllers/concerns/controller_helpers"
 require "json_api/controllers/concerns/resource_actions"
 require "json_api/controllers/base_controller"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jpie
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 2.0.1
 platform: ruby
 authors:
 - Emil Kampp
@@ -15,40 +15,68 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '8.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.0.0
+        version: 8.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '8.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.0.0
+        version: 8.1.0
+- !ruby/object:Gem::Dependency
+  name: pg_query
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: prosopite
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '8.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.0.0
+        version: 8.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '8.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.0.0
+        version: 8.1.0
 description: A Rails 8+ gem that provides jsonapi_resources routing DSL and generic
   JSON:API controllers
 email:
@@ -94,22 +122,23 @@ files:
 - lib/json_api/controllers/concerns/resource_actions/crud_helpers.rb
 - lib/json_api/controllers/concerns/resource_actions/field_validation.rb
 - lib/json_api/controllers/concerns/resource_actions/filter_validation.rb
+- lib/json_api/controllers/concerns/resource_actions/include_preloading.rb
+- lib/json_api/controllers/concerns/resource_actions/include_validation.rb
 - lib/json_api/controllers/concerns/resource_actions/pagination.rb
-- lib/json_api/controllers/concerns/resource_actions/preloading.rb
 - lib/json_api/controllers/concerns/resource_actions/resource_loading.rb
 - lib/json_api/controllers/concerns/resource_actions/serialization.rb
 - lib/json_api/controllers/concerns/resource_actions/type_validation.rb
 - lib/json_api/controllers/relationships_controller.rb
 - lib/json_api/controllers/resources_controller.rb
 - lib/json_api/errors/parameter_not_allowed.rb
+- lib/json_api/rack/n1_detection.rb
+- lib/json_api/rack/query_tracking.rb
 - lib/json_api/railtie.rb
 - lib/json_api/resources/active_storage_blob_resource.rb
 - lib/json_api/resources/concerns/attributes_dsl.rb
-- lib/json_api/resources/concerns/eager_load_dsl.rb
 - lib/json_api/resources/concerns/filters_dsl.rb
 - lib/json_api/resources/concerns/meta_dsl.rb
 - lib/json_api/resources/concerns/model_class_helpers.rb
-- lib/json_api/resources/concerns/preload_dsl.rb
 - lib/json_api/resources/concerns/relationships_dsl.rb
 - lib/json_api/resources/concerns/sortable_fields_dsl.rb
 - lib/json_api/resources/resource.rb
@@ -118,6 +147,7 @@ files:
 - lib/json_api/serialization/concerns/attributes_deserialization.rb
 - lib/json_api/serialization/concerns/attributes_serialization.rb
 - lib/json_api/serialization/concerns/deserialization_helpers.rb
+- lib/json_api/serialization/concerns/include_filtering.rb
 - lib/json_api/serialization/concerns/includes_serialization.rb
 - lib/json_api/serialization/concerns/links_serialization.rb
 - lib/json_api/serialization/concerns/meta_serialization.rb
@@ -136,13 +166,19 @@ files:
 - lib/json_api/support/concerns/polymorphic_filters.rb
 - lib/json_api/support/concerns/regular_filters.rb
 - lib/json_api/support/concerns/sorting.rb
+- lib/json_api/support/correlation_id.rb
+- lib/json_api/support/filter_parsing.rb
+- lib/json_api/support/header_warning_subscriber.rb
 - lib/json_api/support/instrumentation.rb
+- lib/json_api/support/n1_log_subscriber.rb
 - lib/json_api/support/param_helpers.rb
+- lib/json_api/support/prosopite_instrumentation_logger.rb
+- lib/json_api/support/query_tracking_log_subscriber.rb
+- lib/json_api/support/query_tracking_subscriber.rb
 - lib/json_api/support/relationship_guard.rb
 - lib/json_api/support/relationship_helpers.rb
 - lib/json_api/support/resource_identifier.rb
 - lib/json_api/support/responders.rb
-- lib/json_api/support/response_helpers.rb
 - lib/json_api/support/sort_parsing.rb
 - lib/json_api/support/type_conversion.rb
 - lib/json_api/testing.rb

data/lib/json_api/controllers/concerns/resource_actions/preloading.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module ResourceActions
-    module Preloading
-      extend ActiveSupport::Concern
-
-      def preload_includes
-        includes_hash = build_combined_includes_hash
-        return if includes_hash.empty?
-
-        preload_resources(includes_hash)
-      rescue ActiveRecord::RecordNotFound
-        # Will be handled by set_resource
-      end
-
-      private
-
-      def build_combined_includes_hash
-        param_includes = parse_include_param
-        dsl_includes = resource_eager_load_associations
-
-        combined = dsl_includes.map(&:to_s)
-        combined.concat(param_includes)
-        combined.uniq!
-
-        build_includes_hash(combined)
-      end
-
-      def resource_eager_load_associations
-        return [] unless resource_class.respond_to?(:eager_load_associations)
-
-        resource_class.eager_load_associations
-      end
-
-      def build_includes_hash(includes)
-        includes.each_with_object({}) do |path, hash|
-          merge_include_path(hash, path)
-        end
-      end
-
-      def merge_include_path(hash, path)
-        parts = path.to_s.split(".")
-        current = hash
-
-        parts.each_with_index do |part, i|
-          sym = part.to_sym
-          current[sym] ||= {}
-          current = current[sym] if i < parts.length - 1
-        end
-      end
-
-      def preload_resources(includes_hash)
-        filtered = filter_includes_for_preload(includes_hash)
-
-        case action_name
-        when "index" then @preloaded_resources = preload_collection(filtered)
-        when "show" then @preloaded_resource = preload_single(filtered)
-        end
-      end
-
-      def filter_includes_for_preload(hash)
-        filtered = filter_active_storage_from_includes(hash, model_class)
-        filter_polymorphic_from_includes(filtered, model_class)
-      end
-
-      def preload_collection(includes)
-        return resource_class.records if includes.empty?
-
-        resource_class.records.includes(includes)
-      end
-
-      def preload_single(includes)
-        return resource_class.records.find(params[:id]) if includes.empty?
-
-        resource_class.records.includes(includes).find(params[:id])
-      end
-    end
-  end
-end

data/lib/json_api/resources/concerns/eager_load_dsl.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module Resources
-    module EagerLoadDsl
-      extend ActiveSupport::Concern
-
-      class_methods do
-        # Declare associations to always eager-load for this resource
-        # @param associations [Array<Symbol>] list of association names to eager-load
-        def eager_load(*associations)
-          @declared_eager_loads ||= []
-          @declared_eager_loads.concat(associations.map(&:to_sym))
-          reset_eager_load_associations!
-        end
-
-        # Get all eager-load associations including inherited ones
-        # @return [Array<Symbol>] frozen array of association names
-        def eager_load_associations
-          return @eager_load_associations if defined?(@eager_load_associations)
-
-          @eager_load_associations = build_eager_load_associations.freeze
-        end
-
-        def reset_eager_load_associations!
-          remove_instance_variable(:@eager_load_associations) if defined?(@eager_load_associations)
-        end
-      end
-
-      module EagerLoadHelperMethods
-        def build_eager_load_associations
-          own_associations = @declared_eager_loads || []
-          inherited = inherit_eager_load_associations
-          (inherited + own_associations).uniq
-        end
-
-        def inherit_eager_load_associations
-          return [] unless superclass.respond_to?(:eager_load_associations)
-          return [] if superclass == JSONAPI::Resource
-
-          superclass.eager_load_associations
-        end
-      end
-
-      included do
-        extend EagerLoadHelperMethods
-      end
-    end
-  end
-end

data/lib/json_api/resources/concerns/preload_dsl.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module Resources
-    module PreloadDsl
-      extend ActiveSupport::Concern
-
-      class_methods do
-        # Override this method in resource subclasses to preload data before serialization.
-        # This is called once with all records before serialization starts.
-        # Use this to batch-load data needed by meta methods to avoid N+1 queries.
-        #
-        # @param records [Array<ActiveRecord::Base>] the records that will be serialized
-        # @param context [Hash] optional context (e.g., current user, request params)
-        # @return [Hash] a hash of preloaded data keyed by record id
-        #
-        # @example
-        #   class WorkstreamResource < ApplicationResource
-        #     def self.preload_for_serialization(records, context = {})
-        #       stats = Preloaders::StatsPreloader.call(records: records)
-        #       { stats: stats }
-        #     end
-        #
-        #     def meta(...)
-        #       preloaded = self.class.preloaded_data[record.id]
-        #       super.merge(loading: preloaded[:stats])
-        #     end
-        #   end
-        def preload_for_serialization(_records, _context = {})
-          # Default implementation does nothing - override in subclasses
-          {}
-        end
-
-        # Storage for preloaded data (request-scoped via Thread.current)
-        def preloaded_data
-          Thread.current["#{name}_preloaded_data"] ||= {}
-        end
-
-        def preloaded_data=(data)
-          Thread.current["#{name}_preloaded_data"] = data
-        end
-
-        def clear_preloaded_data!
-          Thread.current["#{name}_preloaded_data"] = nil
-        end
-      end
-    end
-  end
-end