Ensure hit rate is tracked on `get_or_store`

reapply-cache-change2
Adam Rutkowski 3 years ago
parent 317cb8aa85
commit 6019ebe146

@ -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

@ -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

@ -40,7 +40,9 @@ defmodule Plausible.MixProject do
:logger,
:runtime_tools,
:tls_certificate_check,
:opentelemetry_exporter
:opentelemetry_exporter,
:wx,
:observer
]
]
end

@ -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

@ -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

Loading…
Cancel
Save