feat(oban): add support for :should_report_error_callback option (#832)

* 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.

* tests(oban): add integration tests for :skip_error_report_callback config

* docs: update CHANGELOG.md

* Apply suggestion from @whatyouhide

Co-authored-by: Andrea Leopardi <an.leopardi@gmail.com>

* Apply suggestions from code review

Co-authored-by: Andrea Leopardi <an.leopardi@gmail.com>

* Rename to :should_report_error_callback

* Remove unused validation fns

* mix format

---------

Co-authored-by: Andrea Leopardi <an.leopardi@gmail.com>

Author: solnic

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 #### Features
 
+- Add `should_report_error_callback` option to Oban.ErrorReporter for flexible error reporting logic ([#832](https://github.com/getsentry/sentry-elixir/pull/832))
 - Support for Structured Logs ([#969](https://github.com/getsentry/sentry-elixir/pull/969))
 - Support for Distributed Tracing ([957](https://github.com/getsentry/sentry-elixir/pull/957))
 - Support for LiveView spans captured under single trace root ([#977](https://github.com/getsentry/sentry-elixir/pull/977))

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*.
           """
         ],
+        should_report_error_callback: [
+          type: {:or, [nil, {:fun, 2}]},
+          default: nil,
+          type_doc: "`(Oban.Worker.t() | nil, Oban.Job.t() -> boolean())` or `nil`",
+          doc: """
+          A function that determines whether to report errors for Oban jobs.
+          The function receives the worker module and the `Oban.Job` struct and should return
+          `true` to report the error or `false` to skip reporting.
+
+          ```elixir
+          should_report_error_callback: fn _worker, job ->
+            job.attempt >= job.max_attempts
+          end
+          ```
+
+          This example only reports errors on final retry attempts.
+          *Available since 12.0.0*.
+          """
+        ],
         cron: [
           doc: """
           Configuration options for configuring [*crons*](https://docs.sentry.io/product/crons/)

lib/sentry/integrations/oban/error_reporter.ex

@@ -31,13 +31,52 @@ 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, :should_report_error_callback) do
+      callback when is_function(callback, 2) ->
+        call_should_report_error_callback(callback, job)
+
+      _ ->
+        true
+    end
+  end
+
+  defp call_should_report_error_callback(callback, job) do
+    worker =
+      case apply(Oban.Worker, :from_string, [job.worker]) do
+        {:ok, mod} ->
+          mod
+
+        {:error, _} ->
+          Logger.warning(
+            "Could not resolve Oban worker module from string: #{inspect(job.worker)}"
+          )
+
+          nil
+      end
+
+    try do
+      callback.(worker, job) == true
+    rescue
+      error ->
+        Logger.warning("""
+        :should_report_error_callback failed for worker #{inspect(worker)} \
+        (job ID #{job.id}):
+
+        #{Exception.format(:error, error, __STACKTRACE__)}\
+        """)
+
+        true
+    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 "should_report_error_callback configuration validation" do
+    test "accepts nil" do
+      assert :ok = put_test_config(integrations: [oban: [should_report_error_callback: nil]])
+      assert Sentry.Config.integrations()[:oban][:should_report_error_callback] == nil
+    end
+
+    test "accepts function with arity 2" do
+      fun = fn _worker, _job -> true end
+      assert :ok = put_test_config(integrations: [oban: [should_report_error_callback: fun]])
+      assert Sentry.Config.integrations()[:oban][:should_report_error_callback] == fun
+    end
+
+    test "rejects function with wrong arity" do
+      fun = fn _job -> true end
+
+      assert_raise ArgumentError, ~r/invalid value for :should_report_error_callback/, fn ->
+        put_test_config(integrations: [oban: [should_report_error_callback: fun]])
+      end
+    end
+
+    test "rejects invalid types" do
+      assert_raise ArgumentError, ~r/invalid value for :should_report_error_callback/, fn ->
+        put_test_config(integrations: [oban: [should_report_error_callback: "invalid"]])
+      end
+
+      assert_raise ArgumentError, ~r/invalid value for :should_report_error_callback/, fn ->
+        put_test_config(integrations: [oban: [should_report_error_callback: 123]])
+      end
+
+      assert_raise ArgumentError, ~r/invalid value for :should_report_error_callback/, fn ->
+        put_test_config(integrations: [oban: [should_report_error_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,105 @@ defmodule Sentry.Integrations.Oban.ErrorReporterTest do
       assert [event] = Sentry.Test.pop_sentry_reports()
       assert event.tags.custom_tag == "custom_value"
     end
+
+    test "should_report_error_callback skips when callback returns false" 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 false -> skip reporting
+      assert :ok =
+               ErrorReporter.handle_event(
+                 [:oban, :job, :exception],
+                 %{},
+                 %{job: job_attempt_1, kind: :error, reason: reason, stacktrace: []},
+                 should_report_error_callback: fn _worker, job ->
+                   job.attempt >= job.max_attempts
+                 end
+               )
+
+      assert [] = Sentry.Test.pop_sentry_reports()
+
+      # Final attempt: callback returns true -> 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: []},
+                 should_report_error_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 "should_report_error_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: []},
+                 should_report_error_callback: fn worker, received_job ->
+                   send(test_pid, {:callback_args, worker, received_job})
+                   true
+                 end
+               )
+
+      assert_receive {:callback_args, worker, received_job}
+      assert worker == MyWorker
+      assert received_job == job
+    end
+
+    test "should_report_error_callback reports when callback returns true" do
+      Sentry.Test.start_collecting()
+
+      emit_telemetry_for_failed_job(:error, %RuntimeError{message: "oops"}, [],
+        should_report_error_callback: fn _worker, _job -> true end
+      )
+
+      assert [event] = Sentry.Test.pop_sentry_reports()
+      assert event.original_exception == %RuntimeError{message: "oops"}
+    end
+
+    test "should_report_error_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"}, [],
+            should_report_error_callback: fn _worker, _job -> raise "callback error" end
+          )
+        end)
+
+      assert log =~ "should_report_error_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