chronos-ruby 0.3.0.pre.1 → 0.5.0.pre.1

data/docs/modules/telemetry-events.md

@@ -0,0 +1,9 @@
+# Framework telemetry events
+
+`Chronos::Core::TelemetryEvent` and `Chronos::Core::TelemetrySerializer` extend the v1 envelope to `request`, `query`, `job`, and `cache` events. These values exist so framework adapters do not model operational timings as fake exceptions.
+
+Telemetry has the same `schema_version`, event ID, timestamps, project, environment, service, runtime, context, sanitization, payload-size limit, idempotency header, asynchronous queue, retry, circuit breaker, and memory backlog used by exception events. Unsupported types are rejected locally.
+
+`Chronos.record_event` is the narrow integration entry point. Application code should prefer documented higher-level APIs; its payload is allowlisted by each bundled integration and then sanitized. Remote configuration can reduce or disable any locally enabled telemetry type but cannot enable a type excluded by local configuration.
+
+Version 0.5 intentionally sends individual framework events. Aggregation, percentiles, slow-query analysis, and transaction breakdowns remain part of version 0.7.

data/docs/performance.md

@@ -1,6 +1,6 @@
 # Performance
 
-Performance is a functional requirement, but version 0.3 makes no unverified speed claim.
+Performance is a functional requirement, but version 0.5 makes no unverified speed claim.
 
 Current controls:
 
@@ -15,9 +15,24 @@ Current controls:
 - retry count, delay, jitter, and `Retry-After` are capped;
 - the circuit breaker suppresses requests during sustained failure;
 - retry backlog capacity is fixed and may be disabled;
-- shutdown and flush have caller-controlled timeouts.
+- shutdown and flush have caller-controlled timeouts;
+- request context and breadcrumbs have fixed structural and byte limits;
+- Rack middleware never consumes request or response bodies.
+- Rails subscribers copy only small allowlisted field sets and never copy raw SQL or job arguments.
 
-Run the scripts under `benchmarks/` and record Ruby version, operating system, CPU, warmup, iteration count, median, and dispersion before publishing results. `benchmarks/filtering.rb` measures privacy filtering, while `benchmarks/retry_backlog.rb` measures fixed-memory behavior with an unavailable in-memory transport. Request overhead is not measured because automatic request integration is outside version 0.3.
+Run the scripts under `benchmarks/` and record Ruby version, operating system, CPU, warmup, iteration count, median, and dispersion before publishing results. `benchmarks/filtering.rb` measures privacy filtering, `benchmarks/retry_backlog.rb` measures fixed-memory outage behavior, `benchmarks/request_overhead.rb` compares Rack-protocol calls, and `benchmarks/rails_notifications.rb` isolates subscriber normalization overhead.
+
+## Version 0.5 Rails subscriber benchmark
+
+Run:
+
+```bash
+ITERATIONS=100000 bundle _1.17.3_ exec ruby benchmarks/rails_notifications.rb
+```
+
+This synthetic benchmark invokes the SQL notification normalizer with a no-op notifier. It verifies that raw SQL and binds are not copied and measures local allowlist normalization only; it does not include Rails dispatch, serialization, queueing, or network delivery.
+
+A local diagnostic run on 2026-07-20 used Ruby 2.2.10 on macOS arm64 and 10,000 iterations. It completed in 0.041232 seconds, or approximately 4.123 microseconds per normalization. This single run has no warmup, median, or dispersion and is not a production performance claim.
 
 ## Version 0.2 development measurement
 
@@ -51,3 +66,13 @@ A local diagnostic run on 2026-07-20 used Ruby 2.2.10 on macOS arm64 with 1,000
 | Open-circuit backlog handling | 88,922 operations/second |
 
 The outage run retained exactly 100 events and rejected 9,900 additional events without growing the backlog. These are single development runs without median or dispersion and are not comparative performance claims.
+
+## Version 0.4 Rack middleware benchmark
+
+Run:
+
+```bash
+ITERATIONS=100000 bundle _1.17.3_ exec ruby benchmarks/request_overhead.rb
+```
+
+A local diagnostic run on 2026-07-20 used Ruby 2.2.10 on macOS arm64 and 10,000 successful Rack-protocol calls. The direct application calls took 0.013272 seconds and middleware calls took 0.539758 seconds, for an estimated 52.649 microseconds of middleware work per request. The fixture uses no network, error capture, or response-body enumeration. This is a single development measurement, not a production latency claim; controlled warmup, median, and dispersion remain required before publishing a performance claim.

data/docs/privacy-lgpd.md

@@ -1,6 +1,6 @@
 # Privacy and LGPD
 
-Version 0.3 sanitizes every exception event before JSON serialization, queueing, retry backlog, or transport. This reduces accidental exposure, but the host application remains responsible for lawful purpose, minimization, access control, retention, and responses to data-subject requests.
+Version 0.5 sanitizes exception and framework telemetry before JSON serialization, queueing, retry backlog, or transport. This reduces accidental exposure, but the host application remains responsible for lawful purpose, minimization, access control, retention, and responses to data-subject requests.
 
 ## Default policy
 
@@ -13,9 +13,19 @@ Version 0.3 sanitizes every exception event before JSON serialization, queueing,
 | Payment-card candidates that pass the Luhn check | Replaced with `[FILTERED_CARD]` |
 | IPv4 addresses | Last octet replaced with `0` |
 | Unknown Ruby objects | Represented by class name without calling application serialization |
-| Request/response bodies, cookies, HTTP headers, SQL binds, environment variables | Never collected automatically in version 0.3 |
+| Request/response bodies, raw query strings, cookies, authorization headers, raw SQL/binds, cache values, mail bodies, job arguments, environment variables | Never collected automatically in version 0.5 |
 
-The retry backlog exists only in process memory, accepts only `SerializedEvent`, has a fixed capacity, and disappears on process exit. Version 0.3 does not persist telemetry to disk.
+The retry backlog exists only in process memory, accepts only `SerializedEvent`, has a fixed capacity, and disappears on process exit. Version 0.5 does not persist telemetry to disk.
+
+## Rails telemetry
+
+Rails subscribers use per-notification allowlists. SQL events retain only the operation name, cached flag, and duration; cache events omit key and value; mailer events omit addresses and content; Active Job events omit job ID and arguments; view identifiers are reduced to basenames. Controller parameters are sanitized by the normal payload pipeline before queueing.
+
+## Rack context and breadcrumbs
+
+The Rack middleware copies only bounded operational fields and parameter hashes that another component already parsed. It does not read `rack.input` or copy `QUERY_STRING`. User context is opt-in through `chronos.user`, and user agent collection is disabled unless the middleware option enables it.
+
+Breadcrumbs contain category, bounded message, bounded metadata, and timestamp. No raw request, response, SQL, cache, job, log, or external HTTP payload is added automatically. Rack context and breadcrumbs pass through the same sanitizer as manual context before queueing.
 
 Blocklist matching accepts `String`, `Symbol`, and `Regexp`. String and Symbol matching is case-insensitive after punctuation normalization and also protects namespaced keys such as `user_password`.
 

data/docs/troubleshooting.md

@@ -2,7 +2,7 @@
 
 ## Configuration raises an error
 
-Verify `project_id`, `project_key`, and `host`. HTTPS is required while `ssl_verify` is true. Queue size, worker count, payload size, and timeouts must be positive.
+Verify `project_id`, `project_key`, and `host`. HTTPS is required while `ssl_verify` is true. Queue size, worker count, payload size, breadcrumb capacity, and timeouts must be positive. `breadcrumb_max_bytes` must be at least 128.
 
 ## `Chronos.notify` returns false
 
@@ -10,7 +10,23 @@ The agent may be unconfigured, disabled, ignored in the current environment, una
 
 ## `Chronos.notify_sync` returns false
 
-Check DNS, TLS certificates, credentials, HTTP status, proxy configuration, and timeout values. Version 0.3 retries only network errors, HTTP `408`, `429`, and `5xx` responses. Inspect `agent.diagnostics` when constructing an agent directly to see retry state, backlog usage, and the circuit state.
+Check DNS, TLS certificates, credentials, HTTP status, proxy configuration, and timeout values. The resilience layer retries only network errors, HTTP `408`, `429`, and `5xx` responses. Inspect `agent.diagnostics` when constructing an agent directly to see retry state, backlog usage, and the circuit state.
+
+## Rack exception is not captured
+
+Confirm that `Chronos.configure` runs before the middleware handles requests and that the middleware wraps the application component that raises. Version 0.5 captures exceptions raised by the initial downstream Rack call; an exception raised later while a server enumerates a streaming response body is outside this release. The original exception is always re-raised, so the server log should still show it.
+
+## Rails middleware or telemetry is missing
+
+Require `chronos/rails` from the generated initializer and confirm it runs before requests. Automatic integration is disabled by default in Rails test and console; set `rails_capture_in_test` or `rails_capture_in_console` explicitly when validating those environments. `rails_enabled = false` disables all automatic Rails hooks. Active Job is subscribed only when its constant is available during installation.
+
+## Rails telemetry contains no SQL or cache key
+
+This is intentional. Version 0.5 records SQL operation name/duration and cache operation/store/hit status without raw statements, binds, keys, or values. These omissions are privacy and cardinality boundaries, not capture failures.
+
+## Context appears missing
+
+The legacy context store is thread-local. A new application-created thread does not inherit context. Establish a new `Chronos.with_context` scope inside that thread, and issue manual notification before the scope exits. For Rack capture, supply user and explicit parameters through the documented environment keys.
 
 ## Events disappear during shutdown
 

data/lib/chronos/adapters/thread_local_context_store.rb

@@ -0,0 +1,52 @@
+module Chronos
+  module Adapters
+    # Stores execution context in the current Ruby thread.
+    #
+    # @responsibility Isolate request context and restore nested scopes reliably.
+    # @motivation Legacy Ruby does not provide a portable fiber-local storage API.
+    # @limits Context does not propagate to new threads or across processes.
+    # @collaborators ContextStore port and Rack middleware.
+    # @thread_safety Each thread owns an independent value; one instance may be shared.
+    # @compatibility Ruby 2.2.10 through Ruby 2.6.
+    # @example
+    #   store.with_context(:request_id => "r1") { store.get }
+    # @errors The previous value is restored in ensure even when the block raises.
+    # @performance Reads and writes are constant-time thread-local operations.
+    class ThreadLocalContextStore
+      def initialize
+        @key = "chronos_context_#{object_id}".freeze
+      end
+
+      def get
+        Thread.current[@key] || {}
+      end
+
+      def set(context)
+        raise ArgumentError, "context must be a Hash" unless context.is_a?(Hash)
+
+        Thread.current[@key] = context
+      end
+
+      def clear
+        Thread.current[@key] = nil
+        nil
+      end
+
+      def with_context(context)
+        previous = Thread.current[@key]
+        set(merge_context(previous || {}, context))
+        yield
+      ensure
+        previous ? Thread.current[@key] = previous : clear
+      end
+
+      private
+
+      def merge_context(current, additional)
+        raise ArgumentError, "context must be a Hash" unless additional.is_a?(Hash)
+
+        current.merge(additional)
+      end
+    end
+  end
+end

data/lib/chronos/agent.rb

@@ -1,10 +1,10 @@
 module Chronos
   # Runtime composition root for the framework-independent Chronos agent.
   #
-  # @responsibility Own transport, resilient delivery pipeline, and the capture use case.
+  # @responsibility Own delivery, capture, execution context, and breadcrumb collaborators.
   # @motivation Keep construction details outside the public module facade.
-  # @limits It does not integrate with Rails, Rack, or job systems.
-  # @collaborators Configuration snapshot, CaptureException, DeliveryPipeline, and NetHttpTransport.
+  # @limits It does not install Rack, Rails, or job integrations automatically.
+  # @collaborators CaptureException, DeliveryPipeline, ContextStore, and BreadcrumbBuffer.
   # @thread_safety Runtime collaborators synchronize mutable state.
   # @compatibility Ruby 2.2.10 through Ruby 2.6.
   # @example
@@ -19,6 +19,10 @@ module Chronos
     def initialize(config, options = {})
       @config = config
       @logger = options[:logger] || Internal::SafeLogger.new(config.logger)
+      @context_store = options[:context_store] || build_context_store(config.context_store)
+      unless Ports::ContextStore.compatible?(@context_store)
+        raise ArgumentError, "context store does not implement the Chronos context-store port"
+      end
       @transport = options[:transport] || Adapters::NetHttpTransport.new(config, @logger)
       unless Ports::Transport.compatible?(@transport)
         raise ArgumentError, "transport does not implement the Chronos transport port"
@@ -32,15 +36,56 @@ module Chronos
         @logger,
         pipeline_options
       )
-      @capture = options[:capture] || Application::CaptureException.new(config, @delivery_pipeline, @logger)
+      initialize_capture(options)
     end
 
     def notify(exception, context = {})
-      @capture.call(exception, context)
+      @capture.call(exception, context_for_capture(context))
     end
 
     def notify_sync(exception, context = {})
-      @capture.call_sync(exception, context)
+      @capture.call_sync(exception, context_for_capture(context))
+    end
+
+    def with_context(context = {}, &block)
+      @context_store.with_context(context, &block)
+    end
+
+    def add_breadcrumb(attributes = {})
+      context = @context_store.get
+      buffer = context[:__chronos_breadcrumbs]
+      buffer ||= Core::BreadcrumbBuffer.new(@config.breadcrumb_capacity, @config.breadcrumb_max_bytes)
+      buffer.add(attributes)
+      @context_store.set(context.merge(:__chronos_breadcrumbs => buffer))
+      true
+    rescue StandardError => error
+      @logger.warn("Chronos breadcrumb failed: #{error.class}")
+      false
+    end
+
+    def record_event(event_type, payload = {}, context = {})
+      @telemetry.call(event_type, payload, telemetry_context(context))
+    end
+
+    def notify_once(exception, context = {})
+      execution = @context_store.get
+      captured = execution[:__chronos_captured_exceptions] || {}
+      keys = [[:object, exception.object_id], [:message, exception.message.to_s]]
+      return false if keys.any? { |key| captured[key] }
+
+      keys.each { |key| captured[key] = true }
+      @context_store.set(execution.merge(:__chronos_captured_exceptions => captured))
+      notify(exception, context)
+    rescue StandardError
+      false
+    end
+
+    def rails_integration_options(environment = nil, console = false)
+      current_environment = (environment || @config.environment).to_s
+      enabled = @config.rails_enabled
+      enabled = false if console && !@config.rails_capture_in_console
+      enabled = false if current_environment == "test" && !@config.rails_capture_in_test
+      {:enabled => enabled, :include_user_agent => @config.rails_capture_user_agent}
     end
 
     def flush(timeout = DEFAULT_FLUSH_TIMEOUT)
@@ -61,5 +106,51 @@ module Chronos
       details = @delivery_pipeline.diagnostics
       details[:queue].merge(details)
     end
+
+    private
+
+    def initialize_capture(options)
+      @capture = options[:capture] || Application::CaptureException.new(@config, @delivery_pipeline, @logger)
+      @telemetry = options[:telemetry] || Application::CaptureTelemetry.new(@config, @delivery_pipeline, @logger)
+    end
+
+    def build_context_store(strategy)
+      return Adapters::ThreadLocalContextStore.new if strategy == :thread_local
+
+      strategy
+    end
+
+    def context_for_capture(additional)
+      merged = deep_merge(context_hash(@context_store.get), context_hash(additional))
+      merged.delete(:__chronos_captured_exceptions)
+      merged.delete("__chronos_captured_exceptions")
+      buffer = merged.delete(:__chronos_breadcrumbs) || merged.delete("__chronos_breadcrumbs")
+      if buffer.respond_to?(:to_a)
+        merged[:context] = context_hash(merged[:context]).merge("breadcrumbs" => buffer.to_a)
+      end
+      merged
+    rescue StandardError
+      context_hash(additional)
+    end
+
+    def telemetry_context(additional)
+      merged = context_for_capture(additional)
+      context = context_hash(merged.delete(:context) || merged.delete("context"))
+      parameters = merged.delete(:parameters) || merged.delete("parameters")
+      user = merged.delete(:user) || merged.delete("user")
+      context["parameters"] = parameters if parameters.is_a?(Hash) && !parameters.empty?
+      context["user"] = user if user.is_a?(Hash) && !user.empty?
+      context.merge(merged)
+    end
+
+    def deep_merge(left, right)
+      left.merge(right) do |_key, old_value, new_value|
+        old_value.is_a?(Hash) && new_value.is_a?(Hash) ? deep_merge(old_value, new_value) : new_value
+      end
+    end
+
+    def context_hash(value)
+      value.is_a?(Hash) ? value : {}
+    end
   end
 end

data/lib/chronos/application/capture_exception.rb

@@ -2,9 +2,9 @@ module Chronos
   module Application
     # Orchestrates exception normalization, serialization, queueing, and delivery.
     #
-    # @responsibility Execute the version 0.3 exception capture pipeline.
+    # @responsibility Execute the exception capture pipeline for manual and integration callers.
     # @motivation Keep the public facade and transport adapters free of use-case logic.
-    # @limits It does not implement framework hooks or automatic capture.
+    # @limits Framework hooks remain separate integration adapters.
     # @collaborators NoticeBuilder, PayloadSerializer, and DeliveryPipeline.
     # @thread_safety Collaborators are immutable or synchronized; calls may run concurrently.
     # @compatibility Ruby 2.2.10 through Ruby 2.6; independent of Rails.

data/lib/chronos/application/capture_telemetry.rb

@@ -0,0 +1,37 @@
+module Chronos
+  module Application
+    # Coordinates bounded non-exception telemetry capture.
+    #
+    # @responsibility Build, sanitize, serialize, and enqueue integration events.
+    # @motivation Keep Rails notification policy outside transport and domain objects.
+    # @limits It handles request, query, job, and cache events only.
+    # @collaborators TelemetryEvent, TelemetrySerializer, and DeliveryPipeline.
+    # @thread_safety Calls own event state and may execute concurrently.
+    # @compatibility Ruby 2.2.10 through Ruby 2.6; independent of Rails.
+    # @example
+    #   capture.call("query", {"duration_ms" => 3.2})
+    # @errors Internal StandardError failures are contained and logged.
+    # @performance Local normalization is bounded before asynchronous queue insertion.
+    class CaptureTelemetry
+      def initialize(config, delivery_pipeline, logger = nil, options = {})
+        @config = config
+        @delivery_pipeline = delivery_pipeline
+        @logger = logger || Internal::SafeLogger.new(config.logger)
+        @serializer = options[:serializer] || Core::TelemetrySerializer.new(
+          config, nil, :max_payload_size => proc { @delivery_pipeline.max_payload_size }
+        )
+      end
+
+      def call(event_type, payload = {}, context = {})
+        return false unless @config.enabled_for_environment?
+        return false unless @delivery_pipeline.capture_allowed?(event_type)
+
+        event = Core::TelemetryEvent.new(event_type, payload, context)
+        @delivery_pipeline.enqueue(@serializer.call(event))
+      rescue StandardError => error
+        @logger.warn("Chronos telemetry capture failed: #{error.class}")
+        false
+      end
+    end
+  end
+end

data/lib/chronos/application/remote_configuration.rb

@@ -13,7 +13,7 @@ module Chronos
     # @errors Invalid documents are ignored and return false.
     # @performance Validation is bounded by configured document and list limits.
     class RemoteConfiguration
-      SUPPORTED_EVENT_TYPES = ["exception"].freeze
+      SUPPORTED_EVENT_TYPES = ["exception", "request", "query", "job", "cache"].freeze
       MAX_IGNORED_FINGERPRINTS = 100
       MAX_FINGERPRINT_BYTES = 256
       MIN_PAYLOAD_SIZE = 256

data/lib/chronos/configuration/snapshot.rb

@@ -0,0 +1,53 @@
+module Chronos
+  # Immutable configuration shared by all runtime components.
+  #
+  # @responsibility Expose validated settings without mutable containers.
+  # @motivation Keep capture behavior stable while multiple threads run.
+  # @limits It cannot be edited after creation.
+  # @collaborators Configuration and runtime services.
+  # @thread_safety Safe to share between threads after construction.
+  # @compatibility Ruby 2.2.10 through Ruby 2.6.
+  # @example
+  #   snapshot.enabled_for_environment? #=> true
+  # @errors Construction occurs only after Configuration validation.
+  # @performance Deep freezing is paid once during configuration.
+  Configuration::Snapshot = Class.new do
+    attr_reader(*Configuration::ATTRIBUTES)
+
+    def initialize(values)
+      Configuration::ATTRIBUTES.each do |attribute|
+        value = values[attribute]
+        deep_freeze(value)
+        instance_variable_set("@#{attribute}", value)
+      end
+      freeze
+    end
+
+    def enabled_for_environment?
+      enabled && !ignored_environments.map(&:to_s).include?(environment.to_s)
+    end
+
+    private # rubocop:disable Layout/AccessModifierIndentation
+
+    def deep_freeze(value)
+      return value if value.respond_to?(:call) || context_store?(value)
+
+      case value
+      when Hash
+        value.each do |key, child|
+          deep_freeze(key)
+          deep_freeze(child)
+        end
+      when Array
+        value.each { |child| deep_freeze(child) }
+      end
+      value.freeze
+    end
+
+    def context_store?(value)
+      Configuration::CONTEXT_STORE_METHODS.all? { |method_name| value.respond_to?(method_name) }
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/chronos/configuration/validation.rb

@@ -0,0 +1,122 @@
+module Chronos
+  module Internal
+    # Shared validation predicates for mutable Chronos configuration.
+    #
+    # @responsibility Validate resilience, privacy, context, Rails, and endpoint settings.
+    # @motivation Keep Configuration focused on option storage and snapshot creation.
+    # @limits It is mixed into Configuration and is not a public extension API.
+    # @collaborators Chronos::Configuration values.
+    # @thread_safety Validation reads one configuration instance without shared state.
+    # @compatibility Ruby 2.2.10 through Ruby 2.6.
+    # @errors Invalid values become messages; malformed URLs are contained.
+    module ConfigurationValidation
+      private
+
+      def resilience_errors
+        retry_errors + backlog_and_circuit_errors + remote_policy_errors
+      end
+
+      def retry_errors
+        errors = []
+        errors << "max_retries must be a non-negative integer" unless non_negative_integer?(max_retries)
+        errors << "retry_base_interval must be greater than zero" unless positive_number?(retry_base_interval)
+        errors << "retry_max_interval must be greater than zero" unless positive_number?(retry_max_interval)
+        if positive_number?(retry_base_interval) && positive_number?(retry_max_interval) &&
+           retry_max_interval < retry_base_interval
+          errors << "retry_max_interval must be greater than or equal to retry_base_interval"
+        end
+        errors << "retry_jitter must be between zero and one" unless rate?(retry_jitter)
+        errors
+      end
+
+      def backlog_and_circuit_errors
+        errors = []
+        errors << "backlog_size must be a non-negative integer" unless non_negative_integer?(backlog_size)
+        unless positive_integer?(circuit_failure_threshold)
+          errors << "circuit_failure_threshold must be a positive integer"
+        end
+        errors << "circuit_reset_timeout must be greater than zero" unless positive_number?(circuit_reset_timeout)
+        errors
+      end
+
+      def remote_policy_errors
+        errors = []
+        errors << "remote_configuration must be true or false" unless [true, false].include?(remote_configuration)
+        errors << "remote_config_max_bytes must be a positive integer" unless positive_integer?(remote_config_max_bytes)
+        errors << "sampling_rate must be between zero and one" unless rate?(sampling_rate)
+        unless enabled_event_types.is_a?(Array) && enabled_event_types.all? { |value| value.is_a?(String) }
+          errors << "enabled_event_types must contain only String values"
+        end
+        errors << "max_remote_send_interval must be greater than zero" unless positive_number?(max_remote_send_interval)
+        errors
+      end
+
+      def privacy_errors
+        errors = []
+        errors << "blocklist_keys must be an array" unless blocklist_keys.is_a?(Array)
+        errors << "allowlist_keys must be an array" unless allowlist_keys.is_a?(Array)
+        errors << "hash_keys must be an array" unless hash_keys.is_a?(Array)
+        errors.concat(matcher_errors("blocklist_keys", blocklist_keys))
+        errors.concat(matcher_errors("allowlist_keys", allowlist_keys))
+        errors.concat(matcher_errors("hash_keys", hash_keys))
+        errors.concat(filter_errors)
+        errors.concat(anonymization_errors)
+        errors
+      end
+
+      def context_errors
+        errors = []
+        unless context_store == :thread_local || compatible_context_store?
+          errors << "context_store must be :thread_local or implement get, set, clear, and with_context"
+        end
+        errors << "breadcrumb_capacity must be a positive integer" unless positive_integer?(breadcrumb_capacity)
+        unless breadcrumb_max_bytes.is_a?(Integer) && breadcrumb_max_bytes >= 128
+          errors << "breadcrumb_max_bytes must be an integer greater than or equal to 128"
+        end
+        rails_boolean_errors.each { |error| errors << error }
+        errors
+      end
+
+      def compatible_context_store?
+        self.class::CONTEXT_STORE_METHODS.all? { |method_name| context_store.respond_to?(method_name) }
+      end
+
+      def rails_boolean_errors
+        names = [:rails_enabled, :rails_capture_in_console, :rails_capture_in_test, :rails_capture_user_agent]
+        names.reject { |name| [true, false].include?(public_send(name)) }.map do |name|
+          "#{name} must be true or false"
+        end
+      end
+
+      def filter_errors
+        return ["filters must be an array"] unless filters.is_a?(Array)
+        return [] if filters.all? { |filter| filter.respond_to?(:call) }
+
+        ["filters must contain only callable objects"]
+      end
+
+      def anonymization_errors
+        [true, false].include?(anonymize_ip) ? [] : ["anonymize_ip must be true or false"]
+      end
+
+      def matcher_errors(name, values)
+        return [] unless values.is_a?(Array)
+        return [] if values.all? { |value| value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Regexp) }
+
+        ["#{name} must contain only String, Symbol, or Regexp values"]
+      end
+
+      def host_errors
+        return ["host is required"] if blank?(host)
+
+        uri = URI.parse(host.to_s)
+        return ["host must be an absolute HTTP or HTTPS URL"] unless uri.host && %w(http https).include?(uri.scheme)
+        return ["host must use HTTPS unless ssl_verify is explicitly disabled"] if uri.scheme != "https" && ssl_verify
+
+        []
+      rescue URI::InvalidURIError
+        ["host must be a valid URL"]
+      end
+    end
+  end
+end