julewire-rails 1.0.0

data/lib/julewire/rails/request_context.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    class RequestContext
+      def initialize(configuration:, request:, active_support_context: Core::UNSET, event_reporter: Core::UNSET)
+        @configuration = configuration
+        @request = request
+        @active_support_context = default_provider(active_support_context) { ::ActiveSupport::ExecutionContext }
+        @event_reporter = default_provider(event_reporter) { Julewire::RailsSupport::EventReporter.default }
+      end
+
+      def neutral_fields
+        RequestAttributes.request(@request)
+      end
+
+      def call(&)
+        with_request_carry do
+          with_request_context(&)
+        end
+      end
+
+      private
+
+      def default_provider(value)
+        value.equal?(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
+          with_active_support_execution_context(fields) do
+            with_rails_event_context(fields, &)
+          end
+        end
+      end
+
+      def with_request_carry(&)
+        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)
+        return yield if headers.empty?
+
+        Core::Integration::Facade.with_carry(http: { request_headers: headers }, &)
+      end
+
+      def all_carry_headers?
+        @configuration.carry_request_headers == true
+      end
+
+      def with_active_support_execution_context(fields, &)
+        return yield unless @active_support_context.respond_to?(:set)
+
+        @active_support_context.set(**fields, &)
+      end
+
+      def with_rails_event_context(fields)
+        return yield unless rails_event_context_supported?
+
+        previous = nil
+        context_set = false
+        begin
+          previous = @event_reporter.context
+          @event_reporter.set_context(fields)
+          context_set = true
+        rescue StandardError
+          return yield
+        end
+        yield
+      ensure
+        restore_rails_event_context(previous) if context_set
+      end
+
+      def rails_event_context_supported?
+        @event_reporter.respond_to?(:context) &&
+          @event_reporter.respond_to?(:set_context) &&
+          @event_reporter.respond_to?(:clear_context)
+      end
+
+      def restore_rails_event_context(previous)
+        @event_reporter.clear_context
+        @event_reporter.set_context(previous) unless previous.nil? || previous.empty?
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/julewire/rails/request_error_ownership.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "active_support/isolated_execution_state"
+
+module Julewire
+  module Rails
+    module RequestErrorOwnership
+      KEY = :julewire_rails_request_error_objects
+      private_constant :KEY
+
+      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
+        end
+
+        def consume?(error)
+          errors = current_error_map
+          return false unless errors
+
+          each_exception(error).any? { errors.delete(it) }
+        rescue StandardError
+          false
+        end
+
+        private
+
+        def error_map
+          current_error_map || set_error_map
+        end
+
+        def set_error_map
+          ObjectSpace::WeakKeyMap.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?
+
+          seen = {}.compare_by_identity
+          while error && !seen.key?(error)
+            yield error
+            seen[error] = true
+            error = error.cause
+          end
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/request_fields.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    class RequestFields
+      REMOTE_IP_ENV_KEY = "julewire.rails.remote_ip"
+
+      def initialize(request)
+        @request = request
+      end
+
+      def id
+        value = @request.request_id if @request.respond_to?(:request_id)
+        value || header("action_dispatch.request_id") || header("HTTP_X_REQUEST_ID")
+      rescue StandardError
+        nil
+      end
+
+      def method
+        @request.request_method
+      end
+
+      def path
+        @request.path
+      end
+
+      def filtered_path
+        @request.filtered_path
+      end
+
+      def filtered_url
+        "#{@request.protocol}#{@request.host_with_port}#{filtered_path}"
+      rescue StandardError
+        nil
+      end
+
+      def user_agent
+        header("HTTP_USER_AGENT")
+      end
+
+      def remote_ip
+        env = @request.env if @request.respond_to?(:env)
+        return env[REMOTE_IP_ENV_KEY] if env&.key?(REMOTE_IP_ENV_KEY)
+
+        value = @request.remote_ip
+        env[REMOTE_IP_ENV_KEY] = value if env
+        value
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def header(key)
+        @request.get_header(key)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/julewire/rails/request_lifecycle.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+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:)
+        @execution_handle = Julewire.start_execution(
+          type: :request,
+          id: RequestAttributes.request_id(@request),
+          neutral: neutral,
+          emit_summary: @configuration.request_summary?,
+          summary_event: @configuration.summary_event,
+          summary_source: @configuration.source
+        )
+      end
+
+      def attach_body_finalizer(response)
+        finish_request_thread_logging
+        @completion_attached = true
+        RequestCompletion.new(
+          configuration: @configuration,
+          execution_handle: @execution_handle,
+          instrumenter_handle: @instrumenter_handle,
+          env: @env,
+          request: @request,
+          request_error: @env[RequestMiddleware::REQUEST_ERROR_ENV_KEY]
+        ).attach(response)
+      end
+
+      def finish_error(error)
+        @execution_handle&.finish(reason: :error, error: error)
+      end
+
+      def finish_unattached
+        return if @completion_attached
+
+        finish_unattached_request
+        finish_request_thread_logging
+      end
+
+      private
+
+      def push_tags
+        return 0 unless ::Rails.logger.respond_to?(:push_tags)
+
+        ::Rails.logger.push_tags(*compute_tags).size
+      end
+
+      def compute_tags
+        @taggers.collect do |tag|
+          case tag
+          when Proc
+            tag.call(@request)
+          when Symbol
+            @request.public_send(tag)
+          else
+            tag
+          end
+        end
+      end
+
+      def start_request_instrumentation
+        handle = ::ActiveSupport::Notifications.instrumenter.build_handle(
+          "request.action_dispatch",
+          request: @request
+        )
+        handle.start
+        handle
+      end
+
+      def finish_request_thread_logging
+        return unless @tag_count.to_i.positive? && ::Rails.logger.respond_to?(:pop_tags)
+
+        ::Rails.logger.pop_tags(@tag_count)
+        @tag_count = 0
+      rescue StandardError
+        nil
+      end
+
+      def finish_unattached_request
+        return RequestCompletion.finish_instrumentation(@instrumenter_handle) unless @execution_handle
+
+        @execution_handle.with_context do
+          RequestCompletion.finish_instrumentation(@instrumenter_handle)
+          @execution_handle.finish(reason: :closed)
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/request_middleware.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "action_dispatch/http/request"
+require "action_dispatch/middleware/exception_wrapper"
+require "action_view"
+require "active_support/log_subscriber"
+
+module Julewire
+  module Rails
+    class RequestMiddleware
+      REQUEST_ERROR_ENV_KEY = "julewire.rails.request_error"
+      RENDERED_EXCEPTION_ENV_KEY = "julewire.rails.rendered_exception"
+
+      def initialize(app, configuration = Configuration.new, taggers = nil)
+        @app = app
+        @configuration = configuration
+        @taggers = taggers || []
+      end
+
+      def call(env)
+        lifecycle = nil
+        request = ::ActionDispatch::Request.new(env)
+        RequestErrorOwnership.clear
+        return Suppression.suppress { @app.call(env) } if excluded_request?(request)
+
+        lifecycle = RequestLifecycle.new(
+          configuration: @configuration,
+          env: env,
+          request: request,
+          taggers: @taggers
+        ).start
+        request_context = RequestContext.new(configuration: @configuration, request: request)
+
+        response = request_context.call do
+          execution_handle = lifecycle.start_execution!(neutral: request_context.neutral_fields)
+          execution_handle.run do
+            call_app(request, env, execution_handle)
+          end
+        end
+
+        lifecycle.attach_body_finalizer(response)
+      rescue Exception => e # rubocop:disable Lint/RescueException -- Rack middleware must re-raise all application exits.
+        lifecycle&.finish_error(e)
+        raise
+      ensure
+        lifecycle&.finish_unattached
+      end
+
+      private
+
+      def excluded_request?(request)
+        @configuration.request_exclude_prefixes.any? { excluded_path?(request.path, it) }
+      end
+
+      def excluded_path?(path, prefix)
+        return true if prefix == "/"
+
+        path == prefix || path.start_with?("#{prefix}/")
+      end
+
+      def call_app(request, env, execution_handle)
+        status, headers, body = @app.call(env)
+        add_summary_fields(response_summary_attributes(request, status, headers))
+        capture_rendered_request_error(request, env, status)
+        [status, headers, body]
+      rescue Exception => e # rubocop:disable Lint/RescueException -- Rack middleware must re-raise all application exits.
+        severity = request_exception_severity(request)
+        wrapper = exception_wrapper(request, e)
+        own_request_error(env, e, severity: severity)
+        add_summary_fields(error_summary_attributes(request, e, status: 500, wrapper: wrapper))
+        execution_handle.finish(reason: :error, error: e, severity: severity)
+        raise
+      end
+
+      def response_summary_attributes(request, status, headers)
+        RequestAttributes.response_summary(request, status, headers)
+      end
+
+      def capture_rendered_request_error(request, env, status)
+        rendered_error = env[RENDERED_EXCEPTION_ENV_KEY]
+        if rendered_error
+          own_request_error(env, rendered_error.fetch(:error), severity: rendered_error.fetch(:severity))
+          add_summary_fields(rendered_error_summary_attributes(request, rendered_error, status: status))
+          return
+        end
+
+        error = env["action_dispatch.exception"]
+        return unless error
+
+        severity = request_exception_severity(request)
+        wrapper = exception_wrapper(request, error)
+        own_request_error(env, error, severity: severity)
+        add_summary_fields(error_summary_attributes(request, error, status: status, wrapper: wrapper))
+      end
+
+      def own_request_error(env, error, severity:)
+        return unless @configuration.request_summary?
+
+        env[REQUEST_ERROR_ENV_KEY] = { error: error, severity: severity }
+        RequestErrorOwnership.mark(error)
+      end
+
+      def rendered_error_summary_attributes(request, rendered_error, status:)
+        RequestAttributes.rendered_error_summary(
+          request,
+          rendered_error,
+          status: status
+        )
+      end
+
+      def error_summary_attributes(request, error, status:, wrapper:)
+        RequestAttributes.error_summary(request, error, status: status, wrapper: wrapper)
+      end
+
+      def request_exception_severity(request)
+        ExceptionSeverity.for_request(request)
+      end
+
+      def exception_wrapper(request, error)
+        cleaner = request.get_header("action_dispatch.backtrace_cleaner")
+        ::ActionDispatch::ExceptionWrapper.new(cleaner, error)
+      end
+
+      def add_summary_fields(fields)
+        Core::Integration::Facade.add_summary_attributes(fields[:attributes])
+        Core::Integration::Facade.add_summary_neutral(fields[:neutral])
+      end
+    end
+  end
+end

data/lib/julewire/rails/request_summary_timeout_scheduler.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    module RequestSummaryTimeoutScheduler
+      class << self
+        def schedule(timeout, &block)
+          return unless timeout && block
+
+          Core::Scheduling::SharedScheduler.schedule(timeout, &block)
+        rescue StandardError
+          nil
+        end
+
+        def cancel(token)
+          return unless token
+
+          Core::Scheduling::SharedScheduler.cancel(token)
+        rescue StandardError
+          nil
+        end
+
+        # Private testing seam for request-timeout isolation.
+        def reset_for_test!
+          Core::Scheduling::SharedScheduler.__send__(:reset_for_test!)
+          nil
+        end
+
+        def after_fork!
+          Core::Scheduling::SharedScheduler.after_fork!
+          nil
+        end
+
+        private :reset_for_test!
+      end
+    end
+  end
+end

data/lib/julewire/rails/structured_event_record.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "active_support/parameter_filter"
+
+module Julewire
+  module Rails
+    class StructuredEventRecord
+      DEBUG_EVENT_PREFIXES = %w[
+        action_view.
+        active_record.
+      ].freeze
+
+      DEBUG_EVENTS = %w[
+        action_controller.unpermitted_parameters
+      ].freeze
+
+      def initialize(configuration, parameter_filter: Core::UNSET)
+        @configuration = configuration
+        @parameter_filter_override = parameter_filter
+      end
+
+      def call(event, name:, payload:)
+        values = Core::Integration::Values::Shape
+        {
+          timestamp: values.timestamp(event[:timestamp]),
+          severity: severity_for(name),
+          event: name,
+          logger: "Rails.event",
+          source: @configuration.source,
+          context: values.hash_or_empty(event[:context]),
+          attributes: attributes_for(event, payload),
+          neutral: neutral_for(event)
+        }.compact
+      end
+
+      def payload_hash(payload)
+        case payload
+        when nil
+          {}
+        when Hash
+          values = Core::Integration::Values::Shape
+          values.payload_hash(payload)
+        else
+          serialize_payload_object(payload)
+        end
+      end
+
+      private
+
+      def attributes_for(event, payload)
+        values = Core::Integration::Values::Shape
+        rails = payload.empty? ? {} : payload
+        values.append_compact_field(rails, :tags, values.hash_or_empty(event[:tags]))
+        { rails: rails }
+      end
+
+      def neutral_for(event)
+        values = Core::Integration::Values::Shape
+        values.source_location_attributes(event[:source_location])
+      end
+
+      def severity_for(name)
+        return :debug if DEBUG_EVENTS.include?(name)
+        return :debug if DEBUG_EVENT_PREFIXES.any? { name.start_with?(it) }
+
+        :info
+      end
+
+      def serialize_payload_object(payload)
+        if payload.respond_to?(:serialize)
+          serialized = payload.serialize
+          return object_payload_hash(serialized) if serialized.is_a?(Hash)
+
+          { Julewire::Core::Fields::FieldSet::VALUE_KEY => serialized }
+        else
+          { Julewire::Core::Fields::FieldSet::VALUE_KEY => payload }
+        end
+      rescue StandardError => e
+        {
+          Julewire::Core::Fields::FieldSet::VALUE_KEY => payload,
+          serialize_error_class: e.class.name
+        }
+      end
+
+      def object_payload_hash(serialized)
+        Julewire::Core::Fields::FieldSet.deep_symbolize_keys(filter_event_payload(serialized))
+      end
+
+      def filter_event_payload(payload)
+        return payload unless @configuration.filter_event_payloads?
+
+        filter = rails_parameter_filter
+        return payload unless filter
+
+        filtered = filter.filter(payload)
+        filtered.is_a?(Hash) ? filtered : payload
+      rescue StandardError
+        payload
+      end
+
+      def rails_parameter_filter
+        return @parameter_filter_override unless @parameter_filter_override.equal?(Core::UNSET)
+        return @rails_parameter_filter if @rails_parameter_filter_loaded
+
+        @rails_parameter_filter_loaded = true
+        filters = rails_filter_parameters
+        @rails_parameter_filter = build_parameter_filter(filters)
+      end
+
+      def build_parameter_filter(filters)
+        return if filters.empty?
+
+        ::ActiveSupport::ParameterFilter.new(::ActiveSupport::ParameterFilter.precompile_filters(filters))
+      end
+
+      def rails_filter_parameters
+        app = ::Rails.application if defined?(::Rails) && ::Rails.respond_to?(:application)
+        return Array(app.filter_parameters) if app.respond_to?(:filter_parameters)
+
+        config = app.config if app.respond_to?(:config)
+        filters = config.filter_parameters if config.respond_to?(:filter_parameters)
+        Array(filters)
+      rescue StandardError
+        []
+      end
+    end
+  end
+end