e11y 0.1.0 → 0.2.0

data/lib/e11y/middleware/routing.rb

@@ -2,141 +2,172 @@
 
 module E11y
   module Middleware
-    # Routing middleware routes events to appropriate buffers/adapters.
+    # Routing middleware routes events to appropriate adapters based on retention policies.
     #
     # This is the FINAL middleware in the pipeline (adapters zone),
     # running AFTER all processing (TraceContext, Validation, PII Filtering,
     # Rate Limiting, Sampling, Versioning).
     #
-    # **Phase 1 Implementation:**
-    # - Determines target adapters from event configuration
-    # - Logs routing decisions for debugging
-    # - Increments metrics for observability
-    # - Does NOT actually send events (Phase 2: Collector will handle delivery)
+    # **Routing Logic (Priority Order):**
+    # 1. **Explicit adapters** - event_data[:adapters] bypasses routing rules
+    # 2. **Routing rules** - lambdas from config.routing_rules
+    # 3. **Fallback adapters** - config.fallback_adapters if no rule matches
     #
-    # **Routing Logic:**
-    # 1. Get adapters from event_data[:adapters] (configured in Event class)
-    # 2. Determine buffer type based on severity/flags
-    # 3. Log/metric routing decision
-    # 4. Pass event_data to next app (Collector in Phase 2)
+    # **Routing Rules (Lambdas):**
+    # Rules are evaluated in order. Each rule receives event_data hash and returns:
+    # - Symbol (adapter name) - route to this adapter
+    # - Array<Symbol> (adapter names) - route to multiple adapters
+    # - nil - rule doesn't match, try next rule
     #
-    # @see ADR-015 §3.1 Pipeline Flow (line 113-117)
-    # @see ADR-001 §3 Adapter Architecture
-    # @see UC-001 Request-Scoped Debug Buffering
+    # @see ADR-004 §14 (Retention-Based Routing)
+    # @see ADR-009 §6 (Cost Optimization via Routing)
+    # @see UC-019 (Retention-Based Event Routing)
     #
-    # @example Standard event routing
+    # @example Explicit adapters (bypass routing)
     #   event_data = {
-    #     event_name: 'Events::OrderPaid',
-    #     severity: :info,
-    #     adapters: [:logs, :errors_tracker],
-    #     payload: { ... }
+    #     event_name: 'payment.completed',
+    #     adapters: [:audit_encrypted, :loki],  # ← Explicit
+    #     retention_until: '2027-01-21T...'
     #   }
+    #   # Routes to: [:audit_encrypted, :loki] (ignores routing rules)
     #
-    #   # Routes to: main buffer → [:logs, :errors_tracker] adapters
-    #
-    # @example Debug event routing (request-scoped)
+    # @example Audit event routing (via rules)
     #   event_data = {
-    #     event_name: 'Events::DebugInfo',
-    #     severity: :debug,
-    #     adapters: [:logs],
-    #     payload: { ... }
+    #     event_name: 'user.deleted',
+    #     audit_event: true,
+    #     retention_until: '2033-01-21T...'
     #   }
+    #   # Rule: ->(e) { :audit_encrypted if e[:audit_event] }
+    #   # Routes to: [:audit_encrypted]
     #
-    #   # Routes to: request-scoped buffer (buffered, flushed on error)
-    #
-    # @example Audit event routing
+    # @example Retention-based routing
     #   event_data = {
-    #     event_name: 'Events::PermissionChanged',
-    #     severity: :warn,
-    #     audit_event: true,
-    #     adapters: [:audit_encrypted],
-    #     payload: { ... }
+    #     event_name: 'order.placed',
+    #     retention_until: '2026-04-21T...'  # 90 days
     #   }
-    #
-    #   # Routes to: audit buffer → [:audit_encrypted] adapter
+    #   # Rule: ->(e) { days > 30 ? :s3_standard : :loki }
+    #   # Routes to: [:s3_standard]
     class Routing < Base
       middleware_zone :adapters
 
-      # Routes event to appropriate buffer/adapters.
+      # Routes event to appropriate adapters based on retention policies.
       #
       # @param event_data [Hash] The event data to route
-      # @option event_data [Array<Symbol>] :adapters Target adapter names (required)
-      # @option event_data [Symbol] :severity Event severity (required)
-      # @option event_data [Boolean] :audit_event Audit event flag (optional)
-      # @return [Hash, nil] Event data (passed to Collector in Phase 2), or nil if dropped
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      # @option event_data [Array<Symbol>] :adapters Explicit adapter names (optional, bypasses routing)
+      # @option event_data [String] :retention_until ISO8601 timestamp (optional, for routing rules)
+      # @option event_data [Boolean] :audit_event Audit event flag (optional, for routing rules)
+      # @option event_data [Symbol] :severity Event severity (optional, for routing rules)
+      # @return [Hash, nil] Event data (passed to next middleware), or nil if dropped
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      # Routing logic requires adapter selection, iteration with error handling,
+      # metadata enrichment, and metrics tracking
       def call(event_data)
-        # Skip if no adapters or severity
-        unless event_data[:adapters] && event_data[:severity]
-          increment_metric("e11y.middleware.routing.skipped")
-          return @app.call(event_data)
-        end
+        # 1. Determine target adapters (explicit or via routing rules)
+        target_adapters = if event_data[:adapters]&.any?
+                            # Explicit adapters bypass routing rules
+                            event_data[:adapters]
+                          else
+                            # Apply routing rules from configuration
+                            apply_routing_rules(event_data)
+                          end
 
-        adapters = event_data[:adapters]
-        severity = event_data[:severity]
-        audit_event = event_data[:audit_event] || false
+        # 2. Write to selected adapters
+        target_adapters.each do |adapter_name|
+          adapter = E11y.configuration.adapters[adapter_name]
+          next unless adapter
 
-        # Determine buffer type
-        buffer_type = determine_buffer_type(severity, audit_event)
+          begin
+            adapter.write(event_data)
+            increment_metric("e11y.middleware.routing.write_success", adapter: adapter_name)
+          rescue StandardError => e
+            # Log routing error but don't fail pipeline
+            warn "E11y routing error for adapter #{adapter_name}: #{e.message}"
+            increment_metric("e11y.middleware.routing.write_error", adapter: adapter_name)
+          end
+        end
 
-        # Add routing metadata to event_data
+        # 3. Add routing metadata to event_data
         event_data[:routing] = {
-          buffer_type: buffer_type,
-          adapters: adapters,
-          routed_at: Time.now.utc
+          adapters: target_adapters,
+          routed_at: Time.now.utc,
+          routing_type: event_data[:adapters]&.any? ? :explicit : :rules
         }
 
-        # Increment metrics
+        # 4. Increment metrics
         increment_metric("e11y.middleware.routing.routed",
-                         buffer: buffer_type,
-                         severity: severity,
-                         adapters_count: adapters.size)
+                         adapters_count: target_adapters.size,
+                         routing_type: event_data[:routing][:routing_type])
 
-        # Log routing decision (for Phase 1 debugging)
-        log_routing_decision(event_data, buffer_type, adapters) if debug_enabled?
+        # 5. Log routing decision (for debugging)
+        log_routing_decision(event_data, target_adapters) if debug_enabled?
 
-        # Pass to next app (Collector in Phase 2)
-        @app.call(event_data)
+        # 6. Pass to next app (if any)
+        @app&.call(event_data)
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
       private
 
-      # Determine which buffer type to use based on severity and flags.
+      # Apply routing rules from configuration.
+      #
+      # Evaluates routing rules in order until a match is found.
+      # Each rule is a lambda that receives event_data and returns:
+      # - Symbol (adapter name) - route to this adapter
+      # - Array<Symbol> (adapter names) - route to multiple adapters
+      # - nil - rule doesn't match, try next rule
+      #
+      # @param event_data [Hash] Event data with retention_until, audit_event, severity, etc.
+      # @return [Array<Symbol>] Target adapter names
       #
-      # @param severity [Symbol] Event severity
-      # @param audit_event [Boolean] Audit event flag
-      # @return [Symbol] Buffer type (:main, :request_scoped, :audit)
+      # @example
+      #   rules = [
+      #     ->(event) { :audit_encrypted if event[:audit_event] },
+      #     ->(event) {
+      #       days = (Time.parse(event[:retention_until]) - Time.now) / 86400
+      #       days > 90 ? :s3_glacier : :loki
+      #     }
+      #   ]
       #
-      # Routing rules:
-      # - Audit events → :audit buffer (separate pipeline, no PII filtering)
-      # - Debug events → :request_scoped buffer (buffered, flushed on error)
-      # - Other events → :main buffer (immediate sending)
-      def determine_buffer_type(severity, audit_event)
-        return :audit if audit_event
-        return :request_scoped if severity == :debug
+      #   apply_routing_rules(event_data)
+      #   # => [:audit_encrypted] or [:loki] or [:s3_glacier]
+      def apply_routing_rules(event_data)
+        matched_adapters = []
 
-        :main
+        # Apply each rule, collect matched adapters
+        rules = E11y.configuration.routing_rules || []
+        rules.each do |rule|
+          result = rule.call(event_data)
+          matched_adapters.concat(Array(result)) if result
+        rescue StandardError => e
+          # Log rule evaluation error but continue
+          warn "E11y routing rule error: #{e.message}"
+        end
+
+        # Return unique adapters or fallback
+        if matched_adapters.any?
+          matched_adapters.uniq
+        else
+          E11y.configuration.fallback_adapters || [:stdout]
+        end
       end
 
-      # Log routing decision for debugging (Phase 1).
+      # Log routing decision for debugging.
       #
       # @param event_data [Hash] Event data
-      # @param buffer_type [Symbol] Determined buffer type
       # @param adapters [Array<Symbol>] Target adapters
       # @return [void]
-      def log_routing_decision(event_data, buffer_type, adapters)
-        # TODO: Replace with structured logging in Phase 2
-        # Rails.logger.debug "[E11y] Routing: #{event_data[:event_name]} → #{buffer_type} → #{adapters.inspect}"
+      def log_routing_decision(event_data, adapters)
+        # TODO: Replace with structured logging
+        # Rails.logger.debug "[E11y] Routing: #{event_data[:event_name]} → #{adapters.inspect}"
       end
 
       # Check if debug logging is enabled.
       #
       # @return [Boolean]
       def debug_enabled?
-        # TODO: Read from configuration in Phase 2
+        # TODO: Read from configuration
         # E11y.configuration.debug_enabled
-        false # Disabled in Phase 1
+        false # Disabled for now
       end
 
       # Placeholder for metrics instrumentation.
@@ -145,12 +176,8 @@ module E11y
       # @param tags [Hash] Metric tags
       # @return [void]
       def increment_metric(_metric_name, **_tags)
-        # TODO: Integrate with Yabeda/Prometheus in Phase 2
-        # Yabeda.e11y.middleware_routing_routed.increment(
-        #   buffer: buffer,
-        #   severity: severity,
-        #   adapters_count: adapters_count
-        # )
+        # TODO: Integrate with Yabeda/Prometheus
+        # Yabeda.e11y.middleware_routing_routed.increment(tags)
       end
     end
   end

data/lib/e11y/middleware/sampling.rb

@@ -64,33 +64,14 @@ module E11y
       # @option config [Hash] :error_spike_config ({}) Configuration for ErrorSpikeDetector
       # @option config [Boolean] :load_based_adaptive (false) Enable load-based adaptive sampling (FEAT-4842)
       # @option config [Hash] :load_monitor_config ({}) Configuration for LoadMonitor
-      def initialize(config = {})
-        # Extract config before calling super (which sets @config)
-        config ||= {}
-        @default_sample_rate = config.fetch(:default_sample_rate, 1.0)
-        @trace_aware = config.fetch(:trace_aware, true)
-        @severity_rates = config.fetch(:severity_rates, {})
-        @trace_decisions = {} # Cache for trace-level sampling decisions
-        @trace_decisions_mutex = Mutex.new
-
-        # Error-based adaptive sampling (FEAT-4838)
-        @error_based_adaptive = config.fetch(:error_based_adaptive, false)
-        if @error_based_adaptive
-          require "e11y/sampling/error_spike_detector"
-          error_spike_config = config.fetch(:error_spike_config, {})
-          @error_spike_detector = E11y::Sampling::ErrorSpikeDetector.new(error_spike_config)
-        end
+      def initialize(app = nil, **config)
+        # Call parent only if app provided (for production usage)
+        super(app) if app
+        @app = app
 
-        # Load-based adaptive sampling (FEAT-4842)
-        @load_based_adaptive = config.fetch(:load_based_adaptive, false)
-        if @load_based_adaptive
-          require "e11y/sampling/load_monitor"
-          load_monitor_config = config.fetch(:load_monitor_config, {})
-          @load_monitor = E11y::Sampling::LoadMonitor.new(load_monitor_config)
-        end
-
-        # Call super to set @config and other base middleware state
-        super
+        setup_basic_config(config)
+        setup_error_based_sampling(config)
+        setup_load_based_sampling(config)
       end
 
       # Process event through sampling filter
@@ -133,6 +114,41 @@ module E11y
 
       private
 
+      # Setup basic sampling configuration
+      #
+      # @param config [Hash] Configuration options
+      def setup_basic_config(config)
+        @default_sample_rate = config.fetch(:default_sample_rate, 1.0)
+        @trace_aware = config.fetch(:trace_aware, true)
+        @severity_rates = config.fetch(:severity_rates, {})
+        @trace_decisions = {} # Cache for trace-level sampling decisions
+        @trace_decisions_mutex = Mutex.new
+      end
+
+      # Setup error-based adaptive sampling (FEAT-4838)
+      #
+      # @param config [Hash] Configuration options
+      def setup_error_based_sampling(config)
+        @error_based_adaptive = config.fetch(:error_based_adaptive, false)
+        return unless @error_based_adaptive
+
+        require "e11y/sampling/error_spike_detector"
+        error_spike_config = config.fetch(:error_spike_config, {})
+        @error_spike_detector = E11y::Sampling::ErrorSpikeDetector.new(error_spike_config)
+      end
+
+      # Setup load-based adaptive sampling (FEAT-4842)
+      #
+      # @param config [Hash] Configuration options
+      def setup_load_based_sampling(config)
+        @load_based_adaptive = config.fetch(:load_based_adaptive, false)
+        return unless @load_based_adaptive
+
+        require "e11y/sampling/load_monitor"
+        load_monitor_config = config.fetch(:load_monitor_config, {})
+        @load_monitor = E11y::Sampling::LoadMonitor.new(load_monitor_config)
+      end
+
       # Determine if event should be sampled
       #
       # @param event_data [Hash] The event payload
@@ -144,8 +160,7 @@ module E11y
 
         # 2. Check trace-aware sampling (C05)
         if @trace_aware && event_data[:trace_id]
-          return trace_sampling_decision(event_data[:trace_id], event_class,
-                                         event_data)
+          return trace_sampling_decision(event_data[:trace_id], event_class, event_data)
         end
 
         # 3. Get sample rate for this event
@@ -168,6 +183,9 @@ module E11y
       # @param event_class [Class] The event class
       # @param event_data [Hash] Event payload (for value-based sampling)
       # @return [Float] Sample rate (0.0-1.0)
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      # Sample rate determination follows priority chain: error spike → value-based →
+      # load-based → severity → event-level → default
       def determine_sample_rate(event_class, event_data = nil)
         # 0. Error-based adaptive sampling (FEAT-4838) - highest priority!
         if @error_based_adaptive && @error_spike_detector&.error_spike?
@@ -210,6 +228,7 @@ module E11y
         # 4. Default/load-based rate
         base_rate
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
       # Trace-aware sampling decision (C05 Resolution)
       #

data/lib/e11y/middleware/trace_context.rb

@@ -54,25 +54,54 @@ module E11y
       # @option event_data [Time,String] :timestamp Existing timestamp (optional)
       # @return [Hash, nil] Enriched event data, or nil if dropped
       def call(event_data)
-        # Add trace_id (propagate from E11y::Current or Thread.current or generate new)
-        event_data[:trace_id] ||= current_trace_id || generate_trace_id
+        enrich_trace_context(event_data)
+        enrich_service_context(event_data)
+        increment_metric("e11y.middleware.trace_context.processed")
+        @app.call(event_data)
+      end
 
-        # Add span_id (always generate new for this event)
-        event_data[:span_id] ||= generate_span_id
+      private
 
-        # Add parent_trace_id (if job has parent trace) - C17 Resolution
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      # Add distributed tracing fields to event data
+      # @param event_data [Hash] Event data to enrich
+      # @return [void]
+      def enrich_trace_context(event_data)
+        event_data[:trace_id] ||= current_trace_id || generate_trace_id
+        event_data[:span_id] ||= generate_span_id
         event_data[:parent_trace_id] ||= current_parent_trace_id if current_parent_trace_id
 
-        # Add timestamp (use existing or current time)
-        event_data[:timestamp] ||= format_timestamp(Time.now.utc)
+        # Format timestamp if it's a Time object
+        timestamp = event_data[:timestamp]
+        event_data[:timestamp] = if timestamp.is_a?(Time)
+                                   format_timestamp(timestamp)
+                                 else
+                                   timestamp || format_timestamp(Time.now.utc)
+                                 end
 
-        # Increment metrics
-        increment_metric("e11y.middleware.trace_context.processed")
+        # Calculate retention_until from retention_period
+        if event_data[:retention_period] && !event_data[:retention_until]
+          # Parse timestamp back to Time to calculate retention_until
+          base_time = timestamp.is_a?(Time) ? timestamp : Time.parse(event_data[:timestamp])
+          retention_time = base_time + event_data[:retention_period]
+          event_data[:retention_until] = retention_time.iso8601
+        end
 
-        @app.call(event_data)
+        # Add audit_event flag
+        event_class = event_data[:event_class]
+        return unless event_class.respond_to?(:audit_event?)
+
+        event_data[:audit_event] = event_class.audit_event?
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
-      private
+      # Add service context fields to event data
+      # @param event_data [Hash] Event data to enrich
+      # @return [void]
+      def enrich_service_context(event_data)
+        event_data[:service_name] ||= E11y.config.service_name
+        event_data[:environment] ||= E11y.config.environment
+      end
 
       # Get current trace ID from E11y::Current or thread-local storage (request context).
       #

data/lib/e11y/middleware/validation.rb

@@ -56,7 +56,7 @@ module E11y
       # @option event_data [Hash] :payload The event payload (required)
       # @return [Hash, nil] Validated event data, or nil if dropped
       # @raise [E11y::ValidationError] if validation fails
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def call(event_data)
         # Skip validation if no event_class or payload
         return @app.call(event_data) unless event_data[:event_class] && event_data[:payload]
@@ -64,6 +64,24 @@ module E11y
         event_class = event_data[:event_class]
         payload = event_data[:payload]
 
+        # Check validation mode (FEAT-4850: performance tuning)
+        validation_mode = event_class.respond_to?(:validation_mode) ? event_class.validation_mode : :always
+
+        # Skip validation if mode is :never
+        if validation_mode == :never
+          increment_metric("e11y.middleware.validation.skipped")
+          return @app.call(event_data)
+        end
+
+        # Skip validation probabilistically if mode is :sampled
+        if validation_mode == :sampled
+          sample_rate = event_class.respond_to?(:validation_sample_rate) ? event_class.validation_sample_rate : 0.01
+          if rand >= sample_rate
+            increment_metric("e11y.middleware.validation.skipped")
+            return @app.call(event_data)
+          end
+        end
+
         # Get compiled schema from event class
         schema = event_class.compiled_schema
 
@@ -88,7 +106,7 @@ module E11y
           raise E11y::ValidationError, error_message
         end
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       private
 

data/lib/e11y/middleware/versioning.rb

@@ -125,7 +125,7 @@ module E11y
         name.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2') # ABCWord → ABC_Word
             .gsub(/([a-z\d])([A-Z])/, '\1_\2') # wordWord → word_Word
             .downcase
-            .gsub("_", ".") # Convert underscores to dots for event names
+            .tr("_", ".") # Convert underscores to dots for event names
       end
     end
   end

data/lib/e11y/pii.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-# E11y::PII module - PII detection and filtering utilities
-#
-# This module provides PII pattern detection and filtering strategies
-# for the PIIFiltering middleware.
-#
-# @see E11y::PII::Patterns
-# @see E11y::Middleware::PIIFiltering
 module E11y
+  # PII detection and filtering utilities
+  #
+  # This module provides PII pattern detection and filtering strategies
+  # for the PIIFiltering middleware.
+  #
+  # @see E11y::PII::Patterns
+  # @see E11y::Middleware::PIIFiltering
   module PII
   end
 end

data/lib/e11y/railtie.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# Skip Railtie if Rails is not available
-return unless defined?(Rails)
-
 require "rails/railtie"
 
 module E11y
@@ -29,26 +26,41 @@ module E11y
   #   end
   #
   # @see ADR-008 §3 (Railtie & Initialization)
+
+  # Rails integration engine that handles E11y initialization and setup
+  #
+  # This Railtie manages the lifecycle of E11y within a Rails application,
+  # including configuration, middleware insertion, instrumentation setup,
+  # and console integration.
   class Railtie < Rails::Railtie
+    # Derive service name from Rails application class
+    # @return [String] Service name (e.g., "my_app")
+    def self.derive_service_name
+      Rails.application.class.module_parent_name.underscore
+    rescue StandardError
+      "rails_app"
+    end
+
     # Run before framework initialization
     config.before_initialize do
       # Set up basic configuration from Rails
       E11y.configure do |config|
-        config.environment = Rails.env.to_s
-        config.service_name = derive_service_name
-        config.enabled = !Rails.env.test? # Disabled in tests by default
+        config.environment ||= Rails.env.to_s
+        config.service_name ||= E11y::Railtie.derive_service_name
+        # Only set enabled if not already configured
+        config.enabled = !Rails.env.test? if config.enabled.nil?
       end
     end
 
-    # Run after framework initialization
-    config.after_initialize do
+    # Setup instrumentation after Rails initialization
+    initializer "e11y.setup_instrumentation", after: :load_config_initializers do
       next unless E11y.config.enabled
 
       # Setup instruments (each can be enabled/disabled separately)
-      setup_rails_instrumentation if E11y.config.rails_instrumentation&.enabled
-      setup_logger_bridge if E11y.config.logger_bridge&.enabled
-      setup_sidekiq if defined?(::Sidekiq) && E11y.config.sidekiq&.enabled
-      setup_active_job if defined?(::ActiveJob) && E11y.config.active_job&.enabled
+      E11y::Railtie.setup_rails_instrumentation if E11y.config.rails_instrumentation&.enabled
+      E11y::Railtie.setup_logger_bridge if E11y.config.logger_bridge&.enabled
+      E11y::Railtie.setup_sidekiq if defined?(::Sidekiq) && E11y.config.sidekiq&.enabled
+      E11y::Railtie.setup_active_job if defined?(::ActiveJob) && E11y.config.active_job&.enabled
     end
 
     # Middleware insertion
@@ -81,14 +93,6 @@ module E11y
       # load 'e11y/tasks.rake'
     end
 
-    # Derive service name from Rails application class
-    # @return [String] Service name (e.g., "my_app")
-    def self.derive_service_name
-      Rails.application.class.module_parent_name.underscore
-    rescue StandardError
-      "rails_app"
-    end
-
     # Setup Rails instrumentation (ActiveSupport::Notifications → E11y)
     # @return [void]
     def self.setup_rails_instrumentation

data/lib/e11y/reliability/circuit_breaker.rb

@@ -17,6 +17,8 @@ module E11y
     #
     # @see ADR-013 §5 (Circuit Breaker)
     # @see UC-021 §4 (Circuit Breaker for Adapters)
+    # rubocop:disable Metrics/ClassLength
+    # Circuit breaker is a cohesive state machine with complex state transitions and recovery logic
     class CircuitBreaker
       # Circuit is closed (healthy) - all requests pass through
       STATE_CLOSED = :closed
@@ -212,5 +214,6 @@ module E11y
         # E11y::Metrics.increment(metric_name, tags.merge(adapter: @adapter_name, state: @state))
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end