Implement event deduplication (#650)

Author: whatyouhide

lib/sentry/application.ex

@@ -20,7 +20,7 @@ defmodule Sentry.Application do
       end
 
     children =
-      [{Registry, keys: :unique, name: Sentry.Transport.SenderRegistry}] ++
+      [{Registry, keys: :unique, name: Sentry.Transport.SenderRegistry}, Sentry.Dedupe] ++
         maybe_http_client_spec ++
         [Sentry.Transport.SenderPool]
 

lib/sentry/client.ex

@@ -5,7 +5,7 @@ defmodule Sentry.Client do
   # and sampling.
   # See https://develop.sentry.dev/sdk/unified-api/#client.
 
-  alias Sentry.{Config, Envelope, Event, Interfaces, Transport}
+  alias Sentry.{Config, Dedupe, Envelope, Event, Interfaces, Transport}
 
   require Logger
 
@@ -31,7 +31,8 @@ defmodule Sentry.Client do
 
     result =
       with {:ok, %Event{} = event} <- maybe_call_before_send(event, before_send),
-           :ok <- sample_event(sample_rate) do
+           :ok <- sample_event(sample_rate),
+           :ok <- maybe_dedupe(event) do
         send_result = encode_and_send(event, result_type, client, request_retries)
         _ignored = maybe_call_after_send(event, send_result, after_send_event)
         send_result
@@ -64,6 +65,21 @@ defmodule Sentry.Client do
     end
   end
 
+  defp maybe_dedupe(%Event{} = event) do
+    if Config.dedup_events?() do
+      case Dedupe.insert(event) do
+        :new ->
+          :ok
+
+        :existing ->
+          log("Event dropped due to being a duplicate of a previously-captured event.")
+          :excluded
+      end
+    else
+      :ok
+    end
+  end
+
   defp maybe_call_before_send(event, nil) do
     {:ok, event}
   end
@@ -228,9 +244,10 @@ defmodule Sentry.Client do
           nil
       end
 
-    if message do
-      level = Config.log_level()
-      Logger.log(level, fn -> ["Failed to send Sentry event. ", message] end, domain: [:sentry])
-    end
+    if message, do: log(fn -> ["Failed to send Sentry event. ", message] end)
+  end
+
+  defp log(message) do
+    Logger.log(Config.log_level(), message, domain: [:sentry])
   end
 end

lib/sentry/config.ex

@@ -129,6 +129,18 @@ defmodule Sentry.Config do
       behaviour. Defaults to `Sentry.DefaultEventFilter`. See the
       [*Filtering Exceptions* section](#module-filtering-exceptions) below.
       """
+    ],
+    dedup_events: [
+      type: :boolean,
+      default: true,
+      doc: """
+      Whether to **deduplicate** events before reporting them to Sentry. If this option is `true`,
+      then the SDK will store reported events for around 30 seconds after they're reported.
+      Any time the SDK is about to report an event, it will check if it has already reported
+      within the past 30 seconds. If it has, then it will not report the event again, and will
+      log a message instead. Events are deduplicated by comparing their message, exception,
+      stacktrace, and fingerprint. *Available since v10.0.0*.
+      """
     ]
   ]
 
@@ -443,6 +455,9 @@ defmodule Sentry.Config do
   @spec max_breadcrumbs() :: non_neg_integer()
   def max_breadcrumbs, do: fetch!(:max_breadcrumbs)
 
+  @spec dedup_events?() :: boolean()
+  def dedup_events?, do: fetch!(:dedup_events)
+
   @spec put_config(atom(), term()) :: :ok
   def put_config(key, value) when is_atom(key) do
     case NimbleOptions.validate([{key, value}], @opts_schema) do

lib/sentry/dedupe.ex

@@ -0,0 +1,54 @@
+defmodule Sentry.Dedupe do
+  @moduledoc false
+
+  use GenServer
+
+  alias Sentry.Event
+
+  @ets __MODULE__
+  @sweep_interval_millisec 10_000
+  @ttl_millisec 30_000
+
+  @spec start_link(keyword()) :: GenServer.on_start()
+  def start_link(opts) when is_list(opts) do
+    ttl_millisec = Keyword.get(opts, :ttl_millisec, @ttl_millisec)
+    GenServer.start_link(__MODULE__, ttl_millisec, name: __MODULE__)
+  end
+
+  @spec insert(Event.t()) :: :new | :existing
+  def insert(%Event{} = event) do
+    hash = Event.hash(event)
+    now = System.system_time(:millisecond)
+
+    cond do
+      _found? = :ets.update_element(@ets, hash, {_position = 2, now}) -> :existing
+      _inserted_new? = :ets.insert_new(@ets, {hash, now}) -> :new
+      true -> :existing
+    end
+  end
+
+  ## State
+  defstruct [:ttl_millisec]
+
+  ## Callbacks
+
+  @impl true
+  def init(ttl_millisec) do
+    _table = :ets.new(@ets, [:named_table, :public, :set])
+    Process.send_after(self(), :sweep, @sweep_interval_millisec)
+    {:ok, %__MODULE__{ttl_millisec: ttl_millisec}}
+  end
+
+  @impl true
+  def handle_info(:sweep, %__MODULE__{} = state) do
+    now = System.system_time(:millisecond)
+
+    # All rows (which are {hash, inserted_at}) with an inserted_at older than
+    # now - @ttl_millisec.
+    match_spec = [{{:"$1", :"$2"}, [], [{:<, :"$2", now - state.ttl_millisec}]}]
+    _ = :ets.select_delete(@ets, match_spec)
+
+    Process.send_after(self(), :sweep, @sweep_interval_millisec)
+    {:noreply, state}
+  end
+end

lib/sentry/event.ex

@@ -466,4 +466,16 @@ defmodule Sentry.Event do
       runtime: %{name: "elixir", version: System.build_info().build}
     }
   end
+
+  # Used to compare events for deduplication. See "Sentry.Dedupe".
+  @doc false
+  @spec hash(t()) :: non_neg_integer()
+  def hash(%__MODULE__{} = event) do
+    :erlang.phash2([
+      event.exception,
+      event.message,
+      event.level,
+      event.fingerprint
+    ])
+  end
 end

mix.exs

@@ -66,6 +66,7 @@ defmodule Sentry.Mixfile do
       mod: {Sentry.Application, []},
       extra_applications: [:logger],
       registered: [
+        Sentry.Dedupe,
         Sentry.Transport.SenderRegistry,
         Sentry.Supervisor
       ]

test/envelope_test.exs

@@ -2,6 +2,7 @@ defmodule Sentry.EnvelopeTest do
   use ExUnit.Case, async: false
 
   alias Sentry.{Envelope, Event, Interfaces}
+  alias Sentry.TestEnvironmentHelper
 
   describe "from_binary/1" do
     test "parses envelope with empty headers" do
@@ -132,6 +133,8 @@ defmodule Sentry.EnvelopeTest do
 
   describe "to_binary/1" do
     test "encodes an envelope" do
+      TestEnvironmentHelper.modify_env(:sentry, environment_name: "test")
+
       event = Event.create_event([])
       envelope = Envelope.new([event])
 

test/sentry/client_test.exs

@@ -59,24 +59,23 @@ defmodule Sentry.ClientTest do
     end
 
     test "respects the :sample_rate option", %{bypass: bypass} do
-      event = Event.create_event([])
-
       # Always sends with sample rate of 1.
       Bypass.expect_once(bypass, fn conn ->
         Plug.Conn.resp(conn, 200, ~s<{"id": "340"}>)
       end)
 
-      assert {:ok, "340"} = Client.send_event(event, sample_rate: 1.0)
+      assert {:ok, "340"} = Client.send_event(Event.create_event([]), sample_rate: 1.0)
 
       # Never sends with sample rate of 0.
-      assert :unsampled = Client.send_event(event, sample_rate: 0.0)
+      assert :unsampled = Client.send_event(Event.create_event([]), sample_rate: 0.0)
 
       # Either sends or doesn't with :sample_rate of 0.5.
       Bypass.expect(bypass, fn conn ->
         Plug.Conn.resp(conn, 200, ~s<{"id": "340"}>)
       end)
 
       for _ <- 1..10 do
+        event = Event.create_event(message: "Unique: #{System.unique_integer()}")
         result = Client.send_event(event, sample_rate: 0.5)
         assert match?({:ok, _}, result) or result == :unsampled
       end
@@ -276,5 +275,45 @@ defmodule Sentry.ClientTest do
       assert %Event{} = event
       assert event.message == "Something went wrong"
     end
+
+    test "dedupes events", %{bypass: bypass} do
+      {:current_stacktrace, stacktrace} = Process.info(self(), :current_stacktrace)
+
+      events = [
+        Event.create_event(message: "Dedupes by message")
+        |> Tuple.duplicate(2),
+        Event.create_event(exception: %RuntimeError{message: "Dedupes by exception"})
+        |> Tuple.duplicate(2),
+        Event.create_event(message: "Dedupes by message and stacktrace", stacktrace: stacktrace)
+        |> Tuple.duplicate(2),
+        {
+          Event.create_event(
+            message: "Same message but diff extra",
+            user: %{id: 1},
+            request: %{method: :GET}
+          ),
+          Event.create_event(
+            message: "Same message but diff extra",
+            user: %{id: 2},
+            request: %{method: :POST}
+          )
+        }
+      ]
+
+      for {event, dup_event} <- events do
+        Bypass.expect_once(bypass, fn conn ->
+          Plug.Conn.resp(conn, 200, ~s<{"id": "340"}>)
+        end)
+
+        assert {:ok, "340"} = Client.send_event(event, [])
+
+        log =
+          capture_log(fn ->
+            assert :excluded = Client.send_event(dup_event, [])
+          end)
+
+        assert log =~ "Event dropped due to being a duplicate of a previously-captured event."
+      end
+    end
   end
 end

test/sentry/dedupe_test.exs

@@ -0,0 +1,48 @@
+defmodule Sentry.DedupeTest do
+  # This is not async because it tests a singleton (the dedupe GenServer).
+  use ExUnit.Case, async: false
+
+  alias Sentry.Dedupe
+  alias Sentry.Event
+
+  @ttl_millisec 25
+
+  describe "insert/1" do
+    test "works correctly" do
+      stop_application()
+      start_supervised({Dedupe, ttl_millisec: @ttl_millisec})
+
+      event = %Event{
+        message: "Something went wrong",
+        timestamp: System.system_time(:millisecond),
+        event_id: Sentry.UUID.uuid4_hex()
+      }
+
+      # First time, it's :new.
+      assert Dedupe.insert(event) == :new
+
+      # Then, it's :existing.
+      assert Dedupe.insert(event) == :existing
+      assert Dedupe.insert(event) == :existing
+
+      # Now, we trigger a sweep after waiting for the TTL interval.
+      # To ensure the :sweep message is processed, we use the trick
+      # of asking the GenServer for its state (which is a sync call).
+      Process.sleep(@ttl_millisec * 2)
+      send(Dedupe, :sweep)
+      _ = :sys.get_state(Dedupe)
+
+      # Now, it's :new again.
+      assert Dedupe.insert(event) == :new
+      assert Dedupe.insert(event) == :existing
+    end
+  end
+
+  defp stop_application do
+    for {{:sentry_config, _} = key, _val} <- :persistent_term.get() do
+      :persistent_term.erase(key)
+    end
+
+    ExUnit.CaptureLog.capture_log(fn -> Application.stop(:sentry) end)
+  end
+end