julewire-rails 1.0.0

data/lib/julewire/rails/logger_outputs.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_support/logger"
+
+module Julewire
+  module Rails
+    module LoggerOutputs
+      class << self
+        def install!
+          return if @installed
+
+          ::ActiveSupport::Logger.singleton_class.prepend(Patch)
+          @installed = true
+        end
+
+        def julewire_logger?(logger)
+          loggers = logger.respond_to?(:broadcasts) ? logger.broadcasts : [logger]
+          loggers.any?(Logger)
+        end
+
+        def console_sources?(sources)
+          sources.any? { it.equal?($stdout) || it.equal?($stderr) }
+        end
+      end
+
+      module Patch
+        def logger_outputs_to?(logger, *sources)
+          return true if LoggerOutputs.julewire_logger?(logger) && LoggerOutputs.console_sources?(sources)
+
+          super
+        end
+      end
+      private_constant :Patch
+    end
+  end
+end

data/lib/julewire/rails/output_requirement.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    module OutputRequirement
+      MESSAGE = "julewire-rails installed Rails.logger, but Julewire has no configured destinations. " \
+                "Configure Julewire.destinations or set config.julewire_rails.require_output = false."
+
+      class << self
+        def check!(settings, health: Julewire.health, warning: Warning)
+          return unless settings.logger?
+
+          mode = normalized_mode(settings.require_output)
+          return if mode == false || health.dig(:pipeline, :configured)
+
+          case mode
+          when :warn
+            warning.warn("#{MESSAGE}\n")
+          when :raise
+            raise Error, MESSAGE
+          end
+        end
+
+        private
+
+        def normalized_mode(value)
+          case value
+          when false, nil then false
+          when true, :warn, "warn" then :warn
+          when :raise, "raise" then :raise
+          else
+            raise Error, "config.julewire_rails.require_output must be false, :warn, or :raise"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/parameter_filter_plan.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    class ParameterFilterPlan
+      FILTERED = ::ActiveSupport::ParameterFilter::FILTERED
+      RECORD_CONTAINER_KEYS = Core::Processing::RecordFieldTransform.container_keys
+      RECORD_SCALAR_KEYS = Core::Processing::RecordFieldTransform.scalar_keys
+      private_constant :FILTERED
+      private_constant :RECORD_CONTAINER_KEYS
+      private_constant :RECORD_SCALAR_KEYS
+
+      attr_reader :filtered_field_keys
+
+      class << self
+        def build(filters)
+          filters = Array(filters)
+          return if filters.any? { it.is_a?(Regexp) || it.is_a?(Proc) }
+
+          new(filters)
+        end
+      end
+
+      def initialize(filters)
+        simple, deep = partition_filters(filters)
+        @filtered_field_keys = build_filtered_field_keys(simple, deep)
+        @direct_container_filter = simple.any? && deep.empty?
+        @simple_pattern = simple_filter_pattern(simple) if @direct_container_filter
+      end
+
+      def direct_container_filter? = @direct_container_filter
+
+      def filter_value(value)
+        return filter_hash(value) if value.is_a?(Hash)
+        return filter_array(value) if value.is_a?(Array)
+
+        value
+      end
+
+      private
+
+      def partition_filters(filters)
+        filters.map { it.to_s.downcase }.partition { !it.include?(".") }
+      end
+
+      def build_filtered_field_keys(simple, deep)
+        (container_filter_keys(simple, deep) + scalar_filter_keys(simple)).uniq.freeze
+      end
+
+      def container_filter_keys(simple, deep)
+        return RECORD_CONTAINER_KEYS if simple.any?
+
+        deep.filter_map { it.split(".", 2).first&.to_sym }
+      end
+
+      def scalar_filter_keys(simple)
+        RECORD_SCALAR_KEYS.filter do |key|
+          name = key_name(key)
+          simple.any? { name.include?(it) }
+        end
+      end
+
+      def simple_filter_pattern(filters)
+        Regexp.new(filters.map { Regexp.escape(it) }.join("|"), Regexp::IGNORECASE)
+      end
+
+      def filter_hash(value)
+        result = nil
+        value.each do |key, item|
+          filtered = simple_key_match?(key) ? FILTERED : filter_value(item)
+          next if filtered.equal?(item)
+
+          result ||= value.dup
+          result[key] = filtered
+        end
+        result || value
+      end
+
+      def filter_array(value)
+        result = nil
+        value.each_with_index do |item, index|
+          filtered = filter_value(item)
+          next if filtered.equal?(item)
+
+          result ||= value.dup
+          result[index] = filtered
+        end
+        result || value
+      end
+
+      def simple_key_match?(key)
+        @simple_pattern.match?(key_name(key))
+      end
+
+      def key_name(key)
+        key.is_a?(Symbol) ? key.name : key.to_s
+      end
+    end
+  end
+end

data/lib/julewire/rails/parameter_filter_processor.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "active_support/parameter_filter"
+
+module Julewire
+  module Rails
+    class ParameterFilterProcessor
+      EMPTY_CONTAINER_MARKER = Core.sentinel(:empty_container)
+      private_constant :EMPTY_CONTAINER_MARKER
+
+      def initialize(filters = rails_filter_parameters)
+        @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)
+        @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)
+      end
+
+      private
+
+      def validate_draft!(draft)
+        return draft if draft.is_a?(Julewire::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))
+      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) }
+      end
+
+      def filter_draft_fields!(draft)
+        each_filter_field_key(draft) do |key|
+          next unless draft.key?(key)
+
+          value = draft[key]
+          next if skip_empty_container?(key, value)
+
+          filtered = filter_record_param(key, value)
+          draft.transform_field!(key) { filtered } unless filtered.equal?(value)
+        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)
+        draft.transform_record! { @filter.filter(it) }
+      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
+
+        filtered = @filter.filter_param(key, value)
+        return filtered unless record_container_key?(key) && !filtered.is_a?(Hash)
+        return value unless value.is_a?(Hash)
+
+        @filter.filter(value)
+      end
+
+      def skip_empty_container?(key, value)
+        return false unless empty_container?(value)
+        return true if record_container_key?(key)
+
+        @filter.filter_param(key, EMPTY_CONTAINER_MARKER).equal?(EMPTY_CONTAINER_MARKER)
+      end
+
+      def empty_container?(value)
+        (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
+      end
+
+      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/railtie.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "active_support/tagged_logging"
+require "rails/rack/logger"
+
+module Julewire
+  module Rails
+    class Railtie < ::Rails::Railtie
+      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!
+      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)
+      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)
+      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)
+      end
+
+      class << self
+        def install_subscribers(settings)
+          Subscribers::ControllerResponse.install!(settings)
+          settings.error_reports? ? Subscribers::Error.install!(settings) : Subscribers::Error.reset!
+          Subscribers::RenderedException.install!(settings)
+          if settings.structured_events?
+            Subscribers::Event.install!(settings)
+            LogSubscriberSilencer.silence! if settings.silence_log_subscribers?
+          else
+            Subscribers::Event.reset!
+          end
+        end
+
+        def install_request_middleware(app, settings, log_tags = nil)
+          operation = settings.replace_rack_logger? ? :swap : :insert_after
+          app.config.middleware.public_send(operation, ::Rails::Rack::Logger, RequestMiddleware, settings, log_tags)
+        rescue StandardError => e
+          IntegrationHealth.record_failure(e, component: :request_middleware, action: :install)
+          raise
+        end
+
+        def configure_exception_logging(app, settings)
+          value = log_rescued_responses_value(settings)
+          app.config.action_dispatch.log_rescued_responses = value unless value.nil?
+        end
+
+        def log_rescued_responses_value(settings)
+          if settings.log_rescued_responses == :auto
+            return false if settings.logger? && settings.request_summary?
+
+            return
+          end
+
+          settings.log_rescued_responses
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/request_attributes.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    module RequestAttributes
+      class << self
+        def context_fields(request)
+          request = request_fields(request)
+          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, :path, request.path)
+            values.append_field(fields, :remote_ip, request.remote_ip)
+          end
+        end
+
+        def request(request)
+          request_neutral_attributes(request)
+        end
+
+        def response_summary(request, status, headers)
+          {
+            attributes: { rails: rails_response_attributes(request, status, headers) },
+            neutral: neutral_fields(Core::Fields::AttributeKeys::HTTP_RESPONSE_STATUS_CODE => status)
+          }
+        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
+        end
+
+        def error_summary(request, error, status:, wrapper:)
+          {
+            attributes: { rails: rails_error_attributes(request, error, status: status, wrapper: wrapper) },
+            neutral: neutral_fields(Core::Fields::AttributeKeys::HTTP_RESPONSE_STATUS_CODE => status)
+          }
+        end
+
+        def request_id(request)
+          request_fields(request).id
+        end
+
+        private
+
+        def request_neutral_attributes(request)
+          request = request_fields(request)
+          values = Core::Integration::Values::Shape
+          fields = {}
+          values.append_field(
+            fields,
+            Core::Fields::AttributeKeys::HTTP_REQUEST_METHOD,
+            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)
+          values.append_field(
+            fields,
+            Core::Fields::AttributeKeys::USER_AGENT_ORIGINAL,
+            request.user_agent
+          )
+          values.append_field(fields, Core::Fields::AttributeKeys::CLIENT_ADDRESS, request.remote_ip)
+          fields
+        end
+
+        def rails_response_attributes(request, status, headers)
+          rails_request_attributes(request).tap do |rails|
+            values = Core::Integration::Values::Shape
+            values.append_field(rails, :status, status)
+            values.append_field(rails, :response_content_type, response_header(headers, "content-type"))
+          end
+        end
+
+        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))
+          end
+        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, :path, request.path)
+            values.append_field(fields, :user_agent, request.user_agent)
+          end
+        end
+
+        def rescue_response?(wrapper)
+          wrapper.rescue_response?
+        rescue StandardError
+          false
+        end
+
+        def rescue_template(wrapper)
+          wrapper.rescue_template
+        rescue StandardError
+          nil
+        end
+
+        def response_header(headers, key)
+          Julewire::Rack::Capture::BodyContentType.header_value(headers, key)
+        end
+
+        def request_fields(request) = RequestFields.new(request)
+
+        def neutral_fields(fields) = Core::Fields::AttributeKeys.fields(fields)
+      end
+    end
+  end
+end

data/lib/julewire/rails/request_completion.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    class RequestCompletion
+      class << self
+        def finish_instrumentation(instrumenter_handle)
+          instrumenter_handle&.finish
+        rescue StandardError
+          nil
+        ensure
+          begin
+            ::ActiveSupport::LogSubscriber.flush_all!
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      def initialize(configuration:, execution_handle:, instrumenter_handle:, env:, request:, request_error:)
+        @configuration = configuration
+        @execution_handle = execution_handle
+        @instrumenter_handle = instrumenter_handle
+        @env = env
+        @request = request
+        @request_error = request_error
+      end
+
+      def attach(response)
+        status, headers, body = response
+        timeout_token = nil
+        finish_once = completion_callback { RequestSummaryTimeoutScheduler.cancel(timeout_token) }
+        install_response_finished_callback(finish_once)
+        timeout_token = install_completion_timeout
+        body = ContextBodyProxy.new(body, handle: @execution_handle, on_close: -> { finish_once.call(nil) })
+        response.frozen? ? [status, headers, body] : response.tap { it[2] = body }
+      end
+
+      private
+
+      def install_completion_timeout
+        timeout = @configuration.request_summary_timeout
+        return unless timeout
+
+        context = completion_timeout_context
+        RequestSummaryTimeoutScheduler.schedule(timeout) { emit_completion_timeout_warning(timeout, context) }
+      end
+
+      def install_response_finished_callback(finish_once)
+        response_finished = @env["rack.response_finished"]
+        return unless response_finished.respond_to?(:<<)
+
+        response_finished << proc do |_rack_env, _status, _headers, error|
+          finish_once.call(error)
+        end
+      end
+
+      def completion_callback
+        mutex = Mutex.new
+        finished = false
+        lambda do |error|
+          mutex.synchronize do
+            return if finished
+
+            finished = true
+          end
+          yield if block_given?
+          @execution_handle.with_context { finish_completion(error) }
+        end
+      end
+
+      def finish_completion(error)
+        self.class.finish_instrumentation(@instrumenter_handle)
+        if error
+          @execution_handle.finish(
+            reason: :error,
+            attributes: { rails: { completion: "error", completion_error_class: error.class.name } },
+            error: error
+          )
+        elsif @request_error
+          @execution_handle.finish(
+            reason: :error,
+            attributes: { rails: { completion: "error" } },
+            error: @request_error.fetch(:error),
+            severity: @request_error.fetch(:severity)
+          )
+        else
+          @execution_handle.finish(reason: :closed, attributes: { rails: { completion: "closed" } })
+        end
+      end
+
+      def completion_timeout_context
+        return {} unless @configuration.request_context?
+
+        {
+          request_id: request_id,
+          path: @request.path
+        }.compact
+      end
+
+      def emit_completion_timeout_warning(timeout, context)
+        record = {
+          event: "request.completion_timeout",
+          logger: @configuration.logger_name,
+          source: @configuration.source,
+          attributes: { rails: { completion_timeout_ms: (timeout * 1000).round } }
+        }
+        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")
+      end
+    end
+  end
+end