julewire-rails 1.0.0 → 1.1.0

data/lib/julewire/rails/parameter_filter_processor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/parameter_filter"
+require "julewire/rails/parameter_filters"
 
 module Julewire
   module Rails
@@ -8,70 +9,47 @@ module Julewire
       EMPTY_CONTAINER_MARKER = Core.sentinel(:empty_container)
       private_constant :EMPTY_CONTAINER_MARKER
 
-      def initialize(filters = rails_filter_parameters)
+      def initialize(filters = ParameterFilters.configured)
         @filter = build_filter(filters)
         # Rails exposes filter_param for scalar fields; use it to avoid whole-record
-        # copies when the filter list has no Proc semantics to preserve. Regex-only
-        # filters fall back to whole-record filtering unless they can scalarize a
-        # required record container.
-        @filter_param_fast_path = filter_param_safe?(filters) && @filter.respond_to?(:filter_param)
+        # copies when the filter list has no Proc semantics to preserve.
+        @filter_param_fast_path = filter_param_safe?(filters)
         @field_plan = ParameterFilterPlan.build(filters) if @filter_param_fast_path
       end
 
       def call(draft)
         validate_draft!(draft)
-        return if @filter.nil?
-
         @filter_param_fast_path ? filter_draft_fields!(draft) : filter_whole_record!(draft)
+        draft
       end
 
       private
 
       def validate_draft!(draft)
-        return draft if draft.is_a?(Julewire::RecordDraft)
+        return if draft.instance_of?(RecordDraft)
 
         raise TypeError, "expected Julewire::RecordDraft"
       end
 
       def build_filter(filters)
-        return filters if filters.respond_to?(:filter) && !filters.is_a?(Array)
-
-        filters = Array(filters)
-        return if filters.empty?
-
-        ::ActiveSupport::ParameterFilter.new(::ActiveSupport::ParameterFilter.precompile_filters(filters))
+        ParameterFilters.build(filters)
       end
 
       def filter_param_safe?(filters)
         return false if filters.respond_to?(:filter) && !filters.is_a?(Array)
 
         filters = Array(filters)
-        return false if filters.any?(Proc)
-
-        filters.none?(Regexp) || filters.any? { regexp_matches_record_container?(it) }
-      end
-
-      def regexp_matches_record_container?(filter)
-        filter.is_a?(Regexp) && Core::Processing::RecordFieldTransform.container_keys.any? { filter.match?(it.name) }
+        filters.none?(Proc)
       end
 
       def filter_draft_fields!(draft)
-        each_filter_field_key(draft) do |key|
-          next unless draft.key?(key)
-
-          value = draft[key]
+        draft.each_key do |key|
+          value = draft.fetch(key)
           next if skip_empty_container?(key, value)
 
           filtered = filter_record_param(key, value)
-          draft.transform_field!(key) { filtered } unless filtered.equal?(value)
+          draft.transform_field!(key) { filtered }
         end
-        draft
-      end
-
-      def each_filter_field_key(draft, &)
-        return @field_plan.filtered_field_keys.each(&) if @field_plan&.filtered_field_keys
-
-        draft.each_key(&)
       end
 
       def filter_whole_record!(draft)
@@ -79,12 +57,10 @@ module Julewire
       end
 
       def filter_record_param(key, value)
-        if @field_plan&.direct_container_filter? && record_container_key?(key) && value.is_a?(Hash)
-          return @field_plan.filter_value(value)
-        end
+        return @field_plan.filter_value(value) if @field_plan && record_container_key?(key)
 
         filtered = @filter.filter_param(key, value)
-        return filtered unless record_container_key?(key) && !filtered.is_a?(Hash)
+        return filtered unless record_container_key?(key) && !filtered.instance_of?(Hash)
         return value unless value.is_a?(Hash)
 
         @filter.filter(value)
@@ -104,14 +80,6 @@ module Julewire
       def record_container_key?(key)
         Core::Processing::RecordFieldTransform.container_key?(key)
       end
-
-      def rails_filter_parameters
-        app = ::Rails.application if defined?(::Rails) && ::Rails.respond_to?(:application)
-        config = app.config if app.respond_to?(:config)
-        config.filter_parameters if config.respond_to?(:filter_parameters)
-      rescue StandardError
-        []
-      end
     end
   end
 end

data/lib/julewire/rails/parameter_filters.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    module ParameterFilters
+      class << self
+        def configured
+          Array(::Rails.application.config.filter_parameters)
+        rescue StandardError
+          []
+        end
+
+        def build(filters)
+          return filters if filters.respond_to?(:filter) && !filters.is_a?(Array)
+
+          ActiveSupport::ParameterFilter.new(Array(filters))
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/railtie.rb

@@ -9,41 +9,53 @@ module Julewire
       config.julewire_rails = Configuration.new
 
       initializer "julewire_rails.logger", before: :initialize_logger do |app|
-        settings = app.config.julewire_rails
-        settings.validate!
-        next unless settings.logger?
-
-        logger = Logger.new(name: settings.logger_name, source: settings.source)
-        logger.level = ::Logger::Severity.const_get(app.config.log_level.to_s.upcase)
-        logger.formatter = app.config.log_formatter if app.config.respond_to?(:log_formatter)
-        app.config.logger = ::ActiveSupport::TaggedLogging.new(logger)
-        LoggerOutputs.install!
+        Railtie.initialize_logger!(app)
       end
 
       initializer "julewire_rails.request_middleware", before: :build_middleware_stack do |app|
-        settings = app.config.julewire_rails
-        settings.validate!
-        next unless settings.request_middleware?
-
-        self.class.install_request_middleware(app, settings, app.config.log_tags)
+        Railtie.initialize_request_middleware!(app)
       end
 
       initializer "julewire_rails.exception_logging", before: :build_middleware_stack do |app|
-        settings = app.config.julewire_rails
-        settings.validate!
-        self.class.configure_exception_logging(app, settings)
+        Railtie.initialize_exception_logging!(app)
       end
 
       config.after_initialize do |app|
-        settings = app.config.julewire_rails
-        settings.validate!
-        OutputRequirement.check!(settings)
-        LifecycleHooks.install!(settings)
-        Railtie.install_subscribers(settings)
-        DebugExceptionLogSilencer.install!(settings)
+        Railtie.finish_initialization!(app)
       end
 
       class << self
+        def initialize_logger!(app)
+          settings = validated_settings(app)
+          return unless settings.logger?
+
+          logger = Logger.new(name: settings.logger_name, source: settings.source)
+          logger.level = app.config.log_level
+          logger.formatter = app.config.log_formatter
+          app.config.logger = ::ActiveSupport::TaggedLogging.new(logger)
+          LoggerOutputs.install!
+        end
+
+        def initialize_request_middleware!(app)
+          settings = validated_settings(app)
+          return unless settings.request_middleware?
+
+          install_request_middleware(app, settings, app.config.log_tags)
+        end
+
+        def initialize_exception_logging!(app)
+          settings = validated_settings(app)
+          configure_exception_logging(app, settings)
+        end
+
+        def finish_initialization!(app)
+          settings = validated_settings(app)
+          OutputRequirement.check!(settings)
+          LifecycleHooks.install!(settings)
+          install_subscribers(settings)
+          DebugExceptionLogSilencer.install!(settings)
+        end
+
         def install_subscribers(settings)
           Subscribers::ControllerResponse.install!(settings)
           settings.error_reports? ? Subscribers::Error.install!(settings) : Subscribers::Error.reset!
@@ -70,13 +82,15 @@ module Julewire
         end
 
         def log_rescued_responses_value(settings)
-          if settings.log_rescued_responses == :auto
-            return false if settings.logger? && settings.request_summary?
+          return settings.log_rescued_responses unless settings.log_rescued_responses == :auto
 
-            return
-          end
+          false if settings.logger? && settings.request_summary?
+        end
+
+        private
 
-          settings.log_rescued_responses
+        def validated_settings(app)
+          app.config.julewire_rails.tap(&:validate!)
         end
       end
     end

data/lib/julewire/rails/request_attributes.rb

@@ -9,7 +9,7 @@ module Julewire
           values = Core::Integration::Values::Shape
           {}.tap do |fields|
             values.append_field(fields, :request_id, request.id)
-            values.append_field(fields, :http_method, request.method)
+            values.append_field(fields, :http_method, request.request_method)
             values.append_field(fields, :path, request.path)
             values.append_field(fields, :remote_ip, request.remote_ip)
           end
@@ -26,16 +26,8 @@ module Julewire
           }
         end
 
-        def rendered_error_summary(request, rendered_error, status:)
-          error_summary(
-            request,
-            rendered_error.fetch(:error),
-            status: status,
-            wrapper: nil
-          ).tap do |fields|
-            fields[:attributes][:rails][:rescue_response] = rendered_error[:rescue_response]
-            fields[:attributes][:rails][:rescue_template] = rendered_error[:rescue_template]
-          end
+        def rendered_error_details(rendered_error)
+          apply_rendered_error_metadata(error_details(rendered_error.fetch(:error), wrapper: nil), rendered_error)
         end
 
         def error_summary(request, error, status:, wrapper:)
@@ -45,10 +37,23 @@ module Julewire
           }
         end
 
+        def error_details(error, wrapper:)
+          {
+            attributes: { rails: rails_exception_attributes(error, wrapper: wrapper) },
+            neutral: {}
+          }
+        end
+
         def request_id(request)
           request_fields(request).id
         end
 
+        # Rack headers and parsed bodies are user input. Normalize them before
+        # passing adapter-owned records to the core integration boundary.
+        def normalize_user_fields(fields)
+          Core::Fields::FieldSet.deep_symbolize_keys(fields)
+        end
+
         private
 
         def request_neutral_attributes(request)
@@ -58,7 +63,7 @@ module Julewire
           values.append_field(
             fields,
             Core::Fields::AttributeKeys::HTTP_REQUEST_METHOD,
-            request.method
+            request.request_method
           )
           values.append_field(fields, Core::Fields::AttributeKeys::URL_FULL, request.filtered_url)
           values.append_field(fields, Core::Fields::AttributeKeys::URL_PATH, request.path)
@@ -82,20 +87,36 @@ module Julewire
         def rails_error_attributes(request, error, status:, wrapper:)
           rails_request_attributes(request).tap do |rails|
             values = Core::Integration::Values::Shape
-            values.append_field(rails, :error_class, error.class.name)
             values.append_field(rails, :status, status)
-            values.append_field(rails, :rescue_response, rescue_response?(wrapper))
-            values.append_field(rails, :rescue_template, rescue_template(wrapper))
+            rails_exception_attributes(error, wrapper: wrapper).each do |key, value|
+              values.append_field(rails, key, value)
+            end
           end
         end
 
+        def rails_exception_attributes(error, wrapper:)
+          values = Core::Integration::Values::Shape
+          {}.tap do |fields|
+            values.append_field(fields, :error_class, error.class.name)
+            values.append_field(fields, :rescue_response, rescue_response?(wrapper))
+            values.append_field(fields, :rescue_template, rescue_template(wrapper))
+          end
+        end
+
+        def apply_rendered_error_metadata(fields, rendered_error)
+          rails = fields.fetch(:attributes).fetch(:rails)
+          rails[:rescue_response] = rendered_error[:rescue_response]
+          rails[:rescue_template] = rendered_error[:rescue_template]
+          fields
+        end
+
         def rails_request_attributes(request)
           request = request_fields(request)
           values = Core::Integration::Values::Shape
           {}.tap do |fields|
             values.append_field(fields, :filtered_url, request.filtered_url)
             values.append_field(fields, :filtered_path, request.filtered_path)
-            values.append_field(fields, :request_method, request.method)
+            values.append_field(fields, :request_method, request.request_method)
             values.append_field(fields, :path, request.path)
             values.append_field(fields, :user_agent, request.user_agent)
           end

data/lib/julewire/rails/request_completion.rb

@@ -1,19 +1,25 @@
 # frozen_string_literal: true
 
+require "concurrent/atomic/atomic_boolean"
+
 module Julewire
   module Rails
     class RequestCompletion
       class << self
         def finish_instrumentation(instrumenter_handle)
-          instrumenter_handle&.finish
+          instrumenter_handle.finish
         rescue StandardError
           nil
         ensure
-          begin
-            ::ActiveSupport::LogSubscriber.flush_all!
-          rescue StandardError
-            nil
-          end
+          flush_log_subscribers
+        end
+
+        private
+
+        def flush_log_subscribers
+          ::ActiveSupport::LogSubscriber.flush_all!
+        rescue StandardError
+          nil
         end
       end
 
@@ -50,21 +56,17 @@ module Julewire
         response_finished = @env["rack.response_finished"]
         return unless response_finished.respond_to?(:<<)
 
-        response_finished << proc do |_rack_env, _status, _headers, error|
+        response_finished << lambda do |_rack_env, _status, _headers, error|
           finish_once.call(error)
         end
       end
 
       def completion_callback
-        mutex = Mutex.new
-        finished = false
+        finished = Concurrent::AtomicBoolean.new
         lambda do |error|
-          mutex.synchronize do
-            return if finished
+          return unless finished.make_true
 
-            finished = true
-          end
-          yield if block_given?
+          yield
           @execution_handle.with_context { finish_completion(error) }
         end
       end
@@ -90,12 +92,12 @@ module Julewire
       end
 
       def completion_timeout_context
-        return {} unless @configuration.request_context?
+        return unless @configuration.request_context?
 
         {
           request_id: request_id,
           path: @request.path
-        }.compact
+        }
       end
 
       def emit_completion_timeout_warning(timeout, context)
@@ -103,17 +105,16 @@ module Julewire
           event: "request.completion_timeout",
           logger: @configuration.logger_name,
           source: @configuration.source,
-          attributes: { rails: { completion_timeout_ms: (timeout * 1000).round } }
+          attributes: { rails: { completion_timeout_ms: (timeout * 1000).round } },
+          context: context
         }
-        record[:context] = context unless context.empty?
         Julewire.warn(record)
       rescue StandardError
         nil
       end
 
       def request_id
-        value = @request.request_id if @request.respond_to?(:request_id)
-        value || @request.get_header("action_dispatch.request_id") || @request.get_header("HTTP_X_REQUEST_ID")
+        RequestAttributes.request_id(@request)
       end
     end
   end

data/lib/julewire/rails/request_context.rb

@@ -3,7 +3,12 @@
 module Julewire
   module Rails
     class RequestContext
-      def initialize(configuration:, request:, active_support_context: Core::UNSET, event_reporter: Core::UNSET)
+      def initialize(
+        configuration:,
+        request:,
+        active_support_context: Julewire::Core::UNSET,
+        event_reporter: Julewire::Core::UNSET
+      )
         @configuration = configuration
         @request = request
         @active_support_context = default_provider(active_support_context) { ::ActiveSupport::ExecutionContext }
@@ -23,14 +28,14 @@ module Julewire
       private
 
       def default_provider(value)
-        value.equal?(Core::UNSET) ? yield : value
+        value.equal?(Julewire::Core::UNSET) ? yield : value
       end
 
       def with_request_context(&)
         return yield unless @configuration.request_context?
 
         fields = RequestAttributes.context_fields(@request)
-        Core::Integration::Facade.with_context(fields) do
+        Julewire::Core::Integration::Facade.with_context(fields) do
           with_active_support_execution_context(fields) do
             with_rails_event_context(fields, &)
           end
@@ -41,10 +46,14 @@ module Julewire
         return yield unless @configuration.carry_request_headers
         raise ArgumentError, "carry_request_headers must be an explicit header list" if all_carry_headers?
 
-        headers = Julewire::Rack::Capture::Headers.request(@request, selector: @configuration.carry_request_headers)
+        headers = Julewire::Rack::Capture::Headers.request(
+          @request,
+          selector: @configuration.carry_request_headers
+        )
         return yield if headers.empty?
 
-        Core::Integration::Facade.with_carry(http: { request_headers: headers }, &)
+        headers = RequestAttributes.normalize_user_fields(headers)
+        Julewire::Core::Integration::Facade.with_carry(http: { request_headers: headers }, &)
       end
 
       def all_carry_headers?
@@ -67,7 +76,7 @@ module Julewire
           @event_reporter.set_context(fields)
           context_set = true
         rescue StandardError
-          return yield
+          nil
         end
         yield
       ensure
@@ -81,8 +90,21 @@ module Julewire
       end
 
       def restore_rails_event_context(previous)
+        return unless clear_rails_event_context
+        return if previous.nil? || previous.empty?
+
+        apply_rails_event_context(previous)
+      end
+
+      def clear_rails_event_context
         @event_reporter.clear_context
-        @event_reporter.set_context(previous) unless previous.nil? || previous.empty?
+        true
+      rescue StandardError
+        false
+      end
+
+      def apply_rails_event_context(previous)
+        @event_reporter.set_context(previous)
       rescue StandardError
         nil
       end

data/lib/julewire/rails/request_error_ownership.rb

@@ -11,25 +11,19 @@ module Julewire
       class << self
         def clear
           ::ActiveSupport::IsolatedExecutionState.delete(KEY)
-        rescue StandardError
-          nil
         end
 
         def mark(error)
-          return unless error
-
-          errors = error_map
-          each_exception(error) { errors[it] = true }
-        rescue StandardError
-          nil
+          each_exception(error) { error_map[it] = true }
         end
 
         def consume?(error)
           errors = current_error_map
           return false unless errors
 
-          each_exception(error).any? { errors.delete(it) }
-        rescue StandardError
+          each_exception(error) do |exception|
+            return true if errors.delete(exception)
+          end
           false
         end
 
@@ -40,22 +34,20 @@ module Julewire
         end
 
         def set_error_map
-          ObjectSpace::WeakKeyMap.new.tap { ::ActiveSupport::IsolatedExecutionState[KEY] = it }
+          ObjectSpace::WeakMap.new.tap { ::ActiveSupport::IsolatedExecutionState[KEY] = it }
         end
 
         def current_error_map
           ::ActiveSupport::IsolatedExecutionState[KEY]
         end
 
-        def each_exception(error)
-          return enum_for(:each_exception, error) unless block_given?
+        def each_exception(error, seen = {}.compare_by_identity, &)
+          return unless error
+          return if seen.key?(error)
 
-          seen = {}.compare_by_identity
-          while error && !seen.key?(error)
-            yield error
-            seen[error] = true
-            error = error.cause
-          end
+          seen[error] = nil
+          yield error
+          each_exception(error.cause, seen, &)
         end
       end
     end

data/lib/julewire/rails/request_fields.rb

@@ -16,7 +16,7 @@ module Julewire
         nil
       end
 
-      def method
+      def request_method
         @request.request_method
       end
 
@@ -40,7 +40,7 @@ module Julewire
 
       def remote_ip
         env = @request.env if @request.respond_to?(:env)
-        return env[REMOTE_IP_ENV_KEY] if env&.key?(REMOTE_IP_ENV_KEY)
+        return env.fetch(REMOTE_IP_ENV_KEY) if env&.key?(REMOTE_IP_ENV_KEY)
 
         value = @request.remote_ip
         env[REMOTE_IP_ENV_KEY] = value if env

data/lib/julewire/rails/request_lifecycle.rb

@@ -3,23 +3,16 @@
 module Julewire
   module Rails
     class RequestLifecycle
-      attr_reader :execution_handle
-
       def initialize(configuration:, env:, request:, taggers:)
         @configuration = configuration
         @env = env
         @request = request
         @taggers = taggers
-        @completion_attached = false
-        @execution_handle = nil
-        @instrumenter_handle = nil
-        @tag_count = 0
       end
 
       def start
         @tag_count = push_tags
         @instrumenter_handle = start_request_instrumentation
-        self
       end
 
       def start_execution!(neutral:)
@@ -60,7 +53,7 @@ module Julewire
       private
 
       def push_tags
-        return 0 unless ::Rails.logger.respond_to?(:push_tags)
+        return unless ::Rails.logger.respond_to?(:push_tags)
 
         ::Rails.logger.push_tags(*compute_tags).size
       end
@@ -88,12 +81,13 @@ module Julewire
       end
 
       def finish_request_thread_logging
-        return unless @tag_count.to_i.positive? && ::Rails.logger.respond_to?(:pop_tags)
+        return unless @tag_count&.positive?
 
-        ::Rails.logger.pop_tags(@tag_count)
-        @tag_count = 0
-      rescue StandardError
-        nil
+        begin
+          ::Rails.logger.pop_tags(@tag_count)
+        rescue StandardError
+          nil
+        end
       end
 
       def finish_unattached_request