e11y 0.1.0

data/lib/e11y/middleware/sampling.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require "e11y/middleware/base"
+
+module E11y
+  module Middleware
+    # Sampling Middleware
+    #
+    # Filters events based on sampling configuration to reduce volume and costs.
+    # Supports:
+    # - Per-event sample rates (from Event::Base)
+    # - Severity-based sampling (errors always sampled)
+    # - Pattern-based sampling (e.g., "debug.*" → 1%)
+    # - Trace-aware sampling (C05 - all events in trace sampled or none)
+    # - Error-based adaptive sampling (FEAT-4838 - 100% during error spikes)
+    # - Load-based adaptive sampling (FEAT-4842 - tiered sampling based on event volume)
+    #
+    # @example Basic usage
+    #   E11y.configure do |config|
+    #     config.middleware.use E11y::Middleware::Sampling, zone: :routing
+    #   end
+    #
+    # @example Event-level sampling
+    #   class Events::DebugQuery < E11y::Event::Base
+    #     sample_rate 0.01  # 1% sampling
+    #   end
+    #
+    # @example Error-based adaptive sampling
+    #   E11y.configure do |config|
+    #     config.middleware.use E11y::Middleware::Sampling,
+    #       error_based_adaptive: true,
+    #       error_spike_config: {
+    #         window: 60,
+    #         absolute_threshold: 100,
+    #         relative_threshold: 3.0,
+    #         spike_duration: 300
+    #       }
+    #   end
+    #
+    # @example Load-based adaptive sampling
+    #   E11y.configure do |config|
+    #     config.middleware.use E11y::Middleware::Sampling,
+    #       load_based_adaptive: true,
+    #       load_monitor_config: {
+    #         window: 60,
+    #         thresholds: {
+    #           normal: 1_000,    # 0-1k events/sec → 100% sampling
+    #           high: 10_000,     # 1k-10k → 50%
+    #           very_high: 50_000,# 10k-50k → 10%
+    #           overload: 100_000 # >100k → 1%
+    #         }
+    #       }
+    #   end
+    class Sampling < Base
+      middleware_zone :routing
+
+      # Initialize sampling middleware
+      #
+      # @param config [Hash] Configuration options
+      # @option config [Float] :default_sample_rate (1.0) Default sample rate for events without explicit config
+      # @option config [Boolean] :trace_aware (true) Enable trace-aware sampling (C05)
+      # @option config [Hash] :severity_rates ({}) Override sample rates by severity
+      # @option config [Boolean] :error_based_adaptive (false) Enable error-based adaptive sampling (FEAT-4838)
+      # @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
+
+        # 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
+      end
+
+      # Process event through sampling filter
+      #
+      # @param event_data [Hash] The event payload
+      # @return [Hash, nil] The event payload if sampled, nil if dropped
+      def call(event_data)
+        event_class = event_data[:event_class]
+
+        # Track errors for error-based adaptive sampling (FEAT-4838)
+        @error_spike_detector.record_event(event_data) if @error_based_adaptive && @error_spike_detector
+
+        # Track events for load-based adaptive sampling (FEAT-4842)
+        @load_monitor&.record_event
+
+        # Determine if event should be sampled
+        # Drop event if not sampled
+        return nil unless should_sample?(event_data, event_class)
+
+        # Mark as sampled for downstream middleware
+        event_data[:sampled] = true
+        event_data[:sample_rate] = determine_sample_rate(event_class, event_data)
+
+        # Pass to next middleware
+        @app.call(event_data)
+      end
+
+      # Returns capabilities of this middleware
+      #
+      # @return [Hash] Capabilities
+      def capabilities
+        {
+          filters_events: true,
+          trace_aware: @trace_aware,
+          severity_aware: true,
+          error_based_adaptive: @error_based_adaptive,  # FEAT-4838
+          load_based_adaptive: @load_based_adaptive     # FEAT-4842
+        }
+      end
+
+      private
+
+      # Determine if event should be sampled
+      #
+      # @param event_data [Hash] The event payload
+      # @param event_class [Class] The event class
+      # @return [Boolean] true if event should be sampled
+      def should_sample?(event_data, event_class)
+        # 1. Check if audit event (never sample audit events!)
+        return true if event_class.respond_to?(:audit_event?) && event_class.audit_event?
+
+        # 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)
+        end
+
+        # 3. Get sample rate for this event
+        sample_rate = determine_sample_rate(event_class, event_data)
+
+        # 4. Random sampling decision
+        rand < sample_rate
+      end
+
+      # Determine sample rate for event
+      #
+      # Priority (highest to lowest):
+      # 0. Error spike override (100% during spike) - FEAT-4838
+      # 1. Value-based sampling (high-value events) - FEAT-4849
+      # 2. Load-based adaptive (tiered rates) - FEAT-4842
+      # 3. Severity-based override from config (@severity_rates)
+      # 4. Event-level config (event_class.resolve_sample_rate)
+      # 5. Default sample rate (@default_sample_rate)
+      #
+      # @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)
+      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?
+          return 1.0 # 100% sampling during error spike
+        end
+
+        # 1. Value-based sampling (FEAT-4849) - high-value events always sampled
+        if event_data && event_class.respond_to?(:value_sampling_configs)
+          configs = event_class.value_sampling_configs
+          unless configs.empty?
+            require "e11y/sampling/value_extractor"
+            extractor = E11y::Sampling::ValueExtractor.new
+            if configs.any? { |config| config.matches?(event_data, extractor) }
+              return 1.0 # 100% sampling for high-value events
+            end
+          end
+        end
+
+        # 2. Load-based adaptive sampling (FEAT-4842)
+        # Apply load-based rate if enabled, but can be overridden by higher priority rules below
+        base_rate = if @load_based_adaptive && @load_monitor
+                      @load_monitor.recommended_sample_rate
+                    else
+                      @default_sample_rate
+                    end
+
+        # 2. Severity-based override from middleware config
+        if event_class.respond_to?(:severity)
+          severity = event_class.severity
+          return @severity_rates[severity] if @severity_rates.key?(severity)
+        end
+
+        # 3. Event-level config (from Event::Base)
+        # If event has explicit sample_rate, use min(event_rate, load_rate)
+        if event_class.respond_to?(:resolve_sample_rate)
+          event_rate = event_class.resolve_sample_rate
+          return [event_rate, base_rate].min # Take the more restrictive rate
+        end
+
+        # 4. Default/load-based rate
+        base_rate
+      end
+
+      # Trace-aware sampling decision (C05 Resolution)
+      #
+      # All events in a trace share the same sampling decision.
+      # This prevents incomplete traces in distributed systems.
+      #
+      # @param trace_id [String] The trace ID
+      # @param event_class [Class] The event class
+      # @param event_data [Hash] Event payload (for value-based sampling)
+      # @return [Boolean] true if trace should be sampled
+      def trace_sampling_decision(trace_id, event_class, event_data = nil)
+        @trace_decisions_mutex.synchronize do
+          # Check if decision already made for this trace
+          return @trace_decisions[trace_id] if @trace_decisions.key?(trace_id)
+
+          # Make new sampling decision
+          sample_rate = determine_sample_rate(event_class, event_data)
+          decision = rand < sample_rate
+
+          # Cache decision (TTL handled by periodic cleanup)
+          @trace_decisions[trace_id] = decision
+
+          # Cleanup old decisions periodically (every 1000 traces)
+          cleanup_trace_decisions if @trace_decisions.size > 1000
+
+          decision
+        end
+      end
+
+      # Cleanup old trace decisions to prevent memory leaks
+      #
+      # Removes random 50% of cached decisions when cache grows too large.
+      # This is a simple heuristic - traces typically complete in <10 seconds,
+      # so old decisions are likely stale.
+      def cleanup_trace_decisions
+        # Remove random 50% of decisions
+        keys_to_remove = @trace_decisions.keys.sample(@trace_decisions.size / 2)
+        keys_to_remove.each { |key| @trace_decisions.delete(key) }
+      end
+    end
+  end
+end

data/lib/e11y/middleware/slo.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "e11y/middleware/base"
+require "e11y/slo/event_driven"
+
+module E11y
+  module Middleware
+    # SLO Middleware for Event-Driven SLO tracking (ADR-014).
+    #
+    # Automatically processes events with SLO configuration enabled,
+    # computes `slo_status` from payload, and emits metrics.
+    #
+    # **Features:**
+    # - Auto-detects events with `slo { enabled true }`
+    # - Calls `slo_status_from` proc to compute 'success'/'failure'
+    # - Emits `slo_event_result_total{slo_status}` metric to Yabeda
+    # - Never fails event tracking (graceful error handling)
+    #
+    # **Middleware Zone:** `:post_processing` (after routing, before adapters)
+    #
+    # **ADR References:**
+    # - ADR-014 §3 (Event SLO DSL)
+    # - ADR-014 §4 (SLO Status Calculation)
+    # - ADR-014 §6 (Metrics Export)
+    # - ADR-015 §3 (Middleware Order)
+    #
+    # **Use Case:** UC-014 (Event-Driven SLO)
+    #
+    # @example Configuration
+    #   E11y.configure do |config|
+    #     # Enable SLO middleware (auto-enabled if any Events have slo { enabled true })
+    #     config.pipeline.use E11y::Middleware::SLO, zone: :post_processing
+    #   end
+    #
+    # @example Event with SLO
+    #   module Events
+    #     class PaymentProcessed < E11y::Event::Base
+    #       schema do
+    #         required(:payment_id).filled(:string)
+    #         required(:status).filled(:string)
+    #       end
+    #
+    #       slo do
+    #         enabled true
+    #         slo_status_from do |payload|
+    #           case payload[:status]
+    #           when 'completed' then 'success'
+    #           when 'failed' then 'failure'
+    #           else nil  # Not counted
+    #           end
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    #   # Tracking will automatically emit SLO metric:
+    #   Events::PaymentProcessed.track(payment_id: 'p123', status: 'completed')
+    #   # → Emits: slo_event_result_total{event_name="payment.processed", slo_status="success"} +1
+    #
+    # @see ADR-014 for complete Event-Driven SLO architecture
+    class SLO < Base
+      middleware_zone :post_processing
+
+      # Process event and emit SLO metric if SLO is enabled.
+      #
+      # @param event_data [Hash] Event payload
+      # @return [Hash] Unchanged event_data (passthrough)
+      def call(event_data)
+        # Skip if SLO not enabled for this event
+        event_class = resolve_event_class(event_data)
+        return event_data unless event_class&.respond_to?(:slo_config)
+        return event_data unless event_class.slo_config&.enabled
+
+        # Compute slo_status from payload
+        slo_status = compute_slo_status(event_class, event_data[:payload])
+        return event_data unless slo_status
+
+        # Emit SLO metric
+        emit_slo_metric(event_class, slo_status, event_data[:payload])
+
+        event_data # Passthrough (never modify event_data)
+      rescue StandardError => e
+        # Never fail event tracking due to SLO processing
+        E11y.logger.error(
+          "[E11y::Middleware::SLO] SLO processing failed for #{event_data[:event_name]}: #{e.message}"
+        )
+        event_data
+      end
+
+      private
+
+      # Resolve Event class from event_name.
+      #
+      # @param event_data [Hash] Event payload
+      # @return [Class, nil] Event class or nil if not found
+      def resolve_event_class(event_data)
+        event_name = event_data[:event_name]
+        return nil unless event_name
+
+        # Convert event_name to class name (e.g., "payment.processed" → "Events::PaymentProcessed")
+        # This assumes Rails autoloading or explicit requires
+        class_name = event_name.to_s.split(".").map(&:capitalize).join
+        "Events::#{class_name}".constantize
+      rescue NameError
+        # Event class not found (may be from external source)
+        nil
+      end
+
+      # Compute slo_status using event's slo_status_from proc.
+      #
+      # @param event_class [Class] Event class
+      # @param payload [Hash] Event payload
+      # @return [String, nil] 'success', 'failure', or nil
+      def compute_slo_status(event_class, payload)
+        return nil unless event_class.slo_config.slo_status_proc
+
+        event_class.slo_config.slo_status_proc.call(payload)
+      rescue StandardError => e
+        E11y.logger.error(
+          "[E11y::Middleware::SLO] Failed to compute slo_status for #{event_class.name}: #{e.message}"
+        )
+        nil
+      end
+
+      # Emit SLO metric to Yabeda/Prometheus.
+      #
+      # @param event_class [Class] Event class
+      # @param slo_status [String] 'success' or 'failure'
+      # @param payload [Hash] Event payload
+      # @return [void]
+      def emit_slo_metric(event_class, slo_status, payload)
+        labels = build_slo_labels(event_class, slo_status, payload)
+
+        E11y::Metrics.increment(:slo_event_result_total, labels)
+      rescue StandardError => e
+        E11y.logger.error(
+          "[E11y::Middleware::SLO] Failed to emit SLO metric for #{event_class.name}: #{e.message}"
+        )
+      end
+
+      # Build metric labels for SLO.
+      #
+      # @param event_class [Class] Event class
+      # @param slo_status [String] 'success' or 'failure'
+      # @param payload [Hash] Event payload
+      # @return [Hash] Metric labels
+      def build_slo_labels(event_class, slo_status, payload)
+        labels = {
+          event_name: event_class.event_name,
+          slo_status: slo_status
+        }
+
+        # Add custom SLO name if configured
+        if event_class.slo_config.contributes_to
+          labels[:slo_name] = event_class.slo_config.contributes_to
+        end
+
+        # Add group_by field if configured
+        if event_class.slo_config.group_by_field
+          field = event_class.slo_config.group_by_field
+          labels[:group_by] = payload[field].to_s if payload[field]
+        end
+
+        labels
+      end
+    end
+  end
+end

data/lib/e11y/middleware/trace_context.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+
+module E11y
+  module Middleware
+    # TraceContext middleware adds distributed tracing metadata to all events.
+    #
+    # This is the FIRST middleware in the pipeline (pre-processing zone),
+    # ensuring every event has tracing context for correlation across services.
+    #
+    # @see ADR-015 §3.1 Pipeline Flow
+    # @see ADR-005 Tracing Context Management
+    # @see UC-006 Trace Context Management
+    # @see UC-009 Multi-Service Tracing
+    #
+    # @example Automatic tracing metadata
+    #   Events::OrderPaid.track(order_id: 123)
+    #
+    #   # Event data after TraceContext middleware:
+    #   {
+    #     event_name: 'Events::OrderPaid',
+    #     payload: { order_id: 123 },
+    #     trace_id: 'a1b2c3d4e5f6g7h8',       # 32-char hex
+    #     span_id: 'i9j0k1l2',                 # 16-char hex
+    #     timestamp: '2026-01-17T12:34:56.789Z' # ISO8601
+    #   }
+    #
+    # @example Request-scoped tracing (propagation)
+    #   # In Rails controller/middleware:
+    #   Thread.current[:e11y_trace_id] = request.headers['X-Trace-ID']
+    #
+    #   Events::OrderPaid.track(order_id: 123)
+    #   # Uses propagated trace_id from thread-local storage
+    #
+    # @example Manual trace_id injection
+    #   Events::OrderPaid.track(order_id: 123, trace_id: 'custom-trace-id')
+    #   # Manual trace_id preserved (not overridden)
+    class TraceContext < Base
+      middleware_zone :pre_processing
+
+      # Adds tracing metadata to event data.
+      #
+      # **Hybrid Tracing (C17 Resolution)**:
+      # - trace_id: Current trace (from E11y::Current or generated)
+      # - span_id: Always new for each event
+      # - parent_trace_id: Link to parent trace (for background jobs)
+      #
+      # @param event_data [Hash] The event data to enrich
+      # @option event_data [String] :trace_id Existing trace ID (optional)
+      # @option event_data [String] :span_id Existing span ID (optional)
+      # @option event_data [String] :parent_trace_id Parent trace ID (optional)
+      # @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
+
+        # Add span_id (always generate new for this event)
+        event_data[:span_id] ||= generate_span_id
+
+        # Add parent_trace_id (if job has parent trace) - C17 Resolution
+        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)
+
+        # Increment metrics
+        increment_metric("e11y.middleware.trace_context.processed")
+
+        @app.call(event_data)
+      end
+
+      private
+
+      # Get current trace ID from E11y::Current or thread-local storage (request context).
+      #
+      # Priority: E11y::Current > Thread.current
+      #
+      # @return [String, nil] Current trace ID if set, nil otherwise
+      def current_trace_id
+        E11y::Current.trace_id || Thread.current[:e11y_trace_id]
+      end
+
+      # Get current parent trace ID from E11y::Current (background job context).
+      #
+      # Only set for background jobs that have a parent request trace.
+      #
+      # @return [String, nil] Parent trace ID if set, nil otherwise
+      def current_parent_trace_id
+        E11y::Current.parent_trace_id
+      end
+
+      # Generate a new trace ID (32-character hexadecimal).
+      #
+      # Compatible with OpenTelemetry trace_id format (16 bytes = 32 hex chars).
+      #
+      # @return [String] New trace ID
+      def generate_trace_id
+        SecureRandom.hex(16) # 32 chars
+      end
+
+      # Generate a new span ID (16-character hexadecimal).
+      #
+      # Compatible with OpenTelemetry span_id format (8 bytes = 16 hex chars).
+      #
+      # @return [String] New span ID
+      def generate_span_id
+        SecureRandom.hex(8) # 16 chars
+      end
+
+      # Format timestamp to ISO8601 with millisecond precision.
+      #
+      # @param time [Time] Time object to format
+      # @return [String] ISO8601 formatted timestamp (e.g., "2026-01-17T12:34:56.789Z")
+      def format_timestamp(time)
+        time.utc.iso8601(3)
+      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_trace_context_processed.increment
+      end
+    end
+  end
+end

data/lib/e11y/middleware/validation.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module E11y
+  module Middleware
+    # Validation middleware performs schema validation on event payloads.
+    #
+    # This middleware runs in the pre-processing zone, AFTER TraceContext and
+    # BEFORE PII filtering. It validates the event payload against the schema
+    # defined in the event class.
+    #
+    # **CRITICAL:** Validation MUST use the ORIGINAL class name (e.g., Events::OrderPaidV2),
+    # NOT the normalized name (Events::OrderPaid), because schemas are version-specific.
+    #
+    # @see ADR-015 §3.1 Pipeline Flow (line 96-97)
+    # @see ADR-015 §3.2 Why Each Middleware Needs Original Class Name (line 125)
+    # @see E11y::Event::Base#validate_payload! for validation logic
+    #
+    # @example Valid event passes through
+    #   class Events::OrderPaid < E11y::Event::Base
+    #     schema do
+    #       required(:order_id).filled(:integer)
+    #     end
+    #   end
+    #
+    #   event_data = {
+    #     event_class: Events::OrderPaid,
+    #     payload: { order_id: 123 }
+    #   }
+    #
+    #   # Validation passes ✅
+    #   middleware.call(event_data) # → event_data (unchanged)
+    #
+    # @example Invalid event raises error
+    #   event_data = {
+    #     event_class: Events::OrderPaid,
+    #     payload: { order_id: "invalid" } # ❌ Should be integer
+    #   }
+    #
+    #   middleware.call(event_data)
+    #   # Raises E11y::ValidationError: "Validation failed for Events::OrderPaid: order_id must be an integer"
+    #
+    # @example Schema-less events pass through
+    #   class Events::SimpleEvent < E11y::Event::Base
+    #     # No schema defined
+    #   end
+    #
+    #   # Validation skipped (no schema) ✅
+    #   middleware.call(event_data) # → event_data (unchanged)
+    class Validation < Base
+      middleware_zone :pre_processing
+
+      # Validates event payload against its schema.
+      #
+      # @param event_data [Hash] The event data to validate
+      # @option event_data [Class] :event_class The event class (required)
+      # @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
+      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]
+
+        event_class = event_data[:event_class]
+        payload = event_data[:payload]
+
+        # Get compiled schema from event class
+        schema = event_class.compiled_schema
+
+        # Skip validation if no schema defined (schema-less events)
+        unless schema
+          increment_metric("e11y.middleware.validation.skipped")
+          return @app.call(event_data)
+        end
+
+        # Perform validation
+        result = schema.call(payload)
+
+        if result.success?
+          # Validation passed
+          increment_metric("e11y.middleware.validation.passed")
+          @app.call(event_data)
+        else
+          # Validation failed - raise error with details
+          increment_metric("e11y.middleware.validation.failed")
+
+          error_message = format_validation_errors(event_class, result.errors)
+          raise E11y::ValidationError, error_message
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      private
+
+      # Format validation errors into a human-readable message.
+      #
+      # @param event_class [Class] The event class
+      # @param errors [Dry::Schema::MessageSet] Validation errors
+      # @return [String] Formatted error message
+      def format_validation_errors(event_class, errors)
+        error_details = errors.to_h.map do |field, messages|
+          "#{field}: #{messages.join(', ')}"
+        end.join("; ")
+
+        "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