webhookdb 1.3.1 → 1.5.0

data/lib/webhookdb/replicator/fake.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "webhookdb/replicator/partitionable_mixin"
+
 class Webhookdb::Replicator::Fake < Webhookdb::Replicator::Base
   extend Webhookdb::MethodUtilities
 
@@ -10,18 +12,24 @@ class Webhookdb::Replicator::Fake < Webhookdb::Replicator::Base
   singleton_attr_accessor :process_webhooks_synchronously
   singleton_attr_accessor :obfuscate_headers_for_logging
   singleton_attr_accessor :requires_sequence
+  singleton_attr_accessor :extra_index_specs
 
-  def self.descriptor
-    return Webhookdb::Replicator::Descriptor.new(
-      name: "fake_v1",
-      ctor: ->(sint) { Webhookdb::Replicator::Fake.new(sint) },
+  def self._descriptor(**kw)
+    clsname = self.name.split("::").last
+    opts = {
+      name: clsname.underscore + "_v1",
+      ctor: ->(sint) { self.new(sint) },
       feature_roles: ["internal"],
-      resource_name_singular: "Fake",
+      resource_name_singular: clsname,
       supports_webhooks: true,
       supports_backfill: true,
-    )
+    }
+    opts.merge!(kw)
+    return Webhookdb::Replicator::Descriptor.new(**opts)
   end
 
+  def self.descriptor = self._descriptor
+
   def self.reset
     self.webhook_response = Webhookdb::WebhookResponse.ok
     self.upsert_has_deps = false
@@ -30,6 +38,11 @@ class Webhookdb::Replicator::Fake < Webhookdb::Replicator::Base
     self.process_webhooks_synchronously = nil
     self.obfuscate_headers_for_logging = []
     self.requires_sequence = false
+    self.descendants&.each do |d|
+      d.reset if d.respond_to?(:reset)
+    end
+    self.extra_index_specs = nil
+    self.descendants&.each(&:reset)
   end
 
   def self.stub_backfill_request(items, status: 200)
@@ -121,6 +134,8 @@ class Webhookdb::Replicator::Fake < Webhookdb::Replicator::Base
     return self.class.requires_sequence
   end
 
+  def _extra_index_specs = super + (self.class.extra_index_specs || [])
+
   def dispatch_request_to(request)
     return self.class.dispatch_request_to_hook.call(request) if self.class.dispatch_request_to_hook
     return super
@@ -138,16 +153,7 @@ class Webhookdb::Replicator::Fake < Webhookdb::Replicator::Base
 end
 
 class Webhookdb::Replicator::FakeWithEnrichments < Webhookdb::Replicator::Fake
-  def self.descriptor
-    return Webhookdb::Replicator::Descriptor.new(
-      name: "fake_with_enrichments_v1",
-      ctor: ->(sint) { Webhookdb::Replicator::FakeWithEnrichments.new(sint) },
-      feature_roles: ["internal"],
-      resource_name_singular: "Enriched Fake",
-      supports_webhooks: true,
-      supports_backfill: true,
-    )
-  end
+  def self.descriptor = self._descriptor(supports_webhooks: true, supports_backfill: true)
 
   def _denormalized_columns
     return super << Webhookdb::Replicator::Column.new(:extra, TEXT, from_enrichment: true)
@@ -166,17 +172,7 @@ end
 class Webhookdb::Replicator::FakeDependent < Webhookdb::Replicator::Fake
   singleton_attr_accessor :on_dependency_webhook_upsert_callback
 
-  def self.descriptor
-    return Webhookdb::Replicator::Descriptor.new(
-      name: "fake_dependent_v1",
-      ctor: ->(sint) { Webhookdb::Replicator::FakeDependent.new(sint) },
-      feature_roles: ["internal"],
-      resource_name_singular: "FakeDependent",
-      dependency_descriptor: Webhookdb::Replicator::Fake.descriptor,
-      supports_webhooks: true,
-      supports_backfill: true,
-    )
-  end
+  def self.descriptor = self._descriptor(dependency_descriptor: Webhookdb::Replicator::Fake.descriptor)
 
   def on_dependency_webhook_upsert(replicator, payload, changed:)
     self.class.on_dependency_webhook_upsert_callback&.call(replicator, payload, changed:)
@@ -194,17 +190,7 @@ end
 class Webhookdb::Replicator::FakeDependentDependent < Webhookdb::Replicator::Fake
   singleton_attr_accessor :on_dependency_webhook_upsert_callback
 
-  def self.descriptor
-    return Webhookdb::Replicator::Descriptor.new(
-      name: "fake_dependent_dependent_v1",
-      ctor: ->(sint) { Webhookdb::Replicator::FakeDependentDependent.new(sint) },
-      feature_roles: ["internal"],
-      resource_name_singular: "FakeDependentDependent",
-      dependency_descriptor: Webhookdb::Replicator::FakeDependent.descriptor,
-      supports_webhooks: true,
-      supports_backfill: true,
-    )
-  end
+  def self.descriptor = self._descriptor(dependency_descriptor: Webhookdb::Replicator::FakeDependent.descriptor)
 
   def on_dependency_webhook_upsert(replicator, payload, changed:)
     self.class.on_dependency_webhook_upsert_callback&.call(replicator, payload, changed:)
@@ -222,16 +208,7 @@ end
 class Webhookdb::Replicator::FakeEnqueueBackfillOnCreate < Webhookdb::Replicator::Fake
   singleton_attr_accessor :on_dependency_webhook_upsert_callback
 
-  def self.descriptor
-    return Webhookdb::Replicator::Descriptor.new(
-      name: "fake_enqueue_backfill_on_create_v1",
-      ctor: ->(sint) { Webhookdb::Replicator::FakeEnqueueBackfillOnCreate.new(sint) },
-      feature_roles: ["internal"],
-      resource_name_singular: "FakeEnqueueBackfillOnCreate",
-      supports_webhooks: true,
-      supports_backfill: true,
-    )
-  end
+  def self.descriptor = self._descriptor
 
   def calculate_backfill_state_machine
     # To mimic situations where it is possible to enqueue a backfill job on create, this backfill machine does
@@ -246,16 +223,7 @@ class Webhookdb::Replicator::FakeEnqueueBackfillOnCreate < Webhookdb::Replicator
 end
 
 class Webhookdb::Replicator::FakeWebhooksOnly < Webhookdb::Replicator::Fake
-  def self.descriptor
-    return Webhookdb::Replicator::Descriptor.new(
-      name: "fake_webhooks_only_v1",
-      ctor: ->(sint) { Webhookdb::Replicator::FakeWebhooksOnly.new(sint) },
-      feature_roles: ["internal"],
-      resource_name_singular: "Fake Webhooks Only (No Backfill)",
-      supports_webhooks: true,
-      supports_backfill: false,
-    )
-  end
+  def self.descriptor = self._descriptor(supports_backfill: false)
 
   def documentation_url = "https://abc.xyz"
 
@@ -263,31 +231,13 @@ class Webhookdb::Replicator::FakeWebhooksOnly < Webhookdb::Replicator::Fake
 end
 
 class Webhookdb::Replicator::FakeBackfillOnly < Webhookdb::Replicator::Fake
-  def self.descriptor
-    return Webhookdb::Replicator::Descriptor.new(
-      name: "fake_backfill_only_v1",
-      ctor: ->(sint) { Webhookdb::Replicator::FakeBackfillOnly.new(sint) },
-      feature_roles: ["internal"],
-      resource_name_singular: "Fake Backfill Only (No Webhooks)",
-      supports_webhooks: false,
-      supports_backfill: true,
-    )
-  end
+  def self.descriptor = self._descriptor(supports_webhooks: false)
 
   def calculate_webhook_state_machine = raise NotImplementedError
 end
 
 class Webhookdb::Replicator::FakeBackfillWithCriteria < Webhookdb::Replicator::Fake
-  def self.descriptor
-    return Webhookdb::Replicator::Descriptor.new(
-      name: "fake_backfill_with_criteria_v1",
-      ctor: ->(sint) { Webhookdb::Replicator::FakeBackfillWithCriteria.new(sint) },
-      feature_roles: ["internal"],
-      resource_name_singular: "Fake Backfill with Criteria",
-      dependency_descriptor: Webhookdb::Replicator::Fake,
-      supports_backfill: true,
-    )
-  end
+  def self.descriptor = self._descriptor(dependency_descriptor: Webhookdb::Replicator::Fake)
 
   def _denormalized_columns
     return super << Webhookdb::Replicator::Column.new(:backfill_kwargs, OBJECT, optional: true)
@@ -316,16 +266,7 @@ class Webhookdb::Replicator::FakeBackfillWithCriteria < Webhookdb::Replicator::F
 end
 
 class Webhookdb::Replicator::FakeExhaustiveConverter < Webhookdb::Replicator::Fake
-  def self.descriptor
-    return Webhookdb::Replicator::Descriptor.new(
-      name: "fake_exhaustive_converter_v1",
-      ctor: ->(sint) { Webhookdb::Replicator::FakeExhaustiveConverter.new(sint) },
-      feature_roles: ["internal"],
-      resource_name_singular: "Fake with all converters",
-      supports_webhooks: true,
-      supports_backfill: false,
-    )
-  end
+  def self.descriptor = self._descriptor(supports_backfill: false)
 
   def requires_sequence? = true
 
@@ -409,6 +350,12 @@ class Webhookdb::Replicator::FakeExhaustiveConverter < Webhookdb::Replicator::Fa
         data_key: "my_id",
         backfill_expr: "hi there",
       ),
+      Webhookdb::Replicator::Column.new(
+        :using_null_backfill_expr,
+        TEXT,
+        data_key: "my_id",
+        backfill_expr: Sequel[nil],
+      ),
       Webhookdb::Replicator::Column.new(
         :using_backfill_statement,
         TEXT,
@@ -450,3 +397,74 @@ class Webhookdb::Replicator::FakeExhaustiveConverter < Webhookdb::Replicator::Fa
     return cols
   end
 end
+
+class Webhookdb::Replicator::FakeStaleRow < Webhookdb::Replicator::Fake
+  def self.descriptor = self._descriptor
+
+  def _denormalized_columns
+    return [
+      Webhookdb::Replicator::Column.new(:at, TIMESTAMP, index: true),
+      Webhookdb::Replicator::Column.new(:textcol, TEXT),
+    ]
+  end
+
+  class StaleRowDeleter < Webhookdb::Replicator::BaseStaleRowDeleter
+    def stale_at = 5.days
+    def lookback_window = 5.days
+    def updated_at_column = :at
+    def stale_condition = {textcol: "cancelled"}
+    def chunk_size = 10
+  end
+
+  def stale_row_deleter = StaleRowDeleter.new(self)
+end
+
+class Webhookdb::Replicator::FakeStaleRowPartitioned < Webhookdb::Replicator::FakeStaleRow
+  include Webhookdb::Replicator::PartitionableMixin
+
+  def self.descriptor = self._descriptor
+
+  def partition_method = Webhookdb::DBAdapter::Partitioning::HASH
+  def partition_column_name = :textcol
+  def partition_value(r) = r.fetch("textcol")
+end
+
+class Webhookdb::Replicator::FakeWithWatchChannel < Webhookdb::Replicator::Fake
+  singleton_attr_accessor :renew_calls
+
+  def self.reset
+    self.renew_calls = []
+  end
+
+  def self.descriptor = self._descriptor
+
+  def renew_watch_channel(row_pk:, expiring_before:)
+    self.class.renew_calls << {row_pk:, expiring_before:}
+  end
+end
+
+class Webhookdb::Replicator::FakeHashPartition < Webhookdb::Replicator::Fake
+  def self.descriptor = self._descriptor
+
+  include Webhookdb::Replicator::PartitionableMixin
+
+  def _denormalized_columns
+    d = super
+    d << Webhookdb::Replicator::Column.new(:hashkey, INTEGER, optional: true)
+    return d
+  end
+
+  def partition_method = Webhookdb::DBAdapter::Partitioning::HASH
+  def partition_column_name = :hashkey
+  def partition_value(resource) = self._str2inthash(resource.fetch("my_id"))
+end
+
+class Webhookdb::Replicator::FakeRangePartition < Webhookdb::Replicator::Fake
+  def self.descriptor = self._descriptor
+
+  include Webhookdb::Replicator::PartitionableMixin
+
+  def partition_method = Webhookdb::DBAdapter::Partitioning::RANGE
+  def partition_column_name = :at
+  def partition_value(resource) = resource.fetch("at")
+end

data/lib/webhookdb/replicator/front_signalwire_message_channel_app_v1.rb

@@ -4,6 +4,7 @@ require "jwt"
 
 require "webhookdb/messages/error_signalwire_send_sms"
 require "webhookdb/replicator/front_v1_mixin"
+require "webhookdb/jobs/front_signalwire_message_channel_sync_inbound"
 
 # Front has a system of 'channels' but it is a challenge to use.
 # This replicator leverages WebhookDB (and our existing Front app)
@@ -154,8 +155,8 @@ All of this information can be found in the WebhookDB docs, at https://docs.webh
       when "message", "message_autoreply"
         return {
           type: "success",
-          external_id: upserted.fetch(:external_id),
-          external_conversation_id: upserted.fetch(:external_conversation_id),
+          external_id: upserted.map { |r| r.fetch(:external_id) }.join(","),
+          external_conversation_id: upserted.map { |r| r.fetch(:external_conversation_id) }.join(","),
         }.to_json
       else
         return "{}"
@@ -191,35 +192,52 @@ All of this information can be found in the WebhookDB docs, at https://docs.webh
         "#{replied_to_id}_autoreply"
     end
     resource["front_message_id"] = mid
-    # Use the Front ID to identify this outbound message.
-    resource["external_id"] = mid
     resource["direction"] = "outbound"
     resource["body"] = payload.fetch("text")
     resource["sender"] = self.support_phone
-    resource["recipient"] = self._front_recipient_phone(payload)
-    # All messages get the same conversation with SMS/chat, unlike email.
-    resource["external_conversation_id"] = resource["recipient"]
-    return resource, nil
+    resources = self._front_recipient_phones(payload).map do |recipient|
+      r = resource.dup
+      r["recipient"] = recipient
+      # The same message can go to multiple recipients, but we want to treat them as separate conversations.
+      # That is, we CANNOT use signalwire/front to do 'group chats' since we don't want to
+      # allow one user to send a message that is sent to other users (would be a spam vector).
+      r["external_id"] = "#{mid}-#{recipient}"
+      # Thread this message into the recipient's specific conversation, unlike email.
+      r["external_conversation_id"] = recipient
+      r
+    end
+    return resources, nil
   end
 
-  def _front_recipient_phone(payload)
-    recipient = payload["recipients"].find { |r| r.fetch("role") == "to" }
-    raise Webhookdb::InvariantViolation, "no recipient found in #{payload}" if recipient.nil?
-    return self.format_phone(recipient.fetch("handle"))
+  def _front_recipient_phones(payload)
+    recipients = payload["recipients"].select { |r| r.fetch("role") == "to" }
+    raise Webhookdb::InvariantViolation, "no recipient found in #{payload}" if recipients.empty?
+    return recipients.map { |r| self.format_phone(r.fetch("handle")) }
   end
 
-  def on_dependency_webhook_upsert(_replicator, payload, changed:)
+  def on_dependency_webhook_upsert(_sw_replicator, sw_payload, changed:)
     return unless changed
-    return unless payload.fetch(:direction) == "inbound"
-    return unless payload.fetch(:to) == self.support_phone
-    body = JSON.parse(payload.fetch(:data))
+
+    # If the signalwire message is failed, update the Front convo with a notification that the send failed
+    failed_notifier_cutoff = Time.now - 4.days
+    signalwire_send_failed = sw_payload.fetch(:date_updated) > failed_notifier_cutoff &&
+      ["failed", "undelivered"].include?(sw_payload.fetch(:status)) &&
+      sw_payload.fetch(:from) == self.support_phone
+    self.alert_async_failed_signalwire_send(sw_payload) if signalwire_send_failed
+
+    # If a message has come in from a user, insert a row so it'll be imported into Front
+    signalwire_payload_inbound_to_support = sw_payload.fetch(:direction) == "inbound" &&
+      sw_payload.fetch(:to) == self.support_phone
+    return unless signalwire_payload_inbound_to_support
+
+    body = JSON.parse(sw_payload.fetch(:data))
     body.merge!(
-      "external_id" => payload.fetch(:signalwire_id),
-      "signalwire_sid" => payload.fetch(:signalwire_id),
+      "external_id" => sw_payload.fetch(:signalwire_id),
+      "signalwire_sid" => sw_payload.fetch(:signalwire_id),
       "direction" => "inbound",
-      "sender" => payload.fetch(:from),
+      "sender" => sw_payload.fetch(:from),
       "recipient" => self.support_phone,
-      "external_conversation_id" => payload.fetch(:from),
+      "external_conversation_id" => sw_payload.fetch(:from),
     )
     self.upsert_webhook_body(body)
   end
@@ -230,6 +248,59 @@ All of this information can be found in the WebhookDB docs, at https://docs.webh
     Webhookdb::BackfillJob.create_recursive(service_integration: self.service_integration, incremental: true).enqueue
   end
 
+  # Send alerts for any undelivered or failed messages.
+  # The (outbound) message is already created in Front, but if the Signalwire message fails to send,
+  # we need to import a new message into Front as a reply explaining why the message failed to send.
+  def alert_async_failed_signalwire_send(sw_row)
+    idempotency_key = "fsmca-swfail-#{sw_row.fetch(:signalwire_id)}"
+    idempotency = Webhookdb::Idempotency.once_ever.stored.using_seperate_connection.under_key(idempotency_key)
+    idempotency.execute do
+      # The 'sender' of this message is who the failed message is sent **to**
+      sender = sw_row.fetch(:to)
+      data = JSON.parse(sw_row.fetch(:data))
+      external_id = sw_row.fetch(:signalwire_id)
+      external_conversation_id = sender
+      trunc_body = data.fetch("body", "")[..25]
+      body = "SMS failed to send. Error (#{data['error_code'] || '-'}): #{data['error_message'] || '-'}\n#{trunc_body}"
+      kwargs = {sender:, delivered_at: Time.now.to_i, body:, external_id:, external_conversation_id:}
+      # The call to Front MUST be done in a job, since if it fails, we would not be able to retry.
+      # The code is called after the signalwire payload is upserted and changes;
+      # but if this fails, the row won't change again in the future,
+      # so this code wouldn't be called again.
+      # This is a general problem and should probably have a general solution,
+      # but because of the external call, it is important to guard against it.
+      Webhookdb::Jobs::FrontSignalwireMessageChannelSyncInbound.perform_async(
+        self.service_integration.id, kwargs.as_json,
+      )
+    end
+  end
+
+  def sync_front_inbound_message(sender:, delivered_at:, body:, external_id:, external_conversation_id:)
+    body = {
+      sender: {handle: sender},
+      body:,
+      delivered_at:,
+      metadata: {external_id:, external_conversation_id:},
+    }
+    token = JWT.encode(
+      {
+        iss: Webhookdb::Front.signalwire_channel_app_id,
+        jti: Webhookdb::Front.channel_jwt_jti,
+        sub: self.front_channel_id,
+        exp: 10.seconds.from_now.to_i,
+      },
+      Webhookdb::Front.signalwire_channel_app_secret,
+    )
+    resp = Webhookdb::Http.post(
+      "https://api2.frontapp.com/channels/#{self.front_channel_id}/inbound_messages",
+      body,
+      headers: {"Authorization" => "Bearer #{token}"},
+      timeout: Webhookdb::Front.http_timeout,
+      logger: self.logger,
+    )
+    return resp.parsed_response
+  end
+
   def _backfillers = [Backfiller.new(self)]
 
   class Backfiller < Webhookdb::Backfiller
@@ -239,35 +310,44 @@ All of this information can be found in the WebhookDB docs, at https://docs.webh
       @signalwire_sint = replicator.service_integration.depends_on
     end
 
-    def handle_item(item)
-      front_id = item.fetch(:front_message_id)
-      sw_id = item.fetch(:signalwire_sid)
+    def handle_item(db_row)
+      front_id = db_row.fetch(:front_message_id)
+      sw_id = db_row.fetch(:signalwire_sid)
+      # This is sort of gross- we get the db row here, and need to re-update it with certain fields
+      # as a result of the signalwire or front sync. To do that, we need to run the upsert on 'data',
+      # but what's in 'data' is incomplete. So we use the db row to form a more fully complete 'data'.
+      upserting_data = db_row.dup
+      # Remove the columns that don't belong in 'data'
+      upserting_data.delete(:pk)
+      upserting_data.delete(:row_updated_at)
+      # Splat the 'data' column into the row so it all gets put back into 'data'
+      upserting_data.merge!(**upserting_data.delete(:data))
       if (front_id && sw_id) || (!front_id && !sw_id)
-        msg = "row should have a front id OR signalwire id, should not have been inserted, or selected: #{item}"
+        msg = "row should have a front id OR signalwire id, should not have been inserted, or selected: #{db_row}"
         raise Webhookdb::InvariantViolation, msg
       end
-      sender = @replicator.format_phone(item.fetch(:sender))
-      recipient = @replicator.format_phone(item.fetch(:recipient))
-      body = item.fetch(:body)
-      idempotency_key = "fsmca-fims-#{item.fetch(:external_id)}"
+      sender = @replicator.format_phone(db_row.fetch(:sender))
+      recipient = @replicator.format_phone(db_row.fetch(:recipient))
+      body = db_row.fetch(:body)
+      idempotency_key = "fsmca-fims-#{db_row.fetch(:external_id)}"
       idempotency = Webhookdb::Idempotency.once_ever.stored.using_seperate_connection.under_key(idempotency_key)
       if front_id.nil?
-        texted_at = Time.parse(item.fetch(:data).fetch("date_created"))
+        texted_at = Time.parse(db_row.fetch(:data).fetch("date_created"))
         if texted_at < Webhookdb::Front.channel_sync_refreshness_cutoff.seconds.ago
           # Do not sync old rows, just mark them synced
-          item[:front_message_id] = "skipped_due_to_age"
+          upserting_data[:front_message_id] = "skipped_due_to_age"
         else
           # sync the message into Front
           front_response_body = idempotency.execute do
-            self._sync_front_inbound(sender:, texted_at:, item:, body:)
+            self._sync_front_inbound(sender:, texted_at:, db_row:, body:)
           end
-          item[:front_message_id] = front_response_body.fetch("message_uid")
+          upserting_data[:front_message_id] = front_response_body.fetch("message_uid")
         end
       else
-        messaged_at = Time.at(item.fetch(:data).fetch("payload").fetch("created_at"))
+        messaged_at = Time.at(db_row.fetch(:data).fetch("payload").fetch("created_at"))
         if messaged_at < Webhookdb::Front.channel_sync_refreshness_cutoff.seconds.ago
           # Do not sync old rows, just mark them synced
-          item[:signalwire_sid] = "skipped_due_to_age"
+          upserting_data[:signalwire_sid] = "skipped_due_to_age"
         else
           # send the SMS via signalwire
           signalwire_resp = _send_sms(
@@ -276,10 +356,10 @@ All of this information can be found in the WebhookDB docs, at https://docs.webh
             to: recipient,
             body:,
           )
-          item[:signalwire_sid] = signalwire_resp.fetch("sid") if signalwire_resp
+          upserting_data[:signalwire_sid] = signalwire_resp.fetch("sid") if signalwire_resp
         end
       end
-      @replicator.upsert_webhook_body(item.deep_stringify_keys)
+      @replicator.upsert_webhook_body(upserting_data.deep_stringify_keys)
     end
 
     def _send_sms(idempotency, from:, to:, body:)
@@ -310,6 +390,14 @@ All of this information can be found in the WebhookDB docs, at https://docs.webh
       # https://developer.signalwire.com/guides/how-to-troubleshoot-common-messaging-issues
       raise e if code.nil?
 
+      # Error handling note as of Jan 2025:
+      # We are choosing to handle synchronous 'send sms' errors through the org alert system,
+      # which will tell developers (not support agents) about the failure.
+      # This is because, if this send fails, it will be retried later.
+      # For example, if we sent a bulk message to 1000 customers,
+      # and Signalwire was down and failed 500 sends, we would just retry the 500 sends.
+      # We do NOT want to update the 500 failed conversations, and force support agents
+      # to deal with the fallout of retrying a send only to those 500 people.
       message = Webhookdb::Messages::ErrorSignalwireSendSms.new(
         @replicator.service_integration,
         response_status:,
@@ -321,33 +409,15 @@ All of this information can be found in the WebhookDB docs, at https://docs.webh
       return nil
     end
 
-    def _sync_front_inbound(sender:, texted_at:, item:, body:)
-      body = {
-        sender: {handle: sender},
-        body: body || "<no body>",
+    def _sync_front_inbound(sender:, texted_at:, db_row:, body:)
+      body ||= "<no body>"
+      return @replicator.sync_front_inbound_message(
+        sender:,
         delivered_at: texted_at.to_i,
-        metadata: {
-          external_id: item.fetch(:external_id),
-          external_conversation_id: item.fetch(:external_conversation_id),
-        },
-      }
-      token = JWT.encode(
-        {
-          iss: Webhookdb::Front.signalwire_channel_app_id,
-          jti: Webhookdb::Front.channel_jwt_jti,
-          sub: @replicator.front_channel_id,
-          exp: 10.seconds.from_now.to_i,
-        },
-        Webhookdb::Front.signalwire_channel_app_secret,
-      )
-      resp = Webhookdb::Http.post(
-        "https://api2.frontapp.com/channels/#{@replicator.front_channel_id}/inbound_messages",
-        body,
-        headers: {"Authorization" => "Bearer #{token}"},
-        timeout: Webhookdb::Front.http_timeout,
-        logger: @replicator.logger,
+        body:,
+        external_id: db_row.fetch(:external_id),
+        external_conversation_id: db_row.fetch(:external_conversation_id),
       )
-      resp.parsed_response
     end
 
     def fetch_backfill_page(*)

data/lib/webhookdb/replicator/github_repo_v1_mixin.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "webhookdb/github"
+require "webhookdb/messages/error_generic_backfill"
 
 # Mixin for repo-specific resources like issues and pull requests.
 module Webhookdb::Replicator::GithubRepoV1Mixin
@@ -236,6 +237,22 @@ Then click 'Generate token'.)
     return data
   end
 
+  def on_backfill_error(be)
+    e = Webhookdb::Errors.find_cause(be) do |ex|
+      next true if ex.is_a?(Webhookdb::Http::Error) && ex.status == 401
+    end
+    return unless e
+    message = Webhookdb::Messages::ErrorGenericBackfill.new(
+      self.service_integration,
+      response_status: e.status,
+      response_body: e.body,
+      request_url: e.uri.to_s,
+      request_method: e.http_method,
+    )
+    self.service_integration.organization.alerting.dispatch_alert(message)
+    return true
+  end
+
   def _prepare_for_insert(resource, event, request, enrichment)
     # if enrichment is not nil, it's the detailed resource.
     # See _mixin_fetch_resource_if_field_missing