oopsie_exceptions 1.1.0 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3c1bf7176b541c4c19f09ca56724e8c873e1bae149ac9ff9963a4f4fb4f1156
-  data.tar.gz: 692fd55d89e3235279b1ba98764f1fbeaeab5e11204c3733674f7a8958956262
+  metadata.gz: 49072b73da34cefc5bf2c080d3bad5f4d0d6f0494225ae8a6e4140488aa00744
+  data.tar.gz: 85a4877ef4f61c7a81932e1b607d2d0a637ecfaebff111b54eb1a59ded96a496
 SHA512:
-  metadata.gz: 0c8a3bfd9907819f35ecd979d114e9784daf71ff7c5b2264246782458463c15271a71319208fe5798de1c11178c7bf643e8bcda693124ed74e7f2a50cc25ef17
-  data.tar.gz: 9d4f5168d31b516127abc0afa2e894ec02c28cdf076e82f96d555f81c1e38fb3884d3fbca46307572ce2f9749798cf1ace9c4e2fa6d98a6263908c4a695a14a1
+  metadata.gz: 7b1936f78e392b54e8fb27ab5c12fdfcf9c95ff2ffb9a86bd6a06b4c6eb35df914caa6eca293e8a1a755cfff224ec9527c944dfc413b89e381f64df29ca32f37
+  data.tar.gz: 5103181f96b85219c367bf6b2df92ce6492d25a98cba35a12868ca2b1f0cfc5a0a239360563d1d45fdfbb2496c6a1ce1a820e542bf974658f62b8014bd58d70e

data/README.md

@@ -90,6 +90,8 @@ end
 
 Each captured exception is enriched with request URL/method/IP/params/headers, the current user (via `context_builder` or `set_context`), server hostname/PID/Ruby version, and a UTC timestamp.
 
+Request context capture is best-effort. If Rack rejects a malformed or truncated request body while OopsieExceptions is collecting params, the exception report is still allowed to continue with `request.params` omitted. Payloads include omission metadata such as `params_omitted` / `params_error_class` or `body_omitted` / `body_error_class` when request enrichment fails.
+
 ## Adding context per-request
 
 If you don't want to use `context_builder`, you can set context from a controller:
@@ -189,6 +191,14 @@ Return `nil` to drop the notification entirely.
 
 ## Upgrading from earlier versions
 
+### Malformed request body handling
+
+Apps that added a local guard around OopsieExceptions request context collection for malformed multipart or truncated request bodies can remove that workaround after upgrading to a gem release that includes best-effort request params/body capture. Until the fixed gem version is deployed in the app, keep the app-local guard in place.
+
+This gem change only prevents OopsieExceptions from turning context enrichment into a new request failure. Production exception groups for the affected app should still be resolved from that app's deploy verification, not from the gem release alone.
+
+### Legacy delivery job cleanup
+
 If you're coming from an older version of the gem that generated `app/jobs/oopsie_exceptions/delivery_job.rb` in your app, **delete that file**. The gem now ships its own `OopsieExceptions::WebhookJob` and the host-app file is obsolete.
 
 ```bash

data/lib/oopsie_exceptions/context.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "rack"
+require "rack/request"
 
 module OopsieExceptions
   module Context
@@ -27,38 +27,63 @@ module OopsieExceptions
         request = Rack::Request.new(env)
         config = OopsieExceptions.configuration
 
-        ctx = {
-          request: {
-            url: request.url,
-            method: request.request_method,
-            ip: request.ip,
-            user_agent: env["HTTP_USER_AGENT"],
-            referer: env["HTTP_REFERER"],
-            request_id: env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"],
-            params: sanitize_params(request.params, config),
-            headers: extract_headers(env, config)
-          }
+        request_context = {
+          url: request.url,
+          method: request.request_method,
+          ip: request.ip,
+          user_agent: env["HTTP_USER_AGENT"],
+          referer: env["HTTP_REFERER"],
+          request_id: env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"],
+          headers: extract_headers(env, config)
         }
 
-        if config.capture_request_body && request.content_type&.include?("application/json")
-          body = request.body.read
-          request.body.rewind
-          ctx[:request][:body] = body[0, 10_000] if body && !body.empty?
-        end
+        request_context.merge!(request_params_context(request, config))
+        request_context.merge!(request_body_context(request, config))
+
+        ctx = {
+          request: request_context
+        }
 
         ctx
       end
 
       private
 
+      def request_params_context(request, config)
+        { params: sanitize_params(request.params, config) }
+      rescue StandardError => error
+        rewind_body(request.body)
+        {
+          params: {},
+          params_omitted: true,
+          params_error_class: error.class.name
+        }
+      end
+
+      def request_body_context(request, config)
+        return {} unless config.capture_request_body
+        return {} unless request.content_type&.include?("application/json")
+
+        body_io = request.body
+        body = body_io.read
+        return {} if body.nil? || body.empty?
+
+        { body: body[0, 10_000] }
+      rescue StandardError => error
+        {
+          body_omitted: true,
+          body_error_class: error.class.name
+        }
+      ensure
+        rewind_body(body_io)
+      end
+
       def sanitize_params(params, config)
         filtered = params.reject { |k, _| k == "controller" || k == "action" }
         filter_keys = config.filter_parameters
         filtered.each_with_object({}) do |(k, v), hash|
-          hash[k] = filter_keys.any? { |f| k.to_s.include?(f) } ? "[FILTERED]" : v
+          hash[k] = filter_keys.any? { |f| k.to_s.include?(f.to_s) } ? "[FILTERED]" : v
         end
-      rescue
-        {}
       end
 
       def extract_headers(env, config)
@@ -66,11 +91,17 @@ module OopsieExceptions
         env.each do |key, value|
           next unless key.start_with?("HTTP_")
           header_name = key.sub("HTTP_", "").split("_").map(&:capitalize).join("-")
-          next if config.filter_headers.any? { |h| h.casecmp(header_name) == 0 }
+          next if config.filter_headers.any? { |h| h.to_s.casecmp(header_name) == 0 }
           headers[header_name] = value
         end
         headers
       end
+
+      def rewind_body(body_io)
+        body_io.rewind if body_io&.respond_to?(:rewind)
+      rescue StandardError
+        nil
+      end
     end
   end
 end

data/lib/oopsie_exceptions/exception_normalizer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module OopsieExceptions
+  class ExceptionNormalizer
+    RETRY_WRAPPER_CLASS_NAMES = %w[
+      Sidekiq::JobRetry::Handled
+    ].freeze
+
+    Result = Struct.new(:exception, :context, :wrappers, keyword_init: true)
+
+    class << self
+      def normalize(exception, context:)
+        wrappers = collect_retry_wrappers(exception)
+        return Result.new(exception: exception, context: context, wrappers: []) if wrappers.empty?
+
+        Result.new(
+          exception: wrappers.last.cause,
+          context: merge_wrapper_context(context, wrappers, wrappers.last.cause),
+          wrappers: wrappers
+        )
+      end
+
+      private
+
+      def collect_retry_wrappers(exception)
+        wrappers = []
+        current = exception
+        seen = {}
+
+        while retry_wrapper?(current) && current.cause && !seen[current.__id__]
+          seen[current.__id__] = true
+          wrappers << current
+          current = current.cause
+        end
+
+        wrappers
+      end
+
+      def retry_wrapper?(exception)
+        RETRY_WRAPPER_CLASS_NAMES.include?(exception.class.name)
+      end
+
+      def merge_wrapper_context(context, wrappers, normalized_exception)
+        merged_context = context.dup
+        metadata = wrappers.map do |wrapper|
+          wrapper_metadata(wrapper, normalized_exception, context)
+        end
+
+        if merged_context.key?(:exception_wrapper) || merged_context.key?("exception_wrapper")
+          merged_context[:oopsie_exception_wrapper] = metadata.first
+        else
+          merged_context[:exception_wrapper] = metadata.first
+        end
+
+        merged_context[:exception_wrappers] = metadata if metadata.length > 1
+        merged_context
+      end
+
+      def wrapper_metadata(wrapper, normalized_exception, context)
+        metadata = {
+          class_name: wrapper.class.name,
+          message: wrapper.message.to_s[0, 1_000],
+          first_line: parse_backtrace_line(wrapper.backtrace&.first),
+          normalized_exception: {
+            class_name: normalized_exception.class.name,
+            message: normalized_exception.message.to_s[0, 1_000]
+          }
+        }
+
+        source = context[:source] || context["source"]
+        metadata[:source] = source if source
+        metadata
+      end
+
+      def parse_backtrace_line(line)
+        return nil unless line
+
+        match = line.match(/\A(.+):(\d+):in [`'](.+)'\z/)
+        return { raw: line } unless match
+
+        {
+          file: match[1],
+          line: match[2].to_i,
+          method: match[3]
+        }
+      end
+    end
+  end
+end

data/lib/oopsie_exceptions/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OopsieExceptions
-  VERSION = "1.1.0"
+  VERSION = "1.1.2"
 end

data/lib/oopsie_exceptions.rb

@@ -3,6 +3,7 @@
 require_relative "oopsie_exceptions/version"
 require_relative "oopsie_exceptions/configuration"
 require_relative "oopsie_exceptions/context"
+require_relative "oopsie_exceptions/exception_normalizer"
 require_relative "oopsie_exceptions/payload"
 require_relative "oopsie_exceptions/webhook_client"
 require_relative "oopsie_exceptions/middleware"
@@ -24,12 +25,17 @@ module OopsieExceptions
 
     def report(exception, context: {}, handled: true)
       return unless configuration.enabled
-      return if configuration.ignored?(exception)
-      return if exception.instance_variable_get(REPORTED_MARKER)
+      normalized = ExceptionNormalizer.normalize(exception, context: context)
+      reportable_exception = normalized.exception
 
-      exception.instance_variable_set(REPORTED_MARKER, true)
+      return if configuration.ignored?(reportable_exception)
+      return if reportable_exception.instance_variable_get(REPORTED_MARKER)
 
-      payload = Payload.build(exception, context: context, handled: handled)
+      ([reportable_exception] + normalized.wrappers).each do |reported_exception|
+        reported_exception.instance_variable_set(REPORTED_MARKER, true)
+      end
+
+      payload = Payload.build(reportable_exception, context: normalized.context, handled: handled)
 
       if configuration.before_notify
         payload = configuration.before_notify.call(payload)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oopsie_exceptions
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.2
 platform: ruby
 authors:
 - Troy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-06 00:00:00.000000000 Z
+date: 2026-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
 description: Captures unhandled exceptions from web requests and background jobs,
   enriches them with request/user/server context, and delivers structured JSON payloads
   to configurable webhook endpoints. Works with any Rack-based framework; optional
@@ -42,6 +56,7 @@ files:
 - lib/oopsie_exceptions/configuration.rb
 - lib/oopsie_exceptions/context.rb
 - lib/oopsie_exceptions/error_subscriber.rb
+- lib/oopsie_exceptions/exception_normalizer.rb
 - lib/oopsie_exceptions/middleware.rb
 - lib/oopsie_exceptions/payload.rb
 - lib/oopsie_exceptions/railtie.rb
@@ -70,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: Lightweight exception capture and webhook delivery for Ruby (framework-agnostic)