e11y 0.2.0 → 1.1.0

data/lib/e11y/middleware/track_latency.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module E11y
+  module Middleware
+    # Measures Event.track() latency from pipeline entry to exit.
+    #
+    # Must be the FIRST middleware so it wraps the entire pipeline.
+    # Records duration for both success and dropped events.
+    #
+    # @see ADR-016 §3.1 (Performance Metrics)
+    # @example Add first in pipeline
+    #   config.pipeline.use E11y::Middleware::TrackLatency
+    #   config.pipeline.use E11y::Middleware::TraceContext
+    #   # ...
+    class TrackLatency < Base
+      middleware_zone :pre_processing
+
+      def call(event_data)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result = @app.call(event_data)
+        duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000
+
+        E11y::SelfMonitoring::PerformanceMonitor.track_latency(
+          duration_ms,
+          event_class: event_data[:event_name].to_s,
+          severity: event_data[:severity].to_s,
+          result: result.nil? ? :dropped : :success
+        )
+
+        result
+      end
+    end
+  end
+end

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, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       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]
@@ -69,7 +69,7 @@ module E11y
 
         # Skip validation if mode is :never
         if validation_mode == :never
-          increment_metric("e11y.middleware.validation.skipped")
+          E11y::Metrics.increment(:e11y_middleware_validation_total, result: "skipped")
           return @app.call(event_data)
         end
 
@@ -77,7 +77,7 @@ module E11y
         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")
+            E11y::Metrics.increment(:e11y_middleware_validation_total, result: "skipped")
             return @app.call(event_data)
           end
         end
@@ -87,7 +87,7 @@ module E11y
 
         # Skip validation if no schema defined (schema-less events)
         unless schema
-          increment_metric("e11y.middleware.validation.skipped")
+          E11y::Metrics.increment(:e11y_middleware_validation_total, result: "skipped")
           return @app.call(event_data)
         end
 
@@ -96,17 +96,17 @@ module E11y
 
         if result.success?
           # Validation passed
-          increment_metric("e11y.middleware.validation.passed")
+          E11y::Metrics.increment(:e11y_middleware_validation_total, result: "passed")
           @app.call(event_data)
         else
           # Validation failed - raise error with details
-          increment_metric("e11y.middleware.validation.failed")
+          E11y::Metrics.increment(:e11y_middleware_validation_total, result: "failed")
 
           error_message = format_validation_errors(event_class, result.errors)
           raise E11y::ValidationError, error_message
         end
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       private
 
@@ -122,15 +122,6 @@ module E11y
 
         "Validation failed for #{event_class.name}: #{error_details}"
       end
-
-      # Placeholder for metrics instrumentation.
-      #
-      # @param metric_name [String] Metric name
-      # @return [void]
-      def increment_metric(_metric_name)
-        # TODO: Integrate with Yabeda/Prometheus in Phase 2
-        # Yabeda.e11y.middleware_validation_passed.increment
-      end
     end
   end
 end

data/lib/e11y/middleware/versioning.rb

@@ -54,43 +54,47 @@ module E11y
     # @see ADR-012 for versioning architecture
     # @see UC-020 for use cases
     class Versioning < Base
-      # Version extraction regex (matches V2, V3, etc. at end of class name)
-      VERSION_REGEX = /V(\d+)$/
+      middleware_zone :pre_processing
+      VERSION_REGEX = E11y::Versioning::VersionExtractor::VERSION_REGEX
+
+      # Lazy cache: class name -> normalized event_name (per class, immutable)
+      NORMALIZED_CACHE = Concurrent::Map.new
 
       # Process event and add version field if needed
       #
       # @param event_data [Hash] Event payload
       # @return [Hash] Event data with version field (if > 1)
       def call(event_data)
-        # Extract version from event_name (class name)
-        version = extract_version(event_data[:event_name])
+        klass = event_data[:event_class]
+        class_name = klass&.name
 
-        # Add version field only if > 1 (ADR-012 §4.2)
+        version = event_data[:version].to_i
+        version = extract_version(class_name) if version <= 1
         event_data[:v] = version if version > 1
 
-        # Normalize event_name (remove version suffix for consistent queries)
-        event_data[:event_name] = normalize_event_name(event_data[:event_name])
+        # event_data[:event_name] set by Base; fallback to klass.event_name for minimal event_data (tests)
+        incoming = event_data[:event_name]
+        incoming = klass.event_name if incoming.nil? && klass.respond_to?(:event_name)
+        incoming = incoming.to_s
+        # Custom uses dot notation ("order.paid"); default from Base uses "::"
+        event_data[:event_name] = incoming != "" && !incoming.include?("::") ? incoming : normalized_for(klass)
 
-        event_data
+        @app&.call(event_data) || event_data
       end
 
       private
 
-      # Extract version from event class name
-      #
-      # @param class_name [String] Event class name (e.g., "Events::OrderPaidV2")
-      # @return [Integer] Version number (default: 1)
-      #
-      # @example
-      #   extract_version("Events::OrderPaid")   => 1
-      #   extract_version("Events::OrderPaidV2") => 2
-      #   extract_version("Events::OrderPaidV3") => 3
-      def extract_version(class_name)
-        return 1 unless class_name
+      def normalized_for(klass)
+        return unless klass
 
-        # Extract version from class name (e.g., "Events::OrderPaidV2" → 2)
-        match = class_name.match(VERSION_REGEX)
-        match ? match[1].to_i : 1
+        name = klass.name
+        return unless name
+
+        NORMALIZED_CACHE.fetch(name) { NORMALIZED_CACHE[name] = normalize_event_name(name) }
+      end
+
+      def extract_version(class_name)
+        E11y::Versioning::VersionExtractor.extract_version(class_name)
       end
 
       # Normalize event_name by removing version suffix

data/lib/e11y/opentelemetry/semantic_conventions.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module E11y
+  module OpenTelemetry
+    # Semantic conventions mapper for OTel attributes (ADR-007 §4, F4).
+    #
+    # Maps E11y payload keys to OpenTelemetry semantic convention attribute names.
+    # When event_name matches a convention type (http, database, etc.), known keys
+    # are mapped to semantic names (e.g. method → http.method).
+    #
+    # @see https://opentelemetry.io/docs/specs/semconv/
+    class SemanticConventions
+      # Key mappings by convention type
+      # https://opentelemetry.io/docs/specs/semconv/http/
+      # https://opentelemetry.io/docs/specs/semconv/database/
+      # https://opentelemetry.io/docs/specs/semconv/exceptions/
+      CONVENTIONS = {
+        http: {
+          "method" => "http.method",
+          "route" => "http.route",
+          "path" => "http.target",
+          "status_code" => "http.status_code",
+          "status" => "http.status_code",
+          "duration_ms" => "http.server.duration",
+          "request_size" => "http.request.body.size",
+          "response_size" => "http.response.body.size",
+          "user_agent" => "http.user_agent",
+          "client_ip" => "http.client_ip",
+          "scheme" => "http.scheme",
+          "host" => "http.host",
+          "server_name" => "http.server_name"
+        },
+        database: {
+          "query" => "db.statement",
+          "statement" => "db.statement",
+          "duration_ms" => "db.operation.duration",
+          "rows_affected" => "db.operation.rows_affected",
+          "connection_id" => "db.connection.id",
+          "database_name" => "db.name",
+          "table_name" => "db.sql.table",
+          "operation" => "db.operation"
+        },
+        rpc: {
+          "service" => "rpc.service",
+          "method" => "rpc.method",
+          "system" => "rpc.system",
+          "status_code" => "rpc.grpc.status_code"
+        },
+        messaging: {
+          "queue_name" => "messaging.destination.name",
+          "message_id" => "messaging.message.id",
+          "conversation_id" => "messaging.message.conversation_id",
+          "payload_size" => "messaging.message.payload_size_bytes",
+          "operation" => "messaging.operation"
+        },
+        exception: {
+          "error_type" => "exception.type",
+          "error_message" => "exception.message",
+          "error_class" => "exception.type",
+          "stacktrace" => "exception.stacktrace"
+        }
+      }.freeze
+
+      # Map payload keys to OTel semantic attribute names.
+      #
+      # @param event_name [String] Event name (used to detect convention type)
+      # @param payload [Hash] Event payload
+      # @return [Hash] Mapped payload with semantic keys where applicable
+      def self.map(event_name, payload)
+        convention_type = detect_convention_type(event_name)
+        return payload.transform_keys { |k| "event.#{k}" } unless convention_type
+
+        conventions = CONVENTIONS[convention_type]
+        payload.each_with_object({}) do |(key, value), mapped|
+          otel_key = conventions[key.to_s] || "event.#{key}"
+          mapped[otel_key] = value
+        end
+      end
+
+      # Map a single key to OTel semantic attribute name.
+      #
+      # @param event_name [String] Event name (used to detect convention type)
+      # @param key [String, Symbol] Payload key
+      # @return [String] OTel attribute key
+      def self.map_key(event_name, key)
+        convention_type = detect_convention_type(event_name)
+        return "event.#{key}" unless convention_type
+
+        conventions = CONVENTIONS[convention_type]
+        conventions[key.to_s] || "event.#{key}"
+      end
+
+      # Detect convention type from event name
+      #
+      # @param event_name [String]
+      # @return [Symbol, nil]
+      def self.detect_convention_type(event_name)
+        name = event_name.to_s
+        return :http if name.match?(/http|request|response/i)
+        return :database if name.match?(/database|query|sql|postgres|mysql/i)
+        return :rpc if name.match?(/rpc|grpc/i)
+        return :messaging if name.match?(/message|queue|kafka|rabbitmq|sidekiq|job/i)
+        return :exception if name.match?(/error|exception|failure/i)
+
+        nil
+      end
+    end
+  end
+end

data/lib/e11y/opentelemetry/span_creator.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "e11y/opentelemetry/semantic_conventions"
+
+module E11y
+  module OpenTelemetry
+    # Creates OpenTelemetry spans from E11y events (ADR-007 §6, F2).
+    #
+    # When enabled via config.opentelemetry_span_creation_patterns, creates
+    # OTel spans for matching events. Errors/fatal always create spans.
+    # Uses SemanticConventions for attribute mapping when applicable.
+    #
+    # @example Configuration
+    #   E11y.configure do |config|
+    #     config.opentelemetry_span_creation_patterns = ["order.*", "payment.*"]
+    #   end
+    #
+    # @see ADR-007 §6 Traces Signal Export
+    # @see E11y::OpenTelemetry::SemanticConventions
+    class SpanCreator
+      ATTR_EVENT_NAME = "event.name"
+      ATTR_SEVERITY = "event.severity"
+      ATTR_E11Y_TRACE_ID = "e11y.trace_id"
+      ATTR_E11Y_SPAN_ID = "e11y.span_id"
+
+      class << self
+        def create_span_from_event(event_data)
+          return unless defined?(::OpenTelemetry::Trace)
+          return unless should_create_span?(event_data)
+
+          tracer = ::OpenTelemetry.tracer_provider.tracer("e11y", E11y::VERSION)
+          parent_ctx = ::OpenTelemetry::Context.current
+          start_ts = time_to_nano(event_data[:timestamp] || Time.now)
+
+          span = tracer.start_span(
+            span_name(event_data),
+            with_parent: parent_ctx,
+            kind: span_kind(event_data),
+            start_timestamp: start_ts
+          )
+
+          set_attributes(span, event_data)
+          set_status(span, event_data)
+          record_exception(span, event_data) if event_data[:severity].in?(%i[error fatal])
+
+          end_ts = compute_end_timestamp(event_data)
+          span.finish(end_timestamp: end_ts)
+
+          span
+        end
+
+        private
+
+        def span_name(event_data)
+          event_data[:event_name].to_s.presence || "e11y.event"
+        end
+
+        def set_attributes(span, event_data)
+          span.set_attribute(ATTR_EVENT_NAME, event_data[:event_name].to_s)
+          span.set_attribute(ATTR_SEVERITY, event_data[:severity].to_s)
+          span.set_attribute(ATTR_E11Y_TRACE_ID, event_data[:trace_id].to_s) if event_data[:trace_id]
+          span.set_attribute(ATTR_E11Y_SPAN_ID, event_data[:span_id].to_s) if event_data[:span_id]
+
+          payload = event_data[:payload] || {}
+          return if payload.empty?
+
+          mapped = E11y::OpenTelemetry::SemanticConventions.map(event_data[:event_name].to_s, payload)
+          mapped.each do |key, value|
+            next if value.nil?
+
+            span.set_attribute(key.to_s, otel_value(value))
+          rescue ArgumentError, TypeError
+            span.set_attribute(key.to_s, value.to_s)
+          end
+        end
+
+        def otel_value(value)
+          case value
+          when TrueClass, FalseClass, Integer, Float, String then value
+          when Array then value.map(&:to_s)
+          else value.to_s # Symbol, NilClass, Hash, etc.
+          end
+        end
+
+        def set_status(span, event_data)
+          if event_data[:severity].in?(%i[error fatal])
+            msg = event_data.dig(:payload, :error_message) ||
+                  event_data.dig(:payload, "error_message") || "Error"
+            span.status = ::OpenTelemetry::Trace::Status.error(msg.to_s)
+          else
+            span.status = ::OpenTelemetry::Trace::Status.ok
+          end
+        end
+
+        def record_exception(span, event_data)
+          exc = event_data[:exception] || event_data.dig(:payload, :exception) || event_data.dig(:payload, "exception")
+          span.record_exception(exc) if exc.is_a?(Exception)
+        end
+
+        def compute_end_timestamp(event_data)
+          start = event_data[:timestamp] || Time.now
+          start_ns = time_to_nano(start)
+          if event_data[:duration_ms]
+            start_ns + (event_data[:duration_ms].to_f * 1_000_000).to_i
+          else
+            time_to_nano(Time.now)
+          end
+        end
+
+        def should_create_span?(event_data)
+          return true if event_data[:severity].in?(%i[error fatal])
+
+          patterns = E11y.config&.opentelemetry_span_creation_patterns || []
+          event_name = event_data[:event_name].to_s
+          return false if event_name.empty?
+
+          patterns.any? { |p| File.fnmatch(p.to_s, event_name) }
+        end
+
+        def span_kind(event_data)
+          kind = (event_data[:span_kind] || :internal).to_sym
+          case kind
+          when :server then ::OpenTelemetry::Trace::SpanKind::SERVER
+          when :client then ::OpenTelemetry::Trace::SpanKind::CLIENT
+          when :producer then ::OpenTelemetry::Trace::SpanKind::PRODUCER
+          when :consumer then ::OpenTelemetry::Trace::SpanKind::CONSUMER
+          else ::OpenTelemetry::Trace::SpanKind::INTERNAL
+          end
+        rescue StandardError
+          ::OpenTelemetry::Trace::SpanKind::INTERNAL
+        end
+
+        def time_to_nano(time)
+          return (Time.now.to_f * 1_000_000_000).to_i if time.nil?
+
+          time = Time.parse(time.to_s) if time.is_a?(String)
+          (time.to_f * 1_000_000_000).to_i
+        end
+      end
+    end
+  end
+end

data/lib/e11y/pii/patterns.rb

@@ -15,7 +15,7 @@ module E11y
       EMAIL = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/
 
       # Password-like field names
-      PASSWORD_FIELDS = /password|passwd|pwd|secret|token|api[_-]?key/i
+      PASSWORD_FIELDS = /\b(?:password|passwd|pwd|secret|token|api[_-]?key)\b/i
 
       # Social Security Number (US format: XXX-XX-XXXX)
       SSN = /\b\d{3}-\d{2}-\d{4}\b/
@@ -40,6 +40,17 @@ module E11y
         PHONE
       ].freeze
 
+      # Patterns applied to STRING VALUES only (excludes PASSWORD_FIELDS).
+      # PASSWORD_FIELDS matches field names (password, token, api_key), not values.
+      # Applying it to values corrupts legitimate strings like "process_token_renewal_completed".
+      VALUE_PATTERNS = [
+        EMAIL,
+        SSN,
+        CREDIT_CARD,
+        IPV4,
+        PHONE
+      ].freeze
+
       # Field name patterns that indicate PII
       # Used for field-level detection (case-insensitive)
       FIELD_PATTERNS = {

data/lib/e11y/pipeline/builder.rb

@@ -12,7 +12,7 @@ module E11y
     #
     #   builder.use E11y::Middleware::TraceContext
     #   builder.use E11y::Middleware::Validation
-    #   builder.use E11y::Middleware::PIIFiltering
+    #   builder.use E11y::Middleware::PIIFilter
     #
     #   builder.validate_zones! # Boot-time validation
     #
@@ -26,14 +26,14 @@ module E11y
     #   end
     #
     #   builder.zone(:security) do
-    #     use E11y::Middleware::PIIFiltering
+    #     use E11y::Middleware::PIIFilter
     #   end
     #
     # @see E11y::Middleware::Base
     # @see ADR-015 §3.4 Middleware Zones & Modification Rules
     class Builder
       # Middleware entry: [middleware_class, args, options]
-      MiddlewareEntry = Struct.new(:middleware_class, :args, :options, keyword_init: true)
+      MiddlewareEntry = Struct.new(:middleware_class, :args, :options)
 
       # @return [Array<MiddlewareEntry>] Registered middlewares
       attr_reader :middlewares
@@ -80,7 +80,7 @@ module E11y
       #
       # @example
       #   builder.zone(:security) do
-      #     use E11y::Middleware::PIIFiltering
+      #     use E11y::Middleware::PIIFilter
       #   end
       #
       # @see ADR-015 §3.4.2 Middleware Zones

data/lib/e11y/presets/audit_event.rb

@@ -38,11 +38,13 @@ module E11y
     module AuditEvent
       def self.included(base)
         base.class_eval do
-          # Audit events will use audit pipeline (Phase 4)
+          audit_event true
+          contains_pii false # Preserve all data for signing (Tier 1 = skip filtering)
+          use_dlq true # Audit events always saved to DLQ (compliance)
           # Severity is NOT set by preset - user decides based on event criticality
         end
 
-        # Extend class with audit-specific methods
+        # Extend class with audit-specific methods (resolve_sample_rate 1.0, resolve_rate_limit nil)
         base.extend(ClassMethods)
       end
 
@@ -59,6 +61,15 @@ module E11y
         def resolve_sample_rate
           1.0 # 100% - compliance requirement
         end
+
+        # Audit events use routing rules (UC-012), not severity-based adapters.
+        # Return [] when no explicit adapters; respect explicit adapters when set.
+        def adapters(*list)
+          @adapters = list.flatten if list.any?
+          return @adapters if @adapters
+
+          []
+        end
       end
     end
   end

data/lib/e11y/railtie.rb

@@ -22,7 +22,7 @@ module E11y
   #   # config/initializers/e11y.rb
   #   E11y.configure do |config|
   #     config.service_name = "my-app"
-  #     config.adapters.register :loki, E11y::Adapters::Loki.new(url: ENV['LOKI_URL'])
+  #     config.adapters[:loki] = E11y::Adapters::Loki.new(url: ENV['LOKI_URL'])
   #   end
   #
   # @see ADR-008 §3 (Railtie & Initialization)
@@ -33,6 +33,13 @@ module E11y
   # including configuration, middleware insertion, instrumentation setup,
   # and console integration.
   class Railtie < Rails::Railtie
+    # Wire up generators so `rails g e11y:*` commands are discoverable.
+    generators do
+      require "generators/e11y/install/install_generator"
+      require "generators/e11y/event/event_generator"
+      require "generators/e11y/grafana_dashboard/grafana_dashboard_generator"
+      require "generators/e11y/prometheus_alerts/prometheus_alerts_generator"
+    end
     # Derive service name from Rails application class
     # @return [String] Service name (e.g., "my_app")
     def self.derive_service_name
@@ -47,7 +54,8 @@ module E11y
       E11y.configure do |config|
         config.environment ||= Rails.env.to_s
         config.service_name ||= E11y::Railtie.derive_service_name
-        # Only set enabled if not already configured
+        # Enable in dev/prod; disable in test by default — only when still unset (nil).
+        # Respects explicit true/false from earlier E11y.configure (e.g. config/application.rb).
         config.enabled = !Rails.env.test? if config.enabled.nil?
       end
     end
@@ -57,10 +65,37 @@ module E11y
       next unless E11y.config.enabled
 
       # Setup instruments (each can be enabled/disabled separately)
-      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
+      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
+
+    # Outgoing HTTP trace propagation (UC-009)
+    initializer "e11y.http_tracing", after: :load_config_initializers do
+      next unless E11y.configuration.enable_http_tracing
+
+      E11y::Tracing.patch_net_http!
+    end
+
+    # Auto-register DevLog adapter in development and test environments.
+    # Skipped if the user has already registered :dev_log in their initializer.
+    initializer "e11y.setup_development", after: :load_config_initializers do |app|
+      next unless Rails.env.development? || Rails.env.test?
+      next if E11y.configuration.adapters.key?(:dev_log)
+
+      E11y.configure do |config|
+        config.register_adapter :dev_log, E11y::Adapters::DevLog.new(
+          path: Rails.root.join("log", "e11y_dev.jsonl"),
+          max_lines: ENV.fetch("E11Y_MAX_EVENTS", "10000").to_i,
+          max_size: ENV.fetch("E11Y_MAX_SIZE", "50").to_i * 1024 * 1024,
+          keep_rotated: ENV.fetch("E11Y_KEEP_ROTATED", "5").to_i,
+          enable_watcher: !Rails.env.test?
+        )
+      end
+
+      require "e11y/middleware/dev_log_source"
+      app.middleware.use E11y::Middleware::DevLogSource
     end
 
     # Middleware insertion
@@ -69,10 +104,13 @@ module E11y
 
       # Insert E11y request middleware before Rails logger
       # This ensures trace context is set up before any Rails logging
-      app.middleware.insert_before(
-        Rails::Rack::Logger,
-        E11y::Middleware::Request
-      )
+      # API-only mode may omit Rails::Rack::Logger — fall back to unshift
+      begin
+        app.middleware.insert_before(Rails::Rack::Logger, E11y::Middleware::Request)
+      rescue RuntimeError
+        # Rails::Rack::Logger not in stack (e.g. api_only)
+        app.middleware.unshift(E11y::Middleware::Request)
+      end
     end
 
     # Console helpers
@@ -87,10 +125,10 @@ module E11y
 
     # Rake task helpers
     rake_tasks do
-      next unless E11y.config.enabled
-
-      # TODO: Add rake tasks (e11y:stats, e11y:test_event, etc.)
-      # load 'e11y/tasks.rake'
+      load File.expand_path("../tasks/e11y_slo.rake", __dir__)
+      load File.expand_path("../tasks/e11y_lint.rake", __dir__)
+      load File.expand_path("../tasks/e11y_events.rake", __dir__)
+      load File.expand_path("../tasks/e11y_docs.rake", __dir__)
     end
 
     # Setup Rails instrumentation (ActiveSupport::Notifications → E11y)