mailtrap 2.8.0 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad3283b7e6c8af70b1ac8bb3a965868e3b312c01682615c86f7da5104add3bcb
-  data.tar.gz: 8bab417f54c310a6a92b93ed4a1c6ca6a4cd88dae2e0614e3d2f21cda05d8cf0
+  metadata.gz: b3a95002cbfb65622fa2d944bf2de1d41dc25a9a7224f8d244982fdf8154776d
+  data.tar.gz: a228f3805ce687e8f34bd410595f6e39f9e7d73a426d1d06ca2b35ec972b5c69
 SHA512:
-  metadata.gz: 317490e679342d1c9ac8ae12162268c4102ee410a3d4a9896237894c2a5cd39063595c613d248938a1770cd8f24c7cb4dc72f109c1dabec48f920f92f47cd89d
-  data.tar.gz: 7da01e190af37689aff6aacdeb411f0858c7c75baf809b51266db920e2988021343e73f164728d9d9bf857139ee2f30cbf004b6c50782d7394685ef6513f05d8
+  metadata.gz: fcec8536fae46762bd7289b7b098f45728c9d00b79bcd1386b6e4cb384fa0fcf859136db5cc956480da7aa1cb5063ed8dbee2312ac0e2bf6c8ac4b872443e650
+  data.tar.gz: 127126f80cded1f05214a173b1c8e78b8acc6c39bdbf1f168b161ca221a5e4230aa11d098f26c8c188c14778a28c579ac0e2bea52bab2713c82068d43836b677

data/CHANGELOG.md

@@ -1,25 +1,41 @@
+## [2.10.0] - 2026-03-23
+
+- Add Email Logs API (list and get email sending logs with filters and cursor pagination)
+- Add `list_each` to Sandbox Messages API for automatic pagination over all messages
+
+## [2.9.0] - 2026-03-13
+
+- Add Sending Stats API
+- Parse `reply_to` as a structured address field instead of passing it as a raw
+  header when sending with Action Mailer
+
 ## [2.8.0] - 2026-03-03
+
 - Add Account Accesses API
 - Add Billing API
 
-## [2.7.0] - 2026-02-24 
+## [2.7.0] - 2026-02-24
+
 - Add Sandbox Messages API
 - Add Sending Domains API
 - Add Sandbox Attachments API
 - Add Accounts API
 
 ## [2.6.0] - 2026-01-27
+
 - Add Inboxes API
 - Add Projects API
 - Models' `to_h` now returns all fields without compacting
 
 ## [2.5.0] - 2025-11-10
+
 - Add Contact Imports API
 - Add Suppressions API
 - Write the message IDs to the message when sending with Action Mailer
 - Fix versioning :)
 
 ## [2.4.1] - 2025-08-21
+
 - Set `template_uuid` and `template_variables` when building mail from `Mail::Message`
 
 ## [2.4.0] - 2025-08-04

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mailtrap (2.8.0)
+    mailtrap (2.10.0)
       base64
 
 GEM

data/README.md

@@ -177,6 +177,8 @@ Email API:
 - Full Email Sending – [`full.rb`](examples/full.rb)
 - Batch Sending – [`batch.rb`](examples/batch.rb)
 - Sending Domains API  – [`sending_domains_api.rb`](examples/sending_domains_api.rb)
+- Sending Stats API – [`stats_api.rb`](examples/stats_api.rb)
+- Email Logs API – [`email_logs_api.rb`](examples/email_logs_api.rb)
 
 Email Sandbox (Testing):
 

data/lib/mailtrap/email_log_event.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Mailtrap
+  # Data Transfer Object for an email log event (delivery, open, click, bounce, etc.)
+  # @see https://docs.mailtrap.io/developers/email-sending/email-logs
+  # @attr_reader event_type [String] One of: delivery, open, click, soft_bounce, bounce, spam, unsubscribe, suspension,
+  #   reject
+  # @attr_reader created_at [String] ISO 8601 timestamp
+  # @attr_reader details [EmailLogEventDetails::Delivery, EmailLogEventDetails::Open, EmailLogEventDetails::Click,
+  #   EmailLogEventDetails::Bounce, EmailLogEventDetails::Spam, EmailLogEventDetails::Unsubscribe,
+  #   EmailLogEventDetails::Reject] Type-specific event details
+  EmailLogEvent = Struct.new(
+    :event_type,
+    :created_at,
+    :details,
+    keyword_init: true
+  )
+end

data/lib/mailtrap/email_log_event_details.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Mailtrap
+  # Type-specific event detail structs for EmailLogEvent. Use event_type to determine which details schema applies.
+  # @see https://docs.mailtrap.io/developers/email-sending/email-logs
+  module EmailLogEventDetails
+    # For event_type = delivery
+    Delivery = Struct.new(:sending_ip, :recipient_mx, :email_service_provider, keyword_init: true)
+
+    # For event_type = open
+    Open = Struct.new(:web_ip_address, keyword_init: true)
+
+    # For event_type = click
+    Click = Struct.new(:click_url, :web_ip_address, keyword_init: true)
+
+    # For event_type = soft_bounce or bounce
+    Bounce = Struct.new(
+      :sending_ip,
+      :recipient_mx,
+      :email_service_provider,
+      :email_service_provider_status,
+      :email_service_provider_response,
+      :bounce_category,
+      keyword_init: true
+    )
+
+    # For event_type = spam
+    Spam = Struct.new(:spam_feedback_type, keyword_init: true)
+
+    # For event_type = unsubscribe
+    Unsubscribe = Struct.new(:web_ip_address, keyword_init: true)
+
+    # For event_type = suspension or reject
+    Reject = Struct.new(:reject_reason, keyword_init: true)
+
+    DETAIL_STRUCTS = {
+      'delivery' => Delivery,
+      'open' => Open,
+      'click' => Click,
+      'soft_bounce' => Bounce,
+      'bounce' => Bounce,
+      'spam' => Spam,
+      'unsubscribe' => Unsubscribe,
+      'suspension' => Reject,
+      'reject' => Reject
+    }.freeze
+
+    # Builds the appropriate detail struct from API response.
+    # @param event_type [String] Known event type (delivery, open, click, etc.)
+    # @param hash [Hash] Symbol-keyed details from parsed JSON
+    # @return [Delivery, Open, Click, Bounce, Spam, Unsubscribe, Reject]
+    # @raise [ArgumentError] when event_type is nil or not in DETAIL_STRUCTS
+    def self.build(event_type, hash)
+      struct_class = DETAIL_STRUCTS[event_type.to_s]
+      raise ArgumentError, "Unknown event_type: #{event_type.inspect}" unless struct_class
+
+      attrs = hash.slice(*struct_class.members)
+      struct_class.new(**attrs)
+    end
+  end
+end

data/lib/mailtrap/email_log_message.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Mailtrap
+  # Data Transfer Object for an email log message (summary in list, full details when fetched by ID)
+  # @see https://docs.mailtrap.io/developers/email-sending/email-logs
+  # @attr_reader message_id [String] Message UUID
+  # @attr_reader status [String] delivered, not_delivered, enqueued, opted_out
+  # @attr_reader subject [String, nil] Email subject
+  # @attr_reader from [String] Sender address
+  # @attr_reader to [String] Recipient address
+  # @attr_reader sent_at [String] ISO 8601 timestamp
+  # @attr_reader client_ip [String, nil] Client IP that sent the email
+  # @attr_reader category [String, nil] Message category
+  # @attr_reader custom_variables [Hash, nil] Custom variables
+  # @attr_reader sending_stream [String] transactional or bulk
+  # @attr_reader sending_domain_id [Integer] Sending domain ID
+  # @attr_reader template_id [Integer, nil] Template ID if sent from template
+  # @attr_reader template_variables [Hash, nil] Template variables
+  # @attr_reader opens_count [Integer] Number of opens
+  # @attr_reader clicks_count [Integer] Number of clicks
+  # @attr_reader raw_message_url [String, nil] Signed URL to download raw .eml (only when fetched by ID)
+  # @attr_reader events [Array<EmailLogEvent>, nil] Event list (only when fetched by ID)
+  EmailLogMessage = Struct.new(
+    :message_id,
+    :status,
+    :subject,
+    :from,
+    :to,
+    :sent_at,
+    :client_ip,
+    :category,
+    :custom_variables,
+    :sending_stream,
+    :sending_domain_id,
+    :template_id,
+    :template_variables,
+    :opens_count,
+    :clicks_count,
+    :raw_message_url,
+    :events,
+    keyword_init: true
+  )
+end

data/lib/mailtrap/email_logs_api.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative 'base_api'
+require_relative 'email_log_message'
+require_relative 'email_log_event'
+require_relative 'email_log_event_details'
+require_relative 'email_logs_list_response'
+
+module Mailtrap
+  class EmailLogsAPI
+    include BaseAPI
+
+    self.response_class = EmailLogMessage
+
+    # Lists email logs with optional filters and cursor-based pagination.
+    #
+    # @param filters [Hash, nil] Optional filters. Top-level date keys use string values (ISO 8601);
+    #   other keys use +{ operator:, value: }+. +value+ can be a single value or an Array for
+    #   operators that accept multiple values (e.g. +equal+, +not_equal+, +ci_equal+, +ci_not_equal+).
+    #   Examples:
+    #   +{ sent_after: "2025-01-01T00:00:00Z", sent_before: "2025-01-31T23:59:59Z" }+
+    #   +{ to: { operator: "ci_equal", value: "recipient@example.com" } }+
+    #   +{ category: { operator: "equal", value: ["Welcome Email", "Transactional Email"] } }+
+    # @param search_after [String, nil] Message UUID cursor for the next page (from previous +next_page_cursor+)
+    # @return [EmailLogsListResponse] messages, total_count, and next_page_cursor
+    # @!macro api_errors
+    def list(filters: nil, search_after: nil)
+      query_params = build_list_query_params(filters:, search_after:)
+
+      response = client.get(base_path, query_params)
+
+      build_list_response(response)
+    end
+
+    # Iterates over all email log messages matching the filters, automatically fetching each page.
+    # Use this when you want to process every message without manually handling +next_page_cursor+.
+    #
+    # @param filters [Hash, nil] Same as +list+
+    # @yield [EmailLogMessage] Gives each message from every page when a block is given.
+    # @return [Enumerator<EmailLogMessage>] if no block given; otherwise the result of the block
+    # @!macro api_errors
+    def list_each(filters: nil, &block)
+      first_page = nil
+      fetch_first_page = -> { first_page ||= list(filters: filters) }
+      enum = Enumerator.new(-> { fetch_first_page.call.total_count }) do |yielder|
+        response = fetch_first_page.call
+        loop do
+          response.messages.each { |message| yielder << message }
+          break if response.next_page_cursor.nil?
+
+          response = list(filters: filters, search_after: response.next_page_cursor)
+        end
+      end
+
+      block ? enum.each(&block) : enum
+    end
+
+    # Fetches a single email log message by ID.
+    #
+    # @param sending_message_id [String] Message UUID
+    # @return [EmailLogMessage] Message with events and raw_message_url when available
+    # @!macro api_errors
+    def get(sending_message_id)
+      base_get(sending_message_id)
+    end
+
+    private
+
+    def base_path
+      "/api/accounts/#{account_id}/email_logs"
+    end
+
+    def build_list_query_params(filters:, search_after:)
+      {}.tap do |params|
+        params[:search_after] = search_after if search_after
+        params.merge!(flatten_filters(filters))
+      end
+    end
+
+    # Flattens a filters Hash into query param keys expected by the API (deepObject style).
+    # Scalar values => filters[key]; Hashes with :operator/:value => filters[key][operator], filters[key][value].
+    # When :value is an Array, the key is repeated (e.g. filters[category][value]=A&filters[category][value]=B)
+    # for operators that accept multiple values (e.g. equal, not_equal, ci_equal, ci_not_equal).
+    def flatten_filters(filters)
+      return {} if filters.nil? || filters.empty?
+
+      filters.each_with_object({}) do |(key, value), result|
+        if value.is_a?(Hash)
+          flatten_filter_hash(key, value, result)
+        else
+          result["filters[#{key}]"] = value.to_s
+        end
+      end
+    end
+
+    def flatten_filter_hash(parent_key, hash, result)
+      hash.each do |key, value|
+        if value.is_a?(Array)
+          result["filters[#{parent_key}][#{key}][]"] = value.map(&:to_s)
+        else
+          result["filters[#{parent_key}][#{key}]"] = value.to_s
+        end
+      end
+    end
+
+    def build_list_response(response)
+      EmailLogsListResponse.new(
+        messages: Array(response[:messages]).map { |item| handle_response(item) },
+        total_count: response[:total_count],
+        next_page_cursor: response[:next_page_cursor]
+      )
+    end
+
+    def handle_response(response)
+      build_message_entity(response)
+    end
+
+    def build_message_entity(hash)
+      attrs = hash.slice(*EmailLogMessage.members)
+      attrs[:events] = build_events(attrs[:events]) if attrs[:events]
+
+      EmailLogMessage.new(**attrs)
+    end
+
+    def build_events(events_array)
+      Array(events_array).map do |e|
+        EmailLogEvent.new(
+          event_type: e[:event_type],
+          created_at: e[:created_at],
+          details: EmailLogEventDetails.build(e[:event_type], e[:details])
+        )
+      end
+    end
+  end
+end

data/lib/mailtrap/email_logs_list_response.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Mailtrap
+  # Response from listing email logs (paginated)
+  # @see https://docs.mailtrap.io/developers/email-sending/email-logs
+  # @attr_reader messages [Array<EmailLogMessage>] Page of message summaries
+  # @attr_reader total_count [Integer] Total number of messages matching filters
+  # @attr_reader next_page_cursor [String, nil] Message UUID to use as search_after for next page, or nil
+  EmailLogsListResponse = Struct.new(
+    :messages,
+    :total_count,
+    :next_page_cursor,
+    keyword_init: true
+  )
+end

data/lib/mailtrap/mail.rb

@@ -17,6 +17,7 @@ module Mailtrap
       category
       customvariables
       contenttype
+      replyto
     ].freeze
     private_constant :SPECIAL_HEADERS
 
@@ -189,12 +190,13 @@ module Mailtrap
       # Builds a mail object from Mail::Message
       # @param message [Mail::Message]
       # @return [Mailtrap::Mail::Base]
-      def from_message(message)
+      def from_message(message) # rubocop:disable Metrics/AbcSize
         Mailtrap::Mail::Base.new(
           from: prepare_addresses(message['from']).first,
           to: prepare_addresses(message['to']),
           cc: prepare_addresses(message['cc']),
           bcc: prepare_addresses(message['bcc']),
+          reply_to: prepare_addresses(message['reply-to']).first,
           subject: message.subject,
           text: prepare_text_part(message),
           html: prepare_html_part(message),

data/lib/mailtrap/sandbox_messages_api.rb

@@ -51,6 +51,26 @@ module Mailtrap
       base_update(message_id, { is_read: is_read })
     end
 
+    # Iterates over all sandbox messages, automatically fetching each page
+    # using cursor-based pagination. Use this when you want to process messages
+    # without manually handling pagination.
+    # @param search [String] Search query string. Matches subject, to_email, and to_name.
+    # @yield [SandboxMessage] Gives each message from every page when a block is given.
+    # @return [Enumerator<SandboxMessage>] if no block given; otherwise the result of the block
+    # @!macro api_errors
+    def list_each(search: nil, &block)
+      return to_enum(__method__, search: search) unless block
+
+      last_id = nil
+      loop do
+        messages = list(search: search, last_id: last_id)
+        break if messages.empty?
+
+        messages.each { |message| block.call(message) }
+        last_id = messages.last.id
+      end
+    end
+
     # Lists all sandbox messages for the account, limited up to 30 at once
     # @param search [String] Search query string. Matches subject, to_email, and to_name.
     # @param last_id [Integer] If specified, a page of records before last_id is returned.

data/lib/mailtrap/sending_stat_group.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Mailtrap
+  # Data Transfer Object for grouped Sending Stats data
+  # @attr_reader name [Symbol] Group type (:category, :date, :sending_domain_id, :email_service_provider)
+  # @attr_reader value [String, Integer] Group value (e.g., "Transactional", "2026-01-01", 1, "Gmail")
+  # @attr_reader stats [SendingStats] Sending stats for this group
+  #
+  SendingStatGroup = Struct.new(
+    :name,
+    :value,
+    :stats,
+    keyword_init: true
+  )
+end

data/lib/mailtrap/sending_stats.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Mailtrap
+  # Data Transfer Object for Sending Stats data
+  # @see https://docs.mailtrap.io/developers/email-sending-stats
+  # @attr_reader delivery_count [Integer] Number of delivered emails
+  # @attr_reader delivery_rate [Float] Delivery rate
+  # @attr_reader bounce_count [Integer] Number of bounced emails
+  # @attr_reader bounce_rate [Float] Bounce rate
+  # @attr_reader open_count [Integer] Number of opened emails
+  # @attr_reader open_rate [Float] Open rate
+  # @attr_reader click_count [Integer] Number of clicked emails
+  # @attr_reader click_rate [Float] Click rate
+  # @attr_reader spam_count [Integer] Number of spam reports
+  # @attr_reader spam_rate [Float] Spam rate
+  #
+  SendingStats = Struct.new(
+    :delivery_count,
+    :delivery_rate,
+    :bounce_count,
+    :bounce_rate,
+    :open_count,
+    :open_rate,
+    :click_count,
+    :click_rate,
+    :spam_count,
+    :spam_rate,
+    keyword_init: true
+  )
+end

data/lib/mailtrap/stats_api.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'date'
+require_relative 'base_api'
+require_relative 'sending_stats'
+require_relative 'sending_stat_group'
+
+module Mailtrap
+  class StatsAPI
+    include BaseAPI
+
+    ARRAY_FILTERS = %i[sending_domain_ids sending_streams categories email_service_providers].freeze
+    GROUP_KEYS = {
+      'domains' => :sending_domain_id,
+      'categories' => :category,
+      'email_service_providers' => :email_service_provider,
+      'date' => :date
+    }.freeze
+
+    # Get aggregated sending stats
+    # @param start_date [String, Date, Time] Start date for the stats period (required)
+    # @param end_date [String, Date, Time] End date for the stats period (required)
+    # @param sending_domain_ids [Array<Integer>] Filter by sending domain IDs
+    # @param sending_streams [Array<String>] Filter by sending streams
+    # @param categories [Array<String>] Filter by categories
+    # @param email_service_providers [Array<String>] Filter by email service providers
+    # @return [SendingStats] Aggregated sending stats
+    # @!macro api_errors
+    def get(start_date:, end_date:, sending_domain_ids: nil, sending_streams: nil, categories: nil, # rubocop:disable Metrics/ParameterLists
+            email_service_providers: nil)
+      query_params = build_query_params(
+        start_date, end_date,
+        { sending_domain_ids:, sending_streams:, categories:, email_service_providers: }
+      )
+      response = client.get(base_path, query_params)
+      build_entity(response, SendingStats)
+    end
+
+    # Get sending stats grouped by domain
+    # @param start_date [String, Date, Time] Start date for the stats period (required)
+    # @param end_date [String, Date, Time] End date for the stats period (required)
+    # @param sending_domain_ids [Array<Integer>] Filter by sending domain IDs
+    # @param sending_streams [Array<String>] Filter by sending streams
+    # @param categories [Array<String>] Filter by categories
+    # @param email_service_providers [Array<String>] Filter by email service providers
+    # @return [Array<SendingStatGroup>] Array of SendingStatGroup structs with sending_domain_id and stats
+    # @!macro api_errors
+    def by_domain(start_date:, end_date:, sending_domain_ids: nil, sending_streams: nil, categories: nil, # rubocop:disable Metrics/ParameterLists
+                  email_service_providers: nil)
+      grouped_stats('domains', start_date, end_date,
+                    { sending_domain_ids:, sending_streams:, categories:, email_service_providers: })
+    end
+
+    # Get sending stats grouped by category
+    # @param start_date [String, Date, Time] Start date for the stats period (required)
+    # @param end_date [String, Date, Time] End date for the stats period (required)
+    # @param sending_domain_ids [Array<Integer>] Filter by sending domain IDs
+    # @param sending_streams [Array<String>] Filter by sending streams
+    # @param categories [Array<String>] Filter by categories
+    # @param email_service_providers [Array<String>] Filter by email service providers
+    # @return [Array<SendingStatGroup>] Array of SendingStatGroup structs with category and stats
+    # @!macro api_errors
+    def by_category(start_date:, end_date:, sending_domain_ids: nil, sending_streams: nil, categories: nil, # rubocop:disable Metrics/ParameterLists
+                    email_service_providers: nil)
+      grouped_stats('categories', start_date, end_date,
+                    { sending_domain_ids:, sending_streams:, categories:, email_service_providers: })
+    end
+
+    # Get sending stats grouped by email service provider
+    # @param start_date [String, Date, Time] Start date for the stats period (required)
+    # @param end_date [String, Date, Time] End date for the stats period (required)
+    # @param sending_domain_ids [Array<Integer>] Filter by sending domain IDs
+    # @param sending_streams [Array<String>] Filter by sending streams
+    # @param categories [Array<String>] Filter by categories
+    # @param email_service_providers [Array<String>] Filter by email service providers
+    # @return [Array<SendingStatGroup>] Array of SendingStatGroup structs with email_service_provider and stats
+    # @!macro api_errors
+    def by_email_service_provider(start_date:, end_date:, sending_domain_ids: nil, sending_streams: nil, # rubocop:disable Metrics/ParameterLists
+                                  categories: nil, email_service_providers: nil)
+      grouped_stats('email_service_providers', start_date, end_date,
+                    { sending_domain_ids:, sending_streams:, categories:, email_service_providers: })
+    end
+
+    # Get sending stats grouped by date
+    # @param start_date [String, Date, Time] Start date for the stats period (required)
+    # @param end_date [String, Date, Time] End date for the stats period (required)
+    # @param sending_domain_ids [Array<Integer>] Filter by sending domain IDs
+    # @param sending_streams [Array<String>] Filter by sending streams
+    # @param categories [Array<String>] Filter by categories
+    # @param email_service_providers [Array<String>] Filter by email service providers
+    # @return [Array<SendingStatGroup>] Array of SendingStatGroup structs with date and stats
+    # @!macro api_errors
+    def by_date(start_date:, end_date:, sending_domain_ids: nil, sending_streams: nil, categories: nil, # rubocop:disable Metrics/ParameterLists
+                email_service_providers: nil)
+      grouped_stats('date', start_date, end_date,
+                    { sending_domain_ids:, sending_streams:, categories:, email_service_providers: })
+    end
+
+    private
+
+    def grouped_stats(group, start_date, end_date, filters)
+      query_params = build_query_params(start_date, end_date, filters)
+      response = client.get("#{base_path}/#{group}", query_params)
+      group_key = GROUP_KEYS.fetch(group)
+
+      response.map do |item|
+        SendingStatGroup.new(
+          name: group_key,
+          value: item[group_key],
+          stats: build_entity(item[:stats], SendingStats)
+        )
+      end
+    end
+
+    def build_query_params(start_date, end_date, filters)
+      params = { start_date: normalize_date(start_date), end_date: normalize_date(end_date) }
+
+      ARRAY_FILTERS.each do |filter_key|
+        values = filters[filter_key]
+        params["#{filter_key}[]"] = values if values
+      end
+
+      params
+    end
+
+    def normalize_date(value)
+      case value
+      when Date
+        value.iso8601
+      when Time
+        value.strftime('%F')
+      when String
+        unless /\A\d{4}-\d{2}-\d{2}\z/.match?(value)
+          raise ArgumentError,
+                "Invalid date: #{value.inspect}. Expected a Date, Time, or String in YYYY-MM-DD format."
+        end
+
+        Date.iso8601(value).iso8601
+      else
+        raise ArgumentError,
+              "Invalid date: #{value.inspect}. Expected a Date, Time, or String in YYYY-MM-DD format."
+      end
+    rescue Date::Error
+      raise ArgumentError, "Invalid date: #{value.inspect}. Expected a Date, Time, or String in YYYY-MM-DD format."
+    end
+
+    def base_path
+      "/api/accounts/#{account_id}/stats"
+    end
+  end
+end

data/lib/mailtrap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mailtrap
-  VERSION = '2.8.0'
+  VERSION = '2.10.0'
 end

data/lib/mailtrap.rb

@@ -14,10 +14,12 @@ require_relative 'mailtrap/contact_fields_api'
 require_relative 'mailtrap/contact_imports_api'
 require_relative 'mailtrap/suppressions_api'
 require_relative 'mailtrap/sending_domains_api'
+require_relative 'mailtrap/email_logs_api'
 require_relative 'mailtrap/projects_api'
 require_relative 'mailtrap/inboxes_api'
 require_relative 'mailtrap/sandbox_messages_api'
 require_relative 'mailtrap/sandbox_attachments_api'
+require_relative 'mailtrap/stats_api'
 
 module Mailtrap
   # @!macro api_errors

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mailtrap
 version: !ruby/object:Gem::Version
-  version: 2.8.0
+  version: 2.10.0
 platform: ruby
 authors:
 - Railsware Products Studio LLC
@@ -63,6 +63,11 @@ files:
 - lib/mailtrap/contact_lists_api.rb
 - lib/mailtrap/contacts_api.rb
 - lib/mailtrap/contacts_import_request.rb
+- lib/mailtrap/email_log_event.rb
+- lib/mailtrap/email_log_event_details.rb
+- lib/mailtrap/email_log_message.rb
+- lib/mailtrap/email_logs_api.rb
+- lib/mailtrap/email_logs_list_response.rb
 - lib/mailtrap/email_template.rb
 - lib/mailtrap/email_templates_api.rb
 - lib/mailtrap/errors.rb
@@ -79,6 +84,9 @@ files:
 - lib/mailtrap/sandbox_messages_api.rb
 - lib/mailtrap/sending_domain.rb
 - lib/mailtrap/sending_domains_api.rb
+- lib/mailtrap/sending_stat_group.rb
+- lib/mailtrap/sending_stats.rb
+- lib/mailtrap/stats_api.rb
 - lib/mailtrap/suppression.rb
 - lib/mailtrap/suppressions_api.rb
 - lib/mailtrap/version.rb