allow custom table name through options

Author: dnsbty

lib/sentry/application.ex

@@ -33,6 +33,14 @@ defmodule Sentry.Application do
         []
       end
 
+    # Don't start RateLimiter in test environment - tests start their own instances
+    maybe_rate_limiter =
+      if Mix.env() == :test do
+        []
+      else
+        [Sentry.Transport.RateLimiter]
+      end
+
     children =
       [
         {Registry, keys: :unique, name: Sentry.Transport.SenderRegistry},
@@ -47,7 +55,8 @@ defmodule Sentry.Application do
       ] ++
         maybe_http_client_spec ++
         maybe_span_storage ++
-        [Sentry.Transport.RateLimiter, Sentry.Transport.SenderPool]
+        maybe_rate_limiter ++
+        [Sentry.Transport.SenderPool]
 
     cache_loaded_applications()
 

lib/sentry/transport/rate_limiter.ex

@@ -10,36 +10,45 @@ defmodule Sentry.Transport.RateLimiter do
 
   use GenServer
 
-  @table __MODULE__
-  @sweep_interval_ms 60_000
+  @default_sweep_interval_ms 60_000
+
+  defstruct [:table_name]
 
   ## Public API
 
   @doc """
   Starts the RateLimiter GenServer.
+
+  ## Options
+
+    * `:name` - The name to register the GenServer under. Defaults to `__MODULE__`.
+    * `:table_name` - The name for the ETS table. Defaults to `__MODULE__`.
+
   """
   @spec start_link(keyword()) :: GenServer.on_start()
   def start_link(opts \\ []) do
-    GenServer.start_link(__MODULE__, nil, name: Keyword.get(opts, :name, __MODULE__))
+    name = Keyword.get(opts, :name, __MODULE__)
+    GenServer.start_link(__MODULE__, opts, name: name)
   end
 
   ## GenServer Callbacks
 
   @impl true
-  def init(nil) do
-    _table = :ets.new(@table, [:named_table, :public, :set, read_concurrency: true])
+  def init(opts) do
+    table_name = Keyword.get(opts, :table_name, __MODULE__)
+    _table = :ets.new(table_name, [:named_table, :public, :set, read_concurrency: true])
     schedule_sweep()
-    {:ok, :no_state}
+    {:ok, %__MODULE__{table_name: table_name}}
   end
 
   @impl true
-  def handle_info(:sweep, state) do
+  def handle_info(:sweep, %__MODULE__{table_name: table_name} = state) do
     now = System.system_time(:second)
 
     # Match spec: select entries where expiry (position 2) < now
     match_spec = [{{:"$1", :"$2"}, [{:<, :"$2", now}], [true]}]
 
-    :ets.select_delete(@table, match_spec)
+    :ets.select_delete(table_name, match_spec)
 
     schedule_sweep()
     {:noreply, state}
@@ -53,6 +62,10 @@ defmodule Sentry.Transport.RateLimiter do
   Returns `true` if the category is rate-limited (either specifically or via
   a global rate limit), `false` otherwise.
 
+  ## Options
+
+    * `:table_name` - The ETS table name. Defaults to `__MODULE__`.
+
   ## Examples
 
       iex> RateLimiter.rate_limited?("error")
@@ -63,10 +76,11 @@ defmodule Sentry.Transport.RateLimiter do
       true
 
   """
-  @spec rate_limited?(String.t()) :: boolean()
-  def rate_limited?(category) do
+  @spec rate_limited?(String.t(), keyword()) :: boolean()
+  def rate_limited?(category, opts \\ []) do
+    table_name = Keyword.get(opts, :table_name, __MODULE__)
     now = System.system_time(:second)
-    check_rate_limited(category, now) or check_rate_limited(:global, now)
+    check_rate_limited(table_name, category, now) or check_rate_limited(table_name, :global, now)
   end
 
   @doc """
@@ -75,17 +89,23 @@ defmodule Sentry.Transport.RateLimiter do
   This is a fallback for when X-Sentry-Rate-Limits is not present.
   Stores a global rate limit (:global key) that affects all categories.
 
+  ## Options
+
+    * `:table_name` - The ETS table name. Defaults to `__MODULE__`.
+
   ## Examples
 
       iex> RateLimiter.update_global_rate_limit(60)
       :ok
 
   """
-  @spec update_global_rate_limit(pos_integer()) :: :ok
-  def update_global_rate_limit(retry_after_seconds) when is_integer(retry_after_seconds) do
+  @spec update_global_rate_limit(pos_integer(), keyword()) :: :ok
+  def update_global_rate_limit(retry_after_seconds, opts \\ [])
+      when is_integer(retry_after_seconds) do
+    table_name = Keyword.get(opts, :table_name, __MODULE__)
     now = System.system_time(:second)
     expiry = now + retry_after_seconds
-    :ets.insert(@table, {:global, expiry})
+    :ets.insert(table_name, {:global, expiry})
     :ok
   end
 
@@ -95,30 +115,35 @@ defmodule Sentry.Transport.RateLimiter do
   Parses the header value and stores expiry timestamps for each category.
   Returns `:ok` regardless of parsing success.
 
+  ## Options
+
+    * `:table_name` - The ETS table name. Defaults to `__MODULE__`.
+
   ## Examples
 
       iex> RateLimiter.update_rate_limits("60:error;transaction")
       :ok
 
   """
-  @spec update_rate_limits(String.t()) :: :ok
-  def update_rate_limits(rate_limits_header) do
+  @spec update_rate_limits(String.t(), keyword()) :: :ok
+  def update_rate_limits(rate_limits_header, opts \\ []) do
+    table_name = Keyword.get(opts, :table_name, __MODULE__)
     now = System.system_time(:second)
     rate_limits = parse_rate_limits_header(rate_limits_header)
 
     Enum.each(rate_limits, fn {category, retry_after_seconds} ->
       expiry = now + retry_after_seconds
-      :ets.insert(@table, {category, expiry})
+      :ets.insert(table_name, {category, expiry})
     end)
 
     :ok
   end
 
   ## Private Helpers
 
-  @spec check_rate_limited(String.t() | :global, integer()) :: boolean()
-  defp check_rate_limited(category, time) do
-    case :ets.lookup(@table, category) do
+  @spec check_rate_limited(atom(), String.t() | :global, integer()) :: boolean()
+  defp check_rate_limited(table_name, category, time) do
+    case :ets.lookup(table_name, category) do
       [{^category, expiry}] when expiry > time -> true
       _ -> false
     end
@@ -167,6 +192,6 @@ defmodule Sentry.Transport.RateLimiter do
 
   @spec schedule_sweep() :: reference()
   defp schedule_sweep do
-    Process.send_after(self(), :sweep, @sweep_interval_ms)
+    Process.send_after(self(), :sweep, @default_sweep_interval_ms)
   end
 end

test/sentry/test_test.exs

@@ -9,6 +9,9 @@ defmodule Sentry.TestTest do
   doctest Test
 
   setup do
+    # Start RateLimiter for tests that send events through Transport
+    start_supervised!(Sentry.Transport.RateLimiter)
+
     bypass = Bypass.open()
     put_test_config(dsn: "http://public:secret@localhost:#{bypass.port}/1", dedup_events: false)
     %{bypass: bypass}