julewire-rails 1.0.0

data/lib/julewire/rails/context_body_proxy.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    class ContextBodyProxy
+      def initialize(body, handle:, on_close:)
+        @body = body
+        @handle = handle
+        @on_close = on_close
+        @closed = false
+      end
+
+      def each(&block)
+        return enum_for(:each) unless block_given?
+
+        @handle.with_context do
+          @body.each { block.yield(it) }
+        end
+      end
+
+      def close
+        return if @closed
+
+        @closed = true
+        begin
+          @handle.with_context { @body.close if @body.respond_to?(:close) }
+        ensure
+          @on_close.call
+        end
+      end
+
+      def closed? = @closed
+
+      def respond_to_missing?(method_name, include_private = false)
+        (method_name != :to_str && @body.respond_to?(method_name, include_private)) || super
+      end
+
+      def method_missing(method_name, ...)
+        case method_name
+        when :to_str
+          super
+        when :to_ary
+          begin
+            @handle.with_context { @body.public_send(method_name, ...) }
+          ensure
+            close
+          end
+        else
+          @handle.with_context { @body.public_send(method_name, ...) }
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/debug_exception_log_silencer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "action_dispatch/middleware/debug_exceptions"
+
+module Julewire
+  module Rails
+    module DebugExceptionLogSilencer
+      Patch = Module.new do
+        def log_error(request, wrapper)
+          return if Julewire::Rails::DebugExceptionLogSilencer.suppress?(request, wrapper)
+
+          super
+        end
+      end
+      private_constant :Patch
+
+      class << self
+        def install!(configuration)
+          @configuration = configuration
+          return false unless defined?(::ActionDispatch::DebugExceptions)
+          return true if @installed
+
+          ::ActionDispatch::DebugExceptions.prepend(Patch)
+          @installed = true
+        end
+
+        def suppress?(_request, _wrapper)
+          suppress_reported_logs?
+        rescue StandardError => e
+          IntegrationHealth.record_failure(
+            e,
+            action: :suppress?,
+            component: :debug_exception_log_silencer
+          )
+        end
+
+        private
+
+        def suppress_reported_logs?
+          configuration = @configuration
+          return false unless configuration
+
+          case configuration.reported_exception_logs
+          when :auto
+            configuration.logger? && (configuration.request_summary? || configuration.error_reports?)
+          else
+            !configuration.reported_exception_logs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/doctor_app.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require "cgi/escape"
+require "json"
+require "rack/request"
+require "time"
+
+module Julewire
+  module Rails
+    class DoctorApp
+      CONTENT_TYPE = { "content-type" => "text/html; charset=utf-8" }.freeze
+      JSON_TYPE = { "content-type" => "application/json; charset=utf-8" }.freeze
+      SSE_TYPE = {
+        "cache-control" => "no-cache",
+        "content-type" => "text/event-stream; charset=utf-8"
+      }.freeze
+      TAIL_LIMIT = 50
+
+      def initialize(runtime: Julewire, tail: nil)
+        @runtime = runtime
+        @tail = tail
+      end
+
+      def call(env)
+        request = ::Rack::Request.new(env)
+        case request.path_info
+        when "", "/", "/doctor"
+          html_response(render_doctor(request))
+        when "/doctor.json"
+          json_response(@runtime.doctor)
+        when "/tail"
+          html_response(render_tail(request))
+        when "/tail.json"
+          json_response(tail_records)
+        when "/tail/events"
+          sse_response(tail_events(request))
+        else
+          not_found_response
+        end
+      end
+
+      private
+
+      def html_response(body)
+        [200, CONTENT_TYPE.dup, [body]]
+      end
+
+      def json_response(value)
+        [200, JSON_TYPE.dup, [JSON.generate(value)]]
+      end
+
+      def sse_response(events)
+        [200, SSE_TYPE.dup, events]
+      end
+
+      def not_found_response
+        [404, CONTENT_TYPE.dup, ["not found"]]
+      end
+
+      def render_doctor(request)
+        report = @runtime.doctor
+        warning_items = report.fetch(:warnings).map do |warning|
+          "<li><code>#{escape(warning.fetch(:code))}</code> #{escape(warning.fetch(:message))}</li>"
+        end.join
+
+        page(
+          "Julewire Doctor",
+          [
+            "<p>Status: <strong>#{escape(report.fetch(:status))}</strong></p>",
+            "<p>Level: <code>#{escape(report.dig(:runtime, :level))}</code></p>",
+            "<p>Pipeline: <strong>#{escape(report.dig(:pipeline, :status))}</strong></p>",
+            "<h2>Warnings</h2>",
+            warning_items.empty? ? "<p>None</p>" : "<ul>#{warning_items}</ul>",
+            nav_links(request, ["/tail", "Tail"], ["/doctor.json", "JSON"])
+          ].join
+        )
+      end
+
+      def render_tail(request)
+        return page("Julewire Tail", "<p>Tail is not attached.</p>") unless @tail
+
+        body = [
+          "<p>#{@tail.health.fetch(:size)} / #{@tail.capacity} records</p>",
+          [
+            "<table><thead><tr><th>Severity</th><th>Event</th><th>Message</th></tr></thead>",
+            %(<tbody data-tail-records data-tail-events-path="#{escape(app_path(request, "/tail/events"))}">),
+            tail_rows,
+            "</tbody></table>"
+          ].join,
+          tail_nav(request),
+          tail_script
+        ].join
+        page("Julewire Tail", body)
+      end
+
+      def tail_rows
+        tail_entries.reverse.map { tail_row(it) }.join
+      end
+
+      def tail_row(entry)
+        record = entry.record
+        [
+          "<tr data-sequence=\"#{entry.sequence}\">",
+          "<td><code>#{escape(record["severity"])}</code></td>",
+          "<td><code>#{escape(record["event"])}</code></td>",
+          "<td>#{escape(record["message"])}</td>",
+          "</tr>"
+        ].join
+      end
+
+      def tail_nav(request)
+        nav_links(request, ["/doctor", "Doctor"], ["/tail.json", "JSON"])
+      end
+
+      def tail_records
+        @tail ? @tail.records(limit: TAIL_LIMIT) : []
+      end
+
+      def tail_entries
+        @tail ? @tail.entries(limit: TAIL_LIMIT) : []
+      end
+
+      def tail_events(request)
+        return ["event: unavailable\ndata: {}\n\n"] unless @tail
+
+        after = event_cursor(request)
+        events = tail_entries.filter_map do |entry|
+          next unless entry.sequence > after
+
+          "id: #{entry.sequence}\nevent: record\ndata: #{JSON.generate(tail_event(entry))}\n\n"
+        end
+        events.empty? ? [": empty\nretry: 1000\n\n"] : ["retry: 1000\n\n", *events]
+      end
+
+      def event_cursor(request)
+        value = request.get_header("HTTP_LAST_EVENT_ID")
+        value = request.params["after"] if value.nil? || value.empty?
+        Integer(value || 0)
+      rescue ArgumentError, TypeError
+        0
+      end
+
+      def tail_event(entry)
+        {
+          at: entry.at.iso8601(6),
+          message: entry.record["message"],
+          record: entry.record,
+          sequence: entry.sequence
+        }
+      end
+
+      def tail_script
+        <<~HTML
+          <script>
+            (() => {
+              const rows = document.querySelector("[data-tail-records]");
+              if (!rows || !window.EventSource) return;
+              const eventsPath = rows.dataset.tailEventsPath;
+              if (!eventsPath) return;
+              const seen = new Set(Array.from(rows.querySelectorAll("[data-sequence]")).map(row => row.dataset.sequence));
+              const cell = value => {
+                const td = document.createElement("td");
+                td.textContent = value == null ? "" : String(value);
+                return td;
+              };
+              const codeCell = value => {
+                const td = document.createElement("td");
+                const code = document.createElement("code");
+                code.textContent = value == null ? "" : String(value);
+                td.appendChild(code);
+                return td;
+              };
+              const prepend = entry => {
+                const sequence = String(entry.sequence);
+                if (seen.has(sequence)) return;
+                seen.add(sequence);
+                const record = entry.record || {};
+                const row = document.createElement("tr");
+                row.dataset.sequence = sequence;
+                row.appendChild(codeCell(record.severity));
+                row.appendChild(codeCell(record.event));
+                row.appendChild(cell(entry.message));
+                rows.prepend(row);
+              };
+              const source = new EventSource(eventsPath);
+              source.addEventListener("record", event => prepend(JSON.parse(event.data)));
+            })();
+          </script>
+        HTML
+      end
+
+      def app_path(request, path)
+        base = request.script_name.to_s
+        base = "" if base == "/"
+        "#{base}#{path}"
+      end
+
+      def nav_links(request, *links)
+        %(<p>#{links.map { link_to(request, it.fetch(0), it.fetch(1)) }.join(" ")}</p>)
+      end
+
+      def link_to(request, path, label)
+        %(<a href="#{escape(app_path(request, path))}">#{escape(label)}</a>)
+      end
+
+      def page(title, body)
+        <<~HTML
+          <!doctype html>
+          <html>
+          <head>
+            <meta charset="utf-8">
+            <title>#{escape(title)}</title>
+            <style>
+              body { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; margin: 2rem; color: #171717; }
+              a { color: #0b5fff; margin-right: 1rem; }
+              table { border-collapse: collapse; width: 100%; }
+              th, td { border-bottom: 1px solid #ddd; padding: 0.45rem; text-align: left; vertical-align: top; }
+            </style>
+          </head>
+          <body>
+            <h1>#{escape(title)}</h1>
+            #{body}
+          </body>
+          </html>
+        HTML
+      end
+
+      def escape(value)
+        ::CGI.escapeHTML(value.to_s)
+      end
+    end
+  end
+end

data/lib/julewire/rails/exception_severity.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    module ExceptionSeverity
+      HEADER = "action_dispatch.debug_exception_log_level"
+      SEVERITY = ::Julewire::Core::Records::Severity
+      private_constant :HEADER, :SEVERITY
+
+      class << self
+        def for_request(request)
+          SEVERITY.normalize(header_value(request))
+        rescue ArgumentError
+          :error
+        end
+
+        private
+
+        def header_value(request)
+          request.get_header(HEADER)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/lifecycle_hooks.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    module LifecycleHooks
+      @at_exit_installed = false
+      @fork_tracker_installed = false
+      @mutex = Mutex.new
+
+      class << self
+        def install!(configuration, registrar: Kernel, fork_tracker: active_support_fork_tracker)
+          return unless configuration.lifecycle_hooks?
+
+          @mutex.synchronize do
+            install_at_exit!(registrar, configuration)
+            register_after_fork!
+            install_fork_tracker!(fork_tracker)
+          end
+        end
+
+        def drain!(timeout:)
+          Julewire.flush(timeout: timeout)
+        ensure
+          Julewire.close(timeout: timeout)
+        end
+
+        def after_fork!
+          RequestSummaryTimeoutScheduler.after_fork!
+          RequestErrorOwnership.clear
+        end
+
+        # Private testing seam for isolating process lifecycle hooks.
+        def reset_for_test!
+          @mutex.synchronize do
+            @at_exit_installed = false
+            @fork_tracker_installed = false
+          end
+        end
+
+        private
+
+        private :reset_for_test!
+
+        def install_at_exit!(registrar, configuration)
+          return if @at_exit_installed
+
+          registrar.at_exit { drain!(timeout: configuration.shutdown_timeout) }
+          @at_exit_installed = true
+        end
+
+        def register_after_fork!
+          Core::Integration::Lifecycle.register_after_fork(:rails, component: :lifecycle_hooks) { after_fork! }
+        end
+
+        def install_fork_tracker!(fork_tracker)
+          return if @fork_tracker_installed
+          return unless fork_tracker.respond_to?(:after_fork)
+
+          fork_tracker.after_fork { Julewire.after_fork! }
+          @fork_tracker_installed = true
+        rescue StandardError => e
+          IntegrationHealth.record_failure(
+            e,
+            action: :install_after_fork,
+            component: :lifecycle_hooks
+          )
+          nil
+        end
+
+        def active_support_fork_tracker
+          ::ActiveSupport::ForkTracker if defined?(::ActiveSupport::ForkTracker)
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/log_subscriber_silencer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "active_support/log_subscriber"
+
+module Julewire
+  module Rails
+    module LogSubscriberSilencer
+      SUBSCRIBERS = [
+        ["ActionController::LogSubscriber", :action_controller],
+        ["ActionDispatch::LogSubscriber", :action_dispatch],
+        ["ActionView::LogSubscriber", :action_view],
+        ["ActiveRecord::LogSubscriber", :active_record]
+      ].freeze
+
+      LOG_SUBSCRIBER_FILES = %w[
+        action_controller/log_subscriber
+        action_dispatch/log_subscriber
+        action_view/log_subscriber
+        active_record/log_subscriber
+      ].freeze
+
+      class << self
+        def silence!
+          require_log_subscribers
+          SUBSCRIBERS.each { |class_name, namespace| detach(class_name, namespace) }
+        end
+
+        private
+
+        def require_log_subscribers
+          LOG_SUBSCRIBER_FILES.each { Core::Integration::Lifecycle.require_optional(it) }
+        end
+
+        def detach(class_name, namespace)
+          subscriber_class = constantize(class_name)
+          return if subscriber_class.nil?
+
+          subscriber_class.detach_from(namespace) if subscriber_class.respond_to?(:detach_from)
+          Julewire::RailsSupport::EventReporter.unsubscribe_log_subscriber(subscriber_class)
+        end
+
+        def constantize(class_name)
+          class_name.split("::").reject(&:empty?).inject(Object) do |namespace, constant_name|
+            break unless namespace.const_defined?(constant_name, false)
+
+            namespace.const_get(constant_name, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/julewire/rails/logger.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "active_support/isolated_execution_state"
+require "logger"
+
+module Julewire
+  module Rails
+    class Logger
+      FORGED_RECORD_KEYS = %i[kind execution carry attributes neutral].freeze
+      RECORD_KEYS = (Julewire::Core::Fields::Bags.required_record_keys - FORGED_RECORD_KEYS).freeze
+      private_constant :FORGED_RECORD_KEYS, :RECORD_KEYS
+
+      attr_accessor :datetime_format, :formatter, :progname
+
+      def initialize(name: "Rails", source: "rails")
+        @level = ::Logger::DEBUG
+        @progname = name
+        @source = source
+        @local_level_key = :"julewire_rails_logger_level_#{object_id}"
+      end
+
+      def add(severity, message = nil, progname = nil) # rubocop:disable Naming/PredicateMethod -- Logger API.
+        severity ||= ::Logger::UNKNOWN
+        return true if severity < level
+        return true if Suppression.active?
+
+        message, progname = resolve_message_and_progname(message, progname) { block_given? ? yield : nil }
+        Core::RuntimeLocator.current.emit_without_level(record_for(severity, message, progname))
+        true
+      end
+
+      def <<(message)
+        add(::Logger::UNKNOWN, message)
+      end
+
+      def debug(progname = nil, &) = add(::Logger::DEBUG, nil, progname, &)
+
+      def info(progname = nil, &) = add(::Logger::INFO, nil, progname, &)
+
+      def warn(progname = nil, &) = add(::Logger::WARN, nil, progname, &)
+
+      def error(progname = nil, &) = add(::Logger::ERROR, nil, progname, &)
+
+      def fatal(progname = nil, &) = add(::Logger::FATAL, nil, progname, &)
+
+      def unknown(progname = nil, &) = add(::Logger::UNKNOWN, nil, progname, &)
+
+      def debug? = level <= ::Logger::DEBUG
+
+      def info? = level <= ::Logger::INFO
+
+      def warn? = level <= ::Logger::WARN
+
+      def error? = level <= ::Logger::ERROR
+
+      def fatal? = level <= ::Logger::FATAL
+
+      def unknown? = level <= ::Logger::UNKNOWN
+
+      def debug! = self.level = ::Logger::DEBUG
+
+      def info! = self.level = ::Logger::INFO
+
+      def warn! = self.level = ::Logger::WARN
+
+      def error! = self.level = ::Logger::ERROR
+
+      def fatal! = self.level = ::Logger::FATAL
+
+      def level
+        local_level || @level
+      end
+
+      def level=(value)
+        @level = normalize_level(value)
+      end
+
+      def local_level
+        ::ActiveSupport::IsolatedExecutionState[@local_level_key]
+      end
+
+      def local_level=(value)
+        if value.nil?
+          ::ActiveSupport::IsolatedExecutionState.delete(@local_level_key)
+        else
+          ::ActiveSupport::IsolatedExecutionState[@local_level_key] = normalize_level(value)
+        end
+      end
+
+      def silence(severity = ::Logger::ERROR)
+        previous_level = local_level
+        self.local_level = severity
+        yield self
+      ensure
+        self.local_level = previous_level
+      end
+
+      def close = flush
+
+      def reopen(*) = flush
+
+      def flush
+        formatter.clear_tags! if formatter.respond_to?(:clear_tags!)
+        Julewire.flush
+      end
+
+      def initialize_copy(other)
+        super
+        @progname = other.progname.is_a?(String) ? other.progname.dup : other.progname
+        @local_level_key = :"julewire_rails_logger_level_#{object_id}"
+      end
+
+      private
+
+      def normalize_level(value)
+        case value
+        when Integer
+          value
+        when Symbol, String
+          ::Logger::Severity.const_get(value.to_s.upcase)
+        else
+          raise ArgumentError, "invalid log level: #{value.inspect}"
+        end
+      rescue NameError
+        raise ArgumentError, "invalid log level: #{value.inspect}"
+      end
+
+      def resolve_message_and_progname(message, progname)
+        return [message, progname || self.progname] unless message.nil?
+
+        block_message = yield
+        return [block_message, progname || self.progname] unless block_message.nil?
+
+        [progname, self.progname]
+      end
+
+      def record_for(severity, message, progname)
+        record = message.is_a?(Hash) ? structured_message(message) : scalar_message(message)
+        record[:severity] = Julewire::Core::Records::Severity.severity_symbol(severity) || :unknown
+        record[:logger] ||= (progname || self.progname).to_s
+        record[:source] ||= @source
+        merge_current_tags(record)
+      end
+
+      def scalar_message(message)
+        case message
+        when Exception
+          { message: "#{message.class}: #{message.message}", error: message }
+        else
+          { message: message.to_s }
+        end
+      end
+
+      def structured_message(message)
+        fields = Julewire::Core::Fields::FieldSet.deep_symbolize_keys(message)
+        record = fields.slice(*RECORD_KEYS)
+        payload = fields.except(*RECORD_KEYS)
+
+        unless payload.empty?
+          record[:payload] = Julewire::Core::Fields::FieldSet.merge(payload_hash(record[:payload]), payload)
+        end
+        record
+      end
+
+      def payload_hash(payload)
+        return {} if payload.nil?
+        return payload if payload.is_a?(Hash)
+
+        { Julewire::Core::Fields::FieldSet::VALUE_KEY => payload }
+      end
+
+      def merge_current_tags(record)
+        current_tags = formatter.respond_to?(:current_tags) ? formatter.current_tags : nil
+        return record if current_tags.nil? || current_tags.empty?
+
+        attributes = record[:attributes].is_a?(Hash) ? record[:attributes] : {}
+        rails = attributes[:rails].is_a?(Hash) ? attributes[:rails] : {}
+        rails[:tags] = Julewire::Core::Fields::FieldSet.deep_dup(current_tags)
+        attributes[:rails] = rails
+        record[:attributes] = attributes
+        record
+      end
+    end
+  end
+end