997dd201c48cfc5a93ab9d8799c4f839ab1728ae

Committed 29 May 2025 07:59PM UTC coverage: 58.374% (-0.05%) from 58.426%

Build # 997dd201c48cfc5a93ab9d8799c4f839ab1728ae

Build Type

push

github

Committed by NSHkr

Commit Message

refactor performance_optimizer

Run Details

0 of 159 new or added lines in 6 files covered. (0.0%)

14 existing lines in 1 file now uncovered.

6082 of 10419 relevant lines covered (58.37%)

3184.09 hits per line

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

0.0

/lib/elixir_scope/ast_repository/performance_optimizer/cache_manager.ex

# ==============================================================================
# Cache Management Component
# ==============================================================================

defmodule ElixirScope.ASTRepository.PerformanceOptimizer.CacheManager do
  @moduledoc """
  Manages intelligent caching with TTL and LRU eviction policies.
  """

  use GenServer
  require Logger

  alias ElixirScope.ASTRepository.{MemoryManager, EnhancedRepository}

  @module_cache_prefix "module:"
  @function_cache_prefix "function:"
  @query_cache_prefix "query:"
  @cache_warming_interval 300_000  # 5 minutes

  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end

  def init(_opts) do
    schedule_cache_warming()
    {:ok, %{}}
  end

  @doc """
  Retrieves module with intelligent caching.
  """
  @spec get_module_cached(atom()) :: {:ok, term()} | {:error, term()}
  def get_module_cached(module_name) do
    cache_key = @module_cache_prefix <> to_string(module_name)

    case MemoryManager.cache_get(:query, cache_key) do
      {:ok, cached_data} ->
        track_access(module_name, :cache_hit)
        {:ok, cached_data}

      :miss ->
        case EnhancedRepository.get_enhanced_module(module_name) do
          {:ok, module_data} ->
            MemoryManager.cache_put(:query, cache_key, module_data)
            track_access(module_name, :cache_miss)
            {:ok, module_data}

          error ->
            error
        end
    end
  end

  @doc """
  Performs optimized analysis queries with result caching.
  """
  @spec query_with_cache(atom(), map()) :: {:ok, term()} | {:error, term()}
  def query_with_cache(query_type, params) do
    cache_key = generate_query_cache_key(query_type, params)

    case MemoryManager.cache_get(:query, cache_key) do
      {:ok, cached_result} ->
        {:ok, cached_result}

      :miss ->
        case EnhancedRepository.query_analysis(query_type, params) do
          {:ok, query_result} ->
            MemoryManager.cache_put(:query, cache_key, query_result)
            {:ok, query_result}

          error ->
            error
        end
    end
  end

  @doc """
  Warms up caches with frequently accessed data.
  """
  @spec warm_caches() :: :ok
  def warm_caches() do
    GenServer.cast(__MODULE__, :warm_caches)
  end

  def handle_cast(:warm_caches, state) do
    perform_cache_warming()
    {:noreply, state}
  end

  def handle_info(:cache_warming, state) do
    perform_cache_warming()
    schedule_cache_warming()
    {:noreply, state}
  end

  # Private implementation
  defp perform_cache_warming() do
    Logger.debug("Performing cache warming")

    frequently_accessed_modules = get_frequently_accessed_modules()

    Enum.each(frequently_accessed_modules, fn module_name ->
      cache_key = @module_cache_prefix <> to_string(module_name)

      case MemoryManager.cache_get(:query, cache_key) do
        :miss ->
          case EnhancedRepository.get_enhanced_module(module_name) do
            {:ok, module_data} ->
              MemoryManager.cache_put(:query, cache_key, module_data)
            _ ->
              :ok
          end
        _ ->
          :ok
      end
    end)
  end

  defp track_access(identifier, access_type) do
    current_time = System.monotonic_time(:second)

    case :ets.lookup(:ast_repo_access_tracking, identifier) do
      [{^identifier, _last_access, access_count}] ->
        new_count = if access_type == :cache_hit, do: access_count + 1, else: access_count
        :ets.insert(:ast_repo_access_tracking, {identifier, current_time, new_count})

      [] ->
        :ets.insert(:ast_repo_access_tracking, {identifier, current_time, 1})
    end
  end

  defp generate_query_cache_key(query_type, params) do
    param_hash = :crypto.hash(:md5, :erlang.term_to_binary(params))
    |> Base.encode16(case: :lower)

    @query_cache_prefix <> "#{query_type}:#{param_hash}"
  end

  defp get_frequently_accessed_modules() do
    :ets.tab2list(:ast_repo_access_tracking)
    |> Enum.filter(fn {identifier, _time, count} ->
      is_atom(identifier) and count > 10
    end)
    |> Enum.map(fn {module, _time, _count} -> module end)
    |> Enum.take(20)
  end

  defp schedule_cache_warming() do
    Process.send_after(self(), :cache_warming, @cache_warming_interval)
  end
end

1	# ==============================================================================
2	# Cache Management Component
3	# ==============================================================================
4
5	defmodule ElixirScope.ASTRepository.PerformanceOptimizer.CacheManager do
6	@moduledoc """
7	Manages intelligent caching with TTL and LRU eviction policies.
8	"""
9
10	use GenServer
11	require Logger
12
13	alias ElixirScope.ASTRepository.{MemoryManager, EnhancedRepository}
14
15	@module_cache_prefix "module:"
16	@function_cache_prefix "function:"
17	@query_cache_prefix "query:"
18	@cache_warming_interval 300_000 # 5 minutes
19
20	def start_link(opts \\ []) do
NEW 21	GenServer.start_link(__MODULE__, opts, name: __MODULE__)	×
22	end
23
24	def init(_opts) do
NEW 25	schedule_cache_warming()	×
26	{:ok, %{}}
27	end
28
29	@doc """
30	Retrieves module with intelligent caching.
31	"""
32	@spec get_module_cached(atom()) :: {:ok, term()} \| {:error, term()}
33	def get_module_cached(module_name) do
NEW 34	cache_key = @module_cache_prefix <> to_string(module_name)	×
35
NEW 36	case MemoryManager.cache_get(:query, cache_key) do	×
37	{:ok, cached_data} ->
NEW 38	track_access(module_name, :cache_hit)	×
39	{:ok, cached_data}
40
41	:miss ->
NEW 42	case EnhancedRepository.get_enhanced_module(module_name) do	×
43	{:ok, module_data} ->
NEW 44	MemoryManager.cache_put(:query, cache_key, module_data)	×
NEW 45	track_access(module_name, :cache_miss)	×
46	{:ok, module_data}
47
48	error ->
NEW 49	error	×
50	end
51	end
52	end
53
54	@doc """
55	Performs optimized analysis queries with result caching.
56	"""
57	@spec query_with_cache(atom(), map()) :: {:ok, term()} \| {:error, term()}
58	def query_with_cache(query_type, params) do
NEW 59	cache_key = generate_query_cache_key(query_type, params)	×
60
NEW 61	case MemoryManager.cache_get(:query, cache_key) do	×
NEW 62	{:ok, cached_result} ->	×
63	{:ok, cached_result}
64
65	:miss ->
NEW 66	case EnhancedRepository.query_analysis(query_type, params) do	×
67	{:ok, query_result} ->
NEW 68	MemoryManager.cache_put(:query, cache_key, query_result)	×
69	{:ok, query_result}
70
71	error ->
NEW 72	error	×
73	end
74	end
75	end
76
77	@doc """
78	Warms up caches with frequently accessed data.
79	"""
80	@spec warm_caches() :: :ok
81	def warm_caches() do
NEW 82	GenServer.cast(__MODULE__, :warm_caches)	×
83	end
84
85	def handle_cast(:warm_caches, state) do
NEW 86	perform_cache_warming()	×
87	{:noreply, state}
88	end
89
90	def handle_info(:cache_warming, state) do
NEW 91	perform_cache_warming()	×
NEW 92	schedule_cache_warming()	×
93	{:noreply, state}
94	end
95
96	# Private implementation
97	defp perform_cache_warming() do
NEW 98	Logger.debug("Performing cache warming")	×
99
NEW 100	frequently_accessed_modules = get_frequently_accessed_modules()	×
101
NEW 102	Enum.each(frequently_accessed_modules, fn module_name ->	×
NEW 103	cache_key = @module_cache_prefix <> to_string(module_name)	×
104
NEW 105	case MemoryManager.cache_get(:query, cache_key) do	×
106	:miss ->
NEW 107	case EnhancedRepository.get_enhanced_module(module_name) do	×
108	{:ok, module_data} ->
NEW 109	MemoryManager.cache_put(:query, cache_key, module_data)	×
NEW 110	_ ->	×
111	:ok
112	end
NEW 113	_ ->	×
114	:ok
115	end
116	end)
117	end
118
119	defp track_access(identifier, access_type) do
NEW 120	current_time = System.monotonic_time(:second)	×
121
NEW 122	case :ets.lookup(:ast_repo_access_tracking, identifier) do	×
123	[{^identifier, _last_access, access_count}] ->
NEW 124	new_count = if access_type == :cache_hit, do: access_count + 1, else: access_count	×
NEW 125	:ets.insert(:ast_repo_access_tracking, {identifier, current_time, new_count})	×
126
127	[] ->
NEW 128	:ets.insert(:ast_repo_access_tracking, {identifier, current_time, 1})	×
129	end
130	end
131
132	defp generate_query_cache_key(query_type, params) do
NEW 133	param_hash = :crypto.hash(:md5, :erlang.term_to_binary(params))	×
134	\|> Base.encode16(case: :lower)
135
NEW 136	@query_cache_prefix <> "#{query_type}:#{param_hash}"	×
137	end
138
139	defp get_frequently_accessed_modules() do
140	:ets.tab2list(:ast_repo_access_tracking)
141	\|> Enum.filter(fn {identifier, _time, count} ->
NEW 142	is_atom(identifier) and count > 10	×
143	end)
NEW 144	\|> Enum.map(fn {module, _time, _count} -> module end)	×
NEW 145	\|> Enum.take(20)	×
146	end
147
148	defp schedule_cache_warming() do
NEW 149	Process.send_after(self(), :cache_warming, @cache_warming_interval)	×
150	end
151	end

nshkrdotcom / ElixirScope / 997dd201c48cfc5a93ab9d8799c4f839ab1728ae

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