debugbundle 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de914935eb26ac5a4a4c7a21e91e13f92fcdef0949c8a19cc9566adf70fa7b5d
-  data.tar.gz: ff2d61415de5d618556d00f4918e4d3a29af38ae7be2bddafc088304a7b11e2b
+  metadata.gz: fa08dbcf220cb84131821cf546272d4d08d6f15f01ba4e8c7f41f77fbc53a1c0
+  data.tar.gz: fe1a46ab795df53b5dd1ac5bee6684b43ea35501d031a345b52c576e9a8881f9
 SHA512:
-  metadata.gz: 7655a43d83ce82e3d7cd6febebc560a2c6c31dde18df9b3a579897fa236c1094c36bc170aa203f1a412caca0ff86c1d6bf529745e9b69e48d55c88799ba84531
-  data.tar.gz: 06b7e321fe0bae17dfe91bd4ffecd4288f84c0151a9909def3d18c02fc1e5f4e262171b7318a2bed337876a0ed7740c9d1d31d0ab518b187a05f72e0db0fcf49
+  metadata.gz: 69e7d24b4c4615dc8ff2da958c90427c0a19d9f781629ff31f9e2918912e97f4298d6a44bba5fd2f19e56cef5fcb426796ed26e7f71b73eefb6384eaa26e0ca7
+  data.tar.gz: 190296bc690b90b3113a59b99c7062ed5f3f95705bb633b4998577d884743f5f64570a727ca81334fb45fe7c3d02f13be4d38cda714244cca79998ad94a2887d

data/README.md

@@ -10,6 +10,114 @@ Version 2.0 changes capture and hook timing. Existing installed 1.5.x applicatio
 
 `make sdk-safety-perf` runs a Docker-backed host-safety budget with 10,000 filtered INFO calls, 1,000 accepted ERROR calls with and without custom privacy fields, and 10,000 concurrent ERROR calls against a full queue while transport is held. CI and the release workflow run this gate before publication. These bounded synthetic checks supplement, but do not replace, installed runtime and workload qualification.
 
+`make evidence-performance` compares the same exception/recovery calls with
+evidence disabled and enabled, including a full warning queue. It reports capture
+time, allocated Ruby objects and retained bytes, and verifies original-error
+priority and the existing queue/diagnostic ceilings. Setup and cleanup are excluded;
+the existing `sdk-safety-perf` timing limits remain unchanged.
+
+## Unreleased evidence candidate
+
+The working candidate adds structured exception evidence and explicit recovery;
+it is not a published release. Enrichment requires a valid capability descriptor
+from the destination on an existing config/ingestion response. No extra discovery
+request is made. Unknown paths keep ordinary exception capture. The optional
+`evidence_capabilities: { version: 1, features: [...] }` pin asserts that every
+receiver, relay, spool/local processor and reader on that path has been qualified;
+it does not upgrade any receiver. `capture_exception_evidence: false` disables
+the new exception fields independently.
+
+`capture_recovery_observations` defaults to `false`. With destination proof and
+the option enabled, report application-observed outcomes inside an operation:
+
+```ruby
+require "securerandom"
+
+client = DebugBundle::Client.new(
+  project_token: ENV.fetch("DEBUGBUNDLE_TOKEN"),
+  capture_recovery_observations: true
+)
+
+client.with_operation_context(kind: "job", name: "asset.prepare", limit_ms: 5000) do
+  begin
+    prepare_asset
+  rescue => error
+    failure_ref = SecureRandom.uuid
+    attempt_id = SecureRandom.uuid
+    client.capture_exception(error, context: { failure_ref: failure_ref })
+    client.capture_recovery(failure_ref: failure_ref, attempt_id: attempt_id, state: "attempt_started")
+    result = application_recovery
+    client.capture_recovery(failure_ref: failure_ref, attempt_id: attempt_id, state: "attempt_completed")
+    client.capture_recovery(
+      failure_ref: failure_ref, attempt_id: attempt_id,
+      state: result.usable? ? "recovery_observed" : "failure_persisted"
+    )
+  end
+end
+```
+
+The application owns recovery and its success check. `attempt_completed` and a
+successful HTTP status do not establish recovery. `attempt_failed` records a
+failed attempt. Observations need no subsequent exception and do not open or
+resolve incidents. Use fresh UUID-v4 failure, attempt and scope IDs. For reporting
+outside the active operation, provide the same explicit `evidence_scope` at
+failure capture and in each observation. Page scopes additionally require the
+same nonblank session correlation; the string `"0"` is valid. Recovery accepts a
+Hash or keyword fields; scope/context Hash keys may be strings or symbols.
+
+Operations retain only bounded kind/name/elapsed/known-limit and correlation
+metadata. They preserve the block's return value and exceptions. Rack/Rails
+request and Sidekiq job capture runs inside its owned scope; other Fibers/threads
+do not inherit it. Completed scopes and process resets revoke ownership. Graphs
+use retained scalar exception snapshots, with no additional custom rendering or
+source/local-variable inspection. Ruby's linear cause path has at most five
+nodes and 32 frames per node, within a combined 32 KiB evidence budget. Fatal
+hooks use at most two nodes, eight frames per node and 4 KiB of total new evidence;
+delivery remains best-effort at process exit. Original sanitised stacks remain.
+Engine metadata is preserved under `payload.runtime.framework_extras`.
+
+Diagnostic metadata and pending events share 64 KiB, at most 50 failure windows,
+five attempts and 20 observations per window, and a five-minute capture window.
+Policy `capture_diagnostic_context: false` and the minimal preset disable recovery.
+Canonical `before_send` replacements may change identity and event type; the SDK
+reapplies privacy, policy, path proof and bounded ownership. An acknowledged
+capability downgrade may retry an original exception once without optional
+evidence, using the same identity and no second hook invocation.
+
+Hook replacements pass the complete vendored canonical schema and its conditional
+frontend identity checks before and after mandatory privacy. Invalid replacements
+fall back to the protected original; explicit `nil` still drops an event. Existing
+queue-pressure aggregate `reason` and `level` fields remain supported.
+
+Outgoing requests stay within the receiver's 256 KiB body limit, counting actual
+escaped UTF-8 JSON. The sender keeps ordered byte-sized batches and schedules
+remaining work on its existing worker. Acknowledgement indices apply to each
+submitted chunk. Oversized optional evidence is removed first; a valid hook
+replacement that still cannot fit is withheld without restoring pre-hook content.
+Invalid or throwing hooks retain the established safe-original fallback. Flush remains a bounded,
+best-effort wait; queued tails can continue after it returns. Local file transport
+keeps its existing bounded ownership and file semantics; the HTTP body limit
+does not narrow admissible local captures.
+
+Native HTTP config/ACK replies request identity encoding and retain at most
+256 KiB before JSON parsing. Existing native connect/read timeouts remain five
+seconds; relay chunks and downgrade retries share one five-second monotonic budget,
+passed to native response reads and remaining connect/read timeouts. A body deadline
+is checked between streamed chunks. Native DNS/socket waits remain advisory. Explicit
+`flush` still waits at most five seconds. `close` stops this process's sender,
+discards queued work and retains active-send accounting until completion. A
+forked child follows the existing fresh-worker contract. `dispose` permanently
+retires a client across process generations; singleton `DebugBundle.init` disposes
+its superseded client. Reinstall explicitly configured logger/integration
+bindings for a replacement client. Independently constructed clients remain
+available for applications that intentionally own multiple projects.
+
+Rack and Rails browser relays preserve validated evidence and server-owned
+credentials. Downstream chunks account for server metadata expansion; a durable
+spool is marked delivered only when every chunk has a complete canonical
+acknowledgement. Legacy custom transport success remains compatible and cannot
+create a delivered marker. Final installed/runtime qualification is in progress.
+
 ## Automatic capture and application filtering
 
 `capture_logger(logger)` respects the logger level, Rails silence and disabled output. Lazy message blocks are evaluated by the native logger: zero times when suppressed and once when accepted. Native return values and application block exceptions are preserved. DebugBundle applies its own configured minimum capture level after the logger accepts a message.
@@ -374,3 +482,22 @@ Apache-2.0. See LICENSE.
 The built-in HTTP transport requires the canonical ingestion acknowledgement (`accepted`, `rejected`, and `errors`). Empty responses, unrelated JSON, malformed counts, or invalid rejection indices retain the full batch with backoff. Valid acknowledgements remove accepted and terminally rejected events and retry only the indexed retryable rejections; an all-rejected batch does not advance `lastEventAt`.
 
 File transports and explicitly supplied custom/legacy transports retain their documented bodyless success fallback. A custom transport that returns acknowledgement fields must return the complete canonical shape. Retry hints (delay seconds or HTTP dates) are bounded to five minutes and measured from response receipt, including partial/protocol acknowledgements and retryable server failures. Without a server hint, existing retry timing is preserved. Failures remain contained within the SDK's existing delivery path.
+
+## Probe checkpoint guidance
+
+Application instrumentation supplies probe labels and bounded data. Deploy a new
+checkpoint before activating it. Remote activation affects future matching calls
+when policy permits; it does not inject code or recover unretained measurements.
+Built-in runtime/error/device collectors keep their documented SDK settings.
+
+Use fixed labels and allowlisted technical states: `media.preview.checkpoint`
+(stage/input kind/attempt), `auth.session.checkpoint` (observed session presence
+and result), `job.dependency.checkpoint` (named dependency/attempt/result), or
+`cache.preview.checkpoint` (hit/miss/coarse age bucket). Omit customer identifiers,
+tokens/cookies, cache keys, URLs and raw payloads. HTTP 200 or attempt completion
+alone does not establish semantic recovery.
+
+Empty probe data means no matching retained observation for the selected sample
+window. It does not confirm activation delivery to every SDK or execution of a
+label. Check the deployed SDK/wrapper version, instrumentation, scope, expiry,
+policy, sampling and delivery receipts. See the [probe recipes](https://debugbundle.com/docs/probes#bounded-checkpoint-recipes).

data/lib/debugbundle/before_send.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'time'
+require 'debugbundle/evidence_wire'
+require 'debugbundle/canonical_event_schema'
 
 module DebugBundle
   module BeforeSend
@@ -12,10 +14,12 @@ module DebugBundle
       'frontend_exception' => %w[name message stack],
       'deploy_metadata' => %w[commit_sha version branch environment deployed_at],
       'error_suppressed' => %w[fingerprint suppressed_count window_seconds first_seen last_seen],
-      'probe_event' => %w[label data activation_id probe_label_pattern]
+      'probe_event' => %w[label data activation_id probe_label_pattern],
+      'diagnostic_context' => %w[version kind failure_ref scope]
     }.freeze
     ALLOWED_PAYLOAD_FIELDS = {
-      'backend_exception' => %w[name message stack handled request response runtime probe_data],
+      'backend_exception' => %w[name message stack handled request response runtime probe_data exception_evidence
+                                execution],
       'request_event' => %w[
         method path query headers body response_status duration_ms route_template
         response_headers response_body device
@@ -24,17 +28,20 @@ module DebugBundle
       'frontend_breadcrumb' => %w[breadcrumb_type route data device],
       'frontend_exception' => %w[
         name message stack route browser breadcrumbs device browser_event
-        rejection_reason dom_context probe_data
+        rejection_reason dom_context probe_data exception_evidence resource_observations
       ],
       'deploy_metadata' => %w[commit_sha version branch environment deployed_at],
       'error_suppressed' => %w[fingerprint suppressed_count window_seconds first_seen last_seen reason level device],
-      'probe_event' => %w[label data activation_id probe_label_pattern device]
+      'probe_event' => %w[label data activation_id probe_label_pattern device],
+      'diagnostic_context' => %w[version kind failure_ref scope attempt_id state operation status_code duration_ms
+                                 source_event_id observations]
     }.freeze
     ROOT_FIELDS = %w[
       schema_version event_id event_type project_token project_id sdk_name sdk_version
       service occurred_at correlation context payload
     ].freeze
-    UUID_PATTERN = /\A[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/i
+    UUID_PATTERN = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+    MOBILE_SDK_NAMES = %w[@debugbundle/sdk-android @debugbundle/sdk-swift @debugbundle/sdk-react-native].freeze
 
     module_function
 
@@ -44,35 +51,56 @@ module DebugBundle
       result = hook.call(Marshal.load(Marshal.dump(event)))
       return nil if result.nil?
 
-      valid?(result) ? result : event
+      checked = normalization_result(result)
+      return nil if checked.equal?(EvidenceValue::EXHAUSTED)
+
+      checked || event
     rescue StandardError
       event
     end
 
     def valid?(event)
-      return false unless event.is_a?(Hash)
-      return false unless (event.keys - ROOT_FIELDS).empty?
-      return false unless %w[schema_version event_id event_type occurred_at sdk_name sdk_version].all? do |field|
-        event[field].is_a?(String) && !event[field].empty?
-      end
-      return false unless UUID_PATTERN.match?(event['event_id'])
+      !normalized(event).nil?
+    end
+
+    def normalized(event)
+      result = normalization_result(event)
+      EvidenceValue.type?(result, Hash) ? result : nil
+    end
+
+    def normalization_result(event)
+      return nil unless EvidenceValue.type?(event, Hash)
+      return nil if Hash.instance_method(:size).bind_call(event) > ROOT_FIELDS.length
+
+      # Local/queued events keep their established ceiling independently of
+      # the smaller evidence DTO and HTTP budgets enforced at those boundaries.
+      owned = EvidenceValue.copy_with_budget(event, symbol_keys: true, max_bytes: 8 * 1024 * 1024,
+                                                    max_string_bytes: 8 * 1024 * 1024)
+      return owned if owned.equal?(EvidenceValue::EXHAUSTED)
+      return nil unless EvidenceValue.type?(owned, Hash)
+      return nil unless CanonicalEventSchema.valid?(owned) && EvidenceWire.valid_optional?(owned)
+      return nil unless required_frontend_context?(owned)
+
+      owned
+    rescue StandardError
+      nil
+    end
+
+    # The canonical Zod contract refines this conditional outside its shape;
+    # the generated JSON Schema alone cannot establish frontend identity.
+    def required_frontend_context?(event)
+      return true unless event['event_type'] == 'frontend_exception'
 
-      Time.iso8601(event['occurred_at'])
-      service = event['service']
       payload = event['payload']
-      fields = REQUIRED_PAYLOAD_FIELDS[event['event_type']]
-      allowed_fields = ALLOWED_PAYLOAD_FIELDS[event['event_type']]
-      service.is_a?(Hash) &&
-        service['name'].is_a?(String) && !service['name'].empty? &&
-        service['environment'].is_a?(String) && !service['environment'].empty? &&
-        payload.is_a?(Hash) &&
-        fields &&
-        allowed_fields &&
-        (payload.keys - allowed_fields).empty? &&
-        fields.all? { |field| payload.key?(field) } &&
-        valid_payload_shape?(event['event_type'], payload)
-    rescue ArgumentError
-      false
+      MOBILE_SDK_NAMES.include?(event['sdk_name']) ? payload['device'].is_a?(Hash) : payload.key?('browser')
+    end
+
+    # Existing shape helpers stay available to integrations. Full acceptance
+    # above uses the vendored canonical contract, including nested fields.
+    def valid_identity?(event)
+      %w[schema_version event_id event_type occurred_at sdk_name sdk_version].all? do |field|
+        event[field].is_a?(String) && !event[field].empty?
+      end && UUID_PATTERN.match?(event['event_id']) && EvidenceWire.timestamp(event['occurred_at'])
     end
 
     def valid_payload_shape?(event_type, payload)
@@ -93,6 +121,8 @@ module DebugBundle
         valid_error_suppressed?(payload)
       when 'probe_event'
         valid_probe_event?(payload)
+      when 'diagnostic_context'
+        EvidenceWire.diagnostic(payload)
       else
         false
       end
@@ -160,9 +190,7 @@ module DebugBundle
     end
 
     def timestamp?(value)
-      value.is_a?(String) && Time.iso8601(value)
-    rescue ArgumentError
-      false
+      EvidenceWire.timestamp(value)
     end
 
     def nullable_uuid?(value)

data/lib/debugbundle/bounded_http_response.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DebugBundle
+  # Native HTTP adapters request identity encoding and stream existing replies.
+  # This cap precedes JSON parsing; no extra discovery request is introduced.
+  module BoundedHttpResponse
+    class LimitExceeded < StandardError; end
+
+    module_function
+
+    def read(deadline: Process.clock_gettime(Process::CLOCK_MONOTONIC) + 5)
+      body = +''
+      response = yield lambda { |chunk|
+        raise LimitExceeded if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+        raise LimitExceeded if body.bytesize + chunk.bytesize > 262_144
+
+        body << chunk
+      }
+      raise LimitExceeded if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+      [response, body]
+    end
+  end
+end

data/lib/debugbundle/canonical_event_schema.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'debugbundle/evidence_wire'
+
+module DebugBundle
+  # A small closed interpreter for the vendored accepting Draft 7 contract.
+  # No remote refs, application serializers or runtime dependency are needed.
+  # Unknown schema keywords fail closed when a future contract is generated.
+  class CanonicalEventSchema
+    KEYWORDS = %w[$schema $id $comment $ref type anyOf const enum properties required additionalProperties
+                  items minimum maximum exclusiveMinimum minLength maxLength minItems maxItems format pattern].freeze
+    TYPES = %w[null boolean number integer string array object].freeze
+    LOAD_MUTEX = Mutex.new
+
+    def self.valid?(value)
+      unless defined?(@engine)
+        LOAD_MUTEX.synchronize do
+          unless defined?(@engine)
+            begin
+              @engine = new(JSON.parse(File.read(File.join(__dir__, 'event-envelope.schema.json'))))
+            rescue StandardError
+              @engine = nil
+            end
+          end
+        end
+      end
+      !!(@engine && @engine.accepts?(value))
+    rescue StandardError
+      false
+    end
+
+    def initialize(schema)
+      @root = schema
+      @references = {}
+      @patterns = {}
+      compile(schema)
+    end
+
+    def compile(node)
+      return if [true, false].include?(node)
+
+      raise ArgumentError, 'unsupported schema keyword' unless (node.keys - KEYWORDS).empty?
+      raise ArgumentError, 'unsupported schema type' unless (Array(node['type']) - TYPES).empty?
+      raise ArgumentError, 'unsupported schema format' unless [nil, 'uuid', 'date-time'].include?(node['format'])
+
+      @patterns[node['pattern']] ||= Regexp.new(node['pattern']) if node.key?('pattern')
+      resolve(node['$ref']) if node.key?('$ref')
+      node.fetch('properties', {}).each_value { |child| compile(child) }
+      node.fetch('anyOf', []).each { |child| compile(child) }
+      %w[items additionalProperties].each { |key| compile(node[key]) if node.key?(key) }
+    end
+
+    def resolve(reference)
+      raise ArgumentError, 'external schema ref' unless reference.start_with?('#/')
+
+      @references[reference] ||= reference.delete_prefix('#/').split('/').reduce(@root) do |node, part|
+        node.fetch(node.is_a?(Array) ? Integer(part) : part.gsub('~1', '/').gsub('~0', '~'))
+      end
+    end
+
+    def accepts?(value)
+      check(@root, value, { steps: 100_000 }, 0)
+    rescue StandardError
+      false
+    end
+
+    def check(node, value, budget, depth)
+      budget[:steps] -= 1
+      return false if depth > 64 || budget[:steps].negative?
+      return node if [true, false].include?(node)
+      return check(resolve(node['$ref']), value, budget, depth + 1) if node.key?('$ref')
+
+      return false if node.key?('anyOf') && node['anyOf'].none? { |child| check(child, value, budget, depth + 1) }
+      return false if node.key?('type') && Array(node['type']).none? { |type| matches_type?(value, type) }
+      return false if node.key?('const') && value != node['const']
+      return false if node.key?('enum') && !node['enum'].include?(value)
+
+      case value
+      when Hash then object?(node, value, budget, depth)
+      when Array then array?(node, value, budget, depth)
+      when String then string?(node, value)
+      when Integer, Float then number?(node, value)
+      else true
+      end
+    end
+
+    def matches_type?(value, type)
+      case type
+      when 'null' then value.nil?
+      when 'boolean' then [true, false].include?(value)
+      when 'string' then value.is_a?(String)
+      when 'object' then value.is_a?(Hash)
+      when 'array' then value.is_a?(Array)
+      when 'number' then (value.is_a?(Integer) || value.is_a?(Float)) && value.to_f.finite?
+      when 'integer' then matches_type?(value, 'number') && value == value.floor
+      else false
+      end
+    end
+
+    def object?(node, value, budget, depth)
+      return false unless node.fetch('required', []).all? { |key| value.key?(key) }
+
+      properties = node.fetch('properties', {})
+      value.all? do |key, child|
+        if properties.key?(key)
+          check(properties[key], child, budget, depth + 1)
+        else
+          check(node.fetch('additionalProperties', true), child, budget, depth + 1)
+        end
+      end
+    end
+
+    def array?(node, value, budget, depth)
+      return false if node.key?('minItems') && value.length < node['minItems']
+      return false if node.key?('maxItems') && value.length > node['maxItems']
+
+      !node.key?('items') || value.all? { |child| check(node['items'], child, budget, depth + 1) }
+    end
+
+    def string?(node, value)
+      return false if node.key?('minLength') && value.length < node['minLength']
+      return false if node.key?('maxLength') && value.length > node['maxLength']
+      return false if node.key?('pattern') && !@patterns.fetch(node['pattern']).match?(value)
+      return EvidenceWire.uuid(value) if node['format'] == 'uuid'
+      return EvidenceWire.timestamp(value) if node['format'] == 'date-time'
+
+      true
+    end
+
+    def number?(node, value)
+      (!node.key?('minimum') || value >= node['minimum']) &&
+        (!node.key?('maximum') || value <= node['maximum']) &&
+        (!node.key?('exclusiveMinimum') || value > node['exclusiveMinimum'])
+    end
+  end
+end

data/lib/debugbundle/client.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 require 'digest'
+require 'English'
 require 'json'
 require 'set'
 require 'time'
 
 require 'debugbundle/client_event_support'
+require 'debugbundle/client_exception_support'
+require 'debugbundle/client_evidence_support'
 require 'debugbundle/client_process_support'
 require 'debugbundle/client_queue_support'
 require 'debugbundle/config_worker'
@@ -91,6 +94,9 @@ module DebugBundle
     def initialize(transport: nil, time_provider: nil, random_provider: nil, config_fetcher: nil, **options)
       @owner_pid = Process.pid
       @config = Config.new(**options)
+      @closed = false
+      @retired = false
+      initialize_evidence
       @time_provider = time_provider || -> { Time.now.utc }
       @random_provider = random_provider || -> { rand }
       @redactor = Redaction::Redactor.new(
@@ -99,17 +105,7 @@ module DebugBundle
       @transport = transport || build_default_transport
       @config_fetcher = config_fetcher || build_default_config_fetcher(custom_transport: !transport.nil?)
       @context = {}
-      @buffer = []
-      @buffer_bytes = 0
-      @buffer_priority_counts = [0, 0, 0, 0]
-      @inflight_event_ids = Set.new
-      @inflight_priority_counts = [0, 0, 0, 0]
-      @event_sizes = {}
-      @pressure_drops = {}
-      @hook_bypass = Set.new
-      @finalized_events = {}
-      @buffer_mutex = Mutex.new
-      @flush_mutex = Mutex.new
+      initialize_buffer_ownership
       @probe_buffers = {}
       @suppression = Suppression::Tracker.new
       @last_event_at = nil
@@ -145,46 +141,6 @@ module DebugBundle
       capture_exception_internal(error, context: context, handled: handled, run_before_send: true)
     end
 
-    def capture_exception_internal(error, context:, handled:, run_before_send:)
-      return unless capture_enabled?
-      return unless preflight_capacity?(3, 'exception')
-
-      request_remote_config_poll_if_due
-
-      merged_context = merge_context(context)
-      payload = {
-        'name' => safe_exception_name(error),
-        'message' => safe_exception_message(error),
-        'stack' => safe_exception_stack(error),
-        'handled' => handled,
-        'request' => request_payload(merged_context['request']),
-        'response' => response_payload(merged_context['response']),
-        'runtime' => runtime_payload
-      }
-
-      causes = exception_causes(error)
-
-      probe_data = probe_snapshot
-      payload['probe_data'] = probe_data unless probe_data.empty?
-
-      extra_context = merged_context.except('request', 'response', 'correlation')
-      extra_context['causes'] = causes unless causes.empty?
-
-      event = base_event('backend_exception', payload, extra_context)
-
-      event_payload = event.fetch('payload')
-      suppression_key = [
-        event['event_type'],
-        event_payload['name'],
-        event_payload['message'],
-        event_payload['stack']
-      ].join(':')
-      return unless @suppression.should_capture(suppression_key, now: monotonic_now)
-
-      enqueue_event(event, skip_before_send: !run_before_send)
-    end
-    private :capture_exception_internal
-
     def capture_error(error, context: nil, handled: true) = capture_exception(error, context: context, handled: handled)
 
     def capture_log(message, level: :warning, context: nil)
@@ -363,6 +319,8 @@ module DebugBundle
       return false unless @config_fetcher
 
       response = @config_fetcher.call(@remote_config_etag)
+      return false if @closed
+
       status_code = response.fetch(:status_code, 500)
       if status_code == 304
         schedule_next_remote_config_poll
@@ -373,7 +331,9 @@ module DebugBundle
         return false
       end
 
-      snapshot = RemoteConfig.parse(response.fetch(:body, {}), config.probes_poll_interval)
+      body = response.fetch(:body, {})
+      snapshot = RemoteConfig.parse(body, config.probes_poll_interval)
+      @evidence.observe(body, required: true, valid: !snapshot.nil? && @evidence.valid_config?(body))
       unless snapshot
         schedule_next_remote_config_poll
         return false
@@ -403,8 +363,17 @@ module DebugBundle
 
     def close
       ensure_current_process!
+      @closed = true
+      @operations.clear
+      @evidence = EvidenceDelivery.new
       @delivery_worker&.close
       @config_worker&.close
+      @buffer_mutex.synchronize { discard_closed_buffer_locked }
+    end
+
+    def dispose
+      @retired = true
+      close
     end
 
     def flush_now
@@ -417,20 +386,12 @@ module DebugBundle
         return false if @transport.nil?
         return false if rate_limited?
 
-        # Replace consumed snapshot slots so dropped events do not remain owned
-        # by this batch while later callbacks run or transport waits.
-        prepared = candidates.map! do |event|
-          finalized = finalized_event_for(event)
-          if finalized.nil?
-            remove_buffered_events([event])
-            next
-          end
-          [event, finalized]
-        end.compact
+        prepared = prepare_wire_batch(candidates)
         return true if prepared.empty?
 
         batch = prepared.map(&:first)
         wire_events = prepared.map(&:last)
+        return true if @closed
 
         result = Transport.coerce_result(
           @transport.call(
@@ -442,7 +403,9 @@ module DebugBundle
 
         case result.status_code
         when 200..299
-          handle_successful_result(result, batch)
+          accepted = handle_successful_result(result, batch)
+          @delivery_worker&.wake if @retry_at.nil? && buffered_event_count.positive?
+          accepted
         when 429, 500..599
           @consecutive_failures += 1
           retry_after_seconds = bounded_retry_hint(result.retry_after_seconds)
@@ -468,22 +431,30 @@ module DebugBundle
     private :flush_now
 
     def finalized_event_for(event)
+      return nil if @closed
+
       event_id = event['event_id']
       cached, bypass = @buffer_mutex.synchronize do
         [@finalized_events[event_id], @hook_bypass.include?(event_id)]
       end
-      return cached if cached
+      finalized = cached || (bypass || !config.before_send ? event : apply_before_send(event))
+      return nil if finalized.nil? || @closed
 
-      finalized = bypass || !config.before_send ? event : apply_before_send(event)
-      return nil if finalized.nil?
+      finalized = filter_evidence(finalized)
+      return nil unless finalized
       return nil unless post_hook_event_allowed?(finalized)
+      return nil unless reconcile_diagnostic(cached || event, finalized)
 
-      cache_finalized_event(event, finalized)
+      retained = cache_finalized_event(event, finalized)
+      @buffer_mutex.synchronize { release_diagnostics_locked(event, finalized) } unless retained
+      retained
     end
     private :finalized_event_for
 
     def post_hook_event_allowed?(event)
       case event['event_type']
+      when 'diagnostic_context'
+        recovery_allowed? && event.dig('payload', 'kind') == 'recovery'
       when 'log_event'
         return false if @capture_policy.capture_logs == 'off'
 
@@ -523,6 +494,8 @@ module DebugBundle
 
     def handle_successful_result(result, batch)
       decision = Acknowledgement.decide(result.body, batch.length, required: @transport.is_a?(Transport::HttpTransport))
+      lost_evidence = !@closed && @evidence.observe(result.body, required: @transport.is_a?(Transport::HttpTransport),
+                                                                 valid: decision[:kind] == :acknowledged)
       return handle_protocol_failure(result.retry_after_seconds) if decision[:kind] == :protocol_failure
 
       if decision[:kind] == :legacy
@@ -533,6 +506,7 @@ module DebugBundle
 
       retryable_indices = decision.fetch(:retryable_indices)
       retryable_events = retryable_indices.map { |index| batch.fetch(index) }
+      retryable_events |= downgrade_evidence_errors(batch, decision, lost_evidence)
       remove_buffered_events(batch - retryable_events)
       @last_event_at = now if decision.fetch(:accepted).positive?