webhookdb 1.3.1 → 1.4.0

data/lib/webhookdb/replicator/transistor_episode_v1.rb

@@ -141,11 +141,17 @@ class Webhookdb::Replicator::TransistorEpisodeV1 < Webhookdb::Replicator::Base
     transcript_url = resource.fetch("attributes").fetch("transcript_url", nil)
     return nil if transcript_url.blank?
     (transcript_url += ".txt") unless transcript_url.end_with?(".txt")
-    resp = Webhookdb::Http.get(
-      transcript_url,
-      logger: self.logger,
-      timeout: Webhookdb::Transistor.http_timeout,
-    )
+    begin
+      resp = Webhookdb::Http.get(
+        transcript_url,
+        logger: self.logger,
+        timeout: Webhookdb::Transistor.http_timeout,
+      )
+    rescue Webhookdb::Http::Error => e
+      # Not sure why this happens, but nothing we can do if it does.
+      return nil if e.status == 404
+      raise e
+    end
     transcript_text = resp.body
     return {transcript_text:}
   end

data/lib/webhookdb/replicator/webhook_request.rb

@@ -6,4 +6,12 @@ class Webhookdb::Replicator::WebhookRequest < Webhookdb::TypedStruct
   # When a webhook is processed synchronously, this will be set to the Rack::Request.
   # Normal (async) webhook processing does not have this available.
   attr_accessor :rack_request
+
+  JSON_KEYS = ["body", "headers", "path", "method"].freeze
+  def as_json
+    return JSON_KEYS.each_with_object({}) do |k, h|
+      v = self.send(k)
+      h[k] = v.as_json unless v.nil?
+    end
+  end
 end

data/lib/webhookdb/replicator.rb

@@ -15,11 +15,11 @@ class Webhookdb::Replicator
   PLUGIN_DIR = Pathname(__FILE__).dirname + PLUGIN_DIRNAME
 
   # Raised when there is no service registered for a name.
-  class Invalid < StandardError; end
+  class Invalid < Webhookdb::WebhookdbError; end
 
   # Raised when credentials to interact with a service are not set up.
   # Usually this is due to a missing dependency.
-  class CredentialsMissing < StandardError; end
+  class CredentialsMissing < Webhookdb::WebhookdbError; end
 
   # Statically describe a replicator.
   class Descriptor < Webhookdb::TypedStruct

data/lib/webhookdb/service/view_api.rb

@@ -3,7 +3,7 @@
 # Mixin for Grape API endpoints that use HTML rendering.
 # This isn't tested well enough.
 module Webhookdb::Service::ViewApi
-  class FormError < StandardError
+  class FormError < Webhookdb::WebhookdbError
     attr_reader :status
 
     def initialize(msg, status=400)

data/lib/webhookdb/service.rb

@@ -163,6 +163,10 @@ class Webhookdb::Service < Grape::API
     error!(e.message, 405)
   end
 
+  rescue_from Webhookdb::ExceptionCarrier do |e|
+    merror!(e.status, e.message, code: e.code, more: e.more, headers: e.headers)
+  end
+
   rescue_from Webhookdb::LockFailed do |_e|
     merror!(
       409,
@@ -191,17 +195,7 @@ class Webhookdb::Service < Grape::API
     status = e.respond_to?(:status) ? e.status : 500
     error_id = SecureRandom.uuid
     error_signature = Digest::MD5.hexdigest("#{e.class}: #{e.message}")
-
-    Webhookdb::Service.logger.error "[%s] Uncaught %p in service: %s" %
-      [error_id, e.class, e.message]
-    Webhookdb::Service.logger.debug { e.backtrace.join("\n") }
-    if ENV["PRINT_API_ERROR"]
-      puts e
-      puts e.backtrace
-    end
-
     more = {error_id:, error_signature:}
-
     if Webhookdb::Service.devmode
       msg = e.message
       more[:backtrace] = e.backtrace.join("\n")
@@ -210,6 +204,12 @@ class Webhookdb::Service < Grape::API
       msg = "An internal error occurred of type #{error_signature}. Error ID: #{error_id}"
     end
     Webhookdb::Service.logger.error("api_exception", {error_id:, error_signature:}, e)
+    Webhookdb::Service.logger.debug { e.backtrace.join("\n") }
+    if ENV["PRINT_API_ERROR"]
+      puts e
+      puts e.backtrace
+    end
+
     merror!(status, msg, code: "api_error", more:)
   end
 

data/lib/webhookdb/service_integration.rb

@@ -6,6 +6,8 @@ require "webhookdb/postgres/model"
 require "sequel/plugins/soft_deletes"
 
 class Webhookdb::ServiceIntegration < Webhookdb::Postgres::Model(:service_integrations)
+  include Webhookdb::Admin::Linked
+
   class TableRenameError < Webhookdb::InvalidInput; end
 
   # We limit the information that a user can access through the CLI to these fields.
@@ -70,7 +72,7 @@ class Webhookdb::ServiceIntegration < Webhookdb::Postgres::Model(:service_integr
                 end)
 
   many_to_one :depends_on, class: self
-  one_to_many :dependents, key: :depends_on_id, class: self
+  one_to_many :dependents, key: :depends_on_id, class: self, order: :id
   one_to_many :sync_targets, class: "Webhookdb::SyncTarget"
 
   # @return [Webhookdb::ServiceIntegration]
@@ -139,10 +141,21 @@ class Webhookdb::ServiceIntegration < Webhookdb::Postgres::Model(:service_integr
         select { |si| si.service_name == dep_descr.name }
   end
 
+  # Return all dependents (integrations that depend on this one), breadth-first
+  # (that is, all children before grandchildren).
+  # @return [Array<Webhookdb::ServiceIntegration>]
   def recursive_dependents
     return self.dependents + self.dependents.flat_map(&:recursive_dependents)
   end
 
+  # Return all service integrations this one depends on,
+  # in closest-ancestor order (that is, parent before grandparent).
+  # @return [Array<Webhookdb::ServiceIntegration>]
+  def recursive_dependencies
+    return [] if self.depends_on.nil?
+    return [self.depends_on].concat(self.depends_on.recursive_dependencies)
+  end
+
   def destroy_self_and_all_dependents
     self.dependents.each(&:destroy_self_and_all_dependents)
 

data/lib/webhookdb/spec_helpers/shared_examples_for_replicators.rb

@@ -4,12 +4,18 @@ require "webhookdb/spec_helpers/whdb"
 
 # The basics: these shared examples are among the most commonly used.
 
-RSpec.shared_examples "a replicator" do |name|
-  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name: name) }
+# @param supports_rowupsert: If true, this replicator will emit the rowupsert event when rows change.
+# Nearly all replicators support this, but in some cases, replicators may not want to,
+# especially when they otherwise do not adhere to normal replicator design.
+# Usually this is only the case in enterprise intergrations.
+#
+# @param supports_row_diff: If true, test that the rowupsert event is not emitted when the row has not changed.
+RSpec.shared_examples "a replicator" do |supports_rowupsert: true, supports_row_diff: true|
+  let(:service_name) { described_class.descriptor.name }
+  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name:) }
   let(:svc) { Webhookdb::Replicator.create(sint) }
   let(:body) { raise NotImplementedError }
   let(:expected_data) { body }
-  let(:supports_row_diff) { true }
   let(:expected_row) { nil }
   Webhookdb::SpecHelpers::Whdb.setup_upsert_webhook_example(self)
 
@@ -70,48 +76,50 @@ RSpec.shared_examples "a replicator" do |name|
     end
   end
 
-  it "emits the rowupsert event if the row has changed", :async, :do_not_defer_events, sidekiq: :fake do
-    Webhookdb::Fixtures.webhook_subscription(service_integration: sint).create
-    svc.create_table
-    upsert_webhook(svc, body:)
-    expect(Sidekiq).to have_queue.consisting_of(
-      job_hash(
-        Webhookdb::Jobs::SendWebhook,
-        args: contain_exactly(
-          hash_including(
-            "id",
-            "name" => "webhookdb.serviceintegration.rowupsert",
-            "payload" => [
-              sint.id,
-              hash_including("external_id", "external_id_column", "row" => hash_including("data")),
-            ],
+  if supports_rowupsert
+    it "emits the rowupsert event if the row has changed", :async, :do_not_defer_events, sidekiq: :fake do
+      Webhookdb::Fixtures.webhook_subscription(service_integration: sint).create
+      svc.create_table
+      upsert_webhook(svc, body:)
+      expect(Sidekiq).to have_queue.consisting_of(
+        job_hash(
+          Webhookdb::Jobs::SendWebhook,
+          args: contain_exactly(
+            hash_including(
+              "id",
+              "name" => "webhookdb.serviceintegration.rowupsert",
+              "payload" => [
+                sint.id,
+                hash_including("external_id", "external_id_column", "row" => hash_including("data")),
+              ],
+            ),
           ),
         ),
-      ),
-    )
-  end
+      )
+    end
 
-  it "does not emit the rowupsert event if the row has not changed", :async, :do_not_defer_events, sidekiq: :fake do
     if supports_row_diff
-      Webhookdb::Fixtures.webhook_subscription(service_integration: sint).create
-      expect(Webhookdb::Jobs::SendWebhook).to receive(:perform_async).once
+      it "does not emit the rowupsert event if the row has not changed", :async, :do_not_defer_events, sidekiq: :fake do
+        Webhookdb::Fixtures.webhook_subscription(service_integration: sint).create
+        expect(Webhookdb::Jobs::SendWebhook).to receive(:perform_async).once
+        svc.create_table
+        upsert_webhook(svc, body:) # Upsert and make sure the next does not run
+        expect do
+          upsert_webhook(svc, body:)
+        end.to_not publish("webhookdb.serviceintegration.rowupsert")
+        expect(Sidekiq).to have_empty_queues
+      end
+    end
+
+    it "does not emit the rowupsert event if there are no subscriptions", :async, :do_not_defer_events do
+      # No subscription is created so should not publish
       svc.create_table
-      upsert_webhook(svc, body:) # Upsert and make sure the next does not run
       expect do
         upsert_webhook(svc, body:)
       end.to_not publish("webhookdb.serviceintegration.rowupsert")
-      expect(Sidekiq).to have_empty_queues
     end
   end
 
-  it "does not emit the rowupsert event if there are no subscriptions", :async, :do_not_defer_events do
-    # No subscription is created so should not publish
-    svc.create_table
-    expect do
-      upsert_webhook(svc, body:)
-    end.to_not publish("webhookdb.serviceintegration.rowupsert")
-  end
-
   it "can serve a webhook response" do
     create_all_dependencies(sint)
     request = fake_request
@@ -174,7 +182,8 @@ RSpec.shared_examples "a replicator" do |name|
   end
 end
 
-RSpec.shared_examples "a replicator with dependents" do |service_name, dependent_service_name|
+RSpec.shared_examples "a replicator with dependents" do |dependent_service_name|
+  let(:service_name) { described_class.descriptor.name }
   let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name:) }
   let(:svc) { Webhookdb::Replicator.create(sint) }
   let(:body) { raise NotImplementedError }
@@ -218,7 +227,8 @@ RSpec.shared_examples "a replicator with dependents" do |service_name, dependent
   end
 end
 
-RSpec.shared_examples "a replicator dependent on another" do |service_name, dependency_service_name|
+RSpec.shared_examples "a replicator dependent on another" do |dependency_service_name|
+  let(:service_name) { described_class.descriptor.name }
   let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name:) }
   let(:svc) { Webhookdb::Replicator.create(sint) }
 
@@ -250,8 +260,9 @@ RSpec.shared_examples "a replicator dependent on another" do |service_name, depe
   end
 end
 
-RSpec.shared_examples "a replicator that prevents overwriting new data with old" do |name|
-  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name: name) }
+RSpec.shared_examples "a replicator that prevents overwriting new data with old" do
+  let(:service_name) { described_class.descriptor.name }
+  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name:) }
   let(:svc) { Webhookdb::Replicator.create(sint) }
   let(:old_body) { raise NotImplementedError }
   let(:new_body) { raise NotImplementedError }
@@ -313,11 +324,12 @@ RSpec.shared_examples "a replicator that prevents overwriting new data with old"
   end
 end
 
-RSpec.shared_examples "a replicator that can backfill" do |name|
+RSpec.shared_examples "a replicator that can backfill" do
   let(:api_url) { "https://fake-url.com" }
+  let(:service_name) { described_class.descriptor.name }
   let(:sint) do
     Webhookdb::Fixtures.service_integration.create(
-      service_name: name,
+      service_name:,
       backfill_key: "bfkey",
       backfill_secret: "bfsek",
       api_url:,
@@ -427,8 +439,9 @@ end
 
 # These shared examples test the way a replicator synthesizes and retrieves information from the API.
 
-RSpec.shared_examples "a replicator that may have a minimal body" do |name|
-  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name: name) }
+RSpec.shared_examples "a replicator that may have a minimal body" do
+  let(:service_name) { described_class.descriptor.name }
+  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name:) }
   let(:svc) { Webhookdb::Replicator.create(sint) }
   let(:body) { raise NotImplementedError }
   let(:other_bodies) { [] }
@@ -453,8 +466,9 @@ RSpec.shared_examples "a replicator that may have a minimal body" do |name|
   end
 end
 
-RSpec.shared_examples "a replicator that deals with resources and wrapped events" do |name|
-  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name: name) }
+RSpec.shared_examples "a replicator that deals with resources and wrapped events" do
+  let(:service_name) { described_class.descriptor.name }
+  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name:) }
   let(:svc) { Webhookdb::Replicator.create(sint) }
   let(:resource_json) { raise NotImplementedError }
   let(:resource_in_envelope_json) { raise NotImplementedError }
@@ -489,8 +503,9 @@ RSpec.shared_examples "a replicator that deals with resources and wrapped events
   end
 end
 
-RSpec.shared_examples "a replicator that uses enrichments" do |name, stores_enrichment_column: true|
-  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name: name) }
+RSpec.shared_examples "a replicator that uses enrichments" do |stores_enrichment_column: true|
+  let(:service_name) { described_class.descriptor.name }
+  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name:) }
   let(:svc) { Webhookdb::Replicator.create(sint) }
   let(:body) { raise NotImplementedError }
   # Needed if stores_enrichment_column is true
@@ -549,8 +564,9 @@ RSpec.shared_examples "a replicator that uses enrichments" do |name, stores_enri
   end
 end
 
-RSpec.shared_examples "a replicator that upserts webhooks only under specific conditions" do |name|
-  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name: name) }
+RSpec.shared_examples "a replicator that upserts webhooks only under specific conditions" do
+  let(:service_name) { described_class.descriptor.name }
+  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name:) }
   let(:svc) { Webhookdb::Replicator.create(sint) }
   let(:incorrect_webhook) { raise NotImplementedError }
   Webhookdb::SpecHelpers::Whdb.setup_upsert_webhook_example(self)
@@ -574,8 +590,9 @@ end
 
 # These shared examples can be used to test replicators that support webhooks.
 
-RSpec.shared_examples "a webhook validating replicator that uses credentials from a dependency" do |name|
-  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name: name) }
+RSpec.shared_examples "a webhook validating replicator that uses credentials from a dependency" do
+  let(:service_name) { described_class.descriptor.name }
+  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name:) }
 
   before(:each) do
     create_all_dependencies(sint)
@@ -597,8 +614,9 @@ RSpec.shared_examples "a webhook validating replicator that uses credentials fro
   end
 end
 
-RSpec.shared_examples "a replicator that processes webhooks synchronously" do |name|
-  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name: name) }
+RSpec.shared_examples "a replicator that processes webhooks synchronously" do
+  let(:service_name) { described_class.descriptor.name }
+  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name:) }
   let(:svc) { Webhookdb::Replicator.create(sint) }
   let(:expected_synchronous_response) { raise NotImplementedError }
   Webhookdb::SpecHelpers::Whdb.setup_upsert_webhook_example(self)
@@ -620,8 +638,9 @@ end
 
 # These shared examples test the intricacies of backfill logic.
 
-RSpec.shared_examples "a backfill replicator that requires credentials from a dependency" do |name|
-  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name: name) }
+RSpec.shared_examples "a backfill replicator that requires credentials from a dependency" do
+  let(:service_name) { described_class.descriptor.name }
+  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name:) }
   let(:error_message) { raise NotImplementedError }
 
   before(:each) do
@@ -640,12 +659,13 @@ RSpec.shared_examples "a backfill replicator that requires credentials from a de
   end
 end
 
-RSpec.shared_examples "a replicator that can backfill incrementally" do |name|
+RSpec.shared_examples "a replicator that can backfill incrementally" do
+  let(:service_name) { described_class.descriptor.name }
   let(:last_backfilled) { raise NotImplementedError, "what should the last_backfilled_at value be to start?" }
   let(:api_url) { "https://fake-url.com" }
   let(:sint) do
     Webhookdb::Fixtures.service_integration.create(
-      service_name: name,
+      service_name:,
       backfill_key: "bfkey",
       backfill_secret: "bfsek",
       api_url:,
@@ -707,6 +727,71 @@ RSpec.shared_examples "a replicator that can backfill incrementally" do |name|
   end
 end
 
+RSpec.shared_examples "a replicator that alerts on backfill auth errors" do
+  let(:service_name) { described_class.descriptor.name }
+  let(:sint_params) { {} }
+  let(:sint) do
+    Webhookdb::Fixtures.service_integration.create(
+      service_name:,
+      backfill_key: "bfkey",
+      backfill_secret: "bfsek",
+      api_url: "https://fake-url.com",
+      **sint_params,
+    )
+  end
+  let(:svc) { Webhookdb::Replicator.create(sint) }
+  let(:template_name) { raise NotImplementedError }
+
+  def stub_service_request
+    raise NotImplementedError, "stub the request without setting the return response"
+  end
+
+  def handled_responses
+    raise NotImplementedError, "Something like: [[:and_return, {status: 401}], [:and_raise, SocketError.new('hi')]]"
+  end
+
+  def unhandled_response
+    raise NotImplementedError, "Something like: [:and_return, {status: 500}]"
+  end
+
+  def insert_required_data_callback
+    # See backfiller example
+    return ->(*) { return }
+  end
+
+  before(:each) do
+    sint.organization.prepare_database_connections
+  end
+
+  after(:each) do
+    sint.organization.remove_related_database
+  end
+
+  it "dispatches an alert and returns true for handled errors" do
+    create_all_dependencies(sint)
+    setup_dependencies(sint, insert_required_data_callback)
+    Webhookdb::Fixtures.organization_membership.org(sint.organization).verified.admin.create
+    req = stub_service_request
+    handled_responses.each { |(m, arg)| req.send(m, arg) }
+    handled_responses.count.times do
+      backfill(sint)
+    end
+    expect(req).to have_been_made.times(handled_responses.count)
+    expect(Webhookdb::Message::Delivery.all).to contain_exactly(
+      have_attributes(template: template_name),
+    )
+  end
+
+  it "does not dispatch an alert, and raises the original error, if unhandled" do
+    create_all_dependencies(sint)
+    setup_dependencies(sint, insert_required_data_callback)
+    Webhookdb::Fixtures.organization_membership.org(sint.organization).verified.admin.create
+    req = stub_service_request.send(*unhandled_response)
+    expect { backfill(sint) }.to raise_error(Amigo::Retry::OrDie)
+    expect(req).to have_been_made
+  end
+end
+
 RSpec.shared_examples "a replicator that verifies backfill secrets" do
   let(:correct_creds_sint) { raise NotImplementedError, "what sint should we use to test correct creds?" }
   let(:incorrect_creds_sint) { raise NotImplementedError, "what sint should we use to test incorrect creds?" }
@@ -748,19 +833,21 @@ RSpec.shared_examples "a replicator that verifies backfill secrets" do
   end
 end
 
-RSpec.shared_examples "a replicator with a custom backfill not supported message" do |name|
+RSpec.shared_examples "a replicator with a custom backfill not supported message" do
+  let(:service_name) { described_class.descriptor.name }
   it "has a custom message" do
-    sint = Webhookdb::Fixtures.service_integration.create(service_name: name)
+    sint = Webhookdb::Fixtures.service_integration.create(service_name:)
     expect(sint.replicator.backfill_not_supported_message).to_not include("You may be looking for one of the following")
   end
 end
 
-RSpec.shared_examples "a backfill replicator that marks missing rows as deleted" do |name|
+RSpec.shared_examples "a backfill replicator that marks missing rows as deleted" do
+  let(:service_name) { described_class.descriptor.name }
   let(:deleted_column_name) { raise NotImplementedError }
   let(:api_url) { "https://fake-url.com" }
   let(:sint) do
     Webhookdb::Fixtures.service_integration.create(
-      service_name: name,
+      service_name:,
       backfill_key: "bfkey",
       backfill_secret: "bfsek",
       api_url:,
@@ -813,11 +900,12 @@ RSpec.shared_examples "a backfill replicator that marks missing rows as deleted"
   end
 end
 
-RSpec.shared_examples "a replicator that ignores HTTP errors during backfill" do |name|
+RSpec.shared_examples "a replicator that ignores HTTP errors during backfill" do
+  let(:service_name) { described_class.descriptor.name }
   let(:api_url) { "https://fake-url.com" }
   let(:sint) do
     Webhookdb::Fixtures.service_integration.create(
-      service_name: name,
+      service_name:,
       backfill_key: "bfkey",
       backfill_secret: "bfsek",
       api_url:,
@@ -856,8 +944,9 @@ RSpec.shared_examples "a replicator that ignores HTTP errors during backfill" do
   end
 end
 
-RSpec.shared_examples "a replicator backfilling against the table of its dependency" do |name|
-  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name: name) }
+RSpec.shared_examples "a replicator backfilling against the table of its dependency" do
+  let(:service_name) { described_class.descriptor.name }
+  let(:sint) { Webhookdb::Fixtures.service_integration.create(service_name:) }
   let(:svc) { Webhookdb::Replicator.create(sint) }
   let(:dep_svc) { @dep_svc }
   let(:external_id_col) { raise NotImplementedError }

data/lib/webhookdb/sync_target.rb

@@ -21,9 +21,9 @@ class Webhookdb::SyncTarget < Webhookdb::Postgres::Model(:sync_targets)
   include Appydays::Configurable
   include Webhookdb::Dbutil
 
-  class Deleted < StandardError; end
-  class InvalidConnection < StandardError; end
-  class SyncInProgress < StandardError; end
+  class Deleted < Webhookdb::WebhookdbError; end
+  class InvalidConnection < Webhookdb::WebhookdbError; end
+  class SyncInProgress < Webhookdb::WebhookdbError; end
 
   # Advisory locks for sync targets use this as the first int, and the id as the second.
   ADVISORY_LOCK_KEYSPACE = 2_000_000_000
@@ -87,8 +87,10 @@ class Webhookdb::SyncTarget < Webhookdb::Postgres::Model(:sync_targets)
   dataset_module do
     def due_for_sync(as_of:)
       never_synced = Sequel[last_synced_at: nil]
-      next_due_at = Sequel[:last_synced_at] + (Sequel.lit("INTERVAL '1 second'") * Sequel[:period_seconds])
-      due_before_now = next_due_at <= as_of
+      # Use 'last_synced_at <= (now - internal)' rather than 'last_synced_at + interval <= now'
+      # so we can use the last_synced_at index.
+      cutoff = (Sequel[as_of].cast("TIMESTAMPTZ") - (Sequel.lit("INTERVAL '1 second'") * Sequel[:period_seconds]))
+      due_before_now = Sequel[:last_synced_at] <= cutoff
       return self.where(never_synced | due_before_now)
     end
   end

data/lib/webhookdb/system_log_event.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "webhookdb/postgres/model"
+
+class Webhookdb::SystemLogEvent < Webhookdb::Postgres::Model(:system_log_events)
+  plugin :text_searchable, terms: [:title, :body]
+
+  many_to_one :actor, class: "Webhookdb::Customer"
+end

data/lib/webhookdb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Webhookdb
-  VERSION = "1.3.1"
+  VERSION = "1.4.0"
 end

data/lib/webhookdb/webhook_subscription.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "webhookdb/jobs/webhook_subscription_delivery_attempt"
+require "webhookdb/jobs/webhook_subscription_delivery_event"
 
 # Webhook subscriptions have a few parts:
 #

data/lib/webhookdb.rb

@@ -35,27 +35,33 @@ module Webhookdb
   include Appydays::Configurable
   extend Webhookdb::MethodUtilities
 
+  # Base class for all WebhookDB errors.
+  class WebhookdbError < StandardError; end
+
+  # Class for errors that usually should not be rescued from.
+  class ProgrammingError < WebhookdbError; end
+
   # Error raised when we cannot take an action
   # because some condition has not been set up right.
-  class InvalidPrecondition < StandardError; end
+  class InvalidPrecondition < ProgrammingError; end
 
   # Error raised when, after we take an action,
   # something we expect to have changed has not changed.
-  class InvalidPostcondition < StandardError; end
+  class InvalidPostcondition < ProgrammingError; end
 
   # Some invariant has been violated, which we never expect to see.
-  class InvariantViolation < StandardError; end
+  class InvariantViolation < ProgrammingError; end
 
   # Error raised when a customer gives us some invalid input.
   # Allows the library to raise the error with the message,
   # and is caught automatically by the service as a 400.
-  class InvalidInput < StandardError; end
+  class InvalidInput < WebhookdbError; end
 
   # Raised when an organization's database cannot be modified.
-  class DatabaseLocked < StandardError; end
+  class DatabaseLocked < WebhookdbError; end
 
   # Used in various places that need to short-circuit code in regression mode.
-  class RegressionModeSkip < StandardError; end
+  class RegressionModeSkip < WebhookdbError; end
 
   APPLICATION_NAME = "Webhookdb"
   RACK_ENV = Appydays::Configurable.fetch_env(["RACK_ENV", "RUBY_ENV"], "development")
@@ -93,6 +99,8 @@ module Webhookdb
     end
   end
 
+  def self.admin_url = self.api_url
+
   # Regression mode is true when we re replaying webhooks locally,
   # or for some other reason, want to disable certain checks we use in production.
   # For example, we may want to ignore certain errors (like if integrations are missing dependency rows),
@@ -134,7 +142,23 @@ module Webhookdb
   # :section: Errors
   #
 
-  class LockFailed < StandardError; end
+  class LockFailed < WebhookdbError; end
+
+  # This exception is rescued in the API and returned to the caller via +merror!+.
+  # This is mostly used in synchronously-processed replicators that need to return
+  # very specific types of errors during processing.
+  # This is very rare.
+  class ExceptionCarrier < WebhookdbError
+    attr_reader :status, :code, :more, :headers
+
+    def initialize(status, message, code: nil, more: {}, headers: {})
+      super(message)
+      @status = status
+      @code = code
+      @more = more
+      @headers = headers
+    end
+  end
 
   ### Generate a key for the specified Sequel model +instance+ and
   ### any additional +parts+ that can be used for idempotent requests.