Merge pull request #364 from getsentry/more-typespecs

before_send_event filter

Author: mitchellhenke

lib/sentry.ex

@@ -117,9 +117,9 @@ defmodule Sentry do
   @spec capture_exception(Exception.t() | atom() | {atom(), atom()}, Keyword.t()) :: send_result
   def capture_exception(exception, opts \\ []) do
     filter_module = Config.filter()
-    {source, opts} = Keyword.pop(opts, :event_source)
+    event_source = Keyword.get(opts, :event_source)
 
-    if filter_module.exclude_exception?(exception, source) do
+    if filter_module.exclude_exception?(exception, event_source) do
       :excluded
     else
       exception

lib/sentry/client.ex

@@ -40,8 +40,10 @@ defmodule Sentry.Client do
 
   require Logger
 
-  @type send_event_result :: {:ok, Task.t() | String.t() | pid()} | :error | :unsampled
+  @type send_event_result ::
+          {:ok, Task.t() | String.t() | pid()} | :error | :unsampled | :excluded
   @type dsn :: {String.t(), String.t(), String.t()} | :error
+  @type result :: :sync | :none | :async
   @sentry_version 5
   @max_attempts 4
   @hackney_pool_name :sentry_pool
@@ -66,13 +68,19 @@ defmodule Sentry.Client do
 
     event = maybe_call_before_send_event(event)
 
-    if sample_event?(sample_rate) do
-      encode_and_send(event, result)
-    else
-      :unsampled
+    case {event, sample_event?(sample_rate)} do
+      {false, _} ->
+        :excluded
+
+      {%Event{}, false} ->
+        :unsampled
+
+      {%Event{}, true} ->
+        encode_and_send(event, result)
     end
   end
 
+  @spec encode_and_send(Event.t(), result()) :: send_event_result()
   defp encode_and_send(event, result) do
     json_library = Config.json_library()
 
@@ -88,6 +96,7 @@ defmodule Sentry.Client do
     end
   end
 
+  @spec do_send_event(Event.t(), map(), :async) :: {:ok, Task.t()} | :error
   defp do_send_event(event, body, :async) do
     case get_headers_and_endpoint() do
       {endpoint, auth_headers} ->
@@ -102,6 +111,7 @@ defmodule Sentry.Client do
     end
   end
 
+  @spec do_send_event(Event.t(), map(), :sync) :: {:ok, String.t()} | :error
   defp do_send_event(event, body, :sync) do
     case get_headers_and_endpoint() do
       {endpoint, auth_headers} ->
@@ -113,6 +123,8 @@ defmodule Sentry.Client do
     end
   end
 
+  @spec do_send_event(Event.t(), map(), :none) ::
+          {:ok, DynamicSupervisor.on_start_child()} | :error
   defp do_send_event(event, body, :none) do
     case get_headers_and_endpoint() do
       {endpoint, auth_headers} ->
@@ -128,6 +140,12 @@ defmodule Sentry.Client do
     end
   end
 
+  @spec try_request(
+          String.t(),
+          list({String.t(), String.t()}),
+          {Event.t(), String.t()},
+          pos_integer()
+        ) :: {:ok, String.t()} | :error
   defp try_request(url, headers, event_body_tuple, current_attempt \\ 1)
 
   defp try_request(_, _, _, current_attempt)
@@ -206,6 +224,7 @@ defmodule Sentry.Client do
     "Sentry " <> query
   end
 
+  @spec authorization_headers(String.t(), String.t()) :: list({String.t(), String.t()})
   defp authorization_headers(public_key, secret_key) do
     [
       {"User-Agent", @sentry_client},
@@ -257,14 +276,14 @@ defmodule Sentry.Client do
     result
   end
 
-  @spec maybe_call_before_send_event(Event.t()) :: Event.t()
+  @spec maybe_call_before_send_event(Event.t()) :: Event.t() | false
   def maybe_call_before_send_event(event) do
     case Config.before_send_event() do
       function when is_function(function, 1) ->
-        function.(event)
+        function.(event) || false
 
       {module, function} ->
-        apply(module, function, [event])
+        apply(module, function, [event]) || false
 
       nil ->
         event
@@ -345,11 +364,13 @@ defmodule Sentry.Client do
     )
   end
 
+  @spec sleep(pos_integer()) :: :ok
   defp sleep(1), do: :timer.sleep(2000)
   defp sleep(2), do: :timer.sleep(4000)
   defp sleep(3), do: :timer.sleep(8000)
   defp sleep(_), do: :timer.sleep(8000)
 
+  @spec sample_event?(number()) :: boolean()
   defp sample_event?(1), do: true
   defp sample_event?(1.0), do: true
   defp sample_event?(0), do: false

lib/sentry/event.ex

@@ -20,6 +20,7 @@ defmodule Sentry.Event do
             server_name: nil,
             environment: nil,
             exception: nil,
+            original_exception: nil,
             release: nil,
             stacktrace: %{
               frames: []
@@ -29,9 +30,34 @@ defmodule Sentry.Event do
             user: %{},
             breadcrumbs: [],
             fingerprint: [],
-            modules: %{}
-
-  @type t :: %__MODULE__{}
+            modules: %{},
+            event_source: nil
+
+  @type sentry_exception :: %{type: String.t(), value: String.t(), module: any()}
+  @type t :: %__MODULE__{
+          event_id: String.t() | nil,
+          culprit: String.t() | nil,
+          timestamp: String.t() | nil,
+          message: String.t() | nil,
+          tags: map(),
+          level: String.t(),
+          platform: String.t(),
+          server_name: any(),
+          environment: any(),
+          exception: [sentry_exception()],
+          original_exception: Exception.t() | nil,
+          release: any(),
+          stacktrace: %{
+            frames: [map()]
+          },
+          request: map(),
+          extra: map(),
+          user: map(),
+          breadcrumbs: list(),
+          fingerprint: list(),
+          modules: map(),
+          event_source: any()
+        }
 
   alias Sentry.{Config, Event, Util}
   @source_code_context_enabled Config.enable_source_code_context()
@@ -47,14 +73,16 @@ defmodule Sentry.Event do
   @doc """
   Creates an Event struct out of context collected and options
   ## Options
-    * `:exception` - expection
+    * `:exception` - Sentry-formatted exception
+    * `:original_exception` - Original exception
     * `:message` - message
     * `:stacktrace` - a list of Exception.stacktrace()
     * `:extra` - map of extra context
     * `:user` - map of user context
     * `:tags` - map of tags context
     * `:request` - map of request context
     * `:breadcrumbs` - list of breadcrumbs
+    * `:event_source` - the source of the event
     * `:level` - error level
     * `:fingerprint` -  list of the fingerprint for grouping this event
   """
@@ -69,9 +97,12 @@ defmodule Sentry.Event do
     } = Sentry.Context.get_all()
 
     exception = Keyword.get(opts, :exception)
+    original_exception = Keyword.get(opts, :original_exception)
 
     message = Keyword.get(opts, :message)
 
+    event_source = Keyword.get(opts, :event_source)
+
     stacktrace =
       Keyword.get(opts, :stacktrace, [])
       |> coerce_stacktrace()
@@ -113,6 +144,7 @@ defmodule Sentry.Event do
       environment: env,
       server_name: server_name,
       exception: exception,
+      original_exception: original_exception,
       stacktrace: %{
         frames: stacktrace_to_frames(stacktrace)
       },
@@ -123,7 +155,8 @@ defmodule Sentry.Event do
       breadcrumbs: breadcrumbs,
       request: request,
       fingerprint: fingerprint,
-      modules: Util.mix_deps_versions(@deps)
+      modules: Util.mix_deps_versions(@deps),
+      event_source: event_source
     }
     |> add_metadata()
   end
@@ -163,7 +196,7 @@ defmodule Sentry.Event do
       end
 
     module = Keyword.get(opts, :module)
-    exception = [%{type: type, value: value, module: module}]
+    transformed_exception = [%{type: type, value: value, module: module}]
 
     message =
       :error
@@ -172,8 +205,9 @@ defmodule Sentry.Event do
       |> String.trim()
 
     opts
-    |> Keyword.put(:exception, exception)
+    |> Keyword.put(:exception, transformed_exception)
     |> Keyword.put(:message, message)
+    |> Keyword.put(:original_exception, exception)
     |> create_event()
   end
 

test/client_test.exs

@@ -182,6 +182,23 @@ defmodule Sentry.ClientTest do
     end
   end
 
+  test "falsey before_send_event does not send event" do
+    modify_env(
+      :sentry,
+      before_send_event: {Sentry.BeforeSendEventTest, :before_send_event_ignore_arithmetic},
+      client: Sentry.Client
+    )
+
+    try do
+      :random.uniform() + "1"
+    rescue
+      e ->
+        capture_log(fn ->
+          assert Sentry.capture_exception(e, result: :sync) == :excluded
+        end)
+    end
+  end
+
   test "calls anonymous after_send_event synchronously" do
     bypass = Bypass.open()
 

test/support/test_before_send_event.exs

@@ -3,4 +3,14 @@ defmodule Sentry.BeforeSendEventTest do
     metadata = Map.new(Logger.metadata())
     %{event | extra: Map.merge(event.extra, metadata)}
   end
+
+  def before_send_event_ignore_arithmetic(event) do
+    case event.original_exception do
+      %ArithmeticError{} ->
+        false
+
+      _ ->
+        event
+    end
+  end
 end