Merge pull request #177 from getsentry/app-frames

App frames

Author: mitchellhenke

README.md

@@ -74,6 +74,7 @@ config :sentry,
 | `before_send_event` | False | | |
 | `after_send_event` | False | | |
 | `sample_rate` | False | 1.0 | |
+| `in_app_module_whitelist` | False | `[]` | |
 | `enable_source_code_context` | True | | |
 | `root_source_code_path` | Required if `enable_source_code_context` is enabled | | Should generally be set to `File.cwd!`|
 | `context_lines` | False  | 3 | |
@@ -92,7 +93,8 @@ config :sentry,
   tags: %{
     env: "production"
   },
-  hackney_opts: [pool: :my_pool]
+  hackney_opts: [pool: :my_pool],
+  in_app_module_whitelist: [MyApp]
 ```
 
 The `environment_name` and `included_environments` work together to determine

docs/config.rst

@@ -93,6 +93,10 @@ Optional settings
 
   The sampling factor to apply to events.  A value of 0.0 will deny sending any events, and a value of 1.0 will send 100% of events.
 
+.. describe:: in_app_module_whitelist
+
+  Expects a list of modules that is used to distinguish among stacktrace frames that belong to your app and ones that are part of libraries or core Elixir.  This is used to better display the significant part of stacktraces.  The logic is greedy, so if your app's root module is ``MyApp`` and your setting is ``[MyApp]``, that module as well as any submodules like ``MyApp.Submodule`` would be considered part of your app.  Defaults to ``[]``.
+
 .. describe:: context_lines
 
   The number of lines of source code before and after the line that caused the exception to be included.  Defaults to ``3``.

lib/sentry/event.ex

@@ -2,6 +2,12 @@ defmodule Sentry.Event do
   @moduledoc """
     Provides an Event Struct as well as transformation of Logger
     entries into Sentry Events.
+
+
+  ### Configuration
+
+  * `:in_app_module_whitelist` - Expects a list of modules that is used to distinguish among stacktrace frames that belong to your app and ones that are part of libraries or core Elixir.  This is used to better display the significant part of stacktraces.  The logic is greedy, so if your app's root module is `MyApp` and your setting is `[MyApp]`, that module as well as any submodules like `MyApp.Submodule` would be considered part of your app.  Defaults to `[]`.
+
   """
 
   defstruct event_id: nil,
@@ -154,6 +160,7 @@ defmodule Sentry.Event do
 
   @spec stacktrace_to_frames(Exception.stacktrace) :: [map]
   def stacktrace_to_frames(stacktrace) do
+    in_app_module_whitelist = Application.get_env(:sentry, :in_app_module_whitelist, [])
     stacktrace
     |> Enum.map(fn(line) ->
         {mod, function, arity, location} = line
@@ -167,6 +174,7 @@ defmodule Sentry.Event do
           function: Exception.format_mfa(mod, function, arity),
           module: mod,
           lineno: line_number,
+          in_app: is_in_app?(mod, in_app_module_whitelist),
         }
         |> put_source_context(file, line_number)
       end)
@@ -191,4 +199,23 @@ defmodule Sentry.Event do
 
   defp arity_to_integer(arity) when is_list(arity), do: Enum.count(arity)
   defp arity_to_integer(arity) when is_integer(arity), do: arity
+
+  defp is_in_app?(nil, _in_app_whitelist), do: false
+  defp is_in_app?(_, []), do: false
+  defp is_in_app?(module, in_app_module_whitelist) do
+    split_modules = module_split(module)
+
+    Enum.any?(in_app_module_whitelist, fn(module) ->
+      whitelisted_split_modules = module_split(module)
+
+      count = Enum.count(whitelisted_split_modules)
+      Enum.take(split_modules, count) == whitelisted_split_modules
+    end)
+  end
+
+  defp module_split(module) when is_binary(module) do
+    String.split(module, ".")
+    |> Enum.reject(&(&1 == "Elixir"))
+  end
+  defp module_split(module), do: module_split(String.Chars.to_string(module))
 end

mix.exs

@@ -30,9 +30,9 @@ defmodule Sentry.Mixfile do
       {:plug, "~> 1.0", optional: true},
 
       {:dialyxir, "> 0.0.0", only: :dev},
-      {:ex_doc, "~> 0.15.0", only: :dev},
+      {:ex_doc, "~> 0.16.0", only: :dev},
       {:credo, "~> 0.8", only: [:dev, :test], runtime: false},
-      {:bypass, "~> 0.6.0", only: [:test]}
+      {:bypass, "~> 0.7.0", only: [:test]}
     ]
   end
 

mix.lock

@@ -1,12 +1,12 @@
 %{"bunt": {:hex, :bunt, "0.2.0", "951c6e801e8b1d2cbe58ebbd3e616a869061ddadcc4863d0a2182541acae9a38", [:mix], []},
-  "bypass": {:hex, :bypass, "0.6.0", "fd0a8004fada4464e2ba98497755310b892a097f2fd975f4f787cf264066a335", [:mix], [{:cowboy, "~> 1.0", [hex: :cowboy, optional: false]}, {:plug, "~> 1.0", [hex: :plug, optional: false]}]},
+  "bypass": {:hex, :bypass, "0.7.0", "591d2ac1d87ba1bb84f62656a79de2fe3909993a211021a881825b59c9f7f58f", [:mix], [{:cowboy, "~> 1.0", [hex: :cowboy, optional: false]}, {:plug, "~> 1.0", [hex: :plug, optional: false]}]},
   "certifi": {:hex, :certifi, "1.1.0", "c9b71a547016c2528a590ccfc28de786c7edb74aafa17446b84f54e04efc00ee", [:rebar3], []},
   "cowboy": {:hex, :cowboy, "1.1.2", "61ac29ea970389a88eca5a65601460162d370a70018afe6f949a29dca91f3bb0", [:rebar3], [{:cowlib, "~> 1.0.2", [hex: :cowlib, optional: false]}, {:ranch, "~> 1.3.2", [hex: :ranch, optional: false]}]},
   "cowlib": {:hex, :cowlib, "1.0.2", "9d769a1d062c9c3ac753096f868ca121e2730b9a377de23dec0f7e08b1df84ee", [:make], []},
   "credo": {:hex, :credo, "0.8.1", "137efcc99b4bc507c958ba9b5dff70149e971250813cbe7d4537ec7e36997402", [:mix], [{:bunt, "~> 0.2.0", [hex: :bunt, optional: false]}]},
   "dialyxir": {:hex, :dialyxir, "0.5.0", "5bc543f9c28ecd51b99cc1a685a3c2a1a93216990347f259406a910cf048d1d7", [:mix], []},
-  "earmark": {:hex, :earmark, "1.2.0", "bf1ce17aea43ab62f6943b97bd6e3dc032ce45d4f787504e3adf738e54b42f3a", [:mix], []},
-  "ex_doc": {:hex, :ex_doc, "0.15.1", "d5f9d588fd802152516fccfdb96d6073753f77314fcfee892b15b6724ca0d596", [:mix], [{:earmark, "~> 1.1", [hex: :earmark, optional: false]}]},
+  "earmark": {:hex, :earmark, "1.2.2", "f718159d6b65068e8daeef709ccddae5f7fdc770707d82e7d126f584cd925b74", [:mix], []},
+  "ex_doc": {:hex, :ex_doc, "0.16.1", "b4b8a23602b4ce0e9a5a960a81260d1f7b29635b9652c67e95b0c2f7ccee5e81", [:mix], [{:earmark, "~> 1.1", [hex: :earmark, optional: false]}]},
   "hackney": {:hex, :hackney, "1.8.0", "8388a22f4e7eb04d171f2cf0285b217410f266d6c13a4c397a6c22ab823a486c", [:rebar3], [{:certifi, "1.1.0", [hex: :certifi, optional: false]}, {:idna, "4.0.0", [hex: :idna, optional: false]}, {:metrics, "1.0.1", [hex: :metrics, optional: false]}, {:mimerl, "1.0.2", [hex: :mimerl, optional: false]}, {:ssl_verify_fun, "1.1.1", [hex: :ssl_verify_fun, optional: false]}]},
   "idna": {:hex, :idna, "4.0.0", "10aaa9f79d0b12cf0def53038547855b91144f1bfcc0ec73494f38bb7b9c4961", [:rebar3], []},
   "metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], []},

test/event_test.exs

@@ -26,12 +26,12 @@ defmodule Sentry.EventTest do
     assert event.message == "(UndefinedFunctionError) function Sentry.Event.not_a_function/0 is undefined or private"
     assert is_binary(event.server_name)
     assert event.stacktrace == %{frames: Enum.reverse([
-      %{filename: nil, function: "Sentry.Event.not_a_function/0", lineno: nil, module: Sentry.Event, context_line: nil, post_context: [], pre_context: []},
-      %{filename: "test/event_test.exs", function: "Sentry.EventTest.event_generated_by_exception/1", lineno: 8, module: Sentry.EventTest, context_line: nil, post_context: [], pre_context: []},
-      %{filename: "test/event_test.exs", function: "Sentry.EventTest.\"test parses error exception\"/1", lineno: 15, module: Sentry.EventTest, context_line: nil, post_context: [], pre_context: []},
-      %{filename: "lib/ex_unit/runner.ex", function: "ExUnit.Runner.exec_test/1", lineno: 302, module: ExUnit.Runner, context_line: nil, post_context: [], pre_context: []},
-      %{filename: "timer.erl", function: ":timer.tc/1", lineno: 166, module: :timer, context_line: nil, post_context: [], pre_context: []},
-      %{filename: "lib/ex_unit/runner.ex", function: "anonymous fn/3 in ExUnit.Runner.spawn_test/3", lineno: 250, module: ExUnit.Runner, context_line: nil, post_context: [], pre_context: []}])
+      %{filename: nil, function: "Sentry.Event.not_a_function/0", lineno: nil, module: Sentry.Event, context_line: nil, post_context: [], pre_context: [], in_app: false},
+      %{filename: "test/event_test.exs", function: "Sentry.EventTest.event_generated_by_exception/1", lineno: 8, module: Sentry.EventTest, context_line: nil, post_context: [], pre_context: [], in_app: false},
+      %{filename: "test/event_test.exs", function: "Sentry.EventTest.\"test parses error exception\"/1", lineno: 15, module: Sentry.EventTest, context_line: nil, post_context: [], pre_context: [], in_app: false},
+      %{filename: "lib/ex_unit/runner.ex", function: "ExUnit.Runner.exec_test/1", lineno: 302, module: ExUnit.Runner, context_line: nil, post_context: [], pre_context: [], in_app: false},
+      %{filename: "timer.erl", function: ":timer.tc/1", lineno: 166, module: :timer, context_line: nil, post_context: [], pre_context: [], in_app: false},
+      %{filename: "lib/ex_unit/runner.ex", function: "anonymous fn/3 in ExUnit.Runner.spawn_test/3", lineno: 250, module: ExUnit.Runner, context_line: nil, post_context: [], pre_context: [], in_app: false}])
     }
     assert event.tags == %{}
     assert event.timestamp =~ ~r/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/
@@ -70,9 +70,58 @@ defmodule Sentry.EventTest do
     event = Sentry.Event.transform_exception(exception, [fingerprint: ["hello", "world"]])
     assert event.fingerprint == ["hello", "world"]
   end
+
   test "not sending fingerprint when unset" do
     exception = RuntimeError.exception("error")
     event = Sentry.Event.transform_exception(exception, [])
     assert event.fingerprint == ["{{ default }}"]
   end
+
+  test "sets app_frame to true when configured" do
+    modify_env(:sentry, in_app_module_whitelist: [Sentry, :random, Sentry.Submodule])
+    exception = RuntimeError.exception("error")
+    event = Sentry.Event.transform_exception(exception, [stacktrace: [{Elixir.Sentry.Fun, :method, 2, []}, {Elixir.Sentry, :other_method, 4, []},
+                                                                      {:other_module, :a_method, 8, []}, {:random, :uniform, 0, []},
+                                                                      {Sentry.Submodule.Fun, :this_method, 0, []}]])
+      assert %{frames: [
+        %{
+          module: Sentry.Submodule.Fun,
+          function: "Sentry.Submodule.Fun.this_method/0",
+          in_app: true,
+          filename: nil, lineno: nil,
+          context_line: nil, post_context: [], pre_context: []
+        },
+        %{
+          module: :random,
+          function: ":random.uniform/0",
+          in_app: true,
+          filename: nil, lineno: nil,
+          context_line: nil, post_context: [], pre_context: []
+        },
+        %{
+          module: :other_module,
+          function: ":other_module.a_method/8",
+          in_app: false,
+          filename: nil, lineno: nil,
+          context_line: nil, post_context: [], pre_context: []
+        },
+        %{
+          module: Sentry,
+          function: "Sentry.other_method/4",
+          in_app: true,
+          filename: nil, lineno: nil,
+          context_line: nil, post_context: [], pre_context: []
+        },
+        %{
+          filename: nil,
+          function: "Sentry.Fun.method/2",
+          module: Sentry.Fun,
+          lineno: nil,
+          in_app: true,
+          context_line: nil,
+          post_context: [],
+          pre_context: []
+        },
+      ]} == event.stacktrace
+  end
 end

test/logger_test.exs

@@ -88,6 +88,7 @@ defmodule Sentry.LoggerTest do
       assert List.first(json["exception"])["value"] == "** (exit) :function_clause"
       assert List.last(json["stacktrace"]["frames"]) == %{"filename" => "lib/calendar.ex",
                                                           "function" => "NaiveDateTime.from_erl/2",
+                                                          "in_app" => false,
                                                           "lineno" => 1214,
                                                           "module" => "Elixir.NaiveDateTime",
                                                           "context_line" => nil,

test/sentry_test.exs

@@ -28,12 +28,13 @@ defmodule SentryTest do
      assert conn.method == "POST"
      Plug.Conn.send_resp(conn, 200, ~s<{"id": "340"}>)
    end
-   Bypass.pass(bypass)
 
    modify_env(:sentry, filter: Sentry.TestFilter, dsn: "http://public:secret@localhost:#{bypass.port}/1")
 
    assert capture_log(fn ->
      assert :error = Sentry.capture_message("error", [])
    end) =~ "Failed to send Sentry event"
+
+   Bypass.pass(bypass)
   end
 end