Fix reading of config in "mix sentry.package_source_code" (#653)

Author: whatyouhide

lib/mix/tasks/sentry.package_source_code.ex

@@ -56,9 +56,12 @@ defmodule Mix.Tasks.Sentry.PackageSourceCode do
   def run(args) do
     {opts, _args} = OptionParser.parse!(args, strict: @switches)
 
+    # We can read the config here because this task depends on the `app.config` task.
+    config = Application.get_all_env(:sentry)
+
     {elapsed, source_map} =
       :timer.tc(fn ->
-        case Sources.load_files() do
+        case Sources.load_files(config) do
           {:ok, source_map} -> source_map
           {:error, message} -> Mix.raise(message)
         end

lib/sentry/config.ex

@@ -400,15 +400,6 @@ defmodule Sentry.Config do
   @spec enable_source_code_context?() :: boolean()
   def enable_source_code_context?, do: fetch!(:enable_source_code_context)
 
-  @spec root_source_code_paths() :: [Path.t()]
-  def root_source_code_paths, do: fetch!(:root_source_code_paths)
-
-  @spec source_code_path_pattern() :: String.t()
-  def source_code_path_pattern, do: fetch!(:source_code_path_pattern)
-
-  @spec source_code_exclude_patterns() :: [Regex.t()]
-  def source_code_exclude_patterns, do: fetch!(:source_code_exclude_patterns)
-
   @spec context_lines() :: pos_integer()
   def context_lines, do: fetch!(:context_lines)
 

lib/sentry/sources.ex

@@ -68,13 +68,15 @@ defmodule Sentry.Sources do
     :persistent_term.get(@source_code_map_key, nil)
   end
 
-  @spec load_files([Path.t()] | nil) :: {:ok, source_map()} | {:error, message :: String.t()}
-  def load_files(root_paths \\ nil) do
-    root_paths = root_paths || Config.root_source_code_paths()
-    path_pattern = Config.source_code_path_pattern()
-    exclude_patterns = Config.source_code_exclude_patterns()
+  @spec load_files(keyword()) :: {:ok, source_map()} | {:error, message :: String.t()}
+  def load_files(config \\ []) when is_list(config) do
+    config = Sentry.Config.validate!(config)
 
-    root_paths
+    path_pattern = Keyword.fetch!(config, :source_code_path_pattern)
+    exclude_patterns = Keyword.fetch!(config, :source_code_exclude_patterns)
+
+    config
+    |> Keyword.fetch!(:root_source_code_paths)
     |> Enum.reduce(%{}, &load_files_for_root_path(&1, &2, path_pattern, exclude_patterns))
     |> Map.new(fn {path, %{lines: lines}} -> {path, lines} end)
   catch

test/sentry_test.exs

@@ -78,52 +78,4 @@ defmodule SentryTest do
 
     assert log =~ "Sentry: unable to parse exception"
   end
-
-  test "reports source code context", %{bypass: bypass} do
-    parent_pid = self()
-    ref = make_ref()
-
-    put_test_config(
-      enable_source_code_context: true,
-      root_source_code_paths: [File.cwd!()],
-      source_code_path_pattern: "{lib,test}/*.{ex,exs}"
-    )
-
-    set_mix_shell(Mix.Shell.Quiet)
-
-    assert :ok = Mix.Task.rerun("sentry.package_source_code")
-
-    assert {:loaded, _source_map} = Sentry.Sources.load_source_code_map_if_present()
-
-    Bypass.expect(bypass, fn conn ->
-      {:ok, body, conn} = Plug.Conn.read_body(conn)
-
-      event = decode_event_from_envelope!(body)
-      send(parent_pid, {ref, event})
-      Plug.Conn.resp(conn, 200, ~s<{"id": "340"}>)
-    end)
-
-    {:current_stacktrace, stacktrace} = Process.info(self(), :current_stacktrace)
-
-    assert {:ok, "340"} =
-             Sentry.capture_exception(%RuntimeError{message: "oops"},
-               stacktrace: stacktrace,
-               result: :sync
-             )
-
-    assert_receive {^ref, event}
-
-    [exception] = event.exception
-    assert exception["type"] == "RuntimeError"
-    assert exception["value"] == "oops"
-
-    assert [%{"function" => "Process.info/2"}, interesting_frame | _rest] =
-             Enum.reverse(exception["stacktrace"]["frames"])
-
-    assert interesting_frame["context_line"] =~ "Process.info(self(), :current_stacktrace)"
-    assert Enum.at(interesting_frame["pre_context"], 0) =~ "Plug.Conn.resp(conn"
-    assert Enum.at(interesting_frame["pre_context"], 1) =~ "end)"
-    assert Enum.at(interesting_frame["post_context"], 0) == ""
-    assert Enum.at(interesting_frame["post_context"], 1) =~ "assert {:ok, "
-  end
 end

test/sources_test.exs

@@ -1,7 +1,7 @@
 defmodule Sentry.SourcesTest do
   use Sentry.Case, async: true
 
-  describe "load_files/0" do
+  describe "load_files/1" do
     test "loads files" do
       paths = [
         File.cwd!() <> "/test/fixtures/example-umbrella-app/apps/app_a",
@@ -24,7 +24,11 @@ defmodule Sentry.SourcesTest do
                   4 => "  end",
                   5 => "end"
                 }
-              }} = Sentry.Sources.load_files(paths)
+              }} =
+               Sentry.Sources.load_files(
+                 root_source_code_paths: paths,
+                 source_code_exclude_patterns: []
+               )
     end
 
     test "raises error when two files have the same relative path" do
@@ -33,7 +37,11 @@ defmodule Sentry.SourcesTest do
         File.cwd!() <> "/test/fixtures/example-umbrella-app-with-conflict/apps/app_b"
       ]
 
-      assert {:error, message} = Sentry.Sources.load_files(paths)
+      assert {:error, message} =
+               Sentry.Sources.load_files(
+                 root_source_code_paths: paths,
+                 source_code_exclude_patterns: []
+               )
 
       assert message == """
              Found two source files in different source root paths with the same relative path: