railwatch 0.1.0

data/lib/railwatch/health.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Railwatch
+  # One background thread per web/worker process, shipping a single `health`
+  # record every config.health_interval seconds: Puma's thread pool, the
+  # Active Record connection pool, and Solid Queue's backlog. Started from the
+  # engine's "railwatch.health" initializer and re-armed in every forked child
+  # from Railwatch.restart_after_fork!.
+  #
+  # A sample must never be visible to the app: the whole thing runs inside
+  # Railwatch.ignore and rescues everything, so a missing constant, an
+  # unmigrated queue database, or a checkout timeout degrades to nil fields
+  # rather than raising on a thread nobody is watching.
+  module Health
+    ROLES = %w[web worker].freeze
+
+    @mutex = Mutex.new
+    @wakeup = ConditionVariable.new
+    @thread = nil
+    @pid = nil
+    @stopping = false
+
+    module_function
+
+    # Idempotent; Railwatch.restart_after_fork! calls it again in every forked
+    # child.
+    def start!
+      return unless Railwatch.enabled?
+      return if defined?(Rails) && Rails.env.test?
+      return unless ROLES.include?(Subscribers::ProcessInfo.role)
+      return if @thread&.alive? && @pid == Process.pid
+
+      @mutex.synchronize do
+        return if @thread&.alive? && @pid == Process.pid
+
+        @pid = Process.pid
+        @stopping = false
+        @thread = Thread.new { run }
+        @thread.name = "railwatch-health"
+        @thread.abort_on_exception = false
+        @thread.report_on_exception = false
+      end
+    end
+
+    # A forked child (Puma cluster worker, Solid Queue forked worker) inherits
+    # a dead thread and may inherit a mutex held by a vanished parent thread,
+    # so every synchronization primitive must be replaced before start!.
+    def restart_after_fork!
+      @mutex = Mutex.new
+      @wakeup = ConditionVariable.new
+      @thread = nil
+      @pid = nil
+      @stopping = false
+      remove_instance_variable(:@puma_server) if defined?(@puma_server)
+      start!
+    end
+
+    def stop!
+      return unless @thread
+
+      @stopping = true
+      @mutex.synchronize { @wakeup.signal }
+      @thread.join(1)
+      @thread = nil
+    end
+
+    # Sleeps on a ConditionVariable rather than Kernel#sleep so stop! (from
+    # at_exit) wakes the thread immediately instead of waiting out the
+    # remainder of the interval. @stopping is re-read while holding the mutex
+    # so a stop! that lands just before the wait can't have its signal missed
+    # and leave the process hanging for a full interval.
+    def run
+      until @stopping
+        @mutex.synchronize { @wakeup.wait(@mutex, Railwatch.config.health_interval) unless @stopping }
+        sample unless @stopping
+      end
+    end
+
+    def sample
+      Railwatch.ignore do
+        puma = puma_stats
+        pool = pool_stats
+        queue = solid_queue_stats
+        Railwatch.record(:health,
+          pid: Process.pid,
+          role: Subscribers::ProcessInfo.role,
+          memory: Execution.sampled_memory,
+          threads_max: puma[:threads_max],
+          threads_busy: puma[:threads_busy],
+          backlog: puma[:backlog],
+          pool_size: pool[:size],
+          pool_busy: pool[:busy],
+          pool_waiting: pool[:waiting],
+          queue_depth: queue[:queue_depth],
+          queue_latency: queue[:queue_latency],
+          detail: JSON.generate(detail(puma, queue)))
+      end
+    rescue StandardError => e
+      Railwatch.debug { "health sample failed: #{e.class}: #{e.message}" }
+      nil
+    end
+
+    EMPTY = {}.freeze
+
+    def detail(puma, queue)
+      detail = {
+        queues: queue[:queues],
+        workers: queue[:workers],
+        requests_count: puma[:requests_count],
+        running: puma[:running],
+        max_threads_reached: puma[:max_threads_reached]
+      }
+      tasks = recurring_tasks
+      detail[:recurring_tasks] = tasks if tasks
+      detail
+    end
+
+    # The recurring tasks this process's Solid Queue knows about, key =>
+    # schedule, so the platform can tell a task that was removed from
+    # config/recurring.yml apart from one that stopped running. Read from
+    # the Jobs subscriber's cache (one query a minute per process, shared
+    # with scheduled-task detection). Left out rather than sent empty when
+    # there are none or the table could not be read: Jobs folds a failed
+    # read into an empty set, and "no manifest" must not read as "no tasks".
+    def recurring_tasks
+      schedules = Subscribers::Jobs.recurring_tasks[:schedules]
+      schedules.empty? ? nil : schedules
+    rescue StandardError
+      nil
+    end
+
+    # Puma::Server#stats is the only public API exposing busy_threads, so it is
+    # used in preference to the individual readers. It also resets Puma's
+    # own since-last-read backlog_max/reactor_max gauges, which Railwatch does
+    # not report.
+    def puma_stats
+      server = puma_server or return EMPTY
+      s = server.stats
+      # Puma's busy_threads counts queued requests too (spawned - waiting +
+      # todo), so it can exceed max_threads under load; the pool cannot,
+      # and that is what a utilisation percentage should describe.
+      {
+        threads_max: s[:max_threads],
+        threads_busy: s[:busy_threads] && s[:max_threads] ? [ s[:busy_threads], s[:max_threads] ].min : s[:busy_threads],
+        backlog: s[:backlog],
+        running: s[:running],
+        requests_count: s[:requests_count],
+        # No idle capacity left in the pool at sample time.
+        max_threads_reached: s[:pool_capacity]&.zero?
+      }
+    rescue StandardError
+      EMPTY
+    end
+
+    # Looked up once per process: ObjectSpace.each_object walks the whole heap,
+    # so it must not run on every sample. Puma constructs its Server while
+    # booting, long before the first sample fires.
+    def puma_server
+      return @puma_server if defined?(@puma_server)
+      @puma_server = defined?(::Puma::Server) ? ObjectSpace.each_object(::Puma::Server).first : nil
+    rescue StandardError
+      @puma_server = nil
+    end
+
+    def pool_stats
+      ActiveRecord::Base.connection_pool.stat
+    rescue StandardError
+      EMPTY
+    end
+
+    # Read-only counts against the queue database. Solid Queue keeps one row
+    # per ready job, so `queue_latency` (the age of the oldest ready job) is
+    # the backlog's head-of-line wait, in microseconds.
+    def solid_queue_stats
+      return EMPTY unless defined?(::SolidQueue)
+
+      oldest = ::SolidQueue::ReadyExecution.minimum(:created_at)
+      {
+        queue_depth: ::SolidQueue::ReadyExecution.count,
+        queue_latency: oldest && ((Clock.now - oldest.to_time.utc.to_f) * 1_000_000).round,
+        queues: ::SolidQueue::ReadyExecution.group(:queue_name).count,
+        workers: ::SolidQueue::Process.where(kind: "Worker").count
+      }
+    rescue StandardError
+      EMPTY
+    end
+  end
+end

data/lib/railwatch/job_tracing.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Railwatch
+  # Carries trace_id, the enqueuing execution id, and that execution's user
+  # and tenant inside the Active Job payload, the same way Rails carries
+  # locale and timezone, so a job attempt links back to the request that
+  # enqueued it and is attributed to the same person and tenant.
+  module JobTracing
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :railwatch_trace_id, :railwatch_parent_id, :railwatch_user, :railwatch_tenant
+    end
+
+    def serialize
+      exe = Railwatch.execution
+      data = super.merge(
+        "railwatch_trace_id" => railwatch_trace_id || exe&.trace_id,
+        "railwatch_parent_id" => railwatch_parent_id || exe&.id
+      )
+      # Identifier strings only -- never a user or tenant record -- and only
+      # when there is one, so a job enqueued with no identity produces the
+      # same payload it did before these keys existed.
+      #
+      # A request resolves its user lazily, at the end (Middleware::Request),
+      # so exe.user_id is usually still nil while the action is enqueuing;
+      # resolving here is what gives such a job its user. The result is
+      # memoised onto the execution with the same `||=` the middleware uses,
+      # so an action that enqueues fifty jobs resolves once, not fifty
+      # times -- resolving a present user costs ~8us. Inside a job the
+      # restored value is already on the execution and wins, so identity
+      # flows on unchanged through jobs that enqueue jobs. No execution means
+      # nothing to attribute (and Railwatch disabled), so nothing is resolved.
+      user = railwatch_user || (exe && (exe.user_id ||= Subscribers::Users.resolve_from_current))
+      tenant = railwatch_tenant || exe&.tenant || Context.current_tenant
+      data["railwatch_user"] = user if user
+      data["railwatch_tenant"] = tenant if tenant
+      data
+    end
+
+    def deserialize(job_data)
+      super
+      self.railwatch_trace_id = job_data["railwatch_trace_id"]
+      self.railwatch_parent_id = job_data["railwatch_parent_id"]
+      self.railwatch_user = job_data["railwatch_user"]
+      self.railwatch_tenant = job_data["railwatch_tenant"]
+    end
+  end
+end

data/lib/railwatch/middleware/request.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Middleware
+    # Outermost Rack middleware. Opens the request execution, times the
+    # lifecycle stages, catches anything that escapes the stack as an
+    # unhandled exception, and emits the request record at the end.
+    class Request
+      # Env keys repeat request after request (same client/proxy headers), so
+      # the Rack key -> "Header-Name" conversion is cached instead of
+      # split/map/capitalize/join-ing on every request.
+      HEADER_NAME_CACHE_LIMIT = 512
+      # W3C trace context: version-trace_id-parent_id-flags, all lower-case hex.
+      TRACEPARENT = /\A([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(.*)\z/
+      # Reverse proxies stamp the moment the request was accepted; the gap to
+      # our own start is how long it waited for a worker. Anything beyond this
+      # is clock skew between the proxy and this box, not a real wait.
+      MAX_QUEUE_TIME = 60_000_000 # microseconds
+      # Only a multipart request can carry an UploadedFile; same raw
+      # CONTENT_TYPE test Subscribers::Requests uses before its params walk.
+      MULTIPART = "multipart/form-data"
+      NO_FILES = [].freeze
+
+      # Returns [trace_id, parent_id, sampled] from an inbound traceparent,
+      # or nil when the header is absent or malformed.
+      def self.traceparent(value)
+        match = value && TRACEPARENT.match(value)
+        return nil unless match
+        return nil if match[1] == "ff"
+        # Version 00 has exactly 55 characters. Future versions may append
+        # opaque fields, but W3C requires the byte after trace-flags to be a
+        # dash; do not inspect or make assumptions about the fields beyond it.
+        return nil if match[1] == "00" && !match[5].empty?
+        return nil unless match[5].empty? || match[5].start_with?("-")
+        return nil if match[2] == "0" * 32 || match[3] == "0" * 16
+
+        [ match[2], match[3], match[4].to_i(16).odd? ]
+      end
+
+      def initialize(app)
+        @app = app
+        @header_name_cache = {}
+        @header_name_mutex = Mutex.new
+      end
+
+      def call(env)
+        return @app.call(env) unless Railwatch.enabled?
+        return @app.call(env) if ignored_request?(env)
+
+        trace_id, parent_id, upstream_sampled = self.class.traceparent(env["HTTP_TRACEPARENT"])
+        exe = Railwatch.start_execution(source: :request, sample_kind: :requests,
+                                      trace_id: trace_id, parent_id: parent_id)
+        # The upstream service sampled this trace in, so keep our end of it
+        # too -- otherwise the trace has a hole where this request should be.
+        exe.keep! if upstream_sampled
+        exe.enter_stage(:middleware_before)
+        env["railwatch.execution"] = exe
+        status = headers = body = nil
+        begin
+          status, headers, body = @app.call(env)
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          Subscribers::Exceptions.capture(e, handled: false, severity: :error, source: "railwatch.middleware")
+          raise
+        ensure
+          exe.enter_stage(:middleware_after) unless exe.stage == :middleware_after
+          finish(env, exe, status, headers)
+        end
+        [ status, headers, body ]
+      end
+
+      private
+
+      def ignored_request?(env)
+        path = env["PATH_INFO"].to_s
+        Railwatch.config.ignored_request_paths.any? do |pattern|
+          pattern.is_a?(Regexp) ? pattern.match?(path) : pattern.to_s == path
+        end || self_ingest_request?(env, path)
+      end
+
+      # Railwatch Cloud monitors itself. Its reporter therefore POSTs back into
+      # the same Rails process, and recording that POST would put another
+      # request record in the reporter forever: flush -> /ingest -> flush.
+      #
+      # Path alone is not enough: a customer application can own an unrelated
+      # /ingest route. This exemption needs the exact transport method, bearer
+      # token and public origin. Rack::Request normalizes Forwarded and
+      # X-Forwarded-* headers (including a non-default forwarded port), so the
+      # comparison still works behind a TLS-terminating reverse proxy without
+      # confusing the proxy's internal host with the public ingest origin.
+      def self_ingest_request?(env, path)
+        return false unless env["REQUEST_METHOD"] == "POST"
+        return false unless env["HTTP_AUTHORIZATION"] == "Bearer #{Railwatch.config.token}"
+
+        endpoint = URI.join(Railwatch.config.ingest_url, "/ingest")
+        return false unless path == endpoint.path
+
+        request = Rack::Request.new(env)
+        request.scheme.casecmp?(endpoint.scheme) &&
+          request.hostname.casecmp?(endpoint.host) &&
+          request.port == endpoint.port
+      rescue StandardError
+        false
+      end
+
+      def finish(env, exe, status, headers)
+        exe.finish_stages
+        # Resolved here, once, for both the request record and the session
+        # key below (the start_processing subscriber ran before the app's
+        # before_actions, so it usually found no user yet).
+        exe.user_id ||= Subscribers::Users.resolve_id(env)
+        # The block is only called when the request record is going to ship;
+        # a head-sampled-out request nothing rescued skips the
+        # ActionDispatch::Request and the header walk entirely.
+        Railwatch.finish_execution(:request) { parent_fields(env, exe, status, headers) }
+        # A request with no user and no session cookie has no session, and
+        # Sessions.touch returns without writing anything.
+        Sessions.touch(exe, env, status) if Railwatch.config.track_sessions
+      rescue StandardError => e
+        Railwatch.debug { "request finish failed: #{e.class}: #{e.message}" }
+        Railwatch.finish_execution
+      end
+
+      def parent_fields(env, exe, status, headers)
+        req = ActionDispatch::Request.new(env)
+        route = env["railwatch.route"] || {}
+        pattern = route[:pattern] || (req.respond_to?(:route_uri_pattern) ? (req.route_uri_pattern rescue nil) : nil) || "unmatched"
+        controller = route[:controller]
+        action = route[:action]
+        method = req.request_method
+        exe.preview ||= "#{method} #{pattern}"
+
+        inertia = inertia_fields(env, headers)
+        payload = Railwatch.config.capture_request_payload && exe.counters[:exceptions].positive? ? Railwatch.redactor.params(req.filtered_parameters.except("controller", "action")) : nil
+
+        {
+          group: Record.group_hash(method, pattern),
+          method: method,
+          url: Record.url_without_sensitive_components(req.original_url, limit: 2048),
+          path: req.path,
+          route: pattern,
+          route_methods: [ route[:verb] ].compact,
+          route_domain: req.host,
+          controller: controller,
+          action: action,
+          format: request_format(req, env),
+          ip: req.remote_ip,
+          status_code: status.to_i,
+          request_size: req.content_length.to_i,
+          response_size: headers && (headers["Content-Length"] || headers["content-length"]).to_i,
+          view_runtime: env["railwatch.view_runtime"],
+          db_runtime: env["railwatch.db_runtime"],
+          redirect_to: env["railwatch.redirect_to"],
+          halted_callback: env["railwatch.halted_callback"],
+          unpermitted_parameters: env["railwatch.unpermitted_parameters"],
+          rate_limited: env["railwatch.rate_limited"],
+          inertia: inertia,
+          headers: request_headers(env),
+          payload: payload,
+          queue_time: queue_time(env, exe),
+          user_agent: req.user_agent.to_s[0, 256],
+          files: env["railwatch.files"] || uploaded_files_fallback(req, env)
+        }
+      end
+
+      # Rack parses the request body the first time anything asks it for
+      # params, and both of the reads below ask -- `uploaded_files` walks
+      # `request.params`, and ActionDispatch::Request#format goes through
+      # `parameters[:format]`.
+      #
+      # Once a controller has run, that parse has already happened and its
+      # result is memoized on env, so both reads are free (and the files were
+      # captured back in Subscribers::Requests, before Rack::TempfileReaper
+      # unlinked the tempfiles). When no controller ran -- a routing 404, a
+      # rack-attack block, a middleware that rejected the request -- doing it
+      # here would make Railwatch the only component that ever reads that body,
+      # at teardown, after the response has been decided. A streaming upload,
+      # or simply megabytes we would immediately throw away.
+      #
+      # So the fallback is narrow: multipart only, because nothing else can
+      # contain a file, and no format symbol is worth parsing a body for.
+      def uploaded_files_fallback(req, env)
+        return NO_FILES unless multipart?(env)
+
+        uploaded_files(req.params)
+      end
+
+      def request_format(req, env)
+        return "" unless env.key?("action_dispatch.request.formats") || multipart?(env)
+
+        (req.format&.symbol rescue nil).to_s
+      end
+
+      def multipart?(env)
+        content_type = env["CONTENT_TYPE"]
+        !content_type.nil? && content_type.start_with?(MULTIPART)
+      end
+
+      # Microseconds this request waited in the proxy/web-server queue before
+      # the execution started, from X-Request-Start (nginx, Heroku, HAProxy)
+      # or X-Queue-Start. nil when absent, unparseable, or implausible.
+      def queue_time(env, exe)
+        raw = env["HTTP_X_REQUEST_START"] || env["HTTP_X_QUEUE_START"]
+        started = raw && request_start_seconds(raw)
+        return nil unless started
+
+        micros = ((exe.started_at - started) * 1_000_000).round
+        return nil if micros > MAX_QUEUE_TIME
+
+        # A proxy clock running slightly ahead reads as a negative wait.
+        micros.negative? ? 0 : micros
+      end
+
+      # "t=1700000000.123" (seconds), "t=1700000000123" (ms),
+      # "t=1700000000123456" (microseconds), or the same values bare. A proxy
+      # chain can collapse several into one comma-separated header; the first
+      # is the outermost. Unit is decided by magnitude, like Sentry's
+      # extract_queue_time.
+      def request_start_seconds(value)
+        raw = value.to_s.split(",").first.to_s.strip.delete_prefix("t=").strip
+        return nil unless /\A\d+(?:\.\d+)?\z/.match?(raw)
+
+        seconds = raw.to_f
+        if seconds > 10_000_000_000_000 then seconds / 1_000_000
+        elsif seconds > 10_000_000_000 then seconds / 1_000
+        else seconds
+        end
+      end
+
+      def inertia_fields(env, headers)
+        # The X-Inertia response header is only set on the XHR-follow-up
+        # branch; a full-page (SSR or not) Inertia render never sets it, so
+        # the presence of the component env var (set on every Inertia
+        # render) also has to open this gate or SSR timing is silently lost.
+        return nil unless env["HTTP_X_INERTIA"] == "true" || (headers && (headers["X-Inertia"] || headers["x-inertia"])) || env["railwatch.inertia_component"]
+
+        {
+          component: env["railwatch.inertia_component"],
+          version: env["HTTP_X_INERTIA_VERSION"],
+          partial_component: env["HTTP_X_INERTIA_PARTIAL_COMPONENT"],
+          partial_only: env["HTTP_X_INERTIA_PARTIAL_DATA"],
+          partial_except: env["HTTP_X_INERTIA_PARTIAL_EXCEPT"],
+          props_bytes: env["railwatch.inertia_props_bytes"],
+          ssr_ms: env["railwatch.inertia_ssr_ms"]
+        }.compact
+      end
+
+      # Recursively pulls ActionDispatch::Http::UploadedFile metadata out of
+      # request.params -- never its contents. Handles both a single file
+      # field and array-of-files fields (e.g. `attachments[]`).
+      def uploaded_files(value, name = nil)
+        case value
+        when ActionDispatch::Http::UploadedFile
+          [ { name: name, size: (value.tempfile.size rescue nil), content_type: value.content_type, error: nil } ]
+        when Hash
+          value.flat_map { |k, v| uploaded_files(v, k.to_s) }
+        when Array
+          value.flat_map { |v| uploaded_files(v, name) }
+        else
+          []
+        end
+      end
+
+      # Builds the (already redacted) header hash in one pass over env so the
+      # redactor does not have to walk a second, intermediate hash.
+      def request_headers(env)
+        redactor = Railwatch.redactor
+        out = {}
+        env.each_pair do |k, v|
+          next unless k.start_with?("HTTP_") || k == "CONTENT_TYPE" || k == "CONTENT_LENGTH"
+          name = header_name(k)
+          out[name] = redactor.redact_header?(name) ? Redactor::FILTERED : v.to_s[0, 512]
+        end
+        out
+      end
+
+      def header_name(key)
+        cached = @header_name_cache[key]
+        return cached if cached
+
+        name = key.delete_prefix("HTTP_").split("_").map(&:capitalize).join("-")
+        @header_name_mutex.synchronize do
+          @header_name_cache.clear if @header_name_cache.size >= HEADER_NAME_CACHE_LIMIT
+          @header_name_cache[key] = name
+        end
+        name
+      end
+    end
+  end
+end

data/lib/railwatch/minitest.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "railwatch/spec_helper"
+
+module Railwatch
+  # The Minitest half of railwatch/rspec: the same block assertions, phrased as
+  # assert_/refute_. Add to test/test_helper.rb:
+  #
+  #   require "railwatch/minitest"
+  #   class ActiveSupport::TestCase
+  #     include Railwatch::Minitest
+  #   end
+  #
+  # Includes Railwatch::SpecHelper, so `railwatch_records(:query)` is available
+  # too. See docs/testing.md.
+  module Minitest
+    include SpecHelper
+
+    # assert_railwatch_queries(at_most: 5) { Order.find(id).total }
+    # Also takes exactly: or at_least:.
+    def assert_railwatch_queries(exactly: nil, at_most: nil, at_least: nil, &block)
+      bounds = { exactly: exactly, at_most: at_most, at_least: at_least }
+      queries = railwatch_capture(&block).select { |r| r[:t] == "query" }
+      assert SpecHelper.count_satisfied?(queries.size, **bounds),
+             "Expected the block to run #{SpecHelper.bound_description(**bounds)} database queries, " \
+             "but it ran #{queries.size}:#{SpecHelper.sql_lines(queries)}"
+    end
+
+    def refute_railwatch_n_plus_one(&block)
+      n_plus_ones = railwatch_capture(&block).select { |r| r[:t] == "n_plus_one" }
+      assert n_plus_ones.empty?,
+             "Expected no N+1 queries, but #{n_plus_ones.size} were " \
+             "detected:#{SpecHelper.n_plus_one_lines(n_plus_ones)}"
+    end
+
+    def assert_railwatch_span(name, &block)
+      spans = railwatch_capture(&block).select { |r| r[:t] == "span" }
+      assert spans.any? { |s| s[:name] == name },
+             "Expected the block to record a #{name.inspect} span, but it recorded " \
+             "#{spans.size}: #{SpecHelper.record_names(spans, :name).inspect}"
+    end
+  end
+end

data/lib/railwatch/patches/inertia.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Patches
+    # Records the Inertia component and SSR time per request. inertia_rails
+    # has no instrumentation of its own, so this is a small prepend on the
+    # renderer; skipped entirely if the gem is not loaded.
+    module Inertia
+      module Renderer
+        def render
+          env = @request&.env
+          env["railwatch.inertia_component"] = @component.to_s if env
+          super
+        end
+
+        # Private on InertiaRails::Renderer, only called when SSR is enabled
+        # and the request isn't itself an Inertia XHR visit -- so this adds
+        # no cost to the common (non-SSR) render path.
+        def ssr_render
+          start = Clock.monotonic
+          super
+        ensure
+          env = @request&.env
+          env["railwatch.inertia_ssr_ms"] = ((Clock.monotonic - start) * 1000).round(2) if env
+        end
+      end
+
+      def self.install!
+        return unless defined?(::InertiaRails::Renderer)
+        ::InertiaRails::Renderer.prepend(Renderer) unless ::InertiaRails::Renderer.ancestors.include?(Renderer)
+      end
+    end
+  end
+end