orfeas_lyra 0.6.0

data/lib/lyra/event_analyzer.rb

@@ -0,0 +1,135 @@
+module Lyra
+  # Analyzes collections of events for patterns and metrics
+  class EventAnalyzer
+    attr_reader :events
+
+    def initialize(events)
+      @events = events
+    end
+
+    # Analyze events and return comprehensive metrics
+    def analyze
+      {
+        timeline: calculate_timeline,
+        operations: calculate_operations,
+        metrics: calculate_metrics,
+        privacy: analyze_privacy
+      }
+    end
+
+    private
+
+    def calculate_timeline
+      return {} if @events.empty?
+
+      first_time = extract_timestamp(@events.first)
+      last_time = extract_timestamp(@events.last)
+
+      return {} if first_time.nil? || last_time.nil?
+
+      duration_seconds = last_time - first_time
+
+      {
+        first_event: first_time,
+        last_event: last_time,
+        duration_seconds: duration_seconds,
+        duration_minutes: duration_seconds / 60.0,
+        duration_hours: duration_seconds / 3600.0,
+        duration_days: duration_seconds / 86400.0
+      }
+    end
+
+    def extract_timestamp(event)
+      if event.respond_to?(:timestamp) && event.timestamp
+        event.timestamp
+      elsif event.respond_to?(:data) && event.data.is_a?(Hash) && event.data[:timestamp]
+        event.data[:timestamp]
+      elsif event.respond_to?(:metadata) && event.metadata.is_a?(Hash) && event.metadata[:timestamp]
+        event.metadata[:timestamp]
+      else
+        nil
+      end
+    end
+
+    def calculate_operations
+      operations = Hash.new(0)
+
+      @events.each do |event|
+        operation = if event.respond_to?(:operation)
+                     event.operation
+                   elsif event.respond_to?(:data)
+                     event.data[:operation]
+                   end
+
+        operations[operation] += 1 if operation
+      end
+
+      operations
+    end
+
+    def calculate_metrics
+      timeline = calculate_timeline
+
+      {
+        total_events: @events.length,
+        operations_per_day: if timeline[:duration_days] && timeline[:duration_days] > 0
+                             @events.length.to_f / timeline[:duration_days]
+                           else
+                             0
+                           end,
+        average_time_between_events: if @events.length > 1 && timeline[:duration_seconds]
+                                       timeline[:duration_seconds] / (@events.length - 1)
+                                     else
+                                       0
+                                     end
+      }
+    end
+
+    def analyze_privacy
+      pii_fields = {}
+      events_with_pii = 0
+
+      @events.each do |event|
+        event_pii = detect_event_pii(event)
+
+        if event_pii.any?
+          events_with_pii += 1
+          event_pii.each do |field, info|
+            pii_fields[field] ||= info
+          end
+        end
+      end
+
+      percentage = @events.empty? ? 0.0 : (events_with_pii.to_f / @events.length * 100.0)
+
+      {
+        pii_fields: pii_fields,
+        events_with_pii: events_with_pii,
+        percentage: percentage
+      }
+    end
+
+    def detect_event_pii(event)
+      attributes = if event.respond_to?(:attributes)
+                    event.attributes
+                  elsif event.respond_to?(:data)
+                    event.data[:attributes] || {}
+                  else
+                    {}
+                  end
+
+      changes = if event.respond_to?(:changes)
+                 event.changes
+               elsif event.respond_to?(:data)
+                 event.data[:changes] || {}
+               else
+                 {}
+               end
+
+      return {} unless Lyra.privacy_features_available?
+
+      all_data = attributes.merge(changes)
+      Lyra::Privacy::PIIDetector.detect(all_data)
+    end
+  end
+end

data/lib/lyra/event_flow.rb

@@ -0,0 +1,449 @@
+module Lyra
+  # Visualizes event flows and chains
+  class EventFlow
+    attr_reader :subject_id, :subject_type, :time_range
+
+    def initialize(subject_id: nil, subject_type: nil, time_range: nil)
+      @subject_id = subject_id
+      @subject_type = subject_type
+      @time_range = time_range || (30.days.ago..Time.current)
+    end
+
+    # Get complete event flow for visualization
+    def flow_data
+      events = load_events
+      grouped = group_by_correlation(events)
+
+      {
+        timeline: build_timeline(events),
+        flows: build_flows(grouped),
+        statistics: calculate_statistics(events),
+        privacy_impact: analyze_privacy_impact(events)
+      }
+    end
+
+    # Build timeline view showing CRUD operations and their events
+    def build_timeline(events)
+      events.sort_by { |e| event_timestamp(e) }.map do |event|
+        {
+          event_id: event.event_id,
+          timestamp: event_timestamp(event),
+          operation: event_operation(event),
+          model_class: event_model_class(event),
+          model_id: event_model_id(event),
+          correlation_id: event.metadata[:correlation_id],
+          action_id: event.metadata[:action_id],
+          user_action: event.metadata[:user_action],
+          changes: event_changes(event),
+          pii_fields: detect_pii(event),
+          grouped_with: find_grouped_events(event, events)
+        }
+      end
+    end
+
+    # Build event flows showing cause and effect
+    def build_flows(grouped_events)
+      grouped_events.map do |correlation_id, events|
+        {
+          correlation_id: correlation_id,
+          started_at: event_timestamp(events.min_by { |e| event_timestamp(e) }),
+          completed_at: event_timestamp(events.max_by { |e| event_timestamp(e) }),
+          duration: calculate_duration(events),
+          user_action: events.first.metadata[:user_action],
+          user_id: events.first.metadata[:user_id],
+          events_chain: build_event_chain(events),
+          crud_operations: extract_crud_operations(events),
+          privacy_impact: calculate_flow_privacy_impact(events)
+        }
+      end
+    end
+
+    # Show how a single CRUD operation maps to events
+    def crud_to_event_mapping(model_class, operation, model_id = nil)
+      events = load_events.select do |event|
+        matches = event_model_class(event) == model_class && event_operation(event) == operation
+        matches &&= event_model_id(event) == model_id if model_id
+        matches
+      end
+
+      {
+        crud_operation: {
+          model: model_class,
+          operation: operation,
+          record_id: model_id
+        },
+        generated_events: events.map { |e| event_summary(e) },
+        count: events.count,
+        timeline: events.sort_by { |e| event_timestamp(e) }.map do |e|
+          {
+            timestamp: event_timestamp(e),
+            event_type: e.class.name,
+            event_id: e.event_id,
+            data: e.data
+          }
+        end
+      }
+    end
+
+    # Reconstruct state from event chain
+    def reconstruct_state_chain(model_class, model_id)
+      stream_name = "#{model_class}$#{model_id}"
+      events = Lyra.config.event_store.read.stream(stream_name).to_a
+
+      chain = []
+      state = {}
+
+      events.sort_by { |e| event_timestamp(e) }.each do |event|
+        previous_state = state.dup
+
+        case event_operation(event)
+        when :created
+          state = event_attributes(event).dup
+        when :updated
+          event_changes(event).each { |k, (old, new)| state[k] = new }
+        when :destroyed
+          state[:_deleted] = true
+          state[:_deleted_at] = event_timestamp(event)
+        end
+
+        chain << {
+          event_id: event.event_id,
+          timestamp: event_timestamp(event),
+          operation: event_operation(event),
+          previous_state: previous_state,
+          changes: event_changes(event),
+          new_state: state.dup,
+          pii_changed: identify_pii_changes(previous_state, state),
+          user_action: event.metadata[:user_action]
+        }
+      end
+
+      {
+        model: { class: model_class, id: model_id },
+        initial_state: {},
+        final_state: state,
+        events_count: events.count,
+        state_evolution: chain
+      }
+    end
+
+    # Visualize data lineage for GDPR compliance
+    def data_lineage(field_name, model_class = nil)
+      events = load_events
+
+      if model_class
+        events = events.select { |e| event_model_class(e) == model_class }
+      end
+
+      lineage = []
+
+      events.each do |event|
+        attrs = event_attributes(event)
+        changes = event_changes(event)
+        if attrs.key?(field_name) || attrs.key?(field_name.to_s) || changes.key?(field_name) || changes.key?(field_name.to_s)
+          lineage << {
+            timestamp: event_timestamp(event),
+            event_id: event.event_id,
+            model: event_model_class(event),
+            record_id: event_model_id(event),
+            operation: event_operation(event),
+            old_value: changes.dig(field_name, 0) || changes.dig(field_name.to_s, 0),
+            new_value: changes.dig(field_name, 1) || changes.dig(field_name.to_s, 1) || attrs[field_name] || attrs[field_name.to_s],
+            source: event.metadata[:source],
+            user_id: event.metadata[:user_id],
+            action: event.metadata[:user_action]
+          }
+        end
+      end
+
+      {
+        field: field_name,
+        model_class: model_class,
+        total_modifications: lineage.count,
+        first_seen: lineage.min_by { |l| l[:timestamp] }&.dig(:timestamp),
+        last_modified: lineage.max_by { |l| l[:timestamp] }&.dig(:timestamp),
+        lineage: lineage.sort_by { |l| l[:timestamp] }
+      }
+    end
+
+    # Analyze privacy impact of event chains
+    def privacy_impact_analysis
+      events = load_events
+      pii_inventory = extract_pii_from_events(events)
+
+      {
+        total_events: events.count,
+        events_with_pii: events.count { |e| has_pii?(e) },
+        pii_categories: pii_inventory.keys,
+        pii_fields_count: pii_inventory.values.sum(&:count),
+        sensitive_operations: identify_sensitive_operations(events),
+        data_flows: trace_data_flows(events),
+        risk_assessment: assess_privacy_risk(events, pii_inventory)
+      }
+    end
+
+    private
+
+    # Helper methods to extract data from events (works with both Lyra::Event and RubyEventStore::Event)
+    def event_operation(event)
+      return event.operation if event.respond_to?(:operation)
+      op = event.data[:operation] || event.data["operation"]
+      op.is_a?(String) ? op.to_sym : op
+    end
+
+    def event_model_class(event)
+      return event.model_class if event.respond_to?(:model_class)
+      event.data[:model_class] || event.data["model_class"]
+    end
+
+    def event_model_id(event)
+      return event.model_id if event.respond_to?(:model_id)
+      event.data[:model_id] || event.data["model_id"]
+    end
+
+    def event_timestamp(event)
+      return event.timestamp if event.respond_to?(:timestamp) && event.timestamp
+      event.data[:timestamp] || event.data["timestamp"] || event.metadata[:timestamp]
+    end
+
+    def event_attributes(event)
+      return event.attributes if event.respond_to?(:attributes) && !event.attributes.is_a?(Hash)
+      event.data[:attributes] || event.data["attributes"] || {}
+    end
+
+    def event_changes(event)
+      return event.changes if event.respond_to?(:changes) && event.method(:changes).owner != ActiveRecord::AttributeMethods::Dirty
+      event.data[:changes] || event.data["changes"] || {}
+    end
+
+    def load_events
+      events = Lyra.config.event_store.read.to_a
+
+      # Filter by subject if specified
+      if subject_id && subject_type
+        events = events.select { |e| event_relates_to_subject?(e) }
+      end
+
+      # Filter by time range
+      events = events.select { |e| time_range.cover?(parse_timestamp(event_timestamp(e))) }
+
+      events
+    end
+
+    def event_relates_to_subject?(event)
+      event.metadata[:user_id] == subject_id ||
+      event.data[:user_id] == subject_id ||
+      (event_model_class(event) == subject_type && event_model_id(event) == subject_id)
+    end
+
+    def group_by_correlation(events)
+      events.group_by { |e| e.metadata[:correlation_id] || e.event_id }
+    end
+
+    def build_event_chain(events)
+      events.sort_by { |e| event_timestamp(e) }.map do |event|
+        {
+          event_id: event.event_id,
+          timestamp: event_timestamp(event),
+          event_type: event.class.name,
+          operation: event_operation(event),
+          model: "#{event_model_class(event)}##{event_model_id(event)}",
+          changes: event_changes(event),
+          pii_affected: detect_pii(event).any?
+        }
+      end
+    end
+
+    def extract_crud_operations(events)
+      events.map do |event|
+        {
+          operation: event_operation(event),
+          model: event_model_class(event),
+          record_id: event_model_id(event),
+          timestamp: event_timestamp(event)
+        }
+      end
+    end
+
+    def calculate_duration(events)
+      return 0 if events.empty?
+      max_time = parse_timestamp(event_timestamp(events.max_by { |e| event_timestamp(e) }))
+      min_time = parse_timestamp(event_timestamp(events.min_by { |e| event_timestamp(e) }))
+      (max_time - min_time).to_f
+    end
+
+    def parse_timestamp(timestamp)
+      return timestamp if timestamp.is_a?(Time) || timestamp.is_a?(DateTime)
+      return timestamp.to_time if timestamp.respond_to?(:to_time)
+      Time.parse(timestamp.to_s)
+    end
+
+    def calculate_statistics(events)
+      {
+        total_events: events.count,
+        operations: events.group_by { |e| event_operation(e) }.transform_values(&:count),
+        models: events.group_by { |e| event_model_class(e) }.transform_values(&:count),
+        hourly_distribution: hourly_distribution(events),
+        users: events.map { |e| e.metadata[:user_id] }.compact.uniq.count
+      }
+    end
+
+    def hourly_distribution(events)
+      events.group_by { |e| parse_timestamp(event_timestamp(e)).hour }.transform_values(&:count)
+    end
+
+    def detect_pii(event)
+      return {} unless Lyra.privacy_features_available?
+
+      Lyra::Privacy::PIIDetector.detect(event_attributes(event))
+    end
+
+    def has_pii?(event)
+      detect_pii(event).any?
+    end
+
+    def find_grouped_events(event, all_events)
+      correlation_id = event.metadata[:correlation_id]
+      return [] unless correlation_id
+
+      all_events.select do |e|
+        e.metadata[:correlation_id] == correlation_id && e.event_id != event.event_id
+      end.map(&:event_id)
+    end
+
+    def calculate_flow_privacy_impact(events)
+      pii_count = events.count { |e| has_pii?(e) }
+      {
+        events_with_pii: pii_count,
+        percentage: events.empty? ? 0 : (pii_count.to_f / events.count * 100).round(2),
+        pii_types: events.flat_map { |e| detect_pii(e).values.map { |v| v[:type] } }.uniq
+      }
+    end
+
+    def identify_pii_changes(old_state, new_state)
+      return {} unless Lyra.privacy_features_available?
+
+      changes = {}
+
+      new_state.each do |key, new_value|
+        old_value = old_state[key]
+        if old_value != new_value && Lyra::Privacy::PIIDetector.contains_pii?(key)
+          changes[key] = { from: old_value, to: new_value }
+        end
+      end
+
+      changes
+    end
+
+    def event_summary(event)
+      {
+        event_id: event.event_id,
+        timestamp: event_timestamp(event),
+        operation: event_operation(event),
+        has_pii: has_pii?(event)
+      }
+    end
+
+    def analyze_privacy_impact(events)
+      pii_inventory = extract_pii_from_events(events)
+
+      {
+        pii_categories: pii_inventory.keys,
+        total_pii_fields: pii_inventory.values.sum(&:count),
+        sensitive_data_present: pii_inventory.keys.any? { |k|
+          [:ssn, :credit_card, :health, :biometric].include?(k)
+        }
+      }
+    end
+
+    def extract_pii_from_events(events)
+      # Custom implementation that uses event_attributes helper
+      inventory = Hash.new { |h, k| h[k] = [] }
+      events.each do |event|
+        pii = detect_pii(event)
+        pii.each do |field, info|
+          inventory[info[:type]] << { field: field, model: event_model_class(event) }
+        end
+      end
+      inventory
+    end
+
+    def identify_sensitive_operations(events)
+      events.select { |e| has_pii?(e) && [:destroyed, :updated].include?(event_operation(e)) }
+             .map { |e| event_summary(e) }
+    end
+
+    def trace_data_flows(events)
+      # Identify how data flows between models
+      flows = Hash.new { |h, k| h[k] = [] }
+
+      events.each do |event|
+        pii = detect_pii(event)
+        next if pii.empty?
+
+        source = event_model_class(event)
+        pii.each do |field, info|
+          flows[info[:type]] << {
+            source_model: source,
+            field: field,
+            timestamp: event_timestamp(event),
+            operation: event_operation(event)
+          }
+        end
+      end
+
+      flows
+    end
+
+    def assess_privacy_risk(events, pii_inventory)
+      risk_factors = []
+
+      # Check for sensitive PII
+      if pii_inventory.keys.any? { |k| [:ssn, :credit_card, :health].include?(k) }
+        risk_factors << { level: :high, reason: "Contains highly sensitive PII" }
+      end
+
+      # Check for many PII fields
+      if pii_inventory.values.sum(&:count) > 10
+        risk_factors << { level: :medium, reason: "Large number of PII fields" }
+      end
+
+      # Check for frequent modifications
+      update_events = events.count { |e| event_operation(e) == :updated && has_pii?(e) }
+      if update_events > 50
+        risk_factors << { level: :medium, reason: "Frequent PII modifications" }
+      end
+
+      {
+        overall_risk: calculate_overall_risk(risk_factors),
+        factors: risk_factors,
+        recommendations: generate_recommendations(risk_factors)
+      }
+    end
+
+    def calculate_overall_risk(risk_factors)
+      return :low if risk_factors.empty?
+      return :high if risk_factors.any? { |f| f[:level] == :high }
+      return :medium if risk_factors.any? { |f| f[:level] == :medium }
+      :low
+    end
+
+    def generate_recommendations(risk_factors)
+      recommendations = []
+
+      if risk_factors.any? { |f| f[:reason].include?("sensitive") }
+        recommendations << "Implement field-level encryption for sensitive PII"
+        recommendations << "Enable audit logging for all sensitive data access"
+      end
+
+      if risk_factors.any? { |f| f[:reason].include?("modifications") }
+        recommendations << "Review data retention policies"
+        recommendations << "Implement change approval workflows"
+      end
+
+      recommendations << "Regular GDPR compliance audits recommended" if risk_factors.any?
+
+      recommendations
+    end
+  end
+end

data/lib/lyra/event_mapper.rb

@@ -0,0 +1,106 @@
+module Lyra
+  # Maps CRUD operations to domain events
+  class EventMapper
+    class << self
+      # Map a CRUD operation to an event
+      def map_operation(model_class, operation, data)
+        mapper_class = find_mapper(model_class) || DefaultMapper
+
+        mapper_class.new(model_class, operation, data).to_event
+      end
+
+      # Register a custom mapper for a model
+      def register_mapper(model_class, mapper_class)
+        mappers[model_class.name] = mapper_class
+      end
+
+      private
+
+      def mappers
+        @mappers ||= {}
+      end
+
+      def find_mapper(model_class)
+        mappers[model_class.name]
+      end
+    end
+
+    attr_reader :model_class, :operation, :data
+
+    def initialize(model_class, operation, data)
+      @model_class = model_class
+      @operation = operation
+      @data = data
+    end
+
+    def to_event
+      event_class = resolve_event_class
+      event_class.new(data: event_data, metadata: event_metadata)
+    end
+
+    def event_data
+      {
+        model_class: model_class.name,
+        model_id: data[:id],
+        operation: operation,
+        attributes: data[:attributes] || {},
+        changes: data[:changes] || {},
+        timestamp: Time.current
+      }
+    end
+
+    def event_metadata
+      {
+        user_id: data[:user_id],
+        request_id: data[:request_id],
+        correlation_id: Lyra::Correlation.current_id,
+        causation_id: Lyra::Causation.current_id,
+        source: 'lyra_interceptor'
+      }
+    end
+
+    def resolve_event_class
+      config = Lyra.config.model_config(model_class)
+      event_name = config.event_name_for(operation)
+      # Sanitize namespaced event names for constant lookup
+      sanitized_name = event_name.to_s.gsub("::", "")
+
+      # First check if it exists in Lyra::Events namespace
+      if Lyra::Events.const_defined?(sanitized_name, false)
+        return Lyra::Events.const_get(sanitized_name, false)
+      end
+
+      # Try to constantize (for user-defined event classes)
+      begin
+        event_name.constantize
+      rescue NameError
+        create_dynamic_event_class(event_name)
+      end
+    end
+
+    def create_dynamic_event_class(event_name)
+      # Sanitize namespaced event names (e.g., "Spree::OrderCreated" -> "SpreeOrderCreated")
+      sanitized_name = event_name.to_s.gsub("::", "")
+
+      return Lyra::Events.const_get(sanitized_name, false) if Lyra::Events.const_defined?(sanitized_name, false)
+
+      Lyra::Events.const_set(sanitized_name, Class.new(Lyra::Event))
+    end
+  end
+
+  class DefaultMapper < EventMapper
+    # Uses the base EventMapper behavior
+  end
+
+  # Example of a custom mapper
+  class AuditMapper < EventMapper
+    def event_data
+      super.merge(
+        audit_info: {
+          ip_address: data[:ip_address],
+          user_agent: data[:user_agent]
+        }
+      )
+    end
+  end
+end