hailer 0.1.0-aarch64-linux-gnu

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bcfbb3cf2dc302cc14b847300d52451916bd2b80aa5533efcdf29c028af4237f
+  data.tar.gz: 0ce70e6f6c2990a0e73d696d56c50dd2c643971323b7a3596153283affc1ebed
+SHA512:
+  metadata.gz: '081ded80b436a4303afd0a9ba42dc46b1d95e9754ee163464c1d7715ba19bb560305e171c4d4487d577c607acdcfca5b55b19ced83a5a7755fb482e64fdb43f6'
+  data.tar.gz: 82a14e0aeca47b8ffed8ed733e11362487bad75f2409588577ee46ea6e28c3307429f9d8325295994a4644984c7be091e2614701d6d0ee92aff620e51897e30f

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## 0.1.0 (unreleased)
+
+- Rails 8.1+/Ruby 4.0+ ActionMailer delivery with automatic defaults.
+- Typed provider-neutral feedback client and Rails callback consumer.
+- SES sender, SQS feedback ingestion, durable suppressions, and import tooling.
+- Platform gems carrying the standalone Rust service with a verified launcher.
+- Local CommonShare integration tested without sending real email.

data/LICENSE.txt

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Abdelkader Boudih
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,241 @@
+# Hailer
+
+Rails writes the email. Hailer deals with sending it.
+
+This repository ships two things at version **0.1.0**:
+
+- **`hailer` gem** — an ActionMailer adapter, feedback client, and executable
+  launcher. Platform gems bundle the Rust binary. No Ruby AWS SDK or native extension.
+- **`hailer` crate** — a standalone Rust mail ship, supervised by Mothership.
+  SESv2 is the first provider.
+
+```text
+ActionMailer → hailer gem → private Mothership route → hailer binary → SES
+```
+
+## Rails
+
+Requires Ruby 4.0+ and Rails 8.1 or newer within Rails 8.x.
+Rails main (8.2 alpha) is also exercised in CommonShare. Older releases are not supported.
+
+```ruby
+# Gemfile (use path: "/path/to/hailer" while developing)
+gem "hailer"
+```
+
+The Railtie registers and selects Hailer automatically. Set the private service
+URL in the Rails process's environment:
+
+```sh
+HAILER_URL=http://127.0.0.1:9293/internal/mail/send
+```
+
+No application initializer is needed. To customize connection settings:
+
+```ruby
+config.action_mailer.hailer_settings = {
+  endpoint: ENV.fetch("HAILER_URL"),
+  open_timeout: 5,
+  read_timeout: 30,
+  write_timeout: 30
+}
+```
+
+`HAILER_URL` is the complete private URL, for example
+`http://127.0.0.1:9293/internal/mail/send`. It is also the default endpoint
+when omitted from `hailer_settings`. There is no default host or fallback to SES.
+The app can explicitly override the default, for example
+`config.action_mailer.delivery_method = :test` in its test environment.
+
+Keep using your mailers, interceptors, observers, `deliver_now`, and
+`deliver_later`. Rails still owns job scheduling. The adapter sends rendered MIME
+and separate envelope recipients, preserving explicit `smtp_envelope_from` and
+`smtp_envelope_to` overrides. After SES accepts the message, it sets
+`message.header[:ses_message_id]`.
+
+## Rust service
+
+Platform gems install the `hailer` executable, ready for Mothership to launch.
+Installing the gem does not start the service or send mail.
+
+The source (`ruby`) gem has the same Rails client and launcher, but no binary.
+For source development or an unsupported platform:
+
+```sh
+cargo install --path . --locked
+export HAILER_BINARY=/absolute/path/to/hailer
+```
+
+Run it as a Mothership HTTP bay. Merge this example into your fleet manifest;
+the bind must stay private and must not be routed on a public listener:
+
+```toml
+[mothership.bind]
+mail = "127.0.0.1:9293"
+
+[[bays.http]]
+name = "hailer"
+command = "hailer"
+workers = 0
+threads = 2
+routes = [{ bind = "mail", pattern = "^/internal/mail/send$" }]
+```
+
+Mothership exports `MS_PID`, `MS_SHIP`, and `MS_SOCKET_DIR`. Hailer binds its
+docking Unix socket; it does **not** run another HTTP server. For containers,
+use a private network listener with network policy instead of a loopback address
+if Rails runs in a different network namespace.
+
+Give the **service**, not the Rails adapter, AWS region and credentials through
+the standard AWS credential chain. Its identity needs `ses:SendEmail`, and the
+SES account/identities must be configured for sending.
+
+## Bounces, complaints, and suppressions
+
+```text
+SES → SNS → dedicated SQS queue → Hailer → durable events + suppressions
+```
+
+Hailer atomically commits each event, deduplication key, and suppression change
+to a local redb database **before** acknowledging SQS. Failed acknowledgements
+can be retried without duplicating stored events. Invalid/untrusted messages
+are left for SQS's dead-letter policy.
+
+- Permanent bounces and complaints suppress recipients.
+- Transient/undetermined bounces are recorded without permanent suppression.
+- An explicit `not-spam` complaint does not create a new suppression.
+- Suppression checks cover the actual To/Cc/Bcc envelope, including overrides.
+  Matching preserves CommonShare's case/plus-alias policy.
+- Mixed messages keep allowed recipients and their original addresses; MIME
+  is unchanged. If every recipient is suppressed, Hailer returns HTTP 422
+  without calling SES. A suppression lookup failure fails closed with HTTP 503.
+
+Copy [hailer.example.toml](hailer.example.toml), set the real queue/topic, and
+pass `--config /path/to/hailer.toml` or `HAILER_CONFIG`. Without `[feedback]`,
+the consumer is disabled, but previously stored suppressions are still enforced.
+`HAILER_STATE_PATH` overrides `state_path`; the default is `data/hailer.redb`.
+Use a persistent, private volume in production.
+
+**One Hailer process owns one state file and one dedicated queue.** Run the
+bay with `workers = 0`; this is not a distributed suppression database.
+Do not run competing consumers with separate state files. Back up the state
+file while Hailer is stopped; event history and deduplication currently have
+no automatic retention/pruning.
+
+Hailer also exposes a provider-neutral, nondestructive event feed:
+
+```http
+POST /internal/mail/events
+Content-Type: application/json
+
+{"after":0,"limit":100}
+```
+
+Route it on the **same private bind**, if application tracking needs it:
+
+```toml
+routes = [{ bind = "mail", pattern = "^/internal/mail/(send|events)$" }]
+```
+
+The gem validates the page and exposes immutable `FeedbackEvent` objects:
+
+```ruby
+page = Hailer::FeedbackClient.new(endpoint: ENV.fetch("HAILER_URL")).poll(after: 0)
+page.events.each { |event| puts [event.event_id, event.kind, event.message_id] }
+```
+
+Configure a Rails business-history handler (a callable or reloadable class name):
+
+```ruby
+Rails.application.config.hailer.feedback_handler = "Platform::MailFeedback"
+```
+
+Then `Hailer::FeedbackConsumer.new.call(after: cursor)` calls that handler for
+each validated event and returns the next cursor only after all callbacks
+succeed. A callback must **raise** on failure. Persist the cursor and domain
+updates in one application database transaction. Retried pages require
+idempotent handlers; no hidden poller, scheduling, or checkpoint database is
+started by the gem. Reading does not acknowledge or erase events.
+
+See [feedback setup and migration](docs/feedback.md) before removing a receiver.
+
+**Security:** the route currently has no application-level authentication.
+`/internal/` is a name, not an access control. Keep the bind private. The client
+does not follow redirects or use environment HTTP proxies.
+
+## Failure semantics
+
+An HTTP 200 means **SES accepted the message**, not that the recipient received
+it. A successful response must include a nonblank `message_id`.
+
+| Failure | Ruby exception |
+| --- | --- |
+| HTTP 400 / 422 | `Hailer::ValidationError` |
+| HTTP 502 | `Hailer::RejectedError` |
+| HTTP 503 | `Hailer::UnavailableError` |
+| Other non-200 status | `Hailer::DeliveryError` |
+| Invalid/oversized response, missing message ID | `Hailer::ProtocolError` |
+| Connection, TLS, or timeout failure | `Hailer::TransportError` |
+| Missing/invalid endpoint or timeout settings | `Hailer::ConfigurationError` |
+
+The gem does not retry. A lost response can happen **after** SES accepted the
+message; retrying may duplicate it. There is no durable **outbound** queue or
+send-idempotency store yet; feedback deduplication does not deduplicate sends.
+Rails jobs can also retry, so configure them deliberately.
+The current service maps all SES SDK send errors to HTTP 502; that status is
+not yet a reliable distinction between permanent and transient AWS failures.
+
+## Status and migration
+
+The delivery contract and Hailer-side feedback processing are implemented. CommonShare's
+existing sender is the compatibility reference, not a runtime dependency.
+See [the contract](docs/delivery-contract.md).
+
+Before switching an existing app:
+
+1. Run Hailer on a private Mothership bind and verify real SES delivery.
+2. Add the gem, set `HAILER_URL`, and remove the app's old delivery-method
+   override so Hailer's default takes effect.
+3. Subscribe a dedicated SQS queue before exporting and importing existing
+   suppressions. Let Hailer catch up and verify the event feed.
+4. Keep existing receivers/interceptors until routing, suppression import,
+   and any provider-neutral app history consumer have been verified.
+5. Only then remove the old sender and AWS-specific feedback handling.
+
+CommonShare's local integration is tested with its real application, database,
+Mothership, packaged Hailer binary, and a loopback SES fixture. Its existing AWS
+receivers remain until the real subscription and suppression cutover is verified.
+No deployed AWS routing has been changed.
+Account diagnostics, validation/behavior plugins,
+distributed state, rate limiting, graceful draining, and reliable send-error
+classification are later work. No plugin API is promised yet.
+
+## Development
+
+```sh
+bundle install
+bundle exec rake
+cargo test --locked
+cargo fmt --all -- --check
+gem build hailer.gemspec --output /tmp/hailer-0.1.0.gem
+bundle exec rake native:package
+```
+
+The Ruby suite exercises real local HTTP exchanges and a booted Rails app.
+The Rust suite checks the same JSON fixture and the docking exchange with a
+fake provider. Feedback tests cover redelivery, acknowledgement ordering,
+atomic rollback, restart persistence, imports, and suppression enforcement.
+Neither suite sends real mail or requires AWS credentials.
+
+`native:package` builds a locked release and writes
+`pkg/hailer-0.1.0-<platform>.gem`. Each platform gem contains exactly its host
+binary and a version/platform/SHA-256 manifest. The launcher verifies that
+manifest before `exec`, preserving arguments, exit status, and signal handling.
+`HAILER_BINARY` is an explicit, version-checked source-build override; there is
+no download or PATH fallback.
+
+Build on each supported release host before publishing its artifact. Only
+`arm64-darwin` has been built and exercised in this checkout. Linux GNU builds
+must use your intended minimum-glibc build environment; a native build on a
+newer distro is not automatically portable to older distributions. Nothing in
+the packaging task publishes a gem.

data/exe/hailer

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'hailer/binary'
+
+begin
+  exec Hailer::Binary.path, *ARGV
+rescue Hailer::Error => error
+  warn error.message
+  exit 1
+end

data/hailer.example.toml

@@ -0,0 +1,8 @@
+# Keep this file and its state volume private. One Hailer process owns this file.
+state_path = "/var/lib/hailer/state.redb"
+threads = 2
+
+[feedback]
+# Dedicated queue; subscribe the SNS topic with RawMessageDelivery=false.
+queue_url = "https://sqs.us-east-1.amazonaws.com/123456789012/hailer-feedback"
+topic_arn = "arn:aws:sns:us-east-1:123456789012:mail-feedback"

data/lib/hailer/binary.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+require 'open3'
+require_relative 'errors'
+require_relative 'version'
+
+module Hailer
+  # Used by the executable without booting Rails. Never download a binary or
+  # select an unrelated executable from PATH.
+  module Binary
+    ROOT = File.expand_path('../..', __dir__)
+
+    module_function
+
+    def platform(local = Gem::Platform.local)
+      case local.os
+      when 'darwin'
+        cpu = %w[arm64 aarch64].include?(local.cpu) ? 'arm64' : local.cpu
+        "#{cpu}-darwin"
+      when 'linux'
+        cpu = %w[arm64 aarch64].include?(local.cpu) ? 'aarch64' : local.cpu
+        "#{cpu}-linux-#{local.version == 'musl' ? 'musl' : 'gnu'}"
+      else
+        raise BinaryError, "unsupported Hailer platform: #{local}"
+      end
+    end
+
+    def path(env: ENV, root: ROOT)
+      if env.key?('HAILER_BINARY')
+        candidate = File.expand_path(env.fetch('HAILER_BINARY'))
+        executable!(candidate)
+        output, status = Open3.capture2e(candidate, '--version')
+        unless status.success? && output.strip == "hailer #{VERSION}"
+          raise BinaryError, "HAILER_BINARY must be Hailer #{VERSION}"
+        end
+        return candidate
+      end
+
+      directory = File.join(root, 'vendor', platform)
+      candidate = File.join(directory, 'bin', 'hailer')
+      executable!(candidate)
+      manifest = JSON.parse(File.read(File.join(directory, 'manifest.json')))
+      unless manifest['version'] == VERSION && manifest['platform'] == platform &&
+             manifest['sha256'] == Digest::SHA256.file(candidate).hexdigest
+        raise BinaryError, 'bundled Hailer executable does not match its release manifest'
+      end
+      candidate
+    rescue Errno::ENOENT, JSON::ParserError
+      raise BinaryError, 'missing or invalid Hailer binary manifest; reinstall the platform gem'
+    end
+
+    def executable!(candidate)
+      return if File.file?(candidate) && File.executable?(candidate)
+
+      raise BinaryError, "no executable Hailer binary at #{candidate}; install the platform gem or set HAILER_BINARY"
+    end
+  end
+end

data/lib/hailer/client.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Hailer
+  Response = Data.define(:message_id)
+
+  class Client
+    def initialize(**settings)
+      @transport = Transport.new(**settings)
+    end
+
+    def deliver(payload)
+      document = @transport.post('/internal/mail/send', payload)
+      message_id = document['message_id']
+      unless message_id.is_a?(String) && !message_id.strip.empty?
+        raise ProtocolError, 'Hailer accepted the request without a message_id'
+      end
+      Response.new(message_id: message_id)
+    end
+  end
+end

data/lib/hailer/delivery_method.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'mail'
+
+module Hailer
+  class DeliveryMethod
+    attr_reader :settings
+
+    def initialize(options = {})
+      @settings = { endpoint: ENV['HAILER_URL'], **Transport::DEFAULTS }.merge(options)
+    end
+
+    def deliver!(message)
+      payload = {
+        raw_mime: message.to_s,
+        to_addresses: Array(explicit_envelope?(message, :to) ? message.smtp_envelope_to : message.to),
+        cc_addresses: Array(message.cc),
+        bcc_addresses: Array(message.bcc)
+      }
+      # The default smtp_envelope_from drops display names. Let SES read the
+      # MIME From header unless the caller explicitly overrode the envelope.
+      if explicit_envelope?(message, :from)
+        payload[:from_email_address] = message.smtp_envelope_from
+      end
+
+      Client.new(**settings).deliver(payload).tap do |response|
+        message.header[:ses_message_id] = response.message_id
+      end
+    end
+
+    private
+
+    # Match the existing SESv2 adapter's distinction between Mail's computed
+    # defaults and explicitly assigned SMTP envelope addresses.
+    def explicit_envelope?(message, field)
+      message.instance_variable_get(:"@smtp_envelope_#{field}")
+    end
+  end
+end

data/lib/hailer/errors.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Hailer
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class ProtocolError < Error; end
+  class BinaryError < Error; end
+
+  # The request may already have reached SES. Retrying can send a duplicate.
+  class TransportError < Error; end
+
+  class DeliveryError < Error
+    attr_reader :status
+
+    def initialize(message, status:)
+      @status = status
+      super(message)
+    end
+  end
+
+  class ValidationError < DeliveryError; end
+  class RejectedError < DeliveryError; end
+  class UnavailableError < DeliveryError; end
+end

data/lib/hailer/feedback_client.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Hailer
+  FeedbackEvent = Data.define(
+    :sequence, :event_id, :kind, :provider, :provider_message_id,
+    :message_id, :occurred_at, :recipients, :suppression
+  )
+  FeedbackPage = Data.define(:events, :next_cursor)
+
+  class FeedbackClient
+    KINDS = %w[sent delivered bounced complained rejected rendering_failed delayed opened clicked].freeze
+    MAX_RESPONSE_BYTES = 2 * 1024 * 1024
+
+    def initialize(**settings)
+      @transport = Transport.new(**settings)
+    end
+
+    def poll(after:, limit: 100)
+      unless after.is_a?(Integer) && after >= 0 && limit.is_a?(Integer) && (1..100).cover?(limit)
+        raise ConfigurationError, 'feedback requires a nonnegative cursor and limit in 1..100'
+      end
+      document = @transport.post('/internal/mail/events', { after: after, limit: limit },
+                                 max_response_bytes: MAX_RESPONSE_BYTES)
+      entries = document['events']
+      cursor = document['next_cursor']
+      unless entries.is_a?(Array) && entries.size <= limit && cursor.is_a?(Integer) && cursor >= after
+        raise ProtocolError, 'invalid Hailer feedback page'
+      end
+      previous = after
+      events = entries.map do |entry|
+        event = decode_event(entry)
+        raise ProtocolError, 'feedback sequences must increase past the requested cursor' unless event.sequence > previous
+
+        previous = event.sequence
+        event
+      end
+      raise ProtocolError, 'feedback cursor does not match its page' unless cursor == previous
+
+      FeedbackPage.new(events: events.freeze, next_cursor: cursor)
+    end
+
+    private
+
+    def decode_event(entry)
+      raise ProtocolError, 'invalid feedback entry' unless entry.is_a?(Hash) && entry['sequence'].is_a?(Integer)
+
+      event = entry['event']
+      unless event.is_a?(Hash) && KINDS.include?(event['kind']) &&
+             %w[event_id provider provider_message_id occurred_at].all? { |key| text?(event[key]) } &&
+             (event['message_id'].nil? || text?(event['message_id'])) &&
+             [nil, 'bounce', 'complaint'].include?(event['suppression']) &&
+             event['recipients'].is_a?(Array) && !event['recipients'].empty? &&
+             event['recipients'].all? { |address| text?(address) }
+        raise ProtocolError, 'invalid normalized Hailer event'
+      end
+      FeedbackEvent.new(
+        sequence: entry['sequence'], event_id: event['event_id'].freeze,
+        kind: event['kind'].freeze, provider: event['provider'].freeze,
+        provider_message_id: event['provider_message_id'].freeze,
+        message_id: event['message_id']&.freeze, occurred_at: Time.iso8601(event['occurred_at']).freeze,
+        recipients: event['recipients'].map(&:freeze).freeze, suppression: event['suppression']&.freeze
+      )
+    rescue ArgumentError
+      raise ProtocolError, 'invalid feedback event timestamp'
+    end
+
+    def text?(value) = value.is_a?(String) && !value.strip.empty?
+  end
+end

data/lib/hailer/feedback_consumer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Hailer
+  # The caller persists the returned cursor with its domain changes. An
+  # exception returns no cursor; retrying the page requires idempotent handlers.
+  class FeedbackConsumer
+    def initialize(client: nil, handler: nil)
+      @client = client || FeedbackClient.new(**ActionMailer::Base.hailer_settings)
+      @handler = handler || Rails.application.config.hailer.feedback_handler
+    end
+
+    def call(after:, limit: 100)
+      # Resolve a configured class name on every poll, respecting Rails reloads.
+      handler = @handler.is_a?(String) ? @handler.constantize : @handler
+      raise ConfigurationError, 'configure config.hailer.feedback_handler with a callable handler' unless handler.respond_to?(:call)
+
+      page = @client.poll(after: after, limit: limit)
+      page.events.each { |event| handler.call(event) }
+      page.next_cursor
+    end
+  end
+end

data/lib/hailer/railtie.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'action_mailer/railtie'
+
+module Hailer
+  class Railtie < ::Rails::Railtie
+    # A default, not an after-boot override: an app's test environment can
+    # still choose :test without contacting the service.
+    config.action_mailer.delivery_method = :hailer
+    config.hailer = ActiveSupport::OrderedOptions.new
+    config.hailer.feedback_handler = nil
+
+    initializer 'hailer.action_mailer', before: 'action_mailer.set_configs' do
+      ActiveSupport.on_load(:action_mailer) do
+        add_delivery_method :hailer, Hailer::DeliveryMethod
+      end
+    end
+  end
+end

data/lib/hailer/transport.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+module Hailer
+  # No persistent connection across forks, redirects, HTTP_PROXY, or retries.
+  class Transport
+    DEFAULTS = { open_timeout: 5, read_timeout: 30, write_timeout: 30 }.freeze
+    MAX_RESPONSE_BYTES = 65_536
+    HTTP_ERRORS = {
+      400 => ValidationError, 422 => ValidationError,
+      502 => RejectedError, 503 => UnavailableError
+    }.freeze
+
+    def initialize(endpoint: ENV['HAILER_URL'], **timeouts)
+      @uri = URI.parse(endpoint.to_s)
+      unless @uri.is_a?(URI::HTTP) && @uri.host && !@uri.host.empty? &&
+             !@uri.userinfo && !@uri.query && !@uri.fragment &&
+             @uri.path == '/internal/mail/send'
+        raise ConfigurationError, 'set HAILER_URL or endpoint to an HTTP(S) URL ending in /internal/mail/send'
+      end
+      @timeouts = DEFAULTS.merge(timeouts)
+      raise ConfigurationError, 'unknown Hailer timeout setting' unless (@timeouts.keys - DEFAULTS.keys).empty?
+
+      unless @timeouts.values.all? { |value| value.is_a?(Numeric) && value.finite? && value.positive? }
+        raise ConfigurationError, 'Hailer timeouts must be positive, finite numbers'
+      end
+    rescue URI::InvalidURIError
+      raise ConfigurationError, 'invalid Hailer endpoint URL'
+    end
+
+    def post(path, payload, max_response_bytes: MAX_RESPONSE_BYTES)
+      request = Net::HTTP::Post.new(path)
+      request.content_type = 'application/json'
+      request['Accept'] = 'application/json'
+      request.body = JSON.generate(payload)
+      http = Net::HTTP.new(@uri.hostname, @uri.port, nil)
+      http.use_ssl = @uri.scheme == 'https'
+      http.max_retries = 0
+      @timeouts.each { |name, value| http.public_send(:"#{name}=", value) }
+      status, body = exchange(http, request, max_response_bytes)
+      decode_response(status, body)
+    rescue Timeout::Error, IOError, EOFError, SystemCallError, SocketError,
+           OpenSSL::SSL::SSLError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError => error
+      raise TransportError, "Hailer transport failed (#{error.class}); delivery outcome may be unknown"
+    end
+
+    private
+
+    def exchange(http, request, limit)
+      status = nil
+      body = +''
+      http.start do |connection|
+        connection.request(request) do |response|
+          status = response.code.to_i
+          response.read_body do |chunk|
+            raise ProtocolError, 'Hailer response exceeds the response size limit' if body.bytesize + chunk.bytesize > limit
+
+            body << chunk
+          end
+        end
+      end
+      [status, body]
+    end
+
+    def decode_response(status, body)
+      document = JSON.parse(body)
+      raise ProtocolError, 'Hailer response must be a JSON object' unless document.is_a?(Hash)
+
+      unless status == 200
+        message = document['error']
+        message = "Hailer returned HTTP #{status}" unless message.is_a?(String) && !message.empty?
+        raise HTTP_ERRORS.fetch(status, DeliveryError).new(message, status: status)
+      end
+      document
+    rescue JSON::ParserError
+      raise ProtocolError, "Hailer returned invalid JSON (HTTP #{status})"
+    end
+  end
+end

data/lib/hailer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Hailer
+  VERSION = '0.1.0'
+end

data/lib/hailer.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'hailer/version'
+require_relative 'hailer/errors'
+require_relative 'hailer/transport'
+require_relative 'hailer/client'
+require_relative 'hailer/delivery_method'
+require_relative 'hailer/feedback_client'
+require_relative 'hailer/feedback_consumer'
+require_relative 'hailer/railtie'

data/vendor/aarch64-linux-gnu/manifest.json

@@ -0,0 +1,6 @@
+{
+  "version": "0.1.0",
+  "platform": "aarch64-linux-gnu",
+  "target": "aarch64-unknown-linux-gnu",
+  "sha256": "ee22e7e6b189418986e2b7530d1cf8c696643fe9ab21f69de78578d77f8af13b"
+}

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: hailer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: aarch64-linux-gnu
+authors:
+- Abdelkader Boudih
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionmailer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.18'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.18'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: mail
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A thin ActionMailer adapter for the standalone Hailer Rust service. Rails
+  renders the message; Hailer owns SES delivery.
+email:
+- oss@seuros.com
+executables:
+- hailer
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/hailer
+- hailer.example.toml
+- lib/hailer.rb
+- lib/hailer/binary.rb
+- lib/hailer/client.rb
+- lib/hailer/delivery_method.rb
+- lib/hailer/errors.rb
+- lib/hailer/feedback_client.rb
+- lib/hailer/feedback_consumer.rb
+- lib/hailer/railtie.rb
+- lib/hailer/transport.rb
+- lib/hailer/version.rb
+- vendor/aarch64-linux-gnu/bin/hailer
+- vendor/aarch64-linux-gnu/manifest.json
+homepage: https://github.com/seuros/hailer
+licenses:
+- BSD-3-Clause
+metadata:
+  source_code_uri: https://github.com/seuros/hailer
+  changelog_uri: https://github.com/seuros/hailer/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: ActionMailer delivery through the Hailer mail ship
+test_files: []