julewire-rails 1.0.0

data/lib/julewire/rails/subscribers/controller_response.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module Julewire
+  module Rails
+    module Subscribers
+      class ControllerResponse
+        EVENT_NAME = "process_action.action_controller"
+
+        class << self
+          include Core::Integration::SubscriberInstall
+
+          def install!(configuration)
+            return reset! unless configuration.controller_capture?
+
+            install_subscriber(configuration, enabled: true) do |subscriber|
+              subscription = ::ActiveSupport::Notifications.subscribe(EVENT_NAME) do |*arguments|
+                subscriber.process_action(::ActiveSupport::Notifications::Event.new(*arguments))
+              end
+              -> { ::ActiveSupport::Notifications.unsubscribe(subscription) }
+            end
+          end
+        end
+
+        def initialize(configuration = Configuration.new)
+          @configuration = configuration
+        end
+
+        attr_writer :configuration
+
+        def process_action(event)
+          return unless Julewire.current_execution?
+          return if Suppression.active?
+
+          IntegrationHealth.with_failure_health(action: :process_action, component: :controller_response_subscriber) do
+            fields = capture_attributes(event.payload)
+            Core::Integration::Facade.add_summary_attributes(fields[:attributes])
+            Core::Integration::Facade.add_summary_neutral(fields[:neutral])
+          end
+        end
+
+        private
+
+        def capture_attributes(payload)
+          rails_fields = capture_fields(payload)
+          neutral = {}
+          response_body_bytes = rails_fields[:response_body_bytes]
+          if response_body_bytes
+            neutral = {
+              Core::Fields::AttributeKeys::HTTP_RESPONSE_BODY_SIZE => response_body_bytes
+            }
+          end
+          { attributes: { rails: rails_fields }, neutral: neutral }
+        end
+
+        def capture_fields(payload)
+          fields = {}
+          merge_capture_fields(fields, request_headers_fields(payload))
+          merge_capture_fields(
+            fields,
+            body_fields_for(:request, payload[:request], Julewire::Rack::Capture::RequestBody)
+          )
+          merge_capture_fields(fields, response_headers_fields(payload))
+          merge_capture_fields(
+            fields,
+            body_fields_for(:response, payload[:response], Julewire::Rack::Capture::BufferedResponseBody)
+          )
+          fields
+        end
+
+        def request_headers_fields(payload)
+          return unless @configuration.request_capture.headers?
+
+          capture_headers(:request_headers) do
+            Julewire::Rack::Capture::Headers.request(
+              payload[:request],
+              selector: @configuration.request_capture.headers
+            )
+          end
+        end
+
+        def response_headers_fields(payload)
+          response = payload[:response]
+          return unless @configuration.response_capture.headers? && response
+
+          capture_headers(:response_headers) do
+            Julewire::Rack::Capture::Headers.response(
+              response.headers,
+              selector: @configuration.response_capture.headers
+            )
+          end
+        end
+
+        def body_fields_for(type, target, capture)
+          capture_configuration = @configuration.public_send("#{type}_capture")
+          return unless capture_configuration.body?
+
+          capture.call(
+            target,
+            content_types: capture_configuration.body_content_types,
+            limit: capture_configuration.body_bytes,
+            mode: capture_configuration.body_mode
+          )
+        end
+
+        def capture_headers(key)
+          headers = yield
+          headers.empty? ? nil : { key => headers }
+        end
+
+        def merge_capture_fields(fields, captured)
+          fields.merge!(captured) if captured && !captured.empty?
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/subscribers/error.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    module Subscribers
+      class Error
+        class << self
+          include Core::Integration::SubscriberInstall
+
+          def install!(configuration)
+            return reset! unless configuration.error_reports?
+            return unless defined?(::Rails) && ::Rails.respond_to?(:error)
+            return unless ::Rails.error.respond_to?(:subscribe)
+
+            reporter = ::Rails.error
+            install_subscriber(configuration, enabled: true) do |subscriber|
+              Julewire::RailsSupport::EventReporter.subscribe(reporter, subscriber)
+            end
+          end
+        end
+
+        def initialize(configuration = Configuration.new)
+          @configuration = configuration
+        end
+
+        attr_writer :configuration
+
+        def report(error, handled:, severity:, context:, source:)
+          return unless @configuration.error_reports?
+          return if Suppression.active?
+          return if request_owned_dispatch_error?(error, handled, source)
+
+          Core::Integration::Facade.emit(
+            severity: julewire_severity(severity),
+            event: "rails.error",
+            logger: "Rails.error",
+            source: @configuration.source,
+            context: hash_or_empty(context),
+            attributes: { rails: {
+              handled: handled,
+              source: source
+            } },
+            error: error
+          )
+          IntegrationHealth.record_success(action: :report, component: :error_subscriber)
+        rescue StandardError => e
+          IntegrationHealth.record_failure(
+            e,
+            action: :report,
+            component: :error_subscriber
+          )
+        end
+
+        private
+
+        def request_owned_dispatch_error?(error, handled, source)
+          return false unless handled == false
+          return false unless source == "application.action_dispatch"
+
+          RequestErrorOwnership.consume?(error)
+        end
+
+        def julewire_severity(severity)
+          severity.to_sym == :warning ? :warn : severity
+        rescue StandardError
+          severity
+        end
+
+        def hash_or_empty(value)
+          return {} unless value.is_a?(Hash)
+
+          values = Core::Integration::Values::Shape
+          normalize_context(values.hash_or_empty(value))
+        end
+
+        def normalize_context(context)
+          controller = context[:controller]
+          return context unless context.key?(:controller)
+          return context if controller.nil? || controller.is_a?(String)
+
+          context.merge(controller: controller.class.name || controller.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/subscribers/event.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    module Subscribers
+      class Event
+        include Core::Integration::EventSubscriber
+
+        STRUCTURED_EVENT_FILES = %w[
+          action_controller/structured_event_subscriber
+          action_dispatch/structured_event_subscriber
+          action_view/structured_event_subscriber
+          active_record/structured_event_subscriber
+        ].freeze
+
+        REQUEST_STARTED = "action_controller.request_started"
+        REQUEST_COMPLETED = "action_controller.request_completed"
+        REQUEST_CONTEXT_KEYS = %i[controller action format].freeze
+
+        event_subscriber integration_health: IntegrationHealth, configuration_class: Configuration
+
+        class << self
+          include Core::Integration::SubscriberInstall
+
+          def install!(configuration)
+            return reset! unless configuration.structured_events?
+
+            require_structured_event_subscribers
+            reporter = Julewire::RailsSupport::EventReporter.default
+            return unless Julewire::RailsSupport::EventReporter.subscribable?(reporter)
+
+            install_subscriber(configuration, enabled: true) do |subscriber|
+              Julewire::RailsSupport::EventReporter.subscribe(reporter, subscriber) do |event|
+                subscriber.accept?(event)
+              end
+            end
+          end
+
+          private
+
+          def require_structured_event_subscribers
+            STRUCTURED_EVENT_FILES.each { Core::Integration::Lifecycle.require_optional(it) }
+          end
+        end
+
+        def accept?(event)
+          return false unless @configuration.structured_events?
+          return false if Suppression.active?
+
+          name = event[:name].to_s
+          return false if excluded_event?(name)
+
+          included_event?(name)
+        end
+
+        private
+
+        def emit_event(event)
+          name = event[:name].to_s
+          payload = event_record.payload_hash(event[:payload])
+
+          if name == REQUEST_STARTED && current_execution?
+            enrich_request_start(payload)
+          elsif name == REQUEST_COMPLETED && current_execution?
+            enrich_request_completion(payload)
+          else
+            Core::Integration::Facade.emit(event_record.call(event, name: name, payload: payload))
+          end
+        end
+
+        def after_configuration_change
+          @event_record = nil
+        end
+
+        def current_execution?
+          Julewire.current_execution?
+        end
+
+        def included_event?(name)
+          names = @configuration.structured_event_names
+          prefixes = @configuration.structured_event_prefixes
+          return true if prefixes.nil?
+          return true if Array(names).any? { name == it.to_s }
+
+          Array(prefixes).any? { name.start_with?(it.to_s) }
+        end
+
+        def excluded_event?(name)
+          Array(@configuration.structured_event_exclude_names).any? { name == it.to_s } ||
+            Array(@configuration.structured_event_exclude_prefixes).any? { name.start_with?(it.to_s) }
+        end
+
+        def enrich_request_start(payload)
+          fields = payload.slice(*REQUEST_CONTEXT_KEYS, :params).compact
+          add_summary_attributes(rails: fields)
+        end
+
+        def enrich_request_completion(payload)
+          add_summary_attributes(rails: request_completion_fields(payload))
+        end
+
+        def add_summary_attributes(fields)
+          Core::Integration::Facade.add_summary_attributes(fields)
+        end
+
+        def request_completion_fields(payload)
+          return payload unless payload.key?(:duration_ms)
+
+          payload.merge(action_runtime_ms: payload[:duration_ms]).except(:duration_ms)
+        end
+
+        def event_record
+          @event_record ||= StructuredEventRecord.new(@configuration)
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/subscribers/rendered_exception.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "action_dispatch/middleware/debug_exceptions"
+
+module Julewire
+  module Rails
+    module Subscribers
+      class RenderedException
+        class << self
+          include Core::Integration::SubscriberInstall
+
+          def install!(configuration)
+            return reset! unless configuration.request_summary? || configuration.rendered_exceptions?
+            return unless defined?(::ActionDispatch::DebugExceptions)
+            return unless ::ActionDispatch::DebugExceptions.respond_to?(:register_interceptor)
+
+            install_subscriber(configuration, enabled: true) do |subscriber|
+              ::ActionDispatch::DebugExceptions.register_interceptor(subscriber)
+              -> { unregister_interceptor(subscriber) }
+            end
+          end
+
+          private
+
+          def unregister_interceptor(subscriber)
+            return unless ::ActionDispatch::DebugExceptions.respond_to?(:interceptors)
+
+            ::ActionDispatch::DebugExceptions.interceptors.delete(subscriber)
+          end
+        end
+
+        def initialize(configuration = Configuration.new)
+          @configuration = configuration
+        end
+
+        attr_writer :configuration
+
+        def call(request, exception)
+          return if Suppression.active?
+
+          wrapper = exception_wrapper(request, exception)
+          return unless showable_response?(request, wrapper)
+
+          capture_request_error(request, exception, wrapper)
+          unless @configuration.rendered_exceptions?
+            IntegrationHealth.record_success(action: :call, component: :rendered_exception_subscriber)
+            return
+          end
+
+          Core::Integration::Facade.emit(
+            severity: severity_for(request, wrapper),
+            event: "action_dispatch.rendered_exception",
+            logger: "ActionDispatch::DebugExceptions",
+            source: @configuration.source,
+            attributes: attributes_for(request, wrapper),
+            neutral: neutral_for(request, wrapper),
+            error: exception
+          )
+          IntegrationHealth.record_success(action: :call, component: :rendered_exception_subscriber)
+        rescue StandardError => e
+          IntegrationHealth.record_failure(
+            e,
+            action: :call,
+            component: :rendered_exception_subscriber
+          )
+        end
+
+        private
+
+        def exception_wrapper(request, exception)
+          cleaner = request.get_header("action_dispatch.backtrace_cleaner")
+          ::ActionDispatch::ExceptionWrapper.new(cleaner, exception)
+        end
+
+        def showable_response?(request, wrapper)
+          wrapper.show?(request)
+        rescue StandardError
+          false
+        end
+
+        def capture_request_error(request, exception, wrapper)
+          return unless @configuration.request_summary?
+
+          request.set_header(
+            RequestMiddleware::RENDERED_EXCEPTION_ENV_KEY,
+            {
+              error: exception,
+              severity: severity_for(request, wrapper),
+              status: status_code(wrapper),
+              rescue_response: rescue_response?(wrapper),
+              rescue_template: rescue_template(wrapper)
+            }
+          )
+          RequestErrorOwnership.mark(exception)
+        end
+
+        def severity_for(request, _wrapper)
+          ExceptionSeverity.for_request(request)
+        end
+
+        def attributes_for(request, wrapper)
+          {
+            rails: {
+              rescue_response: rescue_response?(wrapper),
+              request_method: request.request_method,
+              path: request.path,
+              status: status_code(wrapper),
+              rescue_template: rescue_template(wrapper)
+            }.compact
+          }
+        end
+
+        def neutral_for(request, wrapper)
+          Core::Fields::AttributeKeys.fields(
+            Core::Fields::AttributeKeys::HTTP_REQUEST_METHOD => request.request_method,
+            Core::Fields::AttributeKeys::URL_PATH => request.path,
+            Core::Fields::AttributeKeys::HTTP_RESPONSE_STATUS_CODE => status_code(wrapper)
+          )
+        end
+
+        def status_code(wrapper)
+          wrapper.status_code
+        rescue StandardError
+          nil
+        end
+
+        def rescue_response?(wrapper)
+          wrapper.rescue_response?
+        rescue StandardError
+          false
+        end
+
+        def rescue_template(wrapper)
+          wrapper.rescue_template
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/suppression.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "active_support/isolated_execution_state"
+
+module Julewire
+  module Rails
+    module Suppression
+      KEY = :julewire_rails_suppressed
+
+      class << self
+        def active?
+          !!::ActiveSupport::IsolatedExecutionState[KEY]
+        end
+
+        def suppress
+          previous = ::ActiveSupport::IsolatedExecutionState[KEY]
+          ::ActiveSupport::IsolatedExecutionState[KEY] = true
+          yield
+        ensure
+          if previous
+            ::ActiveSupport::IsolatedExecutionState[KEY] = previous
+          else
+            ::ActiveSupport::IsolatedExecutionState.delete(KEY)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    VERSION = "1.0.0"
+  end
+end

data/lib/julewire/rails.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "julewire/core"
+require "julewire/rack"
+require "julewire/rails_support"
+require "rails"
+
+module Julewire
+  module Rails
+    class Error < Julewire::Error; end
+    IntegrationHealth = Core::Integration::Health.scoped(:rails)
+
+    class << self
+      def config
+        application = ::Rails.application
+        raise Error, "Rails.application is not available" unless application
+
+        application.config.julewire_rails
+      end
+
+      def configure
+        raise ArgumentError, "Julewire::Rails.configure requires a block" unless block_given?
+
+        yield config
+        config
+      end
+    end
+  end
+
+  loader = Zeitwerk::Loader.for_gem_extension(self)
+  loader.setup
+  Core::Processing.register(:rails_parameter_filter) do |*args, **options|
+    Rails::ParameterFilterProcessor.new(*args, **options)
+  end
+  Julewire::Rails::Railtie
+end

data/lib/julewire-rails.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "julewire/rails"