loomail 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bee25d3570620ba5495c50774a6f520f0430acef33f7dd936714d52894ead06d
+  data.tar.gz: 9774e9f7cb1062b005f33b51d0e987aadc68adb7644a3a10949f6e769a74d16d
+SHA512:
+  metadata.gz: fc3885e6300e3b078dfa7eb6838b19ff89c952c5958afe4f1931ca97df4d716fd35792b34d6e63828740b6835783e87480fa4d42ad10ffff82d059c3d376aa1b
+  data.tar.gz: 4a89471900043ce6180fdacf4f4f6d0dc84bf90d15742f96b284b33a9cfefd9e122184348350f0a374a54791dba051875cabb576dffa73af92cad1c3ecc2b1ac

data/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Loomail
+Copyright (c) 2026 Claros (original work)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+# loomail (Ruby and Rails)
+
+Server-side client for [Loomail](https://loomail.site). Ruby 3.0+, no dependencies (Net::HTTP), with a Rails integration.
+
+```bash
+gem install loomail      # or: bundle add loomail
+```
+
+```ruby
+loomail = Loomail::Client.new(secret_key: ENV["LOOMAIL_SECRET_KEY"])   # mf_live_...
+
+loomail.identify("user_123", { email: "a@b.c", plan: "trial" })
+loomail.track("user_123", "signed_up", { source: "ads" })
+```
+
+Use a **secret** key (`mf_live_...`). A publishable key (`mf_pub_...`) belongs in the browser snippet, and the client refuses it.
+
+## Rails
+
+The gem is picked up automatically. Give it the key in any one of these:
+
+```ruby
+# config/application.rb or an environment file
+config.loomail.secret_key = ENV["LOOMAIL_SECRET_KEY"]
+config.loomail.host = "https://loomail.example.com"   # only for a self-hosted install
+```
+
+```yaml
+# rails credentials:edit
+loomail:
+  secret_key: mf_live_...
+  host: https://loomail.example.com
+```
+
+or just set `LOOMAIL_SECRET_KEY` (and `LOOMAIL_HOST`) in the environment. Then, anywhere:
+
+```ruby
+Loomail.identify(user.id, email: user.email, plan: "trial")
+Loomail.track(user.id, "signed_up")
+
+# on a background job (ActiveJob), so a Loomail outage never slows the request:
+Loomail.track_later(user.id, "invoice_paid", { amount: 4900 }, message_id: "paid:#{invoice.id}")
+Loomail.identify_later(user.id, email: user.email)
+```
+
+`track_later` fixes the `message_id` when it queues the job, so a retried job is recognised and not counted twice. An outage or rate limit is retried with a growing wait (5 attempts); a refusal that retrying cannot fix (a bad key, a plan limit) is logged and dropped.
+
+Outside Rails, `Loomail.configure { |c| c.secret_key = "..." }` sets the shared client the same way.
+
+## Options
+
+| Option | Default | |
+|---|---|---|
+| `secret_key:` | `LOOMAIL_SECRET_KEY` | Required. |
+| `host:` | `LOOMAIL_HOST`, then `https://loomail.site` | Your Loomail install. |
+| `timeout:` | `10` | Seconds per attempt. |
+| `max_retries:` | `3` | On network errors, 429 and 5xx, with backoff; `Retry-After` is honoured. |
+
+## Calls
+
+- `identify(user_id, traits = {}, timestamp:, message_id:, context:)` creates or updates a person. Traits merge; a `nil` trait removes it. Put `email` here so the person can be mailed, and `payment_status` / `plan` to drive lifecycle flows.
+- `track(user_id, event, properties = {}, timestamp:, message_id:, context:)` records something a person did.
+- `batch(items)` sends many items, split into requests of 100 for you. Refused items come back in `errors` with their position; the rest go through.
+
+Traits and properties can be a Hash or plain keywords (`identify("u1", email: "a@b.c")`). The names `timestamp`, `message_id` and `context` are the options; a trait with one of those names has to go in a Hash.
+
+```ruby
+result = loomail.batch([
+  { type: :identify, user_id: "u1", traits: { plan: "pro" } },
+  { type: :track, user_id: "u1", event: "upgraded", properties: { plan: "pro" }, message_id: "up:1" }
+])
+result.received   # 2
+result.errors     # [{ index: 0, message: "...", code: "plan_limit" }, ...]
+```
+
+## Retries never double-count
+
+Every call carries a `messageId` (generated if you don't give one), and Loomail drops a repeat. So a retried request, or the same request sent twice, records once. To make a repeat safe across restarts too, pass your own: `message_id: "paid:#{invoice.id}"`. The result tells you when it was a repeat: `result.deduplicated?`.
+
+## Errors
+
+Calls raise `Loomail::Error` with `#code`, plus `#status` and `#body` when Loomail answered:
+
+`:invalid_argument` (caught before any request) · `:unauthorized` (401) · `:forbidden` (403) · `:plan_limit` (402, the workspace is at its contact limit) · `:validation` (400/422) · `:rate_limited` (429) · `:server` (5xx) · `:network`.
+
+Only 429, 5xx and network errors are retried; the others are mistakes that retrying cannot fix. Events more than 72 hours from Loomail's clock are re-dated to now by the server.

data/lib/loomail/client.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "securerandom"
+require "time"
+require "uri"
+
+module Loomail
+  # Server-side client for Loomail's ingestion API.
+  #
+  # Sends identify and track calls with a secret key (mf_live_...), retries what is safe to retry, and never
+  # double-counts: every call carries a message_id, which Loomail uses to drop repeats.
+  #
+  #   loomail = Loomail::Client.new(secret_key: ENV["LOOMAIL_SECRET_KEY"])
+  #   loomail.identify("user_123", { email: "a@b.c", plan: "trial" })
+  #   loomail.track("user_123", "signed_up", { source: "ads" })
+  #
+  # Methods raise Loomail::Error when Loomail cannot be reached or refuses the call. In a web request that means a
+  # Loomail outage can fail the request, so use Loomail.track_later (Rails) or rescue Loomail::Error for fire-and-forget.
+  class Client
+    DEFAULT_HOST = "https://loomail.site"
+    # Loomail rejects a batch of more than 100 items or more than 512 KB.
+    MAX_BATCH_ITEMS = 100
+    MAX_BATCH_BYTES = 400 * 1024 # headroom under the server's 512 KB body limit
+
+    # secret_key:  mf_live_... (default ENV["LOOMAIL_SECRET_KEY"]). Never use it in a browser.
+    # host:        your Loomail install (default ENV["LOOMAIL_HOST"], then https://loomail.site)
+    # timeout:     seconds per attempt (default 10)
+    # max_retries: retries after the first attempt, on network errors, 429 and 5xx (default 3)
+    # transport:   replaces Net::HTTP (tests, proxies): callable(url, headers, body, timeout) returning
+    #              [status, headers_hash_with_lowercase_keys, body_string], raising Loomail::Client::TransportError
+    # sleeper:     replaces the wait between retries (tests): callable(seconds)
+    def initialize(secret_key: nil, host: nil, timeout: 10, max_retries: 3, transport: nil, sleeper: nil)
+      key = secret_key || ENV["LOOMAIL_SECRET_KEY"]
+      if key.nil? || key.empty?
+        raise Error.new(:invalid_argument, "secret_key is required (or set LOOMAIL_SECRET_KEY)")
+      end
+      if key.start_with?("mf_pub_")
+        raise Error.new(:invalid_argument,
+                        "That is a publishable key (mf_pub_...), meant for browsers. Server code needs a secret key (mf_live_...).")
+      end
+
+      @secret_key = key
+      host = host || ENV["LOOMAIL_HOST"]
+      host = DEFAULT_HOST if host.nil? || host.empty?
+      @host = host.sub(%r{/+\z}, "")
+      @timeout = timeout.to_f
+      @max_retries = [max_retries.to_i, 0].max
+      @transport = transport || method(:net_http)
+      @sleeper = sleeper || ->(seconds) { sleep(seconds) }
+    end
+
+    # No answer from the server: it could not be reached, or did not reply in time.
+    class TransportError < StandardError; end
+
+    OPTION_KEYS = %i[timestamp message_id context].freeze
+
+    # Create or update a person. Traits merge into what Loomail already knows; a nil trait removes it.
+    #
+    #   client.identify("u1", { email: "a@b.c" })   # a Hash of traits
+    #   client.identify("u1", email: "a@b.c")       # or plain keywords
+    #
+    # The options timestamp: (Time, DateTime or String), message_id: and context: (Hash) are reserved words: a trait
+    # with one of those names has to go in the Hash form.
+    def identify(user_id, traits = {}, **keywords)
+      options, extra = split_keywords(keywords)
+      send_call("/v1/identify", identify_body(user_id, merge_data(traits, extra), options[:timestamp], options[:message_id], options[:context]))
+    end
+
+    # Record something a person did. Properties go in a Hash or as plain keywords, like traits in #identify.
+    def track(user_id, event, properties = {}, **keywords)
+      options, extra = split_keywords(keywords)
+      send_call("/v1/track", track_body(user_id, event, merge_data(properties, extra), options[:timestamp], options[:message_id], options[:context]))
+    end
+
+    # Send many identify/track items. Splits them into requests of at most 100 items (and under the size limit), so any
+    # length is fine. A refused item lands in the result's +errors+ and does not stop the rest; a request that fails
+    # outright (bad key, an outage after retries) raises.
+    #
+    #   loomail.batch([
+    #     { type: :identify, user_id: "u1", traits: { plan: "pro" } },
+    #     { type: :track, user_id: "u1", event: "upgraded", properties: { plan: "pro" }, message_id: "up:1" }
+    #   ])
+    def batch(items)
+      prepared = items.each_with_index.map do |item, i|
+        item = item.transform_keys(&:to_sym)
+        begin
+          case item[:type]&.to_s
+          when "identify"
+            identify_body(item[:user_id], item[:traits] || {}, item[:timestamp], item[:message_id], item[:context]).merge(type: "identify")
+          when "track"
+            track_body(item[:user_id], item[:event], item[:properties] || {}, item[:timestamp], item[:message_id], item[:context]).merge(type: "track")
+          else
+            raise Error.new(:invalid_argument, 'type must be "identify" or "track"')
+          end
+        rescue Error => e
+          raise Error.new(:invalid_argument, "batch[#{i}]: #{e.message}")
+        end
+      end
+
+      received = 0
+      errors = []
+      chunk = []
+      chunk_bytes = 0
+      chunk_start = 0
+      flush = lambda do
+        next if chunk.empty?
+
+        res = post("/v1/batch", { batch: chunk })
+        received += res["received"].to_i
+        Array(res["errors"]).each do |err|
+          entry = { index: err["index"].to_i + chunk_start, message: err["message"].to_s }
+          entry[:code] = err["code"] if err["code"]
+          errors << entry
+        end
+        chunk_start += chunk.length
+        chunk = []
+        chunk_bytes = 0
+      end
+      prepared.each do |item|
+        size = encode(item).bytesize + 1
+        flush.call if chunk.length >= MAX_BATCH_ITEMS || (!chunk.empty? && chunk_bytes + size > MAX_BATCH_BYTES)
+        chunk << item
+        chunk_bytes += size
+      end
+      flush.call
+      BatchResult.new(received: received, errors: errors)
+    end
+
+    private
+
+    # Keywords that are options, and the rest (which are data).
+    def split_keywords(keywords)
+      options = keywords.slice(*OPTION_KEYS)
+      [options, keywords.reject { |key, _| OPTION_KEYS.include?(key) }]
+    end
+
+    def merge_data(hash, extra)
+      return hash if extra.empty?
+
+      (hash || {}).merge(extra)
+    end
+
+    def base_body(user_id, timestamp, message_id, context)
+      raise Error.new(:invalid_argument, "userId must be a non-empty string") if user_id.nil? || user_id.to_s.strip.empty?
+
+      body = { userId: user_id.to_s, messageId: (message_id || SecureRandom.uuid).to_s }
+      body[:timestamp] = iso(timestamp) unless timestamp.nil?
+      body[:context] = context unless context.nil?
+      body
+    end
+
+    def identify_body(user_id, traits, timestamp, message_id, context)
+      base_body(user_id, timestamp, message_id, context).merge(traits: traits || {})
+    end
+
+    def track_body(user_id, event, properties, timestamp, message_id, context)
+      body = base_body(user_id, timestamp, message_id, context)
+      raise Error.new(:invalid_argument, "event must be a non-empty string") if event.nil? || event.to_s.strip.empty?
+
+      body.merge(event: event.to_s, properties: properties || {})
+    end
+
+    def iso(value)
+      time =
+        case value
+        when Time then value
+        when String then Time.parse(value)
+        else value.respond_to?(:to_time) ? value.to_time : raise(ArgumentError)
+        end
+      time.utc.strftime("%Y-%m-%dT%H:%M:%S.%LZ")
+    rescue ArgumentError, TypeError
+      raise Error.new(:invalid_argument, "timestamp is not a valid date: #{value}")
+    end
+
+    def encode(body)
+      JSON.generate(body)
+    rescue JSON::GeneratorError, Encoding::UndefinedConversionError => e
+      raise Error.new(:invalid_argument, "The data could not be encoded as JSON: #{e.message}")
+    end
+
+    def send_call(path, body)
+      Result.new(deduplicated: post(path, body)["deduplicated"] == true)
+    end
+
+    def code_for_status(status)
+      case status
+      when 401 then :unauthorized
+      when 402 then :plan_limit
+      when 403 then :forbidden
+      when 429 then :rate_limited
+      when 500.. then :server
+      else :validation
+      end
+    end
+
+    # One POST with retries. Every body here carries a messageId, so repeating it is safe.
+    def post(path, body)
+      payload = encode(body)
+      headers = {
+        "Authorization" => "Bearer #{@secret_key}",
+        "Content-Type" => "application/json",
+        "User-Agent" => "loomail-ruby/#{VERSION}"
+      }
+      attempt = 0
+      loop do
+        begin
+          status, response_headers, raw = @transport.call(@host + path, headers, payload, @timeout)
+        rescue TransportError => e
+          if attempt >= @max_retries
+            raise Error.new(:network, "Could not reach Loomail at #{@host}: #{e.message}")
+          end
+
+          @sleeper.call([backoff(attempt), 30.0].min)
+          attempt += 1
+          next
+        end
+
+        parsed = parse(raw)
+        return parsed.is_a?(Hash) ? parsed : {} if status.between?(200, 299)
+
+        retryable = status == 429 || status >= 500
+        if !retryable || attempt >= @max_retries
+          detail = parsed.is_a?(Hash) && parsed["error"].is_a?(String) ? ": #{parsed['error']}" : ""
+          raise Error.new(code_for_status(status), "Loomail answered #{status}#{detail}", status: status, body: parsed)
+        end
+
+        after = Float(response_headers["retry-after"], exception: false) if response_headers["retry-after"]
+        wait = after && after >= 0 ? after : backoff(attempt)
+        @sleeper.call([wait, 30.0].min)
+        attempt += 1
+      end
+    end
+
+    def parse(raw)
+      return nil if raw.nil? || raw.empty?
+
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      raw
+    end
+
+    # 0.5s, 1s, 2s... with up to 25% jitter.
+    def backoff(attempt)
+      base = 0.5 * (2**attempt)
+      base + rand * base * 0.25
+    end
+
+    # The default transport.
+    def net_http(url, headers, body, timeout)
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = [timeout, 10.0].min
+      http.read_timeout = timeout
+      http.write_timeout = timeout
+      request = Net::HTTP::Post.new(uri.request_uri, headers)
+      request.body = body
+      response = http.start { |h| h.request(request) }
+      [response.code.to_i, response.each_header.to_h.transform_keys(&:downcase), response.body.to_s]
+    rescue Net::OpenTimeout, Net::ReadTimeout, Net::WriteTimeout, Timeout::Error => e
+      raise TransportError, "timed out (#{e.class})"
+    rescue SocketError, SystemCallError, IOError, OpenSSL::SSL::SSLError, EOFError, URI::InvalidURIError => e
+      raise TransportError, "#{e.class}: #{e.message}"
+    end
+  end
+end

data/lib/loomail/deliver_job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_job"
+
+module Loomail
+  # Sends one identify or track from a background job. The call keeps the message_id it was queued with, so a retry of
+  # the job (or a duplicate delivery) is recognised by Loomail and not counted twice.
+  class DeliverJob < ::ActiveJob::Base
+    RETRYABLE = %i[network server rate_limited].freeze
+
+    queue_as :default
+
+    # An outage or a rate limit is retried with a growing wait. Anything else (a bad key, a plan limit, a payload Loomail
+    # refuses) cannot be fixed by retrying, so it is logged and dropped in #perform.
+    retry_on Loomail::Error, wait: :polynomially_longer, attempts: 5
+
+    def perform(method, args, options)
+      Loomail.public_send(method, *args, **options.transform_keys(&:to_sym))
+    rescue Loomail::Error => e
+      raise if RETRYABLE.include?(e.code)
+
+      logger&.warn("[loomail] dropped #{method}: #{e.message}")
+    end
+  end
+end

data/lib/loomail/error.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Loomail
+  # Raised when Loomail cannot be reached or refuses a call.
+  #
+  # #code is one of:
+  #   :invalid_argument  caught before any request was made
+  #   :unauthorized      401: key missing, wrong or revoked
+  #   :forbidden         403: key not allowed here
+  #   :plan_limit        402: workspace is at its contact limit
+  #   :validation        400 / 422: Loomail did not accept the payload
+  #   :rate_limited      429, still failing after retries
+  #   :server            5xx, still failing after retries
+  #   :network           could not reach Loomail, or it did not answer in time
+  class Error < StandardError
+    attr_reader :code, :status, :body
+
+    def initialize(code, message, status: nil, body: nil)
+      super(message)
+      @code = code
+      @status = status
+      @body = body
+    end
+  end
+
+  # What #identify and #track return.
+  Result = Struct.new(:deduplicated, keyword_init: true) do
+    # True when Loomail had already seen this message_id and ignored the repeat.
+    def deduplicated?
+      deduplicated == true
+    end
+  end
+
+  # What #batch returns. +errors+ is an array of { index:, message:, code: } for the items Loomail refused.
+  BatchResult = Struct.new(:received, :errors, keyword_init: true)
+end

data/lib/loomail/railtie.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module Loomail
+  # Rails integration. Loaded automatically when Rails is present. Reads, in this order of preference:
+  #
+  #   config.loomail.secret_key / .host / .timeout / .max_retries   (config/application.rb or an environment file)
+  #   Rails credentials:  loomail: { secret_key: ..., host: ... }
+  #   ENV["LOOMAIL_SECRET_KEY"] and ENV["LOOMAIL_HOST"]
+  #
+  # Then Loomail.identify / Loomail.track work anywhere, and Loomail.track_later runs on ActiveJob.
+  class Railtie < ::Rails::Railtie
+    config.loomail = ActiveSupport::OrderedOptions.new
+
+    initializer "loomail.configure" do |app|
+      creds = app.credentials.respond_to?(:loomail) ? app.credentials.loomail : nil
+      creds = creds.to_h if creds.respond_to?(:to_h)
+      creds ||= {}
+      settings = app.config.loomail
+
+      Loomail.configure do |c|
+        c.secret_key = settings.secret_key || creds[:secret_key]
+        c.host = settings.host || creds[:host]
+        c.timeout = settings.timeout || creds[:timeout] || c.timeout
+        c.max_retries = settings.max_retries || creds[:max_retries] || c.max_retries
+      end
+    end
+  end
+end

data/lib/loomail/version.rb

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

data/lib/loomail.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "loomail/version"
+require_relative "loomail/error"
+require_relative "loomail/client"
+
+# Server-side client for Loomail. See Loomail::Client.
+#
+# Configure once (a Rails app does this from config.loomail, credentials or the environment automatically):
+#
+#   Loomail.configure do |c|
+#     c.secret_key = ENV["LOOMAIL_SECRET_KEY"]
+#     c.host = "https://loomail.example.com" # only for a self-hosted install
+#   end
+#
+#   Loomail.identify(user.id, email: user.email)
+#   Loomail.track(user.id, "signed_up")
+module Loomail
+  # Settings for the shared client. Anything left empty falls back to LOOMAIL_SECRET_KEY / LOOMAIL_HOST.
+  class Configuration
+    attr_accessor :secret_key, :host, :timeout, :max_retries
+
+    def initialize
+      @timeout = 10
+      @max_retries = 3
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+      @client = nil
+      configuration
+    end
+
+    # The shared client, built from the configuration on first use.
+    def client
+      @client ||= Client.new(
+        secret_key: configuration.secret_key,
+        host: configuration.host,
+        timeout: configuration.timeout,
+        max_retries: configuration.max_retries
+      )
+    end
+
+    # Replace the shared client (tests).
+    attr_writer :client
+
+    def reset!
+      @client = nil
+      @configuration = nil
+    end
+
+    def identify(user_id, traits = {}, **keywords)
+      client.identify(user_id, traits, **keywords)
+    end
+
+    def track(user_id, event, properties = {}, **keywords)
+      client.track(user_id, event, properties, **keywords)
+    end
+
+    def batch(items)
+      client.batch(items)
+    end
+
+    # Same as identify / track, on a background job (Rails with ActiveJob), so a Loomail outage cannot slow or fail the
+    # request. Without ActiveJob it calls straight away and logs nothing.
+    def identify_later(user_id, traits = {}, **options)
+      enqueue(:identify, [user_id, traits], options)
+    end
+
+    def track_later(user_id, event, properties = {}, **options)
+      enqueue(:track, [user_id, event, properties], options)
+    end
+
+    private
+
+    def enqueue(method, args, options)
+      options = options.dup
+      # A time becomes text, and a message_id is fixed now, so a retried job cannot double-count.
+      options[:timestamp] = options[:timestamp].utc.iso8601(3) if options[:timestamp].respond_to?(:utc)
+      options[:message_id] ||= SecureRandom.uuid
+      if defined?(::ActiveJob)
+        require_relative "loomail/deliver_job"
+        Loomail::DeliverJob.perform_later(method.to_s, args, options.transform_keys(&:to_s))
+      else
+        public_send(method, *args, **options)
+      end
+    end
+  end
+end
+
+require_relative "loomail/railtie" if defined?(::Rails::Railtie)

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: loomail
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Loomail
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.20'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: Zero-dependency Ruby client for Loomail's ingestion API, with retries,
+  idempotent calls and a Rails integration.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/loomail.rb
+- lib/loomail/client.rb
+- lib/loomail/deliver_job.rb
+- lib/loomail/error.rb
+- lib/loomail/railtie.rb
+- lib/loomail/version.rb
+homepage: https://loomail.site
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://loomail.site
+  source_code_uri: https://github.com/sasbaws2211-cloud/mailforge/tree/main/packages/sdk-ruby
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: 'Server-side client for Loomail: send identify and track events with a secret
+  key.'
+test_files: []