Sentry.capture_exception only accepts Exception.t()

Author: mitchellhenke

CHANGELOG.md

@@ -18,6 +18,7 @@
   * Remove Sentry.Plug and Sentry.Phoenix.Endpoint in favor of Sentry.PlugContext and Sentry.PlugCapture (#402)
   * Remove feedback form rendering and configuration (#402)
   * Logger metadata is now specified by key in LoggerBackend instead of enabled/disabled
+  * `Sentry.capture_exception/1` now only accepts exceptions
 
 ## 7.2.4 (2020-03-09)
 

lib/sentry.ex

@@ -112,7 +112,7 @@ defmodule Sentry do
   Parses and submits an exception to Sentry if current environment is in included_environments.
   `opts` argument is passed as the second argument to `Sentry.send_event/2`.
   """
-  @spec capture_exception(Exception.t() | atom() | {atom(), atom()}, Keyword.t()) :: send_result
+  @spec capture_exception(Exception.t(), Keyword.t()) :: send_result
   def capture_exception(exception, opts \\ []) do
     filter_module = Config.filter()
     event_source = Keyword.get(opts, :event_source)

lib/sentry/event.ex

@@ -73,8 +73,8 @@ defmodule Sentry.Event do
   @doc """
   Creates an Event struct out of context collected and options
   ## Options
-    * `:exception` - Sentry-formatted exception
-    * `:original_exception` - Original exception
+    * `:exception` - Sentry-structured exception
+    * `:original_exception` - Original Elixir exception struct
     * `:message` - message
     * `:stacktrace` - a list of Exception.stacktrace()
     * `:extra` - map of extra context
@@ -175,34 +175,18 @@ defmodule Sentry.Event do
 
   """
   @spec transform_exception(Exception.t(), keyword()) :: Event.t()
-  def transform_exception(exception, opts) do
-    error_type = Keyword.get(opts, :error_type) || :error
-    normalized = Exception.normalize(:error, exception, Keyword.get(opts, :stacktrace, nil))
-
+  def transform_exception(%_{} = exception, opts) do
     type =
-      if error_type == :error do
-        normalized.__struct__
-        |> to_string()
-        |> String.trim_leading("Elixir.")
-      else
-        error_type
-      end
+      exception.__struct__
+      |> to_string()
+      |> String.trim_leading("Elixir.")
 
-    value =
-      if error_type == :error do
-        Exception.message(normalized)
-      else
-        Exception.format_banner(error_type, exception)
-      end
+    value = Exception.message(exception)
 
     module = Keyword.get(opts, :module)
     transformed_exception = [%{type: type, value: value, module: module}]
 
-    message =
-      :error
-      |> Exception.format_banner(normalized)
-      |> String.trim("*")
-      |> String.trim()
+    message = "(#{type} #{value})"
 
     opts
     |> Keyword.put(:exception, transformed_exception)

test/event_test.exs

@@ -32,7 +32,7 @@ defmodule Sentry.EventTest do
     assert event.level == "error"
 
     assert event.message ==
-             "(UndefinedFunctionError) function Sentry.Event.not_a_function/3 is undefined or private"
+             "(UndefinedFunctionError function Sentry.Event.not_a_function/3 is undefined or private)"
 
     assert is_binary(event.server_name)
 

test/logger_backend_test.exs

@@ -49,7 +49,7 @@ defmodule Sentry.LoggerBackendTest do
       json = Jason.decode!(body)
 
       assert List.first(json["exception"])["value"] ==
-               ~s[Erlang error: {:bad_return_value, "I am throwing"}]
+               ~s[** (exit) bad return value: "I am throwing"]
 
       assert conn.request_path == "/api/1/store/"
       assert conn.method == "POST"
@@ -75,8 +75,8 @@ defmodule Sentry.LoggerBackendTest do
     Bypass.expect(bypass, fn conn ->
       {:ok, body, conn} = Plug.Conn.read_body(conn)
       json = Jason.decode!(body)
-      assert List.first(json["exception"])["type"] == "ErlangError"
-      assert List.first(json["exception"])["value"] == "Erlang error: :bad_exit"
+      assert List.first(json["exception"])["type"] == "Sentry.CrashError"
+      assert List.first(json["exception"])["value"] == "** (exit) :bad_exit"
       assert conn.request_path == "/api/1/store/"
       assert conn.method == "POST"
       send(self_pid, "API called")
@@ -166,11 +166,9 @@ defmodule Sentry.LoggerBackendTest do
       {:ok, body, conn} = Plug.Conn.read_body(conn)
       json = Jason.decode!(body)
 
-      exception_value =
-        List.first(json["exception"])
-        |> Map.fetch!("value")
-
-      assert String.contains?(exception_value, "{:timeout, {GenServer, :call")
+      assert List.first(json["exception"])["type"] == "Sentry.CrashError"
+      assert List.first(json["exception"])["value"] =~ "** (EXIT) time out"
+      assert List.first(json["exception"])["value"] =~ "GenServer\.call"
 
       assert conn.request_path == "/api/1/store/"
       assert conn.method == "POST"

test/plug_capture_test.exs

@@ -100,7 +100,7 @@ defmodule Sentry.PlugCaptureTest do
       {:ok, body, conn} = Plug.Conn.read_body(conn)
       json = Jason.decode!(body)
       assert json["culprit"] == "Sentry.PlugCaptureTest.PhoenixController.error/2"
-      assert json["message"] == "(RuntimeError) PhoenixError"
+      assert json["message"] == "(RuntimeError PhoenixError)"
       Plug.Conn.resp(conn, 200, ~s<{"id": "340"}>)
     end)
 

test/sentry_test.exs

@@ -61,37 +61,6 @@ defmodule SentryTest do
     Bypass.pass(bypass)
   end
 
-  test "handles three element tuple as stacktrace" do
-    bypass = Bypass.open()
-
-    Bypass.expect(bypass, fn conn ->
-      assert conn.request_path == "/api/1/store/"
-      assert conn.method == "POST"
-      {:ok, body, conn} = Plug.Conn.read_body(conn)
-      {:ok, json} = Jason.decode(body)
-      assert json["culprit"] == "GenServer.call/3"
-      assert List.first(json["exception"])["value"] == "Erlang error: :timeout"
-      Plug.Conn.send_resp(conn, 200, ~s<{"id": "340"}>)
-    end)
-
-    modify_env(
-      :sentry,
-      dsn: "http://public:secret@localhost:#{bypass.port}/1"
-    )
-
-    Process.flag(:trap_exit, true)
-
-    {:ok, pid} = Sentry.TestGenServer.start_link(self())
-    spawn_pid = spawn_link(fn -> GenServer.call(pid, {:sleep, 100}, 0) end)
-
-    receive do
-      {:EXIT, ^spawn_pid, {reason, stack}} ->
-        Sentry.capture_exception(reason, stacktrace: stack)
-    end
-
-    Bypass.pass(bypass)
-  end
-
   test "sets last_event_id_and_source when an event is sent" do
     bypass = Bypass.open()