You can define your own exception at the worker level, or externally if you want to share them between workers. Then you’ll raise that exception instead of letting it fall through to the generic Oban.PerformError exception. That way you can completely control the message:

defmodule MyApp.Worker do
  use Oban.Pro.Worker

  defmodule Error do
    defexception [:message]

    @impl true
    def exception(value) do
      message = "did not get what was expected, got: #{inspect(value)}"

      %__MODULE__{message: message}
    end
  end

  @impl true
  def process(job) do
    with {:error, reason} <- do_something(job.args) do
      raise Error, reason
    end
  end
end

Since you’re in control of the message, you’ll have a predictable format for the error value, and you can show that or parse it out.

Thanks, that works.

I’m not super happy with it since I will still need to extract the data I want from it using a regex which seems fragile, but at least I’m able to do that.

Here is the full solution:

  defmodule Error do
    defexception [:error]

    @impl true
    def exception(error) do
      %__MODULE__{error: error}
    end

    def message(%{error: error}) do
      error |> :erlang.term_to_binary() |> Base.encode64(padding: false)
    end

    def blame(exception, _stacktrace) do
      {exception, []}
    end
  end

Then, when I retrieve the job, I will get something like this in the errors key:

  errors: [
    %{
      "at" => "2026-02-05T16:09:52.916947Z",
      "attempt" => 1,
      "error" => "** (Core.Workers.ApiCaller.Error) g3QAAAADdwVlcnJvcm0AAAAFYmxvYnN3Cl9fc3RydWN0X193EUVsaXhpci5FcnJvclJlcGx5dwlodHRwX2NvZGVhAQ"
    },
    %{
      "at" => "2026-02-05T16:10:10.055109Z",
      "attempt" => 2,
      "error" => "** (Core.Workers.ApiCaller.Error) g3QAAAADdwVlcnJvcm0AAAAFYmxvYnN3Cl9fc3RydWN0X193EUVsaXhpci5FcnJvclJlcGx5dwlodHRwX2NvZGVhAQ"
    },
    %{
      "at" => "2026-02-05T16:10:29.159186Z",
      "attempt" => 3,
      "error" => "** (Core.Workers.ApiCaller.Error) g3QAAAADdwVlcnJvcm0AAAAFYmxvYnN3Cl9fc3RydWN0X193EUVsaXhpci5FcnJvclJlcGx5dwlodHRwX2NvZGVhAQ"
    }
  ]

From this list, I can retrieve the data I want with:

  def handle_error(%{errors: errors} = job) do
    Enum.map(errors, fn %{"error" => error} ->
      %{"base_64" => base_64} = Regex.named_captures(~r/(?<base_64>[A-Za-z0-9+\/=]+)$/, error)

      base_64 |> Base.decode64!(padding: false) |> :erlang.binary_to_term()
    end)
  end

Which will return me the desired structs:

iex(86)> Core.Workers.ApiCaller.handle_error(j)
[
  %ErrorReply{http_code: 1, error: "blobs"},
  %ErrorReply{http_code: 1, error: "blobs"},
  %ErrorReply{http_code: 1, error: "blobs"}
]

Raising in the before_process/1 hook isn’t advised; as you noted, that causes error logs because it’s intended for consistent pre-processing more than as a logic extension for process/1 callbacks.

There’s no reason an error/exception should be wrapped in Oban.PerformError as well. Returning {:error, exception} or {:cancel, exception} should just record the exception (though without a stacktrace, since there wasn’t a rescue involved).

That seems reasonable. Having a dedicated exception for each worker is something we considered before, actually.