From 6019ebe14681497d2f64f693df423cf5f2201d4f Mon Sep 17 00:00:00 2001 From: Adam Rutkowski Date: Tue, 12 Mar 2024 20:06:32 +0100 Subject: [PATCH] Ensure hit rate is tracked on `get_or_store` --- lib/plausible/cache/adapter.ex | 45 ++++++++++++++---- lib/plausible/cache/stats.ex | 74 ++++++++++++++++------------- mix.exs | 4 +- test/plausible/cache/stats_test.exs | 39 +++++++-------- test/plausible/cache_test.exs | 17 ++++++- 5 files changed, 115 insertions(+), 64 deletions(-) diff --git a/lib/plausible/cache/adapter.ex b/lib/plausible/cache/adapter.ex index a4a4a8aeb..76a7e95b9 100644 --- a/lib/plausible/cache/adapter.ex +++ b/lib/plausible/cache/adapter.ex @@ -36,9 +36,9 @@ defmodule Plausible.Cache.Adapter do @spec get(atom(), any()) :: any() def get(cache_name, key) do - cache_name - |> ConCache.get(key) - |> Plausible.Cache.Stats.track(cache_name) + result = ConCache.get(cache_name, key) + if is_nil(result), do: miss(cache_name), else: hit(cache_name) + result catch :exit, _ -> Logger.error("Error retrieving key from '#{inspect(cache_name)}'") @@ -47,11 +47,16 @@ defmodule Plausible.Cache.Adapter do @spec get(atom(), any(), (-> any())) :: any() def get(cache_name, key, fallback_fn) do - cache_name - |> ConCache.get_or_store(key, fn -> - {:from_fallback, fallback_fn.()} - end) - |> Plausible.Cache.Stats.track(cache_name) + cache = ConCache.Owner.cache(cache_name) + + case ConCache.Operations.get(cache, key) do + nil -> + get_or_store_isolated(cache, cache_name, key, fallback_fn) + + value -> + hit(cache_name) + value + end catch :exit, _ -> Logger.error("Error retrieving key from '#{inspect(cache_name)}'") @@ -104,4 +109,28 @@ defmodule Plausible.Cache.Adapter do Logger.error("Error retrieving key from '#{inspect(cache_name)}'") [] end + + defp hit(cache_name) do + Plausible.Cache.Stats.record_hit(cache_name) + end + + defp miss(cache_name) do + Plausible.Cache.Stats.record_miss(cache_name) + end + + defp get_or_store_isolated(cache, cache_name, key, fun) do + ConCache.isolated(cache_name, key, fn -> + case ConCache.Operations.get(cache, key) do + nil -> + new_value = fun.() + ConCache.Operations.dirty_put(cache, key, new_value) + miss(cache_name) + new_value + + existing -> + hit(cache_name) + existing + end + end) + end end diff --git a/lib/plausible/cache/stats.ex b/lib/plausible/cache/stats.ex index b1b240eb4..00f31ddcc 100644 --- a/lib/plausible/cache/stats.ex +++ b/lib/plausible/cache/stats.ex @@ -5,15 +5,27 @@ defmodule Plausible.Cache.Stats do use GenServer - def start_link(opts) do - GenServer.start_link(__MODULE__, opts) + @hit :hit + @miss :miss + @telemetry_hit [:plausible, :cache, :adapter, @hit] + @telemetry_miss [:plausible, :cache, :adapter, @miss] + @telemetry_events [@telemetry_hit, @telemetry_miss] + + def start_link(_opts) do + GenServer.start_link(__MODULE__, nil) end - def init(opts) do - table = Keyword.get(opts, :table, __MODULE__) + def record_hit(cache_name) do + :telemetry.execute(@telemetry_hit, %{}, %{cache_name: cache_name}) + end - ^table = - :ets.new(table, [ + def record_miss(cache_name) do + :telemetry.execute(@telemetry_miss, %{}, %{cache_name: cache_name}) + end + + def init(nil) do + __MODULE__ = + :ets.new(__MODULE__, [ :public, :named_table, :ordered_set, @@ -21,48 +33,46 @@ defmodule Plausible.Cache.Stats do write_concurrency: true ]) - {:ok, table} + :telemetry.attach_many( + "plausible-cache-stats", + @telemetry_events, + &__MODULE__.handle_telemetry_event/4, + nil + ) + + {:ok, nil} + end + + def handle_telemetry_event(@telemetry_hit, _measurments, %{cache_name: cache_name}, _) do + bump(cache_name, @hit) end - def gather(cache_name, table \\ __MODULE__) do + def handle_telemetry_event(@telemetry_miss, _measurments, %{cache_name: cache_name}, _) do + bump(cache_name, @miss) + end + + def gather(cache_name) do {:ok, %{ - hit_rate: hit_rate(cache_name, table), + hit_rate: hit_rate(cache_name), count: size(cache_name) || 0 }} end defdelegate size(cache_name), to: Plausible.Cache.Adapter - def track(item, cache_name, table \\ __MODULE__) - - def track({:from_fallback, item}, cache_name, table) do - bump(cache_name, :miss, 1, table) - item - end - - def track(nil, cache_name, table) do - bump(cache_name, :miss, 1, table) - nil - end - - def track(item, cache_name, table) do - bump(cache_name, :hit, 1, table) - item - end - - def bump(cache_name, type, increment, table \\ __MODULE__) do + def bump(cache_name, type) do :ets.update_counter( - table, + __MODULE__, {cache_name, type}, - increment, + 1, {{cache_name, type}, 0} ) end - def hit_rate(cache_name, table \\ __MODULE__) do - hit = :ets.lookup_element(table, {cache_name, :hit}, 2, 0) - miss = :ets.lookup_element(table, {cache_name, :miss}, 2, 0) + def hit_rate(cache_name) do + hit = :ets.lookup_element(__MODULE__, {cache_name, @hit}, 2, 0) + miss = :ets.lookup_element(__MODULE__, {cache_name, @miss}, 2, 0) hit_miss = hit + miss if hit_miss == 0 do diff --git a/mix.exs b/mix.exs index 5d3e1fee2..b35c4d127 100644 --- a/mix.exs +++ b/mix.exs @@ -40,7 +40,9 @@ defmodule Plausible.MixProject do :logger, :runtime_tools, :tls_certificate_check, - :opentelemetry_exporter + :opentelemetry_exporter, + :wx, + :observer ] ] end diff --git a/test/plausible/cache/stats_test.exs b/test/plausible/cache/stats_test.exs index 557ab6f48..c01bf3627 100644 --- a/test/plausible/cache/stats_test.exs +++ b/test/plausible/cache/stats_test.exs @@ -8,43 +8,38 @@ defmodule Plausible.Cache.StatsTest do end test "when cache is started, stats are 0", %{test: test} do - {:ok, _} = Stats.start_link(name: test, table: test) - assert {:ok, %{hit_rate: +0.0, count: 0}} = Stats.gather(test, test) + assert {:ok, %{hit_rate: +0.0, count: 0}} = Stats.gather(test) end test "tracking changes hit ratio", %{test: test} do - {:ok, _} = Stats.start_link(name: test, table: test) + Stats.record_miss(test) + assert {:ok, %{hit_rate: +0.0, count: 0}} = Stats.gather(test) - Stats.track(nil, test, test) - assert {:ok, %{hit_rate: +0.0, count: 0}} = Stats.gather(test, test) + Stats.record_hit(test) + assert {:ok, %{hit_rate: 50.0, count: 0}} = Stats.gather(test) - Stats.track(:not_nil, test, test) - assert {:ok, %{hit_rate: 50.0, count: 0}} = Stats.gather(test, test) + Stats.record_hit(test) + Stats.record_hit(test) + assert {:ok, %{hit_rate: 75.0, count: 0}} = Stats.gather(test) - Stats.track(:not_nil, test, test) - Stats.track(:not_nil, test, test) - assert {:ok, %{hit_rate: 75.0, count: 0}} = Stats.gather(test, test) - - Stats.track(nil, test, test) - Stats.track(nil, test, test) - assert {:ok, %{hit_rate: 50.0, count: 0}} = Stats.gather(test, test) + Stats.record_miss(test) + Stats.record_miss(test) + assert {:ok, %{hit_rate: 50.0, count: 0}} = Stats.gather(test) end - test "bump by custom number", %{test: test} do - {:ok, _} = Stats.start_link(name: test, table: test) - Stats.bump(test, :miss, 10, test) - assert {:ok, %{hit_rate: +0.0, count: 0}} = Stats.gather(test, test) - Stats.bump(test, :hit, 90, test) - assert {:ok, %{hit_rate: 90.0, count: 0}} = Stats.gather(test, test) + test "hit ratio goes up to 100", %{test: test} do + Stats.record_hit(test) + Stats.record_hit(test) + Stats.record_hit(test) + assert {:ok, %{hit_rate: 100.0, count: 0}} = Stats.gather(test) end test "count comes from cache adapter", %{test: test} do - {:ok, _} = Stats.start_link(name: test, table: test) %{start: {m, f, a}} = Plausible.Cache.Adapter.child_spec(test, test) {:ok, _} = apply(m, f, a) Plausible.Cache.Adapter.put(test, :key, :value) assert Stats.size(test) == 1 - assert {:ok, %{hit_rate: +0.0, count: 1}} = Stats.gather(test, test) + assert {:ok, %{hit_rate: +0.0, count: 1}} = Stats.gather(test) end end diff --git a/test/plausible/cache_test.exs b/test/plausible/cache_test.exs index 2190f09c8..24580261a 100644 --- a/test/plausible/cache_test.exs +++ b/test/plausible/cache_test.exs @@ -74,13 +74,28 @@ defmodule Plausible.CacheTest do :ok = ExampleCache.merge_items([{"item1", :item1}], cache_name: test) assert ExampleCache.get("item1", cache_name: test, force?: true) + # first read of item2 is evaluated from a function and stored assert "value" == ExampleCache.get_or_store("item2", fn -> "value" end, cache_name: test, force?: true ) - assert {:ok, %{hit_rate: 50.0}} = Plausible.Cache.Stats.gather(test) + # subsequent gets are read from cache and the function is disregarded + assert "value" == + ExampleCache.get_or_store("item2", fn -> "disregard" end, + cache_name: test, + force?: true + ) + + assert "value" == + ExampleCache.get_or_store("item2", fn -> "disregard" end, + cache_name: test, + force?: true + ) + + # 3 hits, 1 miss + assert {:ok, %{hit_rate: 75.0}} = Plausible.Cache.Stats.gather(test) end end