e11y 0.2.0 → 1.1.0

data/docs/{ADR-011-testing-strategy.md → architecture/ADR-011-testing-strategy.md}

@@ -369,12 +369,12 @@ module E11y
         end
         
         def no_events_message
-          all_events = E11y.test_adapter.all_events
+          events = E11y.test_adapter.events
           
-          if all_events.empty?
+          if events.empty?
             "expected to have tracked #{event_name}, but no events were tracked at all"
           else
-            tracked_names = all_events.map { |e| e[:event_name] }.uniq.join(', ')
+            tracked_names = events.map { |e| e[:event_name] }.uniq.join(', ')
             "expected to have tracked #{event_name}, but only tracked: #{tracked_names}"
           end
         end
@@ -495,78 +495,38 @@ end
 
 ```ruby
 # lib/e11y/adapters/in_memory.rb
+# API: write, write_batch (adapter contract), events, find_events, clear!, any_event?
 module E11y
   module Adapters
     class InMemory < Base
-      def initialize
-        super(name: :test)
-        @events = []
-        @mutex = Mutex.new
-      end
-      
-      def send_batch(events)
-        @mutex.synchronize do
-          events.each do |event|
-            @events << event.dup
-          end
-        end
-        
-        { success: true, sent: events.size }
+      attr_reader :events
+
+      def write(event_data)
+        @mutex.synchronize { @events << event_data }
+        true
       end
-      
-      def health_check
+
+      def write_batch(events)
+        @mutex.synchronize { @events.concat(events) }
         true
       end
-      
+
       # Test helper methods
-      def all_events
-        @mutex.synchronize { @events.dup }
-      end
-      
-      def find_events(pattern)
-        @mutex.synchronize do
-          @events.select do |event|
-            case pattern
-            when String
-              event[:event_name] == pattern
-            when Regexp
-              event[:event_name] =~ pattern
-            when Class
-              event[:event_name] == pattern.event_name
-            else
-              false
-            end
-          end
-        end
-      end
-      
-      def find_event(pattern)
-        find_events(pattern).first
+      def find_events(pattern)  # pattern: String or Regexp
+        pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String)
+        @events.select { |e| e[:event_name].to_s.match?(pattern) }
       end
-      
-      def event_count(pattern = nil)
-        if pattern
-          find_events(pattern).size
-        else
-          @mutex.synchronize { @events.size }
-        end
+
+      def event_count(event_name = nil)
+        event_name ? @events.count { |e| e[:event_name] == event_name } : @events.size
       end
-      
+
       def clear!
-        @mutex.synchronize { @events.clear }
-      end
-      
-      def tracked?(event_class_or_pattern)
-        find_events(event_class_or_pattern).any?
-      end
-      
-      # Pretty print for debugging
-      def inspect
-        "#<E11y::Adapters::InMemory events=#{@events.size}>"
+        @events.clear
       end
-      
-      def to_s
-        inspect
+
+      def any_event?(pattern)  # true if any events match pattern
+        find_events(pattern).any?
       end
     end
   end
@@ -590,7 +550,7 @@ module E11y
         @call_count = 0
       end
       
-      def send_batch(events)
+      def write_batch(events)
         @call_count += 1
         
         # Simulate delay
@@ -634,7 +594,7 @@ RSpec.configure do |config|
       e11y_config.adapters.register :test, E11y::Adapters::InMemory.new
       
       # Disable rate limiting in tests
-      e11y_config.rate_limiting.enabled = false
+      e11y_config.rate_limiting_enabled = false
       
       # Disable sampling (track everything)
       e11y_config.sampling.default_sample_rate = 1.0
@@ -661,10 +621,10 @@ RSpec.configure do |config|
   config.alias_example_group_to :describe_event, type: :event
 end
 
-# Convenience method to access test adapter
+# Convenience method to access test adapter (uses config.adapters[:test] or [:memory])
 module E11y
   def self.test_adapter
-    Adapters::Registry.get(:test)
+    configuration.adapters[:test] || configuration.adapters[:memory]
   end
 end
 ```
@@ -963,7 +923,7 @@ RSpec.describe 'Order flow integration', type: :integration do
       .and have_tracked_event(Events::EmailQueued)
     
     # Verify event sequence
-    events = E11y.test_adapter.all_events
+    events = E11y.test_adapter.events
     event_names = events.map { |e| e[:event_name] }
     
     expect(event_names).to eq([
@@ -982,14 +942,14 @@ RSpec.describe 'Order flow integration', type: :integration do
     
     expect {
       SendOrderEmailJob.perform_later(order.id)
-    }.to have_tracked_event(Events::Rails::Job::Enqueued)
+    }.to have_tracked_event(E11y::Events::Rails::Job::Enqueued)
     
     # Execute job
     perform_enqueued_jobs
     
     # Verify job tracked event with same trace_id
-    enqueued_event = E11y.test_adapter.find_event(Events::Rails::Job::Enqueued)
-    completed_event = E11y.test_adapter.find_event(Events::Rails::Job::Completed)
+    enqueued_event = E11y.test_adapter.find_event(E11y::Events::Rails::Job::Enqueued)
+    completed_event = E11y.test_adapter.find_event(E11y::Events::Rails::Job::Completed)
     
     expect(completed_event[:trace_id]).to eq(enqueued_event[:trace_id])
   end
@@ -1050,16 +1010,16 @@ end
 RSpec.shared_examples 'an E11y adapter' do
   let(:adapter) { described_class.new }
   
-  describe '#send_batch' do
+  describe '#write_batch' do
     it 'accepts array of events' do
       events = [build(:event)]
       
-      expect { adapter.send_batch(events) }.not_to raise_error
+      expect { adapter.write_batch(events) }.not_to raise_error
     end
     
     it 'returns success hash' do
       events = [build(:event)]
-      result = adapter.send_batch(events)
+      result = adapter.write_batch(events)
       
       expect(result).to be_a(Hash)
       expect(result).to have_key(:success)
@@ -1067,11 +1027,11 @@ RSpec.shared_examples 'an E11y adapter' do
     end
     
     it 'handles empty batch' do
-      expect { adapter.send_batch([]) }.not_to raise_error
+      expect { adapter.write_batch([]) }.not_to raise_error
     end
     
     it 'raises on invalid input' do
-      expect { adapter.send_batch(nil) }.to raise_error(ArgumentError)
+      expect { adapter.write_batch(nil) }.to raise_error(ArgumentError)
     end
   end
   
@@ -1537,8 +1497,8 @@ RSpec.describe 'Rate limiting', type: :integration do
   
   before do
     E11y.configure do |config|
-      config.rate_limiting.enabled = true
-      config.rate_limiting.global_limit = 10  # 10 events/sec
+      config.rate_limiting_enabled = true
+      config.rate_limiting_global_limit = 10  # 10 events/sec
     end
   end
   
@@ -1554,7 +1514,7 @@ RSpec.describe 'Rate limiting', type: :integration do
   end
   
   it 'never drops critical events (bypass rate limit)' do
-    E11y.config.rate_limiting.global_limit = 1  # Extremely low
+    E11y.config.rate_limiting_global_limit = 1  # Extremely low
     
     # Track 10 critical events
     10.times { Events::PaymentFailed.track(payment_id: 'p123') }
@@ -1564,9 +1524,7 @@ RSpec.describe 'Rate limiting', type: :integration do
   end
   
   it 'applies per-event rate limits' do
-    E11y.config.rate_limiting.per_event_limits = {
-      'Events::DebugQuery' => 5  # Max 5 per second
-    }
+    E11y.config.add_rate_limit_per_event('Events::DebugQuery', limit: 5)  # Max 5 per second
     
     10.times { Events::DebugQuery.track(sql: 'SELECT 1') }
     
@@ -1659,12 +1617,12 @@ RSpec.configure do |config|
     next unless E11y.config.pii.strict_mode
     
     # Get all events from all adapters
-    all_events = E11y.config.adapters.all.flat_map do |adapter|
-      adapter.respond_to?(:all_events) ? adapter.all_events : []
+    events = E11y.config.adapters.all.flat_map do |adapter|
+      adapter.respond_to?(:events) ? adapter.events : []
     end
     
     # Verify no plain-text PII (if event declares contains_pii)
-    all_events.each do |event|
+    events.each do |event|
       event_class = E11y::Registry.get(event[:event_name])
       
       if event_class&.contains_pii?

data/docs/{ADR-012-event-evolution.md → architecture/ADR-012-event-evolution.md}

@@ -56,7 +56,7 @@ end
 
 # ✅ Enable versioning middleware (optional)
 E11y.configure do |config|
-  config.middleware.use E11y::Middleware::Versioning
+  config.pipeline.use E11y::Middleware::Versioning
 end
 
 # Result: Adds `v:` field to events (only if version > 1)
@@ -218,7 +218,7 @@ module E11y
     # 
     # Usage:
     #   E11y.configure do |config|
-    #     config.middleware.use E11y::Middleware::Versioning
+    #     config.pipeline.use E11y::Middleware::Versioning
     #   end
     class Versioning
       def call(event_data)
@@ -264,16 +264,16 @@ end
 # config/initializers/e11y.rb
 
 E11y.configure do |config|
-  # Default middleware stack (in order):
-  config.middleware.use E11y::Middleware::TraceContext      # 1. Add trace_id
-  config.middleware.use E11y::Middleware::SchemaValidation  # 2. Validate schema
-  config.middleware.use E11y::Middleware::PIIFiltering      # 3. Filter PII
-  config.middleware.use E11y::Middleware::RateLimiting      # 4. Check limits
-  config.middleware.use E11y::Middleware::AdaptiveSampling  # 5. Sample
-  
+  # Illustrative subset — default stack includes additional middleware; see lib/e11y/configuration.rb
+  config.pipeline.use E11y::Middleware::TraceContext      # 1. Add trace_id
+  config.pipeline.use E11y::Middleware::Validation        # 2. Validate schema
+  config.pipeline.use E11y::Middleware::PIIFilter       # 3. Filter PII
+  config.pipeline.use E11y::Middleware::RateLimiting    # 4. Check limits
+  config.pipeline.use E11y::Middleware::Sampling        # 5. Sample
+
   # ✅ Versioning LAST (normalize event_name before adapters)
-  config.middleware.use E11y::Middleware::Versioning        # 6. Normalize
-  
+  config.pipeline.use E11y::Middleware::Versioning      # 6. Normalize
+
   # Then: adapters receive normalized event_name
 end
 ```

data/docs/{ADR-013-reliability-error-handling.md → architecture/ADR-013-reliability-error-handling.md}

@@ -1038,11 +1038,11 @@ module E11y
     class SidekiqErrorHandlingMiddleware
       def call(worker, job, queue)
         # Save original setting
-        original_fail_on_error = E11y.config.error_handling.fail_on_error
+        original_fail_on_error = E11y.config.error_handling_fail_on_error
         
         # Disable failing on errors for this job
         # Observability should NOT block business logic!
-        E11y.config.error_handling.fail_on_error = false
+        E11y.config.error_handling_fail_on_error = false
         
         E11y.logger.debug(
           "Sidekiq job starting with fail_on_error=false",
@@ -1053,7 +1053,7 @@ module E11y
         yield
       ensure
         # Restore original setting
-        E11y.config.error_handling.fail_on_error = original_fail_on_error
+        E11y.config.error_handling_fail_on_error = original_fail_on_error
       end
     end
   end
@@ -1112,7 +1112,7 @@ module E11y
     
     def self.handle_error(error)
       # Should we raise or swallow?
-      if E11y.config.error_handling.fail_on_error
+      if E11y.config.error_handling_fail_on_error
         # Web request context: RAISE (fast feedback!)
         raise error
       else
@@ -1177,7 +1177,7 @@ class CriticalReportJob < ApplicationJob
   
   def perform(report_id)
     # Temporarily enable fail_on_error
-    E11y.config.error_handling.fail_on_error = true
+    E11y.config.error_handling_fail_on_error = true
     
     # Generate report
     report = Report.generate(report_id)
@@ -1190,7 +1190,7 @@ class CriticalReportJob < ApplicationJob
     # ↑ If this fails, job SHOULD fail (retry later)
   ensure
     # Restore default (will be restored by middleware anyway)
-    E11y.config.error_handling.fail_on_error = false
+    E11y.config.error_handling_fail_on_error = false
   end
 end
 ```
@@ -1501,7 +1501,7 @@ module E11y
           # Re-dispatch event through normal pipeline
           E11y::Pipeline.dispatch(
             entry[:event_data],
-            metadata: entry[:metadata].merge(replayed: true)
+            metadata: entry[:metadata].merge(dlq_replayed: true)
           )
           
           # Delete from DLQ after successful replay
@@ -1665,7 +1665,7 @@ module E11y
           # Re-dispatch
           E11y::Pipeline.dispatch(
             entry[:event_data],
-            metadata: entry[:metadata].merge(replayed: true)
+            metadata: entry[:metadata].merge(dlq_replayed: true)
           )
           
           # Delete from DLQ
@@ -1782,6 +1782,31 @@ module E11y
 end
 ```
 
+### 4.4.1. DLQ Filter: Event DSL (Implemented)
+
+The DLQ filter uses **Event DSL** with a single `use_dlq` flag:
+
+```ruby
+# Audit events (Presets::AuditEvent) have use_dlq true by default
+class Events::UserDeleted < E11y::Events::BaseAuditEvent
+  # use_dlq true from preset — always saved to DLQ
+end
+
+# Explicit opt-in for critical business events
+class Events::PaymentFailed < E11y::Event::Base
+  use_dlq true
+end
+
+# Explicit opt-out for noise
+class Events::DebugTrace < E11y::Event::Base
+  use_dlq false
+end
+
+# Default (nil): severity-based (error/fatal saved) + default_behavior
+```
+
+**Priority order:** 1) `use_dlq false` → 2) `use_dlq true` → 3) severity → 4) default.
+
 ### 4.5. DLQ Configuration
 
 ```ruby
@@ -2562,8 +2587,8 @@ module E11y
       end
       
       def check_all_adapters
-        E11y::Adapters::Registry.all.each do |adapter|
-          circuit_breaker = CircuitBreaker.for(adapter.name)
+        E11y.config.adapters.each do |name, adapter|
+          circuit_breaker = CircuitBreaker.for(name)
           
           # Only check adapters with open/half-open circuits
           next if circuit_breaker.healthy?
@@ -2572,11 +2597,11 @@ module E11y
             adapter.health_check
             
             E11y::Metrics.increment('e11y.health_check.success', {
-              adapter: adapter.name
+              adapter: name
             })
           rescue => error
             E11y::Metrics.increment('e11y.health_check.failure', {
-              adapter: adapter.name,
+              adapter: name,
               error: error.class.name
             })
           end

data/docs/{ADR-014-event-driven-slo.md → architecture/ADR-014-event-driven-slo.md}

@@ -752,27 +752,15 @@ app_wide:
 ### 6.1. Yabeda Metrics Definition
 
 ```ruby
-# config/initializers/e11y.rb
-E11y.configure do |config|
-  config.metrics do
-    enabled true
-    adapter :yabeda
-    
-    # Define SLO metrics
-    Yabeda.configure do
-      group :e11y_slo do
-        # Availability metric (counter)
-        counter :event_result_total,
-                comment: "Total count of Event SLO results (success/failure)",
-                tags: [:event_class, :slo_name, :slo_status]  # slo_status = 'success' | 'failure'
-        
-        # Latency metric (histogram)
-        histogram :event_duration_seconds,
-                  comment: "Event processing duration for SLO (seconds)",
-                  tags: [:event_class, :slo_name],
-                  buckets: [0.01, 0.05, 0.1, 0.5, 1.0, 2.0, 5.0, 10.0, 30.0, 60.0]
-      end
-    end
+Yabeda.configure do
+  group :e11y_slo do
+    counter :event_result_total,
+            comment: "Event SLO results (success/failure)",
+            tags: [:event_class, :slo_name, :slo_status]
+    histogram :event_duration_seconds,
+              comment: "Event processing duration (seconds)",
+              tags: [:event_class, :slo_name],
+              buckets: [0.01, 0.05, 0.1, 0.5, 1.0, 2.0, 5.0, 10.0, 30.0, 60.0]
   end
 end
 ```
@@ -814,7 +802,7 @@ module E11y
         def self.validate!
           errors = []
           
-          E11y::Registry.all_events.each do |event_class|
+          E11y::Registry.event_classes.each do |event_class|
             # Check: Has slo declaration?
             has_slo_enabled = event_class.slo_enabled?
             has_slo_disabled = event_class.slo_disabled?
@@ -850,7 +838,7 @@ module E11y
         def self.validate!
           errors = []
           
-          E11y::Registry.all_events.each do |event_class|
+          E11y::Registry.event_classes.each do |event_class|
             next unless event_class.slo_enabled?
             
             # Check: Has slo_status_from block?
@@ -923,7 +911,7 @@ module E11y
           end
           
           # Check reverse: Events with slo enabled but NOT in slo.yml
-          E11y::Registry.all_events.each do |event_class|
+          E11y::Registry.event_classes.each do |event_class|
             next unless event_class.slo_enabled?
             
             slo_name = event_class.slo_config.contributes_to