refactor temporal_bridge_enhancement

Author: NSHkr

lib/elixir_scope/capture/enhanced_instrumentation.ex

@@ -0,0 +1,147 @@
+defmodule ElixirScope.Capture.TemporalBridgeEnhancement.ASTContextBuilder do
+  @moduledoc """
+  AST context building utilities for TemporalBridgeEnhancement.
+
+  Handles building AST contexts, structural information, execution paths,
+  and variable flow tracking from events.
+  """
+
+  alias ElixirScope.ASTRepository.RuntimeCorrelator
+
+  @doc """
+  Builds AST context for a state from events.
+  """
+  @spec build_ast_context_for_state(list(map()), pid()) :: {:ok, map() | nil}
+  def build_ast_context_for_state(events, ast_repo) do
+    # Get the most recent event with AST correlation
+    case Enum.find(events, fn event -> Map.has_key?(event, :ast_node_id) end) do
+      nil -> {:ok, nil}
+      event ->
+        case RuntimeCorrelator.get_runtime_context(ast_repo, event) do
+          {:ok, context} -> {:ok, context}
+          {:error, _} -> {:ok, nil}
+        end
+    end
+  end
+
+  @doc """
+  Extracts structural information for a state.
+  """
+  @spec extract_structural_info_for_state(map() | nil, list(map())) :: {:ok, map()}
+  def extract_structural_info_for_state(ast_context, events) do
+    structural_info = %{
+      current_ast_node: extract_current_ast_node(ast_context),
+      call_depth: calculate_call_depth(events),
+      execution_context: extract_execution_context(events),
+      control_flow_state: determine_control_flow_state(ast_context, events)
+    }
+
+    {:ok, structural_info}
+  end
+
+  @doc """
+  Builds execution path from events and AST repository.
+  """
+  @spec build_execution_path(list(map()), pid()) :: {:ok, list(map())}
+  def build_execution_path(events, _ast_repo) do
+    execution_path = events
+    |> Enum.filter(fn event -> Map.has_key?(event, :ast_node_id) end)
+    |> Enum.map(fn event ->
+      %{
+        ast_node_id: event.ast_node_id,
+        timestamp: Map.get(event, :timestamp),
+        event_type: Map.get(event, :event_type),
+        context: extract_event_context(event)
+      }
+    end)
+
+    {:ok, execution_path}
+  end
+
+  @doc """
+  Builds variable flow tracking for a state.
+  """
+  @spec build_variable_flow_for_state(list(map())) :: {:ok, map()}
+  def build_variable_flow_for_state(events) do
+    variable_flow = events
+    |> Enum.filter(fn event -> Map.has_key?(event, :variables) end)
+    |> Enum.reduce(%{}, fn event, acc ->
+      variables = Map.get(event, :variables, %{})
+      timestamp = Map.get(event, :timestamp)
+
+      Enum.reduce(variables, acc, fn {var_name, var_value}, var_acc ->
+        var_history = Map.get(var_acc, var_name, [])
+        var_entry = %{value: var_value, timestamp: timestamp}
+        Map.put(var_acc, var_name, [var_entry | var_history])
+      end)
+    end)
+    |> Enum.map(fn {var_name, history} ->
+      {var_name, Enum.reverse(history)}
+    end)
+    |> Enum.into(%{})
+
+    {:ok, variable_flow}
+  end
+
+  # Private utility functions
+
+  defp extract_current_ast_node(nil), do: nil
+  defp extract_current_ast_node(ast_context), do: Map.get(ast_context, :ast_node_id)
+
+  defp calculate_call_depth(events) do
+    events
+    |> Enum.filter(fn event -> Map.get(event, :event_type) in [:function_entry, :function_exit] end)
+    |> Enum.reduce(0, fn event, depth ->
+      case Map.get(event, :event_type) do
+        :function_entry -> depth + 1
+        :function_exit -> max(0, depth - 1)
+        _ -> depth
+      end
+    end)
+  end
+
+  defp extract_execution_context(events) do
+    %{
+      total_events: length(events),
+      event_types: events |> Enum.map(fn event -> Map.get(event, :event_type) end) |> Enum.frequencies(),
+      time_span: calculate_time_span(events)
+    }
+  end
+
+  defp determine_control_flow_state(_ast_context, events) do
+    # Determine current control flow state based on recent events
+    recent_events = Enum.take(events, -5)
+
+    cond do
+      Enum.any?(recent_events, fn event -> Map.get(event, :event_type) == :exception end) ->
+        :exception_handling
+
+      Enum.any?(recent_events, fn event -> Map.get(event, :event_type) == :function_entry end) ->
+        :function_call
+
+      Enum.any?(recent_events, fn event -> Map.get(event, :event_type) == :state_change end) ->
+        :state_transition
+
+      true ->
+        :sequential
+    end
+  end
+
+  defp extract_event_context(event) do
+    %{
+      module: Map.get(event, :module),
+      function: Map.get(event, :function),
+      line: Map.get(event, :line),
+      correlation_id: Map.get(event, :correlation_id)
+    }
+  end
+
+  defp calculate_time_span(events) do
+    if length(events) < 2 do
+      0
+    else
+      timestamps = Enum.map(events, fn event -> Map.get(event, :timestamp) end)
+      Enum.max(timestamps) - Enum.min(timestamps)
+    end
+  end
+end

lib/elixir_scope/capture/temporal_bridge_enhancement.ex

@@ -0,0 +1,190 @@
+defmodule ElixirScope.Capture.TemporalBridgeEnhancement.CacheManager do
+  @moduledoc """
+  Cache management for TemporalBridgeEnhancement.
+
+  Handles ETS table creation, caching operations, and cache invalidation
+  for enhanced state reconstruction and execution traces.
+  """
+
+  @ast_state_cache :temporal_bridge_ast_state_cache
+  @execution_trace_cache :temporal_bridge_execution_trace_cache
+
+  # Cache TTL (2 minutes)
+  @cache_ttl 120_000
+
+  @doc """
+  Creates an ETS table, handling existing tables gracefully.
+  """
+  @spec create_table(atom()) :: atom()
+  def create_table(table_name) do
+    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)
+        table_name
+    end
+  end
+
+  @doc """
+  Initializes all cache tables.
+  """
+  @spec init_caches() :: :ok
+  def init_caches() do
+    create_table(@ast_state_cache)
+    create_table(@execution_trace_cache)
+    :ok
+  end
+
+  @doc """
+  Gets a cached state with TTL check.
+  """
+  @spec get_cached_state(String.t(), non_neg_integer()) ::
+    {:hit, any()} | {:miss, :not_found | :expired | :table_not_found}
+  def get_cached_state(session_id, timestamp) do
+    cache_key = "#{session_id}:#{timestamp}"
+
+    try do
+      case :ets.lookup(@ast_state_cache, cache_key) do
+        [{^cache_key, {enhanced_state, cached_timestamp}}] ->
+          if System.monotonic_time(:millisecond) - cached_timestamp < @cache_ttl do
+            {:hit, enhanced_state}
+          else
+            :ets.delete(@ast_state_cache, cache_key)
+            {:miss, :expired}
+          end
+
+        [] ->
+          {:miss, :not_found}
+      end
+    rescue
+      ArgumentError ->
+        {:miss, :table_not_found}
+    end
+  end
+
+  @doc """
+  Caches a state with current timestamp.
+  """
+  @spec cache_state(String.t(), non_neg_integer(), any()) :: :ok
+  def cache_state(session_id, timestamp, enhanced_state) do
+    cache_key = "#{session_id}:#{timestamp}"
+    cache_timestamp = System.monotonic_time(:millisecond)
+
+    try do
+      :ets.insert(@ast_state_cache, {cache_key, {enhanced_state, cache_timestamp}})
+      :ok
+    rescue
+      ArgumentError ->
+        # Table doesn't exist, create it and try again
+        create_table(@ast_state_cache)
+        :ets.insert(@ast_state_cache, {cache_key, {enhanced_state, cache_timestamp}})
+        :ok
+    end
+  end
+
+  @doc """
+  Gets a cached execution trace with TTL check.
+  """
+  @spec get_cached_trace(String.t(), non_neg_integer(), non_neg_integer()) ::
+    {:hit, any()} | {:miss, :not_found | :expired | :table_not_found}
+  def get_cached_trace(session_id, start_time, end_time) do
+    cache_key = "trace:#{session_id}:#{start_time}:#{end_time}"
+
+    try do
+      case :ets.lookup(@execution_trace_cache, cache_key) do
+        [{^cache_key, {trace, cached_timestamp}}] ->
+          if System.monotonic_time(:millisecond) - cached_timestamp < @cache_ttl do
+            {:hit, trace}
+          else
+            :ets.delete(@execution_trace_cache, cache_key)
+            {:miss, :expired}
+          end
+
+        [] ->
+          {:miss, :not_found}
+      end
+    rescue
+      ArgumentError ->
+        {:miss, :table_not_found}
+    end
+  end
+
+  @doc """
+  Caches an execution trace with current timestamp.
+  """
+  @spec cache_trace(String.t(), non_neg_integer(), non_neg_integer(), any()) :: :ok
+  def cache_trace(session_id, start_time, end_time, trace) do
+    cache_key = "trace:#{session_id}:#{start_time}:#{end_time}"
+    cache_timestamp = System.monotonic_time(:millisecond)
+
+    try do
+      :ets.insert(@execution_trace_cache, {cache_key, {trace, cache_timestamp}})
+      :ok
+    rescue
+      ArgumentError ->
+        # Table doesn't exist, create it and try again
+        create_table(@execution_trace_cache)
+        :ets.insert(@execution_trace_cache, {cache_key, {trace, cache_timestamp}})
+        :ok
+    end
+  end
+
+  @doc """
+  Clears all caches.
+  """
+  @spec clear_all_caches() :: :ok
+  def clear_all_caches() do
+    try do
+      :ets.delete_all_objects(@ast_state_cache)
+    rescue
+      ArgumentError -> :ok  # Table doesn't exist, that's fine
+    end
+
+    try do
+      :ets.delete_all_objects(@execution_trace_cache)
+    rescue
+      ArgumentError -> :ok  # Table doesn't exist, that's fine
+    end
+
+    :ok
+  end
+
+  @doc """
+  Gets cache statistics.
+  """
+  @spec get_cache_stats() :: map()
+  def get_cache_stats() do
+    state_cache_size = try do
+      :ets.info(@ast_state_cache, :size) || 0
+    rescue
+      ArgumentError -> 0
+    end
+
+    trace_cache_size = try do
+      :ets.info(@execution_trace_cache, :size) || 0
+    rescue
+      ArgumentError -> 0
+    end
+
+    state_cache_memory = try do
+      :ets.info(@ast_state_cache, :memory) || 0
+    rescue
+      ArgumentError -> 0
+    end
+
+    trace_cache_memory = try do
+      :ets.info(@execution_trace_cache, :memory) || 0
+    rescue
+      ArgumentError -> 0
+    end
+
+    %{
+      state_cache_size: state_cache_size,
+      trace_cache_size: trace_cache_size,
+      state_cache_memory: state_cache_memory,
+      trace_cache_memory: trace_cache_memory
+    }
+  end
+end