fix: :source_code_exclude_patterns support for OTP-28+

Author: solnic

lib/sentry/config.ex

@@ -427,11 +427,14 @@ defmodule Sentry.Config do
     source_code_exclude_patterns: [
       type:
         {:list,
-         {:custom, __MODULE__, :__validate_struct__, [:source_code_exclude_patterns, Regex]}},
-      type_doc: "list of `t:Regex.t/0`",
+         {:custom, __MODULE__, :__validate_source_code_exclude_pattern__, []}},
+      type_doc: "list of `t:Regex.t/0` or `t:String.t/0`",
       doc: """
       A list of regular expressions used to determine which files to
-      exclude from source code context.
+      exclude from source code context. Each element can be either a compiled
+      `Regex` or a string pattern that will be compiled to a regex at runtime.
+      Using strings is recommended for OTP 28+ compatibility with releases, as
+      compiled regexes cannot be serialized in release config files.
       """
     ],
     source_code_map_path: [
@@ -891,4 +894,25 @@ defmodule Sentry.Config do
       {:error, "expected #{inspect(key)} to be a #{inspect(mod)} struct, got: #{inspect(term)}"}
     end
   end
+
+  def __validate_source_code_exclude_pattern__(term) when is_struct(term, Regex) do
+    {:ok, term}
+  end
+
+  def __validate_source_code_exclude_pattern__(term) when is_binary(term) do
+    case Regex.compile(term) do
+      {:ok, _regex} ->
+        # Keep the string - it will be compiled at runtime in Sources
+        {:ok, term}
+
+      {:error, {reason, position}} ->
+        {:error,
+         "invalid regex pattern #{inspect(term)}: #{reason} at position #{position}"}
+    end
+  end
+
+  def __validate_source_code_exclude_pattern__(term) do
+    {:error,
+     "expected a Regex or a string pattern, got: #{inspect(term)}"}
+  end
 end

lib/sentry/sources.ex

@@ -107,11 +107,12 @@ defmodule Sentry.Sources do
     path_pattern = Keyword.fetch!(config, :source_code_path_pattern)
 
     exclude_patterns =
-      Keyword.get(
-        config,
+      config
+      |> Keyword.get(
         :source_code_exclude_patterns,
         [~r"/_build/", ~r"/deps/", ~r"/priv/", ~r"/test/"]
       )
+      |> compile_patterns()
 
     config
     |> Keyword.fetch!(:root_source_code_paths)
@@ -207,6 +208,20 @@ defmodule Sentry.Sources do
     |> exclude_files(rest)
   end
 
+  # Compile string patterns to regexes at runtime, pass through already-compiled regexes.
+  # This supports OTP 28+ where regexes cannot be serialized in release config files.
+  defp compile_patterns(patterns) when is_list(patterns) do
+    Enum.map(patterns, &compile_pattern/1)
+  end
+
+  defp compile_patterns(nil), do: nil
+
+  defp compile_pattern(pattern) when is_struct(pattern, Regex), do: pattern
+
+  defp compile_pattern(pattern) when is_binary(pattern) do
+    Regex.compile!(pattern)
+  end
+
   defp source_to_lines(source) do
     String.replace_suffix(source, "\n", "")
     |> String.split("\n")

test/sentry/config_test.exs

@@ -99,10 +99,24 @@ defmodule Sentry.ConfigTest do
       config = [source_code_exclude_patterns: [regex]]
       assert Config.validate!(config)[:source_code_exclude_patterns] == [regex]
 
-      message = ~r/invalid list in :source_code_exclude_patterns option/
+      config = [source_code_exclude_patterns: ["foo", "bar/baz"]]
+      assert Config.validate!(config)[:source_code_exclude_patterns] == ["foo", "bar/baz"]
+
+      config = [source_code_exclude_patterns: [~r/foo/, "bar"]]
+      [regex, string] = Config.validate!(config)[:source_code_exclude_patterns]
+      assert regex.source == "foo"
+      assert string == "bar"
+
+      message = ~r/invalid regex pattern/
+
+      assert_raise ArgumentError, message, fn ->
+        Config.validate!(source_code_exclude_patterns: ["[invalid"])
+      end
+
+      message = ~r/expected a Regex or a string pattern/
 
       assert_raise ArgumentError, message, fn ->
-        Config.validate!(source_code_exclude_patterns: ["foo"])
+        Config.validate!(source_code_exclude_patterns: [:atom])
       end
     end
 

test/sources_test.exs

@@ -64,6 +64,57 @@ defmodule Sentry.SourcesTest do
              To fix this, you'll have to rename one of the conflicting paths.
              """
     end
+
+    test "accepts string patterns for source_code_exclude_patterns (OTP 28+ compatibility)" do
+      paths = [
+        File.cwd!() <> "/test/fixtures/example-umbrella-app/apps/app_a",
+        File.cwd!() <> "/test/fixtures/example-umbrella-app/apps/app_b"
+      ]
+
+      assert {:ok, result} =
+               Sources.load_files(
+                 root_source_code_paths: paths,
+                 source_code_exclude_patterns: ["module_b"]
+               )
+
+      assert Map.has_key?(result, "lib/module_a.ex")
+      refute Map.has_key?(result, "lib/module_b.ex")
+    end
+
+    test "accepts mixed string and regex patterns for source_code_exclude_patterns" do
+      paths = [
+        File.cwd!() <> "/test/fixtures/example-umbrella-app/apps/app_a",
+        File.cwd!() <> "/test/fixtures/example-umbrella-app/apps/app_b"
+      ]
+
+      assert {:ok, result} =
+               Sources.load_files(
+                 root_source_code_paths: paths,
+                 source_code_exclude_patterns: [~r/module_a/, "module_b"]
+               )
+
+      refute Map.has_key?(result, "lib/module_a.ex")
+      refute Map.has_key?(result, "lib/module_b.ex")
+    end
+
+    test "string patterns survive term serialization (OTP 28+ release simulation)" do
+      paths = [
+        File.cwd!() <> "/test/fixtures/example-umbrella-app/apps/app_a",
+        File.cwd!() <> "/test/fixtures/example-umbrella-app/apps/app_b"
+      ]
+
+      original_config = [
+        root_source_code_paths: paths,
+        source_code_exclude_patterns: ["module_b", "/deps/"]
+      ]
+
+      serialized = :erlang.term_to_binary(original_config)
+      deserialized_config = :erlang.binary_to_term(serialized)
+
+      assert {:ok, result} = Sources.load_files(deserialized_config)
+      assert Map.has_key?(result, "lib/module_a.ex")
+      refute Map.has_key?(result, "lib/module_b.ex")
+    end
   end
 
   describe "load_source_code_map_if_present/0" do

test_integrations/phoenix_app/config/prod.exs

@@ -17,5 +17,13 @@ config :swoosh, local: false
 # Do not print debug messages in production
 config :logger, level: :info
 
+# Configure Sentry for production with source code context
+# Using string patterns instead of regexes for OTP 28+/Elixir 1.18+ compatibility
+# See: https://github.com/getsentry/sentry-elixir/issues/951
+config :sentry,
+  enable_source_code_context: true,
+  root_source_code_paths: [File.cwd!()],
+  source_code_exclude_patterns: ["/_build/", "/deps/", "/priv/", "/test/"]
+
 # Runtime production configuration, including reading
 # of environment variables, is done on config/runtime.exs.