feat(oban): add :skip_error_report_callback option

The callback receives the worker module and job struct, allowing for
per-worker or per-job decision logic on whether to skip error reporting.

Author: solnic

lib/sentry/config.ex

@@ -78,6 +78,25 @@ defmodule Sentry.Config do
           with `oban_tags.` and with a value of `true`. *Available since 12.0.0*.
           """
         ],
+        skip_error_report_callback: [
+          type: {:custom, __MODULE__, :__validate_skip_error_report_callback__, []},
+          default: nil,
+          type_doc: "`(module(), Oban.Job.t() -> boolean())` or `nil`",
+          doc: """
+          A function that determines whether to skip reporting errors for Oban job retries.
+          The function receives the worker module and the `Oban.Job` struct and should return
+          `true` to skip reporting or `false` to report the error.
+
+          ```elixir
+          skip_error_report_callback: fn _worker, job ->
+            job.attempt < job.max_attempts
+          end
+          ```
+
+          This example skips reporting errors for all non-final retry attempts.
+          *Available since 12.0.0*.
+          """
+        ],
         cron: [
           doc: """
           Configuration options for configuring [*crons*](https://docs.sentry.io/product/crons/)
@@ -1064,4 +1083,15 @@ defmodule Sentry.Config do
     {:error,
      "expected :oban_tags_to_sentry_tags to be nil, a function with arity 1, or a {module, function} tuple, got: #{inspect(other)}"}
   end
+
+  def __validate_skip_error_report_callback__(nil), do: {:ok, nil}
+
+  def __validate_skip_error_report_callback__(fun) when is_function(fun, 2) do
+    {:ok, fun}
+  end
+
+  def __validate_skip_error_report_callback__(other) do
+    {:error,
+     "expected :skip_error_report_callback to be nil or a function with arity 2, got: #{inspect(other)}"}
+  end
 end

lib/sentry/integrations/oban/error_reporter.ex

@@ -31,13 +31,43 @@ defmodule Sentry.Integrations.Oban.ErrorReporter do
         %{job: job, kind: kind, reason: reason, stacktrace: stacktrace} = _metadata,
         config
       ) do
-    if report?(reason) do
+    if report?(reason) and should_report?(job, config) do
       report(job, kind, reason, stacktrace, config)
     else
       :ok
     end
   end
 
+  defp should_report?(job, config) do
+    case Keyword.get(config, :skip_error_report_callback) do
+      callback when is_function(callback, 2) ->
+        not call_skip_error_report_callback(callback, job)
+
+      _ ->
+        true
+    end
+  end
+
+  defp call_skip_error_report_callback(callback, job) do
+    worker =
+      case apply(Oban.Worker, :from_string, [job.worker]) do
+        {:ok, mod} -> mod
+        :error -> nil
+      end
+
+    try do
+      callback.(worker, job) == true
+    rescue
+      error ->
+        Logger.warning(
+          "skip_error_report_callback failed for worker #{inspect(worker)} " <>
+            "(job ID #{job.id}): #{inspect(error)}"
+        )
+
+        false
+    end
+  end
+
   defp report(job, kind, reason, stacktrace, config) do
     stacktrace =
       case {apply(Oban.Worker, :from_string, [job.worker]), stacktrace} do

test/sentry/config_oban_tags_to_sentry_tags_test.exs

@@ -59,4 +59,39 @@ defmodule Sentry.ConfigObanTagsToSentryTagsTest do
       end
     end
   end
+
+  describe "skip_error_report_callback configuration validation" do
+    test "accepts nil" do
+      assert :ok = put_test_config(integrations: [oban: [skip_error_report_callback: nil]])
+      assert Sentry.Config.integrations()[:oban][:skip_error_report_callback] == nil
+    end
+
+    test "accepts function with arity 2" do
+      fun = fn _worker, _job -> true end
+      assert :ok = put_test_config(integrations: [oban: [skip_error_report_callback: fun]])
+      assert Sentry.Config.integrations()[:oban][:skip_error_report_callback] == fun
+    end
+
+    test "rejects function with wrong arity" do
+      fun = fn _job -> true end
+
+      assert_raise ArgumentError, ~r/expected :skip_error_report_callback to be/, fn ->
+        put_test_config(integrations: [oban: [skip_error_report_callback: fun]])
+      end
+    end
+
+    test "rejects invalid types" do
+      assert_raise ArgumentError, ~r/expected :skip_error_report_callback to be/, fn ->
+        put_test_config(integrations: [oban: [skip_error_report_callback: "invalid"]])
+      end
+
+      assert_raise ArgumentError, ~r/expected :skip_error_report_callback to be/, fn ->
+        put_test_config(integrations: [oban: [skip_error_report_callback: 123]])
+      end
+
+      assert_raise ArgumentError, ~r/expected :skip_error_report_callback to be/, fn ->
+        put_test_config(integrations: [oban: [skip_error_report_callback: []]])
+      end
+    end
+  end
 end

test/sentry/integrations/oban/error_reporter_test.exs

@@ -1,6 +1,8 @@
 defmodule Sentry.Integrations.Oban.ErrorReporterTest do
   use ExUnit.Case, async: true
 
+  import ExUnit.CaptureLog
+
   alias Sentry.Integrations.Oban.ErrorReporter
 
   defmodule MyWorker do
@@ -210,6 +212,101 @@ defmodule Sentry.Integrations.Oban.ErrorReporterTest do
       assert [event] = Sentry.Test.pop_sentry_reports()
       assert event.tags.custom_tag == "custom_value"
     end
+
+    test "skip_error_report_callback skips when callback returns true" do
+      job =
+        %{"id" => "123", "entity" => "user", "type" => "delete"}
+        |> MyWorker.new()
+        |> Ecto.Changeset.apply_action!(:validate)
+
+      reason = %RuntimeError{message: "oops"}
+
+      Sentry.Test.start_collecting()
+
+      job_attempt_1 = Map.merge(job, %{attempt: 1, max_attempts: 3})
+
+      # Callback returns true -> skip reporting
+      assert :ok =
+               ErrorReporter.handle_event(
+                 [:oban, :job, :exception],
+                 %{},
+                 %{job: job_attempt_1, kind: :error, reason: reason, stacktrace: []},
+                 skip_error_report_callback: fn _worker, job -> job.attempt < job.max_attempts end
+               )
+
+      assert [] = Sentry.Test.pop_sentry_reports()
+
+      # Final attempt: callback returns false -> report
+      job_attempt_3 = Map.merge(job, %{attempt: 3, max_attempts: 3})
+
+      assert :ok =
+               ErrorReporter.handle_event(
+                 [:oban, :job, :exception],
+                 %{},
+                 %{job: job_attempt_3, kind: :error, reason: reason, stacktrace: []},
+                 skip_error_report_callback: fn _worker, job -> job.attempt < job.max_attempts end
+               )
+
+      assert [event] = Sentry.Test.pop_sentry_reports()
+      assert event.original_exception == %RuntimeError{message: "oops"}
+      assert event.tags.oban_worker == "Sentry.Integrations.Oban.ErrorReporterTest.MyWorker"
+    end
+
+    test "skip_error_report_callback receives worker module and job" do
+      job =
+        %{"id" => "123", "entity" => "user", "type" => "delete"}
+        |> MyWorker.new()
+        |> Ecto.Changeset.apply_action!(:validate)
+
+      reason = %RuntimeError{message: "oops"}
+      test_pid = self()
+
+      Sentry.Test.start_collecting()
+
+      assert :ok =
+               ErrorReporter.handle_event(
+                 [:oban, :job, :exception],
+                 %{},
+                 %{job: job, kind: :error, reason: reason, stacktrace: []},
+                 skip_error_report_callback: fn worker, received_job ->
+                   send(test_pid, {:callback_args, worker, received_job})
+                   false
+                 end
+               )
+
+      assert_receive {:callback_args, worker, received_job}
+      assert worker == MyWorker
+      assert received_job == job
+    end
+
+    test "skip_error_report_callback reports when callback returns false" do
+      Sentry.Test.start_collecting()
+
+      emit_telemetry_for_failed_job(:error, %RuntimeError{message: "oops"}, [],
+        skip_error_report_callback: fn _worker, _job -> false end
+      )
+
+      assert [event] = Sentry.Test.pop_sentry_reports()
+      assert event.original_exception == %RuntimeError{message: "oops"}
+    end
+
+    test "skip_error_report_callback handles errors gracefully and defaults to reporting" do
+      Sentry.Test.start_collecting()
+
+      log =
+        capture_log(fn ->
+          emit_telemetry_for_failed_job(:error, %RuntimeError{message: "oops"}, [],
+            skip_error_report_callback: fn _worker, _job -> raise "callback error" end
+          )
+        end)
+
+      assert log =~ "skip_error_report_callback failed"
+      assert log =~ "Sentry.Integrations.Oban.ErrorReporterTest.MyWorker"
+      assert log =~ "callback error"
+
+      assert [event] = Sentry.Test.pop_sentry_reports()
+      assert event.original_exception == %RuntimeError{message: "oops"}
+    end
   end
 
   ## Helpers