671f6c2f62938b306383bc0eb80a3fa9d3d150e6

Committed 28 May 2025 06:03PM UTC coverage: 59.97% (-0.05%) from 60.023%

Build # 671f6c2f62938b306383bc0eb80a3fa9d3d150e6

Build Type

push

github

Committed by NSHkr

Commit Message

CPG formalization plans

Run Details

5675 of 9463 relevant lines covered (59.97%)

3796.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.16

/lib/elixir_scope/ast_repository/runtime_correlator.ex

defmodule ElixirScope.ASTRepository.RuntimeCorrelator do
  @moduledoc """
  AST-Runtime Correlator for the Enhanced AST Repository.
  
  Provides seamless correlation between static AST analysis and runtime behavior,
  enabling revolutionary debugging features:
  
  - **Structural Breakpoints**: Break on AST patterns during execution
  - **Data Flow Breakpoints**: Break when variables flow through specific AST paths
  - **Semantic Watchpoints**: Track variables through AST structure, not just scope
  - **AST-Aware Execution Traces**: Show code structure during execution replay
  
  ## Performance Targets
  
  - Event correlation: <1ms per event
  - AST context lookup: <10ms
  - Runtime query enhancement: <50ms
  - Memory overhead: <10% of base EventStore
  
  ## Integration Points
  
  - EventStore: ast_node_id correlation
  - InstrumentationRuntime: Enhanced event capture
  - Query Engine: Runtime-aware query optimization
  - Temporal Bridge: AST-enhanced state reconstruction
  
  ## Examples
  
      # Correlate runtime event to AST
      {:ok, ast_context} = RuntimeCorrelator.correlate_event_to_ast(repo, event)
      
      # Get AST context for runtime event
      {:ok, context} = RuntimeCorrelator.get_runtime_context(repo, event)
      
      # Enhance event with AST metadata
      {:ok, enhanced_event} = RuntimeCorrelator.enhance_event_with_ast(repo, event)
      
      # Build AST-aware execution trace
      {:ok, trace} = RuntimeCorrelator.build_execution_trace(repo, events)
  """
  
  use GenServer
  require Logger
  
  alias ElixirScope.ASTRepository.EnhancedRepository
  alias ElixirScope.ASTRepository.Enhanced.{
    EnhancedFunctionData,
    EnhancedModuleData,
    CFGData,
    DFGData
  }
  alias ElixirScope.Storage.EventStore
  alias ElixirScope.Events
  
  @table_name :runtime_correlator_main
  @context_cache :runtime_correlator_context_cache
  @trace_cache :runtime_correlator_trace_cache
  
  # Performance targets
  @correlation_timeout 5000
  @context_lookup_timeout 5000
  @query_enhancement_timeout 5000
  
  # Cache TTL (5 minutes)
  @cache_ttl 300_000
  
  defstruct [
    :ast_repo,
    :event_store,
    :correlation_stats,
    :cache_stats,
    :breakpoints,
    :watchpoints
  ]
  
  @type ast_context :: %{
    module: atom(),
    function: atom(),
    arity: non_neg_integer(),
    ast_node_id: String.t(),
    line_number: pos_integer(),
    ast_metadata: map(),
    cfg_node: map() | nil,
    dfg_context: map() | nil,
    variable_scope: map(),
    call_context: list(map())
  }
  
  @type enhanced_event :: %{
    original_event: map(),
    ast_context: ast_context() | nil,
    correlation_metadata: map(),
    structural_info: map(),
    data_flow_info: map()
  }
  
  @type execution_trace :: %{
    events: list(enhanced_event()),
    ast_flow: list(map()),
    variable_flow: map(),
    structural_patterns: list(map()),
    performance_correlation: map(),
    trace_metadata: map()
  }
  
  @type structural_breakpoint :: %{
    id: String.t(),
    pattern: Macro.t(),
    condition: atom(),
    ast_path: list(String.t()),
    enabled: boolean(),
    hit_count: non_neg_integer(),
    metadata: map()
  }
  
  @type data_flow_breakpoint :: %{
    id: String.t(),
    variable: String.t(),
    ast_path: list(String.t()),
    flow_conditions: list(atom()),
    enabled: boolean(),
    hit_count: non_neg_integer(),
    metadata: map()
  }
  
  @type semantic_watchpoint :: %{
    id: String.t(),
    variable: String.t(),
    track_through: list(atom()),
    ast_scope: String.t(),
    enabled: boolean(),
    value_history: list(map()),
    metadata: map()
  }
  
  # GenServer API
  
  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  def init(opts) do
    # Create ETS tables for correlation and caching (handle existing tables gracefully)
    try do
      :ets.new(@table_name, [:named_table, :public, :set, {:read_concurrency, true}])
    rescue
      ArgumentError -> 
        # Table already exists, clear it
        :ets.delete_all_objects(@table_name)
    end
    
    try do
      :ets.new(@context_cache, [:named_table, :public, :set, {:read_concurrency, true}])
    rescue
      ArgumentError -> 
        # Table already exists, clear it
        :ets.delete_all_objects(@context_cache)
    end
    
    try do
      :ets.new(@trace_cache, [:named_table, :public, :set, {:read_concurrency, true}])
    rescue
      ArgumentError -> 
        # Table already exists, clear it
        :ets.delete_all_objects(@trace_cache)
    end
    
    state = %__MODULE__{
      ast_repo: Keyword.get(opts, :ast_repo),
      event_store: Keyword.get(opts, :event_store),
      correlation_stats: %{
        events_correlated: 0,
        context_lookups: 0,
        cache_hits: 0,
        cache_misses: 0
      },
      cache_stats: %{
        context_cache_size: 0,
        trace_cache_size: 0,
        evictions: 0
      },
      breakpoints: %{
        structural: %{},
        data_flow: %{},
        semantic: %{}
      },
      watchpoints: %{}
    }
    
    Logger.info("RuntimeCorrelator started with AST-Runtime integration")
    {:ok, state}
  end
  
  # Public API
  
  @doc """
  Correlates a runtime event to precise AST nodes.
  
  Links runtime events to their corresponding AST structure, enabling
  structural debugging and analysis.
  
  ## Parameters
  
  - `repo` - The Enhanced AST Repository
  - `event` - Runtime event to correlate
  
  ## Returns
  
  - `{:ok, ast_context}` - AST context for the event
  - `{:error, reason}` - Correlation failed
  
  ## Examples
  
      event = %Events.FunctionEntry{
        module: MyModule,
        function: :my_function,
        arity: 2,
        correlation_id: "abc123"
      }
      
      {:ok, context} = RuntimeCorrelator.correlate_event_to_ast(repo, event)
      # context.ast_node_id => "MyModule.my_function/2:line_15"
  """
  @spec correlate_event_to_ast(pid() | atom(), map()) :: {:ok, ast_context()} | {:error, term()}
  def correlate_event_to_ast(repo, event) do
    GenServer.call(__MODULE__, {:correlate_event_to_ast, repo, event}, @correlation_timeout)
  end
  
  @doc """
  Gets comprehensive AST context for a runtime event.
  
  Provides detailed AST metadata including CFG/DFG context,
  variable scope, and call hierarchy.
  
  ## Parameters
  
  - `repo` - The Enhanced AST Repository
  - `event` - Runtime event
  
  ## Returns
  
  - `{:ok, context}` - Comprehensive AST context
  - `{:error, reason}` - Context lookup failed
  """
  @spec get_runtime_context(pid() | atom(), map()) :: {:ok, ast_context()} | {:error, term()}
  def get_runtime_context(repo, event) do
    GenServer.call(__MODULE__, {:get_runtime_context, repo, event}, @context_lookup_timeout)
  end
  
  @doc """
  Enhances a runtime event with AST metadata.
  
  Enriches runtime events with structural information,
  data flow context, and AST-based insights.
  
  ## Parameters
  
  - `repo` - The Enhanced AST Repository
  - `event` - Runtime event to enhance
  
  ## Returns
  
  - `{:ok, enhanced_event}` - Event with AST metadata
  - `{:error, reason}` - Enhancement failed
  """
  @spec enhance_event_with_ast(pid() | atom(), map()) :: {:ok, enhanced_event()} | {:error, term()}
  def enhance_event_with_ast(repo, event) do
    GenServer.call(__MODULE__, {:enhance_event_with_ast, repo, event}, @correlation_timeout)
  end
  
  @doc """
  Builds AST-aware execution traces from runtime events.
  
  Creates comprehensive execution traces that show both
  runtime behavior and underlying AST structure.
  
  ## Parameters
  
  - `repo` - The Enhanced AST Repository
  - `events` - List of runtime events
  
  ## Returns
  
  - `{:ok, trace}` - AST-aware execution trace
  - `{:error, reason}` - Trace building failed
  """
  @spec build_execution_trace(pid() | atom(), list(map())) :: {:ok, execution_trace()} | {:error, term()}
  def build_execution_trace(repo, events) do
    GenServer.call(__MODULE__, {:build_execution_trace, repo, events}, @query_enhancement_timeout)
  end
  
  @doc """
  Sets a structural breakpoint based on AST patterns.
  
  Enables breaking on specific AST patterns during execution,
  such as pattern match failures or specific call structures.
  
  ## Parameters
  
  - `breakpoint_spec` - Structural breakpoint specification
  
  ## Examples
  
      # Break on any pattern match failure in GenServer handle_call
      RuntimeCorrelator.set_structural_breakpoint(%{
        pattern: quote(do: {:handle_call, _, _}),
        condition: :pattern_match_failure,
        ast_path: ["MyGenServer", "handle_call"]
      })
  """
  @spec set_structural_breakpoint(map()) :: {:ok, String.t()} | {:error, term()}
  def set_structural_breakpoint(breakpoint_spec) do
    GenServer.call(__MODULE__, {:set_structural_breakpoint, breakpoint_spec})
  end
  
  @doc """
  Sets a data flow breakpoint for variable tracking.
  
  Enables breaking when variables flow through specific AST paths,
  providing deep insight into data movement through code structure.
  
  ## Parameters
  
  - `breakpoint_spec` - Data flow breakpoint specification
  
  ## Examples
  
      # Break when user_id flows through authentication path
      RuntimeCorrelator.set_data_flow_breakpoint(%{
        variable: "user_id",
        ast_path: ["MyModule", "authenticate", "case_clause_2"],
        flow_conditions: [:assignment, :pattern_match]
      })
  """
  @spec set_data_flow_breakpoint(map()) :: {:ok, String.t()} | {:error, term()}
  def set_data_flow_breakpoint(breakpoint_spec) do
    GenServer.call(__MODULE__, {:set_data_flow_breakpoint, breakpoint_spec})
  end
  
  @doc """
  Sets a semantic watchpoint for variable tracking.
  
  Tracks variables through AST structure rather than just scope,
  providing semantic understanding of variable flow.
  
  ## Parameters
  
  - `watchpoint_spec` - Semantic watchpoint specification
  
  ## Examples
  
      # Watch state variable through AST structure
      RuntimeCorrelator.set_semantic_watchpoint(%{
        variable: "state",
        track_through: [:pattern_match, :pipe_operator, :function_call],
        ast_scope: "MyGenServer.handle_call/3"
      })
  """
  @spec set_semantic_watchpoint(map()) :: {:ok, String.t()} | {:error, term()}
  def set_semantic_watchpoint(watchpoint_spec) do
    GenServer.call(__MODULE__, {:set_semantic_watchpoint, watchpoint_spec})
  end
  
  @doc """
  Gets correlation statistics and performance metrics.
  """
  @spec get_correlation_stats() :: {:ok, map()}
  def get_correlation_stats() do
    GenServer.call(__MODULE__, :get_correlation_stats)
  end
  
  @doc """
  Clears correlation caches and resets statistics.
  """
  @spec clear_caches() :: :ok
  def clear_caches() do
    GenServer.call(__MODULE__, :clear_caches)
  end
  
  # GenServer Callbacks
  
  def handle_call({:correlate_event_to_ast, repo, event}, _from, state) do
    start_time = System.monotonic_time(:millisecond)
    
    case correlate_event_internal(repo, event, state) do
      {:ok, ast_context} ->
        end_time = System.monotonic_time(:millisecond)
        duration = end_time - start_time
        
        # Update statistics
        new_stats = update_correlation_stats(state.correlation_stats, :correlation, duration)
        new_state = %{state | correlation_stats: new_stats}
        
        {:reply, {:ok, ast_context}, new_state}
      
      error ->
        {:reply, error, state}
    end
  end
  
  def handle_call({:get_runtime_context, repo, event}, _from, state) do
    start_time = System.monotonic_time(:millisecond)
    
    case get_runtime_context_internal(repo, event, state) do
      {:ok, context} ->
        end_time = System.monotonic_time(:millisecond)
        duration = end_time - start_time
        
        # Update statistics
        new_stats = update_correlation_stats(state.correlation_stats, :context_lookup, duration)
        new_state = %{state | correlation_stats: new_stats}
        
        {:reply, {:ok, context}, new_state}
      
      error ->
        {:reply, error, state}
    end
  end
  
  def handle_call({:enhance_event_with_ast, repo, event}, _from, state) do
    case enhance_event_internal(repo, event, state) do
      {:ok, enhanced_event} ->
        {:reply, {:ok, enhanced_event}, state}
      
      error ->
        {:reply, error, state}
    end
  end
  
  def handle_call({:build_execution_trace, repo, events}, _from, state) do
    case build_execution_trace_internal(repo, events, state) do
      {:ok, trace} ->
        {:reply, {:ok, trace}, state}
      
      error ->
        {:reply, error, state}
    end
  end
  
  def handle_call({:set_structural_breakpoint, breakpoint_spec}, _from, state) do
    case create_structural_breakpoint(breakpoint_spec) do
      {:ok, breakpoint_id, breakpoint} ->
        new_structural = Map.put(state.breakpoints.structural, breakpoint_id, breakpoint)
        new_breakpoints = %{state.breakpoints | structural: new_structural}
        new_state = %{state | breakpoints: new_breakpoints}
        
        {:reply, {:ok, breakpoint_id}, new_state}
      
      error ->
        {:reply, error, state}
    end
  end
  
  def handle_call({:set_data_flow_breakpoint, breakpoint_spec}, _from, state) do
    case create_data_flow_breakpoint(breakpoint_spec) do
      {:ok, breakpoint_id, breakpoint} ->
        new_data_flow = Map.put(state.breakpoints.data_flow, breakpoint_id, breakpoint)
        new_breakpoints = %{state.breakpoints | data_flow: new_data_flow}
        new_state = %{state | breakpoints: new_breakpoints}
        
        {:reply, {:ok, breakpoint_id}, new_state}
      
      error ->
        {:reply, error, state}
    end
  end
  
  def handle_call({:set_semantic_watchpoint, watchpoint_spec}, _from, state) do
    case create_semantic_watchpoint(watchpoint_spec) do
      {:ok, watchpoint_id, watchpoint} ->
        new_watchpoints = Map.put(state.watchpoints, watchpoint_id, watchpoint)
        new_state = %{state | watchpoints: new_watchpoints}
        
        {:reply, {:ok, watchpoint_id}, new_state}
      
      error ->
        {:reply, error, state}
    end
  end
  
  def handle_call(:get_correlation_stats, _from, state) do
    stats = %{
      correlation: state.correlation_stats,
      cache: state.cache_stats,
      breakpoints: %{
        structural: map_size(state.breakpoints.structural),
        data_flow: map_size(state.breakpoints.data_flow)
      },
      watchpoints: map_size(state.watchpoints)
    }
    
    {:reply, {:ok, stats}, state}
  end
  
  def handle_call(:clear_caches, _from, state) do
    :ets.delete_all_objects(@context_cache)
    :ets.delete_all_objects(@trace_cache)
    
    new_cache_stats = %{
      context_cache_size: 0,
      trace_cache_size: 0,
      evictions: state.cache_stats.evictions
    }
    
    new_state = %{state | cache_stats: new_cache_stats}
    {:reply, :ok, new_state}
  end
  
  # Private Implementation
  
  defp correlate_event_internal(_repo, nil, _state) do
    {:error, :nil_event}
  end
  
  defp correlate_event_internal(_repo, event, _state) when not is_map(event) do
    {:error, :invalid_event_type}
  end
  
  defp correlate_event_internal(repo, event, state) do
    # Validate required fields
    module = extract_module(event)
    function = extract_function(event)
    
    cond do
      is_nil(module) -> {:error, :missing_module}
      is_nil(function) -> {:error, :missing_function}
      not is_atom(module) -> {:error, :invalid_module_type}
      not is_atom(function) -> {:error, :invalid_function_type}
      true -> correlate_event_internal_validated(repo, event, state)
    end
  end
  
  defp correlate_event_internal_validated(repo, event, state) do
    # Check cache first
    cache_key = generate_correlation_cache_key(event)
    
    case :ets.lookup(@context_cache, cache_key) do
      [{^cache_key, {ast_context, timestamp}}] ->
        if System.monotonic_time(:millisecond) - timestamp < @cache_ttl do
          # Cache hit
          _new_stats = update_correlation_stats(state.correlation_stats, :cache_hit, 0)
          {:ok, ast_context}
        else
          # Cache expired
          :ets.delete(@context_cache, cache_key)
          correlate_event_fresh(repo, event, cache_key, state)
        end
      
      [] ->
        # Cache miss
        correlate_event_fresh(repo, event, cache_key, state)
    end
  end
  
  defp correlate_event_fresh(repo, event, cache_key, state) do
    with {:ok, module_data} <- get_module_data(repo, extract_module(event)),
         {:ok, function_data} <- get_function_data(module_data, extract_function(event), extract_arity(event)),
         {:ok, ast_node_id} <- generate_ast_node_id(event, function_data),
         {:ok, ast_context} <- build_ast_context(function_data, ast_node_id, event) do
      
      # Cache the result
      timestamp = System.monotonic_time(:millisecond)
      :ets.insert(@context_cache, {cache_key, {ast_context, timestamp}})
      
      # Update cache statistics
      _new_stats = update_correlation_stats(state.correlation_stats, :cache_miss, 0)
      
      {:ok, ast_context}
    else
      error -> error
    end
  end
  
  defp get_runtime_context_internal(repo, event, state) do
    with {:ok, ast_context} <- correlate_event_internal(repo, event, state),
         {:ok, cfg_context} <- get_cfg_context(repo, ast_context),
         {:ok, dfg_context} <- get_dfg_context(repo, ast_context),
         {:ok, variable_scope} <- get_variable_scope(repo, ast_context, event),
         {:ok, call_context} <- get_call_context(repo, event) do
      
      enhanced_context = %{
        ast_context |
        cfg_node: cfg_context,
        dfg_context: dfg_context,
        variable_scope: variable_scope,
        call_context: call_context
      }
      
      {:ok, enhanced_context}
    else
      error -> error
    end
  end
  
  defp enhance_event_internal(repo, event, state) do
    with {:ok, ast_context} <- correlate_event_internal(repo, event, state),
         {:ok, structural_info} <- extract_structural_info(ast_context),
         {:ok, data_flow_info} <- extract_data_flow_info(repo, ast_context, event) do
      
      enhanced_event = %{
        original_event: event,
        ast_context: ast_context,
        correlation_metadata: %{
          correlation_time: System.monotonic_time(:nanosecond),
          correlation_version: "1.0"
        },
        structural_info: structural_info,
        data_flow_info: data_flow_info
      }
      
      {:ok, enhanced_event}
    else
      error -> error
    end
  end
  
  defp build_execution_trace_internal(repo, events, _state) do
    with {:ok, enhanced_events} <- enhance_events_batch(repo, events),
         {:ok, ast_flow} <- build_ast_flow(enhanced_events),
         {:ok, variable_flow} <- build_variable_flow(enhanced_events),
         {:ok, structural_patterns} <- identify_structural_patterns(enhanced_events),
         {:ok, performance_correlation} <- correlate_performance_data(enhanced_events) do
      
      trace = %{
        events: enhanced_events,
        ast_flow: ast_flow,
        variable_flow: variable_flow,
        structural_patterns: structural_patterns,
        performance_correlation: performance_correlation,
        trace_metadata: %{
          trace_id: generate_trace_id(),
          created_at: System.system_time(:nanosecond),
          event_count: length(events),
          correlation_version: "1.0"
        }
      }
      
      {:ok, trace}
    else
      error -> error
    end
  end
  
  defp create_structural_breakpoint(spec) do
    breakpoint_id = generate_breakpoint_id("structural")
    
    breakpoint = %{
      id: breakpoint_id,
      pattern: Map.get(spec, :pattern),
      condition: Map.get(spec, :condition, :any),
      ast_path: Map.get(spec, :ast_path, []),
      enabled: Map.get(spec, :enabled, true),
      hit_count: 0,
      metadata: Map.get(spec, :metadata, %{})
    }
    
    case validate_structural_breakpoint(breakpoint) do
      :ok -> {:ok, breakpoint_id, breakpoint}
      error -> error
    end
  end
  
  defp create_data_flow_breakpoint(spec) do
    breakpoint_id = generate_breakpoint_id("data_flow")
    
    breakpoint = %{
      id: breakpoint_id,
      variable: Map.get(spec, :variable),
      ast_path: Map.get(spec, :ast_path, []),
      flow_conditions: Map.get(spec, :flow_conditions, [:any]),
      enabled: Map.get(spec, :enabled, true),
      hit_count: 0,
      metadata: Map.get(spec, :metadata, %{})
    }
    
    case validate_data_flow_breakpoint(breakpoint) do
      :ok -> {:ok, breakpoint_id, breakpoint}
      error -> error
    end
  end
  
  defp create_semantic_watchpoint(spec) do
    watchpoint_id = generate_watchpoint_id()
    
    watchpoint = %{
      id: watchpoint_id,
      variable: Map.get(spec, :variable),
      track_through: Map.get(spec, :track_through, [:all]),
      ast_scope: Map.get(spec, :ast_scope),
      enabled: Map.get(spec, :enabled, true),
      value_history: [],
      metadata: Map.get(spec, :metadata, %{})
    }
    
    case validate_semantic_watchpoint(watchpoint) do
      :ok -> {:ok, watchpoint_id, watchpoint}
      error -> error
    end
  end
  
  # Helper Functions
  
  defp extract_module(%{module: module}), do: module
  defp extract_module(%{"module" => module}), do: module
  defp extract_module(_), do: nil
  
  defp extract_function(%{function: function}), do: function
  defp extract_function(%{"function" => function}), do: function
  defp extract_function(_), do: nil
  
  defp extract_arity(%{arity: arity}), do: arity
  defp extract_arity(%{"arity" => arity}), do: arity
  defp extract_arity(_), do: 0
  
  defp extract_timestamp(%{timestamp: timestamp}), do: timestamp
  defp extract_timestamp(%{"timestamp" => timestamp}), do: timestamp
  defp extract_timestamp(_), do: System.monotonic_time(:nanosecond)
  
  defp get_module_data(repo, module) when not is_nil(module) do
    case EnhancedRepository.get_enhanced_module(module) do
      {:ok, module_data} -> {:ok, module_data}
      {:error, :not_found} -> {:error, :module_not_found}
      error -> error
    end
  end
  
  defp get_module_data(_repo, nil), do: {:error, :invalid_module}
  
  defp get_function_data(module_data, function, arity) when not is_nil(function) do
    case Map.get(module_data.functions, {function, arity}) do
      nil -> {:error, :function_not_found}
      function_data -> {:ok, function_data}
    end
  end
  
  defp get_function_data(_module_data, nil, _arity), do: {:error, :invalid_function}
  
  defp generate_ast_node_id(event, function_data) do
    # Check if event already has ast_node_id
    case Map.get(event, :ast_node_id) do
      nil ->
        # Generate ast_node_id from event data
        module = extract_module(event)
        function = extract_function(event)
        arity = extract_arity(event)
        line = extract_line_number(event, function_data)
        
        # Use short module name (last part after the last dot)
        short_module_name = case to_string(module) do
          "Elixir." <> rest -> 
            rest |> String.split(".") |> List.last()
          module_str -> 
            module_str |> String.split(".") |> List.last()
        end
        
        node_id = "#{short_module_name}.#{function}/#{arity}:line_#{line}"
        {:ok, node_id}
      
      existing_ast_node_id ->
        # Use existing ast_node_id from event
        {:ok, existing_ast_node_id}
    end
  end
  
  defp extract_line_number(event, function_data) do
    # Try to extract line number from event or use function start line
    cond do
      Map.has_key?(event, :caller_line) and not is_nil(Map.get(event, :caller_line)) ->
        Map.get(event, :caller_line)
      Map.has_key?(event, :line) and not is_nil(Map.get(event, :line)) ->
        Map.get(event, :line)
      true ->
        function_data.line_start
    end
  end
  
  defp build_ast_context(function_data, ast_node_id, event) do
    context = %{
      module: function_data.module_name,
      function: function_data.function_name,
      arity: function_data.arity,
      ast_node_id: ast_node_id,
      line_number: extract_line_number(event, function_data),
      ast_metadata: %{
        complexity: function_data.complexity,
        visibility: function_data.visibility,
        file_path: function_data.file_path,
        line_start: function_data.line_start,
        line_end: function_data.line_end
      },
      cfg_node: nil,
      dfg_context: nil,
      variable_scope: %{},
      call_context: []
    }
    
    {:ok, context}
  end
  
  defp get_cfg_context(repo, ast_context) do
    # Get CFG data for the function
    case EnhancedRepository.get_enhanced_function(ast_context.module, ast_context.function, ast_context.arity) do
      {:ok, function_data} ->
        # Find the CFG node for the current line
        cfg_node = find_cfg_node_for_line(function_data.cfg_data, ast_context.line_number)
        {:ok, cfg_node}
      
      {:error, :not_found} ->
        {:ok, nil}
      
      error ->
        error
    end
  end
  
  defp get_dfg_context(repo, ast_context) do
    # Get DFG data for the function
    case EnhancedRepository.get_enhanced_function(ast_context.module, ast_context.function, ast_context.arity) do
      {:ok, function_data} ->
        # Extract relevant DFG context for the current line
        dfg_context = extract_dfg_context_for_line(function_data.dfg_data, ast_context.line_number)
        {:ok, dfg_context}
      
      {:error, :not_found} ->
        {:ok, nil}
      
      error ->
        error
    end
  end
  
  defp get_variable_scope(_repo, ast_context, event) do
    # Extract variable scope from event if available
    variables = case Map.get(event, :variables) do
      nil -> %{}
      vars when is_map(vars) -> vars
      _ -> %{}
    end
    
    scope = %{
      local_variables: variables,
      scope_level: ast_context.line_number,
      binding_context: extract_binding_context(event)
    }
    
    {:ok, scope}
  end
  
  defp get_call_context(_repo, event) do
    # Extract call context from correlation ID and call stack
    call_context = case Map.get(event, :correlation_id) do
      nil -> []
      correlation_id -> build_call_context_from_correlation(correlation_id)
    end
    
    {:ok, call_context}
  end
  
  defp extract_structural_info(ast_context) do
    structural_info = %{
      ast_node_type: determine_ast_node_type(ast_context),
      structural_depth: calculate_structural_depth(ast_context),
      pattern_context: extract_pattern_context(ast_context),
      control_flow_position: determine_control_flow_position(ast_context)
    }
    
    {:ok, structural_info}
  end
  
  defp extract_data_flow_info(repo, ast_context, event) do
    with {:ok, dfg_context} <- get_dfg_context(repo, ast_context) do
      data_flow_info = %{
        variable_definitions: extract_variable_definitions(dfg_context),
        variable_uses: extract_variable_uses(dfg_context),
        data_dependencies: extract_data_dependencies(dfg_context),
        flow_direction: determine_flow_direction(event, dfg_context)
      }
      
      {:ok, data_flow_info}
    else
      error -> error
    end
  end
  
  defp enhance_events_batch(repo, events) do
    # Create a minimal state structure for internal calls
    minimal_state = %{
      correlation_stats: %{
        events_correlated: 0,
        context_lookups: 0,
        cache_hits: 0,
        cache_misses: 0
      }
    }
    
    enhanced_events = Enum.map(events, fn event ->
      case enhance_event_internal(repo, event, minimal_state) do
        {:ok, enhanced_event} -> enhanced_event
        {:error, _} -> 
          # Fallback to original event if enhancement fails
          %{
            original_event: event,
            ast_context: nil,
            correlation_metadata: %{},
            structural_info: %{},
            data_flow_info: %{}
          }
      end
    end)
    
    {:ok, enhanced_events}
  end
  
  defp build_ast_flow(enhanced_events) do
    ast_flow = enhanced_events
    |> Enum.filter(fn event -> not is_nil(event.ast_context) end)
    |> Enum.map(fn event ->
      %{
        ast_node_id: event.ast_context.ast_node_id,
        timestamp: extract_timestamp(event.original_event),
        structural_info: event.structural_info
      }
    end)
    |> Enum.sort_by(& &1.timestamp)
    
    {:ok, ast_flow}
  end
  
  defp build_variable_flow(enhanced_events) do
    variable_flow = enhanced_events
    |> Enum.reduce(%{}, fn event, acc ->
      case event.ast_context do
        nil -> 
          # Handle events without ast_context but with variables in original event
          case Map.get(event.original_event, :variables) do
            vars when is_map(vars) and map_size(vars) > 0 ->
              # Create a synthetic ast_node_id for variable tracking
              module = Map.get(event.original_event, :module, "Unknown")
              function = Map.get(event.original_event, :function, "unknown")
              synthetic_ast_node_id = "#{module}.#{function}:variable_snapshot"
              
              Enum.reduce(vars, acc, fn {var_name, var_value}, var_acc ->
                var_history = Map.get(var_acc, var_name, [])
                var_entry = %{
                  value: var_value,
                  timestamp: extract_timestamp(event.original_event),
                  ast_node_id: synthetic_ast_node_id,
                  line_number: Map.get(event.original_event, :line, 0)
                }
                Map.put(var_acc, var_name, [var_entry | var_history])
              end)
            _ -> acc
          end
        context ->
          # Safely get local variables from variable_scope
          local_variables = case Map.get(context, :variable_scope, %{}) do
            %{local_variables: vars} when is_map(vars) -> vars
            vars when is_map(vars) -> vars
            _ -> %{}
          end
          
          Enum.reduce(local_variables, acc, fn {var_name, var_value}, var_acc ->
            var_history = Map.get(var_acc, var_name, [])
            var_entry = %{
              value: var_value,
              timestamp: extract_timestamp(event.original_event),
              ast_node_id: context.ast_node_id,
              line_number: context.line_number
            }
            Map.put(var_acc, var_name, [var_entry | var_history])
          end)
      end
    end)
    |> Enum.map(fn {var_name, history} ->
      {var_name, Enum.reverse(history)}
    end)
    |> Enum.into(%{})
    
    {:ok, variable_flow}
  end
  
  defp identify_structural_patterns(enhanced_events) do
    patterns = enhanced_events
    |> Enum.filter(fn event -> 
      not is_nil(event.structural_info) and Map.has_key?(event.structural_info, :ast_node_type)
    end)
    |> Enum.group_by(fn event -> event.structural_info.ast_node_type end)
    |> Enum.map(fn {pattern_type, events} ->
      %{
        pattern_type: pattern_type,
        occurrences: length(events),
        first_occurrence: extract_timestamp(hd(events).original_event),
        last_occurrence: extract_timestamp(List.last(events).original_event)
      }
    end)
    
    {:ok, patterns}
  end
  
  defp correlate_performance_data(enhanced_events) do
    performance_data = enhanced_events
    |> Enum.filter(fn event -> 
      Map.has_key?(event.original_event, :duration_ns) and not is_nil(event.ast_context)
    end)
    |> Enum.map(fn event ->
      %{
        ast_node_id: event.ast_context.ast_node_id,
        duration_ns: event.original_event.duration_ns,
        complexity: event.ast_context.ast_metadata.complexity,
        timestamp: extract_timestamp(event.original_event)
      }
    end)
    |> Enum.group_by(& &1.ast_node_id)
    |> Enum.map(fn {ast_node_id, measurements} ->
      durations = Enum.map(measurements, & &1.duration_ns)
      complexity = hd(measurements).complexity
      
      {ast_node_id, %{
        avg_duration: Enum.sum(durations) / length(durations),
        min_duration: Enum.min(durations),
        max_duration: Enum.max(durations),
        call_count: length(measurements),
        complexity: complexity,
        performance_ratio: calculate_performance_ratio(durations, complexity)
      }}
    end)
    |> Enum.into(%{})
    
    {:ok, performance_data}
  end
  
  # Utility Functions
  
  defp generate_correlation_cache_key(event) when is_nil(event) do
    "nil_event_#{System.unique_integer()}"
  end
  
  defp generate_correlation_cache_key(event) when is_map(event) do
    module = Map.get(event, :module, "unknown")
    function = Map.get(event, :function, "unknown")
    arity = Map.get(event, :arity, 0)
    line = Map.get(event, :line, 0)
    
    "#{module}.#{function}/#{arity}:#{line}"
  end
  
  defp generate_correlation_cache_key(_event) do
    "invalid_event_#{System.unique_integer()}"
  end
  
  defp generate_trace_id() do
    "trace_" <> Base.encode16(:crypto.strong_rand_bytes(8), case: :lower)
  end
  
  defp generate_breakpoint_id(type) do
    "#{type}_bp_" <> Base.encode16(:crypto.strong_rand_bytes(4), case: :lower)
  end
  
  defp generate_watchpoint_id() do
    "wp_" <> Base.encode16(:crypto.strong_rand_bytes(4), case: :lower)
  end
  
  defp update_correlation_stats(stats, operation, duration) do
    case operation do
      :correlation ->
        %{stats | events_correlated: stats.events_correlated + 1}
      
      :context_lookup ->
        %{stats | context_lookups: stats.context_lookups + 1}
      
      :cache_hit ->
        %{stats | cache_hits: stats.cache_hits + 1}
      
      :cache_miss ->
        %{stats | cache_misses: stats.cache_misses + 1}
    end
  end
  
  # Placeholder implementations for complex analysis functions
  
  defp find_cfg_node_for_line(_cfg_data, _line_number), do: nil
  defp extract_dfg_context_for_line(_dfg_data, _line_number), do: %{}
  defp extract_binding_context(_event), do: %{}
  defp build_call_context_from_correlation(_correlation_id), do: []
  defp determine_ast_node_type(_ast_context), do: :function_call
  defp calculate_structural_depth(_ast_context), do: 1
  defp extract_pattern_context(_ast_context), do: %{}
  defp determine_control_flow_position(_ast_context), do: :sequential
  defp extract_variable_definitions(_dfg_context), do: []
  defp extract_variable_uses(_dfg_context), do: []
  defp extract_data_dependencies(_dfg_context), do: []
  defp determine_flow_direction(_event, _dfg_context), do: :forward
  defp calculate_performance_ratio(durations, complexity) do
    avg_duration = Enum.sum(durations) / length(durations)
    avg_duration / max(complexity, 1)
  end
  
  defp validate_structural_breakpoint(%{pattern: pattern}) when not is_nil(pattern), do: :ok
  defp validate_structural_breakpoint(_), do: {:error, :invalid_pattern}
  
  defp validate_data_flow_breakpoint(%{variable: variable}) when not is_nil(variable), do: :ok
  defp validate_data_flow_breakpoint(_), do: {:error, :invalid_variable}
  
  defp validate_semantic_watchpoint(%{variable: variable}) when not is_nil(variable), do: :ok
  defp validate_semantic_watchpoint(_), do: {:error, :invalid_variable}
end 

nshkrdotcom / ElixirScope / 671f6c2f62938b306383bc0eb80a3fa9d3d150e6

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous