julewire-rails 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f58689c6d6e15c3e4b12887ce1cbc0e744a6335cc733e28b7200b430dff90a5
-  data.tar.gz: 5558cedae8f43deefe4358e8033d9d41f346f2c8b7b1e559a8521ab48a01f28d
+  metadata.gz: '0788f684a45eba2f940fb5a836cb45c7aef84ae6c67d68da62c2e38e4376dcae'
+  data.tar.gz: 72559f89728d55e90a231d25d3bc60a37453fcbaec0f0c8c5e21728547e0cb5b
 SHA512:
-  metadata.gz: ff52b5a8269c70172251391cb16f375d98c5171055b01f7640cc23f0d4d63b781a22d91a1d9bd593202dbab21124130bea0bbd2347e006d536f0d43c937306fa
-  data.tar.gz: 5d1e00972c69b1dd7066c0280e4f8d2c8deb1ae3684abc8dc78b701cd04a3d4b6130c8b2c38fce91768dbe832b7434a7c33be4c9d24b3d1cb8e22d934a9cb719
+  metadata.gz: 137c77cfabe1a91768ce04b7df57e1c00d44f4ec97103fa21ce5ebc333e48135d034ebaead86dfd9ce945d43aa0a834c0a6f3027d4b63da0c440172c842882d5
+  data.tar.gz: 7190bcf29e2aa09995ee3728c9102b25b24ed89ed8d0597c0d51e0de4fe2a1d27c4e8f8e3a20ac7b277a7f9f73c2dc60e8c6faae778c595824a5ead78883288f

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## Unreleased
 
+## 1.1.0 - 2026-07-20
+
+- Roll back pushed request tags when request instrumentation fails during
+  middleware startup.
+- Harden request logging, filtering, suppression, and error ownership around
+  Julewire 1.1 record contracts.
+- Require Julewire 1.1.0 internal gems.
+
 ## 1.0.1 - 2026-06-25
 
 - Require julewire 1.0.1 internal gems.

data/docs/capture-and-filtering.md

@@ -31,8 +31,8 @@ Captured response summaries include:
 - `response_body_bytes`
 - `response_body_truncated`
 
-`*_body_bytes` is the content length when the framework provides it; otherwise
-it is the number of bytes observed while capturing.
+`*_body_bytes` is the declared content length or the bytes observed while
+capturing. When both are known, Julewire reports the larger value.
 
 Request and response headers use `false`, `true`, or an explicit header list:
 
@@ -48,7 +48,8 @@ end
 When header capture is `true`, Julewire omits common sensitive headers such as
 `authorization`, `cookie`, `set-cookie`, `proxy-authorization`, and
 `x-api-key`. Use an explicit header list if the application deliberately wants
-one of those fields.
+one of those fields. Treat `headers = true` as controlled debugging; production
+configs should prefer explicit allowlists.
 
 Captured request summaries can include:
 

data/docs/configuration.md

@@ -38,8 +38,9 @@ These defaults are intended for a normal Rails app:
 | `filter_event_payloads` | `true` | Filter serialized object-event hashes with Rails parameter filters. |
 | `rendered_exceptions` | `false` | Emit diagnostic rendered-exception point records in addition to summaries. |
 
-Broad header capture (`*.headers = true`) skips common sensitive headers.
-Explicit header lists are authoritative.
+Broad header capture (`*.headers = true`) skips common sensitive headers but is
+still a debugging shape. Production configs should prefer explicit header
+lists.
 
 `structured_event_prefixes = nil` accepts all structured-event names. Use it
 only when the app wants Julewire to consider every Rails event.

data/julewire-rails.gemspec

@@ -35,9 +35,9 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "actionpack", ">= 8.1"
   spec.add_dependency "actionview", ">= 8.1"
-  spec.add_dependency "julewire-core", ">= 1.0.1"
-  spec.add_dependency "julewire-rack", ">= 1.0.1"
-  spec.add_dependency "julewire-rails_support", ">= 1.0.1"
+  spec.add_dependency "julewire-core", ">= 1.1.0"
+  spec.add_dependency "julewire-rack", ">= 1.1.0"
+  spec.add_dependency "julewire-rails_support", ">= 1.1.0"
   spec.add_dependency "logger", ">= 1.7"
   spec.add_dependency "railties", ">= 8.1"
   spec.add_dependency "zeitwerk", ">= 2.8.1"

data/lib/julewire/rails/configuration.rb

@@ -46,14 +46,14 @@ module Julewire
       private
 
       def validate_carry_request_headers(value)
-        return value unless value == true
+        return unless value == true
 
         raise Error, "carry_request_headers must be an explicit header list"
       end
 
       def validate_request_summary_timeout(value)
-        return value if value.nil?
-        return value if value.is_a?(Numeric) && value.positive?
+        return if value.nil?
+        return if value.is_a?(Numeric) && value.positive?
 
         raise Error, "request_summary_timeout must be nil or a positive Numeric"
       end
@@ -67,7 +67,7 @@ module Julewire
 
       def validate_capture_settings(settings)
         settings.validate!
-        settings
+        nil
       end
     end
   end

data/lib/julewire/rails/context_body_proxy.rb

@@ -11,7 +11,7 @@ module Julewire
       end
 
       def each(&block)
-        return enum_for(:each) unless block_given?
+        return enum_for unless block_given?
 
         @handle.with_context do
           @body.each { block.yield(it) }
@@ -31,8 +31,13 @@ module Julewire
 
       def closed? = @closed
 
-      def respond_to_missing?(method_name, include_private = false)
-        (method_name != :to_str && @body.respond_to?(method_name, include_private)) || super
+      def respond_to_missing?(method_name, _include_private)
+        case method_name
+        when :to_str
+          false
+        else
+          @body.respond_to?(method_name)
+        end
       end
 
       def method_missing(method_name, ...)

data/lib/julewire/rails/debug_exception_log_silencer.rb

@@ -5,9 +5,9 @@ require "action_dispatch/middleware/debug_exceptions"
 module Julewire
   module Rails
     module DebugExceptionLogSilencer
-      Patch = Module.new do
+      module Patch
         def log_error(request, wrapper)
-          return if Julewire::Rails::DebugExceptionLogSilencer.suppress?(request, wrapper)
+          return if DebugExceptionLogSilencer.suppress?
 
           super
         end
@@ -17,26 +17,11 @@ module Julewire
       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?
+        def suppress?
           configuration = @configuration
           return false unless configuration
 
@@ -46,6 +31,12 @@ module Julewire
           else
             !configuration.reported_exception_logs
           end
+        rescue StandardError => e
+          IntegrationHealth.record_failure(
+            e,
+            action: :suppress?,
+            component: :debug_exception_log_silencer
+          )
         end
       end
     end

data/lib/julewire/rails/doctor_app.rb

@@ -67,8 +67,8 @@ module Julewire
           "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>",
+            "<p>Level: <code>#{escape(report.fetch(:runtime).fetch(:level))}</code></p>",
+            "<p>Pipeline: <strong>#{escape(report.fetch(:pipeline).fetch(:status))}</strong></p>",
             "<h2>Warnings</h2>",
             warning_items.empty? ? "<p>None</p>" : "<ul>#{warning_items}</ul>",
             nav_links(request, ["/tail", "Tail"], ["/doctor.json", "JSON"])
@@ -79,14 +79,15 @@ module Julewire
       def render_tail(request)
         return page("Julewire Tail", "<p>Tail is not attached.</p>") unless @tail
 
+        table = <<~HTML
+          <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>
+        HTML
         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,
+          table,
           tail_nav(request),
           tail_script
         ].join
@@ -99,13 +100,11 @@ module Julewire
 
       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 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)
@@ -117,7 +116,7 @@ module Julewire
       end
 
       def tail_entries
-        @tail ? @tail.entries(limit: TAIL_LIMIT) : []
+        @tail.entries(limit: TAIL_LIMIT)
       end
 
       def tail_events(request)
@@ -135,7 +134,7 @@ module Julewire
       def event_cursor(request)
         value = request.get_header("HTTP_LAST_EVENT_ID")
         value = request.params["after"] if value.nil? || value.empty?
-        Integer(value || 0)
+        Integer(value)
       rescue ArgumentError, TypeError
         0
       end
@@ -190,8 +189,9 @@ module Julewire
       end
 
       def app_path(request, path)
-        base = request.script_name.to_s
-        base = "" if base == "/"
+        base = request.script_name
+        return path if base == "/"
+
         "#{base}#{path}"
       end
 
@@ -200,7 +200,7 @@ module Julewire
       end
 
       def link_to(request, path, label)
-        %(<a href="#{escape(app_path(request, path))}">#{escape(label)}</a>)
+        %(<a href="#{escape(app_path(request, path))}">#{label}</a>)
       end
 
       def page(title, body)
@@ -209,7 +209,7 @@ module Julewire
           <html>
           <head>
             <meta charset="utf-8">
-            <title>#{escape(title)}</title>
+            <title>#{title}</title>
             <style>
               body { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; margin: 2rem; color: #171717; }
               a { color: #0b5fff; margin-right: 1rem; }
@@ -218,7 +218,7 @@ module Julewire
             </style>
           </head>
           <body>
-            <h1>#{escape(title)}</h1>
+            <h1>#{title}</h1>
             #{body}
           </body>
           </html>

data/lib/julewire/rails/lifecycle_hooks.rb

@@ -29,18 +29,8 @@ module Julewire
           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
 
@@ -64,7 +54,6 @@ module Julewire
             action: :install_after_fork,
             component: :lifecycle_hooks
           )
-          nil
         end
 
         def active_support_fork_tracker

data/lib/julewire/rails/log_subscriber_silencer.rb

@@ -22,7 +22,10 @@ module Julewire
       class << self
         def silence!
           require_log_subscribers
-          SUBSCRIBERS.each { |class_name, namespace| detach(class_name, namespace) }
+          SUBSCRIBERS.each do |class_name, namespace|
+            subscriber_class = Julewire::RailsSupport::LogSubscribers.constantize(class_name)
+            Julewire::RailsSupport::LogSubscribers.detach(subscriber_class, namespace)
+          end
         end
 
         private
@@ -30,22 +33,6 @@ module Julewire
         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

data/lib/julewire/rails/logger.rb

@@ -24,13 +24,13 @@ module Julewire
         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))
+        message, progname = resolve_message_and_progname(message, progname) { yield if block_given? }
+        Julewire::Core::RuntimeLocator.current.emit_without_level(record_for(severity, message, progname))
         true
       end
 
       def <<(message)
-        add(::Logger::UNKNOWN, message)
+        add(nil, message)
       end
 
       def debug(progname = nil, &) = add(::Logger::DEBUG, nil, progname, &)
@@ -43,7 +43,7 @@ module Julewire
 
       def fatal(progname = nil, &) = add(::Logger::FATAL, nil, progname, &)
 
-      def unknown(progname = nil, &) = add(::Logger::UNKNOWN, nil, progname, &)
+      def unknown(progname = nil, &) = add(nil, nil, progname, &)
 
       def debug? = level <= ::Logger::DEBUG
 
@@ -104,9 +104,8 @@ module Julewire
         Julewire.flush
       end
 
-      def initialize_copy(other)
-        super
-        @progname = other.progname.is_a?(String) ? other.progname.dup : other.progname
+      def initialize_copy(_other)
+        @progname = @progname.dup if @progname.is_a?(String)
         @local_level_key = :"julewire_rails_logger_level_#{object_id}"
       end
 
@@ -117,31 +116,41 @@ module Julewire
         when Integer
           value
         when Symbol, String
-          ::Logger::Severity.const_get(value.to_s.upcase)
+          ::Logger::Severity.const_get(value.upcase)
         else
-          raise ArgumentError, "invalid log level: #{value.inspect}"
+          raise_invalid_level(value)
         end
       rescue NameError
+        raise_invalid_level(value)
+      end
+
+      def raise_invalid_level(value)
         raise ArgumentError, "invalid log level: #{value.inspect}"
       end
 
       def resolve_message_and_progname(message, progname)
-        return [message, progname || self.progname] unless message.nil?
+        return [message, progname] unless message.nil?
 
         block_message = yield
-        return [block_message, progname || self.progname] unless block_message.nil?
+        return [block_message, progname] unless block_message.nil?
 
-        [progname, self.progname]
+        [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[:severity] = record_severity(severity)
+        record[:logger] ||= (progname || @progname).to_s
         record[:source] ||= @source
         merge_current_tags(record)
       end
 
+      def record_severity(value)
+        Julewire::Core::Records::Severity.normalize(value)
+      rescue ArgumentError
+        :unknown
+      end
+
       def scalar_message(message)
         case message
         when Exception
@@ -156,28 +165,24 @@ module Julewire
         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[:payload] = Julewire::Core::Fields::FieldSet.merge(payload_hash(record[:payload]), payload)
         record
       end
 
       def payload_hash(payload)
         return {} if payload.nil?
-        return payload if payload.is_a?(Hash)
+        return payload if payload.instance_of?(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
+        current_tags = formatter.current_tags if formatter.respond_to?(:current_tags)
         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[:attributes] = {
+          rails: { tags: current_tags }
+        }
         record
       end
     end

data/lib/julewire/rails/logger_outputs.rb

@@ -7,10 +7,7 @@ module Julewire
     module LoggerOutputs
       class << self
         def install!
-          return if @installed
-
           ::ActiveSupport::Logger.singleton_class.prepend(Patch)
-          @installed = true
         end
 
         def julewire_logger?(logger)

data/lib/julewire/rails/output_requirement.rb

@@ -11,7 +11,7 @@ module Julewire
           return unless settings.logger?
 
           mode = normalized_mode(settings.require_output)
-          return if mode == false || health.dig(:pipeline, :configured)
+          return if health.dig(:pipeline, :configured)
 
           case mode
           when :warn
@@ -25,7 +25,7 @@ module Julewire
 
         def normalized_mode(value)
           case value
-          when false, nil then false
+          when false, nil then nil
           when true, :warn, "warn" then :warn
           when :raise, "raise" then :raise
           else

data/lib/julewire/rails/parameter_filter_plan.rb

@@ -4,32 +4,31 @@ 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)
+          simple, deep = partition_filters(filters)
+          return unless simple.any? && deep.empty?
+
+          new(simple)
+        end
+
+        private
+
+        def partition_filters(filters)
+          filters.map { it.to_s.downcase }.partition { !it.include?(".") }
         end
       end
+      private_class_method :new
 
       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
+        @simple_pattern = simple_filter_pattern(filters)
       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)
@@ -39,27 +38,6 @@ module Julewire
 
       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
@@ -92,9 +70,7 @@ module Julewire
         @simple_pattern.match?(key_name(key))
       end
 
-      def key_name(key)
-        key.is_a?(Symbol) ? key.name : key.to_s
-      end
+      def key_name(key) = key.to_s
     end
   end
 end