goodsorcery 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c757cad1765947ffa3b03990f995e418f676ff2a2385d23b9576bb4aec1462c
-  data.tar.gz: be2c7da80aa622f3d8aedf18ce6db47d0427f3740bce87b743dde3ff41117d7d
+  metadata.gz: edbecd397465b4b9853689dcaeb10b832770545b51c4801f3f3dd22d6c126b08
+  data.tar.gz: fd3b3fdf18956d5e9dd9db3af4e042a5385459f531ad6791851551949590ab6c
 SHA512:
-  metadata.gz: 675c74e11fff3d79ff4c4ab47f78f131174b75b98f09a441cce26b274325541f3ce97c630644879de598367f863b4ea93c01719850b1ce46aac782479844a7c3
-  data.tar.gz: 65c4954e28c02247c4b9d00123957827625516a3b218d56773d44b36315de74d9841622d96573d7cd026afcd218949708ca93cb44510d408932b4d8d28aeb81c
+  metadata.gz: dcb53d171bd4f36a48c7208a9cd2b3950bd1be25741b9946945da0db0cba745b75ee8159a6058a12288fda63258d5cdcd3fe413d25f538c9c7d7601592c2fbb8
+  data.tar.gz: 9767d439220b934647dc06cb805fca3d0ba808f97438cb320efc3749e220e0b9d7487fc613cfbb711781a795029cd9b0cfd834d559d2417d79af8f65a176819b

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.3.0 (2026-11-07)
+
+- The `:active_job` delivery: `GoodSorcery::DeliveryJob`, `config.active_job_queue` and `GoodSorcery::RetryableDeliveryError`. Use `:async` (the default). Errors raised in your own jobs are still reported, and jobs are still measured by performance monitoring.
+- Custom delivery objects (`config.delivery = <object responding to #deliver>`).
+- `config.delivery` now accepts only `:async`, `:sync` and `:test`; anything else, including `:active_job` or an object, raises `ArgumentError` from `GoodSorcery.configure` with a message saying what to use instead. Setting `config.active_job_queue` raises `NoMethodError`.
+
 ## 0.2.0 (2026-11-07)
 
 - **Performance monitoring** (opt-in, `config.performance_monitoring = true` or `GOODSORCERY_PERFORMANCE_MONITORING=1`). Records every Rails request and every Active Job and Sidekiq job: count, failures, total time and a shared log-scale histogram (`gs-v1`) with database, external HTTP, view and Ruby time per bucket, plus queue wait for jobs. Metrics are aggregated per transaction per minute in process and sent once a minute to `POST /api/v1/apm/metrics` from a background thread (`goodsorcery-apm`).

data/README.md

@@ -99,14 +99,13 @@ Change settings inside `GoodSorcery.configure`: it recompiles the filters and re
 | `send_job_arguments` | `true` | `false` never sends Active Job, mailer or Sidekiq arguments. |
 | `install_check` | `:verify` | `:verify`, `:test_event` or `false`; see [Install check](#install-check). |
 | `logger` | `Logger.new($stderr)` at `WARN` (`Rails.logger` in Rails) | The gem's own messages, prefixed `[goodsorcery]`. |
-| `delivery` | `:async` | See [Delivery](#delivery). |
+| `delivery` | `:async` | `:async`, `:sync` or `:test`; see [Delivery](#delivery). |
 | `batch_size` | `25` | Events per request, 1–100. |
 | `flush_interval` | `2.0` s | Longest an event waits in the queue. |
 | `max_queue_size` | `1_000` | Events beyond this are dropped and counted. |
 | `max_retries` | `3` | For `5xx`/network failures (exponential backoff with jitter, capped at 60 s). |
 | `shutdown_timeout` | `5` s | How long the exit hook waits for the queue to drain. |
 | `open_timeout` / `read_timeout` | `2` s / `5` s | HTTP timeouts (writes use `read_timeout`). |
-| `active_job_queue` | `"default"` | Queue for `delivery = :active_job`. |
 | `performance_monitoring` | `false` (or `ENV["GOODSORCERY_PERFORMANCE_MONITORING"]` `1`/`0`) | Records every request and job and sends metrics once a minute; see [Performance monitoring](#performance-monitoring). Read when the app boots. |
 | `performance_traces` | `true` | Also sends the timeline of the slowest request per transaction per minute. `false` sends metrics only. |
 | `performance_ignore_transactions` | `["Rails::HealthController#show"]` | Transaction names (exact strings) or regexps never recorded. |
@@ -116,10 +115,10 @@ Change settings inside `GoodSorcery.configure`: it recompiles the filters and re
 | `config.delivery` | What it does | When to use |
 |---|---|---|
 | `:async` (default) | Pushes events onto a bounded in-memory queue. One background thread (`goodsorcery-worker`) sends them to `POST /api/v1/events/batch` when `batch_size` events are waiting or `flush_interval` has passed. Restarts after `fork`; drains at exit. | Web apps and job workers (almost everyone). |
-| `:sync` | Sends each event immediately in the calling thread. | Scripts, rake tasks, serverless functions, debugging. |
-| `:active_job` | Enqueues `GoodSorcery::DeliveryJob` with the filtered event as JSON; the job sends it and retries `429`/`5xx` (5 attempts). Falls back to `:async` if enqueueing fails. **The filtered event is stored in your job backend.** | Apps that want delivery to survive a crash and already run a durable queue. |
+| `:sync` | Sends each event in the calling thread, before `notify` returns. | Serverless functions and other short-lived processes where a background thread doesn't get to run, such as AWS Lambda (the process is frozen between invocations). **Not for normal web apps:** every report adds an HTTPS round trip to the request that hit the error. |
 | `:test` | Keeps events in memory (`GoodSorcery.test_events`). Never touches the network and ignores the environment check. | Your app's test suite. |
-| any object | Must respond to `deliver(event_hash)`; may respond to `flush(timeout)` and `shutdown(timeout)`. | Custom transports. |
+
+Any other value raises an `ArgumentError` from `GoodSorcery.configure`, when the app boots. The `:active_job` delivery and custom delivery objects were removed; use `:async`.
 
 ### Environments
 
@@ -209,7 +208,7 @@ Nothing to set up beyond the initializer. The Railtie:
 - inserts `GoodSorcery::Rack::Middleware` right after `ActionDispatch::ShowExceptions`, so it sees exceptions before Rails renders the error page. Errors that a lower layer turned into a 5xx response (`env["action_dispatch.exception"]`) are reported too;
 - subscribes to `Rails.error`: unhandled errors are reported at level `error`, handled ones (`Rails.error.handle`, `Rails.error.report(handled: true)`) at their severity (`warning` by default). Set `report_handled_errors = false` to skip handled ones;
 - finds the user with the controller's `user_method` (default `current_user`, private methods too), else `Current.user`, and sends only `id`, `email`, `username` and `name`;
-- wraps Active Job's `perform_now` outside the job's own `rescue_from`/`retry_on`, so a job is reported once when it finally fails, not on every attempt it retries itself. `GoodSorcery::DeliveryJob` is never reported;
+- wraps Active Job's `perform_now` outside the job's own `rescue_from`/`retry_on`, so a job is reported once when it finally fails, not on every attempt it retries itself;
 - wraps Action Cable channel subscribe, unsubscribe and actions; errors your channel's `rescue_from` handles are not reported;
 - records breadcrumbs from `ActiveSupport::Notifications` inside requests, jobs and channel actions: `start_processing.action_controller`, `sql.active_record` (without `SCHEMA`, `CACHE` and `TRANSACTION` queries; SQL capped at 1,000 chars, with quoted strings and numbers replaced by `?` so inlined values never leave the app), `perform.active_job` and `deliver.action_mailer`. Turn them off with `config.breadcrumbs = false`;
 - loads the `goodsorcery:verify` and `goodsorcery:test` tasks and reports exceptions that end a rake task.

data/lib/generators/goodsorcery/install/templates/initializer.rb

@@ -27,7 +27,7 @@ GoodSorcery.configure do |config|
   # config.send_job_arguments = true                     # false = never send job arguments
 
   # --- Delivery --------------------------------------------------------------
-  # config.delivery = :async                             # :sync, :active_job, :test or a custom object
+  # config.delivery = :async                             # :sync (serverless, e.g. AWS Lambda) or :test
   # config.batch_size = 25
   # config.flush_interval = 2.0
   # config.max_queue_size = 1_000
@@ -35,7 +35,6 @@ GoodSorcery.configure do |config|
   # config.shutdown_timeout = 5
   # config.open_timeout = 2
   # config.read_timeout = 5
-  # config.active_job_queue = "default"                  # with delivery = :active_job
 
   # --- What gets reported ----------------------------------------------------
   # config.release = ENV["GIT_SHA"]                      # auto-detected from deploy env vars or REVISION

data/lib/goodsorcery/client.rb

@@ -4,7 +4,6 @@ module GoodSorcery
   # Wires configuration to the event pipeline and the delivery. One client
   # per process, built lazily; GoodSorcery.configure rebuilds its parts.
   class Client
-    NETWORK_DELIVERIES = %i[async sync active_job].freeze
     REPORTING_KEY = :__goodsorcery_reporting
 
     attr_reader :config, :log
@@ -74,14 +73,11 @@ module GoodSorcery
     end
 
     # Whether performance monitoring may run (DESIGN.md 8.1): with the :test
-    # delivery, or a network delivery in an enabled environment with a key.
+    # delivery, or in an enabled environment with a key.
     def performance_allowed?
       return true if test_delivery?
-      return @gate.enabled? && !config.api_key.to_s.empty? if NETWORK_DELIVERIES.include?(config.delivery)
 
-      log.warn_once(:apm_custom_delivery,
-                    "performance monitoring needs the :async, :sync or :active_job delivery; it is off")
-      false
+      @gate.enabled? && !config.api_key.to_s.empty?
     end
 
     def verify
@@ -158,7 +154,7 @@ module GoodSorcery
     end
 
     def skip?(exception)
-      ReportedMark.reported?(exception) || exception.is_a?(RetryableDeliveryError) || ignore_list.ignore?(exception)
+      ReportedMark.reported?(exception) || ignore_list.ignore?(exception)
     end
 
     def test_delivery?
@@ -166,7 +162,6 @@ module GoodSorcery
     end
 
     def credentials_present?
-      return true unless NETWORK_DELIVERIES.include?(config.delivery)
       return true unless config.api_key.to_s.empty?
 
       log.warn_once(:missing_api_key,

data/lib/goodsorcery/configuration.rb

@@ -11,17 +11,17 @@ module GoodSorcery
     extend Validation
     include PerformanceSettings
 
-    DELIVERIES = %i[async sync active_job test].freeze
+    DELIVERIES = %i[async sync test].freeze
     DELIVERY_SETTINGS = %i[
       delivery api_key endpoint batch_size flush_interval max_queue_size shutdown_timeout
-      max_retries open_timeout read_timeout active_job_queue
+      max_retries open_timeout read_timeout
     ].freeze
 
     attr_writer :api_key, :environment, :release, :logger, :root
     attr_accessor :disabled_environments, :enabled_environments, :filter_params,
                   :use_rails_filter_parameters, :extra_filters, :ignore_exceptions, :tags,
                   :user_method, :send_code_context, :breadcrumbs,
-                  :report_handled_errors, :active_job_queue, :request_extractor,
+                  :report_handled_errors, :request_extractor,
                   :send_request_params, :send_request_headers, :send_session, :send_job_arguments
     attr_reader :delivery, :batch_size, :flush_interval, :max_queue_size,
                 :shutdown_timeout, :max_retries, :open_timeout, :read_timeout,
@@ -121,9 +121,8 @@ module GoodSorcery
     # Never shows the API key (or endpoint credentials): consoles, error
     # pages and loggers print objects with #inspect.
     def inspect
-      delivery_name = delivery.is_a?(Symbol) ? delivery.inspect : delivery.class.name
       "#<#{self.class.name} api_key=#{masked_api_key} endpoint=#{endpoint_label} " \
-        "environment=#{environment} delivery=#{delivery_name}>"
+        "environment=#{environment} delivery=#{delivery.inspect}>"
     end
 
     private
@@ -146,7 +145,6 @@ module GoodSorcery
       @max_retries = 3
       @open_timeout = 2
       @read_timeout = 5
-      @active_job_queue = "default"
     end
 
     def assign_behaviour_defaults
@@ -193,15 +191,28 @@ module GoodSorcery
     end
   end
 
-  # Normalizes and validates config.delivery.
+  # Normalizes and validates config.delivery. The message names a rejected
+  # symbol but only the class of anything else, which may hold credentials.
   module DeliverySetting
+    REMOVED = {
+      active_job: "The :active_job delivery was removed: use :async (the default), " \
+                  "which sends events from a background thread."
+    }.freeze
+    CUSTOM_REMOVED = "Custom delivery objects are no longer supported: use :async (the default), " \
+                     ":sync in serverless functions or :test in your test suite."
+
     def self.normalize(value)
       symbol = value.is_a?(String) ? value.to_sym : value
       return symbol if Configuration::DELIVERIES.include?(symbol)
-      return value if !value.is_a?(Symbol) && value.respond_to?(:deliver)
 
-      raise ArgumentError, "delivery must be one of #{Configuration::DELIVERIES.map(&:inspect).join(", ")} " \
-                           "or an object responding to #deliver (got a #{value.class})"
+      raise ArgumentError, message(symbol, value)
+    end
+
+    def self.message(symbol, value)
+      got = symbol.is_a?(Symbol) ? symbol.inspect : "an instance of #{value.class}"
+      hint = symbol.is_a?(Symbol) ? REMOVED[symbol] : (CUSTOM_REMOVED if value.respond_to?(:deliver))
+      ["delivery must be one of #{Configuration::DELIVERIES.map(&:inspect).join(", ")} (got #{got}).", hint]
+        .compact.join(" ")
     end
   end
 end

data/lib/goodsorcery/defaults.rb

@@ -37,7 +37,7 @@ module GoodSorcery
     ].freeze
 
     # Transactions (exact names or regexps) that performance monitoring
-    # never records. GoodSorcery::DeliveryJob is always skipped as well.
+    # never records.
     PERFORMANCE_IGNORE_TRANSACTIONS = ["Rails::HealthController#show"].freeze
 
     DISABLED_ENVIRONMENTS = %w[development test].freeze

data/lib/goodsorcery/delivery.rb

@@ -6,20 +6,17 @@ require_relative "delivery/worker"
 require_relative "delivery/async"
 require_relative "delivery/sync"
 require_relative "delivery/test"
-require_relative "delivery/custom"
-require_relative "delivery/active_job_queue"
 
 module GoodSorcery
-  # Delivery strategies (config.delivery). Each exposes deliver(event),
+  # Delivery strategies (config.delivery: :async, :sync or :test; the
+  # setter rejects anything else). Each exposes deliver(event),
   # flush(timeout) and shutdown(timeout).
   module Delivery
     def self.build(config, client)
       case config.delivery
-      when :async then async(config, client.transport, client.serializer, client.log)
       when :sync then Sync.new(transport: client.transport, serializer: client.serializer, log: client.log)
       when :test then Test.new
-      when :active_job then active_job(config, client)
-      else Custom.new(config.delivery)
+      else async(config, client.transport, client.serializer, client.log)
       end
     end
 
@@ -29,11 +26,5 @@ module GoodSorcery
                 max_queue_size: config.max_queue_size, max_retries: config.max_retries,
                 shutdown_timeout: config.shutdown_timeout)
     end
-
-    def self.active_job(config, client)
-      ActiveJobQueue.new(serializer: client.serializer, queue_name: config.active_job_queue, log: client.log) do
-        async(config, client.transport, client.serializer, client.log)
-      end
-    end
   end
 end

data/lib/goodsorcery/errors.rb

@@ -7,8 +7,4 @@ module GoodSorcery
   # Raised (and rescued) by `goodsorcery:test` and the install check to send a
   # realistic test exception.
   class TestError < StandardError; end
-
-  # Raised by GoodSorcery::DeliveryJob so ActiveJob retries a delivery that
-  # failed with a 429, a 5xx or a network error.
-  class RetryableDeliveryError < Error; end
 end

data/lib/goodsorcery/integrations/active_job.rb

@@ -25,7 +25,6 @@ module GoodSorcery
         end
 
         def perform_now
-          return super if Integrations.delivery_job?(self)
           return Integrations.run_unit_of_work(JobDetails.new(self)) { super } unless Performance.active?
 
           Performance.measure_job(Performance::ActiveJobTiming.new(self)) do

data/lib/goodsorcery/integrations/rails/error_subscriber.rb

@@ -12,7 +12,7 @@ module GoodSorcery
 
         def report(error, handled:, severity: nil, context: {}, source: nil)
           return if handled && !GoodSorcery.configuration.report_handled_errors
-          return if ReportedMark.reported?(error) || from_delivery_job?(context)
+          return if ReportedMark.reported?(error)
 
           GoodSorcery.notify(error, level: level(handled, severity),
                                     context: { "rails_error" => rails_error_context(context, source) })
@@ -24,10 +24,6 @@ module GoodSorcery
           handled ? LEVELS.fetch(severity.to_s.to_sym, "warning") : "error"
         end
 
-        def from_delivery_job?(context)
-          context.is_a?(Hash) && Integrations.delivery_job?(context[:job])
-        end
-
         # Controllers and jobs from Rails' execution context become
         # "#<ClassName>"; records become GlobalID strings.
         def rails_error_context(context, source)

data/lib/goodsorcery/integrations.rb

@@ -5,12 +5,6 @@ module GoodSorcery
   # unit of work and leaves an enricher that reads its details only when an
   # error is reported.
   module Integrations
-    # GoodSorcery::DeliveryJob sends events; errors it raises are never
-    # reported (no recursion).
-    def self.delivery_job?(object)
-      GoodSorcery.const_defined?(:DeliveryJob, false) && object.is_a?(GoodSorcery::DeliveryJob)
-    end
-
     # Runs the block in a fresh scope prepared by +details+ (an object with
     # +open(scope)+), reporting any exception that escapes it, then
     # re-raising.

data/lib/goodsorcery/performance/agent.rb

@@ -76,15 +76,14 @@ module GoodSorcery
       end
     end
 
-    # performance_ignore_transactions: exact names or regexps, plus the gem's
-    # own delivery job. Answers are cached per name.
+    # performance_ignore_transactions: exact names or regexps. Answers are
+    # cached per name.
     class IgnoreMatcher
-      ALWAYS = ["GoodSorcery::DeliveryJob"].freeze
       MAX_CACHED = 1_000
 
       def initialize(list)
         entries = Array(list)
-        @names = (entries.grep_v(Regexp).map(&:to_s) + ALWAYS).to_h { |name| [name, true] }
+        @names = entries.grep_v(Regexp).map(&:to_s).to_h { |name| [name, true] }
         @patterns = entries.grep(Regexp)
         @cache = {}
       end

data/lib/goodsorcery/status_report.rb

@@ -43,8 +43,7 @@ module GoodSorcery
     end
 
     def delivery_label
-      delivery = @config.delivery
-      delivery.is_a?(Symbol) ? delivery.to_s : delivery.class.name.to_s
+      @config.delivery.to_s
     end
   end
 end

data/lib/goodsorcery/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module GoodSorcery
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
   NOTIFIER_NAME = "goodsorcery-ruby"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: goodsorcery
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Philip Q Nguyen
@@ -36,15 +36,12 @@ files:
 - lib/goodsorcery/configuration/validation.rb
 - lib/goodsorcery/defaults.rb
 - lib/goodsorcery/delivery.rb
-- lib/goodsorcery/delivery/active_job_queue.rb
 - lib/goodsorcery/delivery/async.rb
 - lib/goodsorcery/delivery/backoff.rb
-- lib/goodsorcery/delivery/custom.rb
 - lib/goodsorcery/delivery/event_queue.rb
 - lib/goodsorcery/delivery/sync.rb
 - lib/goodsorcery/delivery/test.rb
 - lib/goodsorcery/delivery/worker.rb
-- lib/goodsorcery/delivery_job.rb
 - lib/goodsorcery/env_flag.rb
 - lib/goodsorcery/environment_gate.rb
 - lib/goodsorcery/errors.rb

data/lib/goodsorcery/delivery/active_job_queue.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module GoodSorcery
-  module Delivery
-    # Enqueues GoodSorcery::DeliveryJob with the filtered event as a JSON
-    # string. Falls back to the background thread when ActiveJob is not loaded
-    # or enqueueing raises. Note: the event is stored in the job backend.
-    class ActiveJobQueue
-      def initialize(serializer:, queue_name:, log:, &fallback_builder)
-        @serializer = serializer
-        @queue_name = queue_name
-        @log = log
-        @fallback_builder = fallback_builder
-        @fallback = nil
-        @lock = Mutex.new
-      end
-
-      def deliver(event)
-        job = DeliveryJobLoader.job_class
-        return deliver_in_background(event, "ActiveJob is not loaded") unless job
-
-        json = @serializer.dump(event)
-        return false unless json
-
-        return true if enqueued?(job.set(queue: @queue_name).perform_later(json))
-
-        deliver_in_background(event, "GoodSorcery::DeliveryJob was not enqueued")
-      rescue StandardError => e
-        deliver_in_background(event, "enqueueing GoodSorcery::DeliveryJob failed (#{e.class})")
-      end
-
-      def flush(timeout = 5)
-        @fallback ? @fallback.flush(timeout) : true
-      end
-
-      def shutdown(timeout = 5)
-        @fallback ? @fallback.shutdown(timeout) : true
-      end
-
-      private
-
-      # perform_later returns false when a callback aborted the enqueue or
-      # the adapter raised ActiveJob::EnqueueError.
-      def enqueued?(job)
-        return false unless job
-
-        job.respond_to?(:successfully_enqueued?) ? job.successfully_enqueued? != false : true
-      end
-
-      def deliver_in_background(event, reason)
-        @log.warn_every(:active_job_fallback, 60, "#{reason}; delivering in the background thread instead")
-        fallback.deliver(event)
-      end
-
-      def fallback
-        @fallback || @lock.synchronize { @fallback ||= @fallback_builder.call }
-      end
-    end
-
-    # Defines GoodSorcery::DeliveryJob on first use, once ActiveJob is loaded.
-    module DeliveryJobLoader
-      def self.job_class
-        return GoodSorcery::DeliveryJob if GoodSorcery.const_defined?(:DeliveryJob, false)
-        return nil unless defined?(::ActiveJob::Base)
-
-        require_relative "../delivery_job"
-        GoodSorcery::DeliveryJob
-      end
-    end
-  end
-end

data/lib/goodsorcery/delivery/custom.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module GoodSorcery
-  module Delivery
-    # Wraps an app-supplied delivery object. It must respond to
-    # deliver(event_hash) and may respond to flush(timeout) and shutdown(timeout).
-    class Custom
-      attr_reader :target
-
-      def initialize(target)
-        @target = target
-      end
-
-      def deliver(event)
-        @target.deliver(event)
-      end
-
-      def flush(timeout = 5)
-        @target.respond_to?(:flush) ? @target.flush(timeout) : true
-      end
-
-      def shutdown(timeout = 5)
-        @target.respond_to?(:shutdown) ? @target.shutdown(timeout) : true
-      end
-    end
-  end
-end

data/lib/goodsorcery/delivery_job.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module GoodSorcery
-  # Sends one already-filtered event (a JSON string) synchronously. Retries
-  # 429/5xx/network failures with ActiveJob's retry_on. Any exception raised
-  # here is marked as reported first, so no integration reports it back to
-  # Good Sorcery (no recursion). The argument is captured error data, so
-  # Active Job never writes it to the log.
-  class DeliveryJob < ::ActiveJob::Base
-    WAIT = ::ActiveJob.gem_version >= Gem::Version.new("7.1") ? :polynomially_longer : :exponentially_longer
-
-    self.log_arguments = false
-    queue_as { GoodSorcery.configuration.active_job_queue }
-    retry_on GoodSorcery::RetryableDeliveryError, wait: WAIT, attempts: 5
-
-    def perform(event_json)
-      result = GoodSorcery.client.transport.post_event(event_json)
-      return unless result.retry_later?
-
-      raise GoodSorcery::RetryableDeliveryError, "event delivery failed (#{result.description})"
-    rescue Exception => e # rubocop:disable Lint/RescueException
-      ReportedMark.mark(e)
-      raise
-    end
-  end
-end