logister-ruby 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29c7ec6cb1f296ce54ef6081b360d8d3db79781fa70a6d4357ce746602e2ee97
-  data.tar.gz: 076efade8b179ad87615b28271fd3679ebae34f6b41d9cc8cfbcadc347b1f3d0
+  metadata.gz: ff89324842289ec0925e84131ee9442d4dfed5589b86deb1bb56498e55eb5977
+  data.tar.gz: f262d7ab245a8c5703fb28873e65d4ee11194be7146833f656fd74d85434f2ff
 SHA512:
-  metadata.gz: fdd41ab4607104b7b2f53a6233a4b9d600411796ee6b2c709ba8743f08a65565159f3d0eaae366621f01a4c0d0f6b4f0ef9934c99728d493e1303c2f0b9a9726
-  data.tar.gz: c3b81b538e0d434d8bcf681c786e3787b42d130992a40e95f8be367902096bdf84508259ac0a54d313cd5063aefd9438fe192bb9851954694ee7011063edfb97
+  metadata.gz: 28a1b3621688f111349b37c9996d530855d07081c17ce4525e33426b2ff30f1c714f8871555925dd7c11ec78ff09ad0566295552c54d05d141c28b944fe2f383
+  data.tar.gz: c262d8b152f55680dc7ad02d19733089b59415f4a853cf33d5e8ffcade2851a69d4ada2963a7e05e4af8ca758e08340288213ea5e90da68d68c1b6baaf768108

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## v0.4.0 - 2026-08-08
+
+- Added stable UUID assignment before synchronous or asynchronous delivery so retries preserve one logical event identity.
+- Added configurable gzip/NDJSON batching for the Logister batch-ingest endpoint, including deterministic batch IDs, bounded batch size and interval, and automatic fallback to stable single-event delivery for older servers.
+- Added recursive `413` batch splitting while continuing every split or fallback attempt, preventing one failed subset from short-circuiting the remainder.
+- Added transient-only retries with connect, read, and write timeouts, numeric or HTTP-date `Retry-After` support, capped exponential backoff, and bounded jitter.
+- Added batch and retry settings to the Rails generator and Railtie configuration bridge, and made `Logister.flush` wait for in-flight batch delivery rather than only an empty queue.
+
+## v0.3.1 - 2026-07-26
+
+- Added `Logister.suppress_reporting` and `Logister.reporting_suppressed?` for recursion-safe telemetry processing, including early exits in automatic SQL and request subscribers.
+
 ## v0.3.0 - 2026-07-25
 
 - Raised the supported runtime floor to Ruby 3.3 and refreshed the development runtime to Ruby 4.0.6, which includes current interpreter security fixes.

data/README.md

@@ -1,11 +1,47 @@
 # logister-ruby
 
-`logister-ruby` is the Ruby and Rails client for sending errors, logs, metrics, transactions, spans, and check-ins to Logister.
+`logister-ruby` sends Ruby and Rails errors, logs, metrics, transactions, spans, and scheduled-job check-ins to Logister. Rails apps also get automatic reporting for unhandled requests and failed Active Job executions.
 
 Install it from RubyGems as `logister-ruby`.
 
+Requires Ruby 3.3 or newer and Active Support 8.x.
+
+## Quick start
+
+Before you start, create a project in Logister and generate a project API key under **Project settings → API keys**.
+
+Add the gem and generate a Rails initializer:
+
+```bash
+bundle add logister-ruby
+bin/rails generate logister:install
+```
+
+Store configuration in environment variables:
+
+```bash
+export LOGISTER_API_KEY="<project-api-key>"
+export LOGISTER_ENDPOINT="https://logister.example.com/api/v1/ingest_events"
+export LOGISTER_SERVICE="checkout-web"
+export LOGISTER_RELEASE="$(git rev-parse --short HEAD)"
+```
+
+Start Rails, then send a safe test event from `bin/rails console`:
+
+```ruby
+Logister.report_error(
+  RuntimeError.new("README test error"),
+  context: { component: "checkout" },
+  fingerprint: "readme-test-error"
+)
+Logister.flush
+```
+
+Open the project inbox and confirm that **README test error** appears. A `401` response usually means the API key or endpoint is wrong; see the [Ruby integration guide](https://logister.org/docs/integrations/ruby/) for troubleshooting.
+
 ## Table Of Contents
 
+- [Quick start](#quick-start)
 - [What this gem is for](#what-this-gem-is-for)
 - [Package Links](#package-links)
 - [Self-hosted backend](#self-hosted-backend)
@@ -18,17 +54,19 @@ Install it from RubyGems as `logister-ruby`.
 - [Breadcrumbs and dependencies](#breadcrumbs-and-dependencies)
 - [ActiveJob error context](#activejob-error-context)
 - [Manual reporting](#manual-reporting)
-- [Using project Insights beta](#using-project-insights-beta)
+- [Using project Insights](#using-project-insights)
+- [GitHub source context and deployments](#github-source-context-and-deployments)
 - [Documentation](#documentation)
+- [Development](#development)
 - [Release](#release)
 
 ## What this gem is for
 
-Use this gem when you want a Ruby or Rails app to send telemetry into the Logister backend.
+Use this gem when a Ruby process should send telemetry to a hosted or self-hosted Logister server. It is an ingest client, not the Logister server itself.
 
 - Main Logister app: https://github.com/taimoorq/logister
-- Ruby integration docs: https://docs.logister.org/integrations/ruby/
-- Product docs: https://docs.logister.org/
+- Ruby integration docs: https://logister.org/docs/integrations/ruby/
+- Product docs: https://logister.org/docs/
 - RubyGems package: https://rubygems.org/gems/logister-ruby
 
 ## Package Links
@@ -36,7 +74,7 @@ Use this gem when you want a Ruby or Rails app to send telemetry into the Logist
 - RubyGems package: https://rubygems.org/gems/logister-ruby
 - GitHub releases: https://github.com/taimoorq/logister-ruby/releases
 - Source repository: https://github.com/taimoorq/logister-ruby
-- Integration docs: https://docs.logister.org/integrations/ruby/
+- Integration docs: https://logister.org/docs/integrations/ruby/
 
 ## Self-hosted backend
 
@@ -100,17 +138,34 @@ end
 
 If you are using a self-hosted Logister install, point `config.endpoint` at your own Logister host instead of `logister.org`.
 
+Keep `LOGISTER_API_KEY` in your deployment secret store. Project API keys are write-only ingest credentials, but exposing one still lets another party submit unwanted telemetry to the project.
+
 ## Reliability options
 
 ```ruby
 Logister.configure do |config|
   config.async = true
   config.queue_size = 1000
+  config.batch_size = 50
+  config.batch_interval = 0.05
+  config.batch_compression = true
   config.max_retries = 3
   config.retry_base_interval = 0.5
+  config.max_retry_delay = 30.0
+  config.retry_jitter = 0.2
 end
 ```
 
+Asynchronous delivery assigns a UUID before enqueueing, combines queued events into
+gzip/NDJSON batches, and retries the same identifiers. This makes a whole-batch retry
+safe against a Logister server that supports the batch endpoint. Older servers are
+detected automatically and receive the same stable events through the single-event
+endpoint. Call `Logister.flush` before a short-lived process exits.
+
+Every HTTP attempt applies `timeout_seconds` to connect, read, and write operations.
+Retryable responses honor `Retry-After` when present, cap any individual wait at
+`max_retry_delay`, and add bounded positive jitter controlled by `retry_jitter`.
+
 ## Filtering and redaction
 
 ```ruby
@@ -126,12 +181,21 @@ Logister.configure do |config|
 end
 ```
 
+Use scoped suppression around work that handles or forwards telemetry. Every manual reporter and automatic Rails subscriber returns without publishing while the scope is active, and nested scopes restore the previous state even when the block raises:
+
+```ruby
+Logister.suppress_reporting do
+  TelemetryMirror.call(event)
+end
+```
+
+This is especially important when a Rails application reports into a Logister project hosted by that same application. Keep suppression narrow so failures outside the telemetry-processing boundary remain observable.
+
 ## Rails auto-reporting
 
-If Rails is present, the gem installs middleware that reports unhandled exceptions automatically.
-It also attaches richer context such as trace IDs, route/response/performance info, breadcrumbs, dependency calls, and user metadata when available.
-Set `config.capture_request_spans = true` to emit root `server` spans for request load waterfall charts while keeping existing transaction events.
-Manual `Logister.report_error` calls use the same shared enrichment path, so Ruby apps get runtime, deployment, breadcrumb, dependency, user, and nested exception cause context even when an error is reported outside the Rails middleware.
+If Rails is present, the gem installs middleware that reports unhandled exceptions automatically. It attaches trace IDs, route and response data, performance context, breadcrumbs, dependency calls, and user metadata when available.
+
+Set `config.capture_request_spans = true` to emit root `server` spans for request-load waterfall charts while keeping the existing transaction events. Manual `Logister.report_error` calls use the same enrichment path, including runtime, deployment, breadcrumb, dependency, user, and nested-exception context.
 
 ## Database load metrics (ActiveRecord)
 
@@ -225,7 +289,7 @@ Logister.report_check_in(
 )
 ```
 
-## Using project Insights beta
+## Using project Insights
 
 The Logister project Insights tab combines Inbox, Activity, and Performance signals into live dashboard views. Ruby apps get the most useful Insights experience when every event carries stable deployment context plus a few low-cardinality custom attributes.
 
@@ -322,28 +386,33 @@ Logister.record_deployment(
 
 ## Documentation
 
-- Ruby integration docs: https://docs.logister.org/integrations/ruby/
-- Insights beta guide: https://docs.logister.org/product/#insights-beta
-- Main Logister docs: https://docs.logister.org/
+- Ruby integration docs: https://logister.org/docs/integrations/ruby/
+- Insights guide: https://logister.org/docs/product/#insights
+- Main Logister docs: https://logister.org/docs/
 - [Contributing](CONTRIBUTING.md)
 - [Code of Conduct](CODE_OF_CONDUCT.md)
 - [Security Policy](SECURITY.md)
 - [Pull Request Template](.github/PULL_REQUEST_TEMPLATE.md)
 
+## Development
+
+```bash
+bundle install
+bundle-audit check --update
+bundle exec rake test
+bundle exec rake build
+```
+
 ## Release
 
-This repo runs CI on commits and pull requests. After CI passes on `main`, the release-from-main workflow creates the matching version tag. Version tags run the release workflow so RubyGems and GitHub Releases stay aligned:
+`lib/logister/version.rb` is the package version source of truth. Update it and `CHANGELOG.md` together. After CI passes on `main`, the release-from-main workflow creates a matching `vX.Y.Z` tag and dispatches the release workflow.
 
 ```bash
-# 1) bump version in lib/logister/version.rb
-# 2) update CHANGELOG.md
-# 3) commit changes
-# 4) merge to main, or push a matching tag manually:
-git tag -a v0.2.8 -m "Release logister-ruby v0.2.8"
-git push origin main v0.2.8
+git tag -a vX.Y.Z -m "Release logister-ruby vX.Y.Z"
+git push origin vX.Y.Z
 ```
 
-The `.github/workflows/release.yml` workflow verifies the tag matches `Logister::VERSION`, runs tests, builds the gem, publishes to RubyGems with trusted publishing, and then creates or updates the matching GitHub release from `CHANGELOG.md`.
+The release workflow verifies tag/version parity, audits and tests the package, builds the gem, publishes to RubyGems with trusted publishing, and only then creates the GitHub Release. RubyGems versions are immutable; corrections need a new patch version.
 
 Before tag releases can publish the gem, configure a RubyGems trusted publisher for:
 
@@ -352,8 +421,9 @@ Before tag releases can publish the gem, configure a RubyGems trusted publisher
 - Workflow file: `.github/workflows/release.yml`
 - Environment: leave blank unless you also add a GitHub release environment to the workflow
 
-Manual publishing is still possible with Bundler's built-in release flow when needed:
+Verify both release surfaces before calling a release complete:
 
 ```bash
-bundle exec rake release
+curl -fsSL https://rubygems.org/api/v2/rubygems/logister-ruby/versions/X.Y.Z.json | jq '{number,ruby_version,sha}'
+gh release view vX.Y.Z
 ```

data/lib/generators/logister/templates/logister.rb

@@ -10,8 +10,13 @@ Logister.configure do |config|
 
   config.async = true
   config.queue_size = 1000
+  config.batch_size = 50
+  config.batch_interval = 0.05
+  config.batch_compression = true
   config.max_retries = 3
   config.retry_base_interval = 0.5
+  config.max_retry_delay = 30.0
+  config.retry_jitter = 0.2
 
   config.ignore_environments = []
   config.ignore_exceptions = []

data/lib/logister/client.rb

@@ -2,11 +2,29 @@
 
 require 'json'
 require 'net/http'
+require 'digest'
+require 'securerandom'
+require 'time'
 require 'uri'
+require 'zlib'
 
 module Logister
   class Client
     CONTENT_TYPE = 'application/json'
+    BATCH_CONTENT_TYPE = 'application/x-ndjson'
+    UNSUPPORTED_BATCH_STATUSES = %w[404 405 415 501].freeze
+
+    class UnsupportedBatchEndpoint < StandardError; end
+
+    class RequestError < StandardError
+      attr_reader :status, :retry_after
+
+      def initialize(status, retry_after: nil)
+        @status = status.to_i
+        @retry_after = retry_after
+        super("HTTP #{status}")
+      end
+    end
 
     def initialize(configuration)
       @configuration = configuration
@@ -14,12 +32,17 @@ module Logister
       @queue         = SizedQueue.new(@configuration.queue_size)
       @worker        = nil
       @running       = false
+      @pending_mutex = Mutex.new
+      @pending_condition = ConditionVariable.new
+      @pending_count = 0
 
       # Cache values that are static for the lifetime of this client so we
       # don't allocate on every send_request call.
       @uri            = URI.parse(@configuration.endpoint).freeze
+      @batch_uri      = URI.parse(@configuration.batch_endpoint).freeze
       @deployment_uri = URI.parse(@configuration.deployment_endpoint).freeze
       @use_ssl        = @uri.scheme == 'https'
+      @batch_use_ssl  = @batch_uri.scheme == 'https'
       @deployment_use_ssl = @deployment_uri.scheme == 'https'
       @auth_header    = "Bearer #{@configuration.api_key}".freeze
     end
@@ -27,6 +50,8 @@ module Logister
     def publish(payload)
       return false unless ready?
 
+      payload = with_stable_uuid(payload)
+
       return publish_sync(payload) unless @configuration.async
 
       ensure_worker_started
@@ -43,10 +68,13 @@ module Logister
       return true unless @configuration.async
 
       deadline = monotonic_now + timeout
-      until @queue.empty?
-        return false if monotonic_now > deadline
+      @pending_mutex.synchronize do
+        while @pending_count.positive?
+          remaining = deadline - monotonic_now
+          return false unless remaining.positive?
 
-        sleep(0.01)
+          @pending_condition.wait(@pending_mutex, [remaining, 0.05].min)
+        end
       end
 
       true
@@ -69,9 +97,11 @@ module Logister
     private
 
     def enqueue(payload)
+      increment_pending
       @queue.push(payload, true)
       true
     rescue ThreadError
+      complete_pending(1)
       @configuration.logger.warn('logister queue full; dropping event')
       false
     end
@@ -90,11 +120,31 @@ module Logister
     end
 
     def run_worker
+      stop_after_batch = false
       loop do
         payload = @queue.pop
         break if payload.nil?
 
-        publish_sync(payload)
+        batch = [payload]
+        deadline = monotonic_now + batch_interval
+
+        while batch.length < batch_size && monotonic_now < deadline
+          begin
+            queued = @queue.pop(true)
+            if queued.nil?
+              stop_after_batch = true
+              break
+            end
+            batch << queued
+          rescue ThreadError
+            remaining = deadline - monotonic_now
+            sleep([remaining, 0.005].min) if remaining.positive?
+          end
+        end
+
+        publish_batch_sync(batch)
+        complete_pending(batch.length)
+        break if stop_after_batch
       end
     rescue StandardError => e
       @configuration.logger.warn("logister worker crashed: #{e.class} #{e.message}")
@@ -110,8 +160,8 @@ module Logister
         attempts += 1
         send_request(payload)
       rescue StandardError => e
-        if attempts <= @configuration.max_retries
-          sleep(@configuration.retry_base_interval * (2**(attempts - 1)))
+        if attempts <= @configuration.max_retries && retryable_error?(e)
+          sleep(retry_delay(e, attempts))
           retry
         end
 
@@ -120,14 +170,46 @@ module Logister
       end
     end
 
+    def publish_batch_sync(payloads)
+      attempts = 0
+      begin
+        attempts += 1
+        send_batch_request(payloads)
+      rescue UnsupportedBatchEndpoint
+        payloads.map { |payload| publish_sync(payload) }.all?
+      rescue RequestError => e
+        if e.status == 413 && payloads.length > 1
+          middle = (payloads.length / 2.0).ceil
+          first_half_delivered = publish_batch_sync(payloads.first(middle))
+          second_half_delivered = publish_batch_sync(payloads.drop(middle))
+          return first_half_delivered && second_half_delivered
+        end
+        if attempts <= @configuration.max_retries && retryable_error?(e)
+          sleep(retry_delay(e, attempts))
+          retry
+        end
+
+        @configuration.logger.warn("logister batch publish failed: #{e.class} #{e.message}")
+        false
+      rescue StandardError => e
+        if attempts <= @configuration.max_retries && retryable_error?(e)
+          sleep(retry_delay(e, attempts))
+          retry
+        end
+
+        @configuration.logger.warn("logister batch publish failed: #{e.class} #{e.message}")
+        false
+      end
+    end
+
     def publish_deployment_sync(payload)
       attempts = 0
       begin
         attempts += 1
         send_deployment_request(payload)
       rescue StandardError => e
-        if attempts <= @configuration.max_retries
-          sleep(@configuration.retry_base_interval * (2**(attempts - 1)))
+        if attempts <= @configuration.max_retries && retryable_error?(e)
+          sleep(retry_delay(e, attempts))
           retry
         end
 
@@ -147,12 +229,41 @@ module Logister
         @uri.port,
         use_ssl:      @use_ssl,
         open_timeout: @configuration.timeout_seconds,
-        read_timeout: @configuration.timeout_seconds
+        read_timeout: @configuration.timeout_seconds,
+        write_timeout: @configuration.timeout_seconds
+      ) { |http| http.request(request) }
+
+      return true if response.is_a?(Net::HTTPSuccess)
+
+      raise request_error(response)
+    end
+
+    def send_batch_request(payloads)
+      request = Net::HTTP::Post.new(@batch_uri)
+      request['Content-Type'] = BATCH_CONTENT_TYPE
+      request['Authorization'] = @auth_header
+      request['X-Logister-Batch-Id'] = batch_id(payloads)
+
+      body = payloads.map { |payload| { event: payload }.to_json }.join("\n") << "\n"
+      if @configuration.batch_compression
+        request['Content-Encoding'] = 'gzip'
+        body = Zlib.gzip(body)
+      end
+      request.body = body
+
+      response = Net::HTTP.start(
+        @batch_uri.host,
+        @batch_uri.port,
+        use_ssl: @batch_use_ssl,
+        open_timeout: @configuration.timeout_seconds,
+        read_timeout: @configuration.timeout_seconds,
+        write_timeout: @configuration.timeout_seconds
       ) { |http| http.request(request) }
 
       return true if response.is_a?(Net::HTTPSuccess)
+      raise UnsupportedBatchEndpoint, "HTTP #{response.code}" if UNSUPPORTED_BATCH_STATUSES.include?(response.code)
 
-      raise "HTTP #{response.code}"
+      raise request_error(response)
     end
 
     def send_deployment_request(payload)
@@ -166,18 +277,99 @@ module Logister
         @deployment_uri.port,
         use_ssl:      @deployment_use_ssl,
         open_timeout: @configuration.timeout_seconds,
-        read_timeout: @configuration.timeout_seconds
+        read_timeout: @configuration.timeout_seconds,
+        write_timeout: @configuration.timeout_seconds
       ) { |http| http.request(request) }
 
       return true if response.is_a?(Net::HTTPSuccess)
 
-      raise "HTTP #{response.code}"
+      raise request_error(response)
     end
 
     def monotonic_now
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
+    def with_stable_uuid(payload)
+      attributes = payload.to_h.dup
+      key = attributes.keys.any? { |candidate| candidate.is_a?(String) } ? 'uuid' : :uuid
+      uuid = [attributes[:uuid], attributes['uuid']].find { |value| !blank_identifier?(value) }
+      event_id = [attributes[:event_id], attributes['event_id']].find { |value| !blank_identifier?(value) }
+
+      attributes.delete(:uuid)
+      attributes.delete('uuid')
+      attributes.delete(:event_id) if blank_identifier?(attributes[:event_id])
+      attributes.delete('event_id') if blank_identifier?(attributes['event_id'])
+      attributes[key] = uuid || event_id || SecureRandom.uuid
+      attributes
+    end
+
+    def blank_identifier?(value)
+      value.nil? || value.to_s.strip.empty?
+    end
+
+    def batch_id(payloads)
+      identifiers = payloads.map do |payload|
+        payload[:uuid] || payload['uuid'] || payload[:event_id] || payload['event_id']
+      end
+      Digest::SHA256.hexdigest(identifiers.join("\n"))
+    end
+
+    def batch_size
+      [@configuration.batch_size.to_i, 1].max
+    end
+
+    def batch_interval
+      [@configuration.batch_interval.to_f, 0.0].max
+    end
+
+    def increment_pending
+      @pending_mutex.synchronize { @pending_count += 1 }
+    end
+
+    def complete_pending(count)
+      @pending_mutex.synchronize do
+        @pending_count = [@pending_count - count, 0].max
+        @pending_condition.broadcast if @pending_count.zero?
+      end
+    end
+
+    def retryable_error?(error)
+      return true unless error.is_a?(RequestError)
+
+      [408, 425, 429].include?(error.status) || error.status >= 500
+    end
+
+    def request_error(response)
+      RequestError.new(response.code, retry_after: retry_after_seconds(response['Retry-After']))
+    end
+
+    def retry_after_seconds(value)
+      header = value.to_s.strip
+      return nil if header.empty?
+
+      seconds = Float(header, exception: false)
+      return [seconds, 0.0].max if seconds&.finite?
+
+      [Time.httpdate(header) - Time.now, 0.0].max
+    rescue ArgumentError
+      nil
+    end
+
+    def retry_delay(error, attempt)
+      configured_cap = [@configuration.max_retry_delay.to_f, 0.0].max
+      base_delay = if error.is_a?(RequestError) && !error.retry_after.nil?
+                     error.retry_after.to_f
+                   else
+                     @configuration.retry_base_interval.to_f * (2**(attempt - 1))
+                   end
+      bounded_delay = [[base_delay, 0.0].max, configured_cap].min
+      jitter_ratio = @configuration.retry_jitter.to_f.clamp(0.0, 1.0)
+      jitter = bounded_delay * jitter_ratio * rand
+
+      [bounded_delay + jitter, configured_cap].min
+    end
+
     def ready?
       @configuration.enabled && !@configuration.api_key.to_s.empty?
     end

data/lib/logister/configuration.rb

@@ -6,11 +6,12 @@ module Logister
                   :repository, :commit_sha, :branch, :enabled, :timeout_seconds, :logger,
                   :ignore_exceptions, :ignore_environments, :ignore_paths, :before_notify,
                   :async, :queue_size, :max_retries, :retry_base_interval,
+                  :max_retry_delay, :retry_jitter, :batch_size, :batch_interval, :batch_compression,
                   :capture_db_metrics, :db_metric_min_duration_ms, :db_metric_sample_rate,
                   :feature_flags_resolver, :dependency_resolver, :anonymize_ip,
                   :max_breadcrumbs, :max_dependencies, :capture_request_spans,
                   :capture_sql_breadcrumbs, :sql_breadcrumb_min_duration_ms
-    attr_writer :deployment_endpoint
+    attr_writer :deployment_endpoint, :batch_endpoint
 
     def initialize
       @api_key = ENV['LOGISTER_API_KEY']
@@ -36,6 +37,11 @@ module Logister
       @queue_size = 1000
       @max_retries = 3
       @retry_base_interval = 0.5
+      @max_retry_delay = 30.0
+      @retry_jitter = 0.2
+      @batch_size = 50
+      @batch_interval = 0.05
+      @batch_compression = true
 
       @capture_db_metrics = false
       @db_metric_min_duration_ms = 0.0
@@ -55,6 +61,10 @@ module Logister
       @deployment_endpoint || endpoint.to_s.sub(%r{/ingest_events\z}, '/deployments')
     end
 
+    def batch_endpoint
+      @batch_endpoint || endpoint.to_s.sub(%r{/ingest_events\z}, '/ingest_events/batch')
+    end
+
     private
 
     def env_value(name)

data/lib/logister/railtie.rb

@@ -20,8 +20,13 @@ module Logister
         copy_setting(app, config, :before_notify)
         copy_setting(app, config, :async)
         copy_setting(app, config, :queue_size)
+        copy_setting(app, config, :batch_size)
+        copy_setting(app, config, :batch_interval)
+        copy_setting(app, config, :batch_compression)
         copy_setting(app, config, :max_retries)
         copy_setting(app, config, :retry_base_interval)
+        copy_setting(app, config, :max_retry_delay)
+        copy_setting(app, config, :retry_jitter)
         copy_setting(app, config, :capture_db_metrics)
         copy_setting(app, config, :db_metric_min_duration_ms)
         copy_setting(app, config, :db_metric_sample_rate)

data/lib/logister/reporter.rb

@@ -44,6 +44,7 @@ module Logister
     end
 
     def report_error(exception, context: {}, tags: {}, level: 'error', fingerprint: nil)
+      return false if Logister.reporting_suppressed?
       return false if ignored_exception?(exception)
       return false if ignored_path?(context)
 
@@ -69,6 +70,7 @@ module Logister
     end
 
     def report_metric(message:, value: nil, unit: nil, level: 'info', context: {}, tags: {}, fingerprint: nil)
+      return false if Logister.reporting_suppressed?
       return false if ignored_environment?
       return false if ignored_path?(context)
 
@@ -100,6 +102,7 @@ module Logister
     end
 
     def report_transaction(name:, duration_ms:, level: 'info', context: {}, tags: {}, fingerprint: nil, status: nil)
+      return false if Logister.reporting_suppressed?
       return false if ignored_environment?
       return false if ignored_path?(context)
 
@@ -137,6 +140,7 @@ module Logister
       tags: {},
       fingerprint: nil
     )
+      return false if Logister.reporting_suppressed?
       return false if ignored_environment?
       return false if ignored_path?(context)
 
@@ -182,6 +186,7 @@ module Logister
     end
 
     def report_log(message:, level: 'info', context: {}, tags: {}, fingerprint: nil)
+      return false if Logister.reporting_suppressed?
       return false if ignored_environment?
       return false if ignored_path?(context)
 
@@ -212,6 +217,7 @@ module Logister
       trace_id: nil,
       request_id: nil
     )
+      return false if Logister.reporting_suppressed?
       return false if ignored_environment?
 
       payload = build_payload(
@@ -253,6 +259,8 @@ module Logister
       workflow_run_url: nil,
       deployment_url: nil
     )
+      return false if Logister.reporting_suppressed?
+
       payload = {
         release: release || @configuration.release,
         environment: environment || @configuration.environment,

data/lib/logister/reporting_scope.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Logister
+  module ReportingScope
+    STATE_KEY = :__logister_reporting_suppressed
+
+    module_function
+
+    def suppress
+      previous = state
+      self.state = true
+      yield
+    ensure
+      self.state = previous
+    end
+
+    def suppressed?
+      state == true
+    end
+
+    def state
+      if defined?(ActiveSupport::IsolatedExecutionState)
+        ActiveSupport::IsolatedExecutionState[STATE_KEY]
+      else
+        Thread.current[STATE_KEY]
+      end
+    end
+    private_class_method :state
+
+    def state=(value)
+      if defined?(ActiveSupport::IsolatedExecutionState)
+        ActiveSupport::IsolatedExecutionState[STATE_KEY] = value
+      else
+        Thread.current[STATE_KEY] = value
+      end
+    end
+    private_class_method :state=
+  end
+end

data/lib/logister/request_subscriber.rb

@@ -22,6 +22,7 @@ module Logister
       private
 
       def handle_process_action(payload)
+        return if Logister.reporting_suppressed?
         return unless payload.is_a?(Hash)
 
         request_id = payload[:request_id].to_s.presence
@@ -89,6 +90,8 @@ module Logister
       end
 
       def handle_sql_breadcrumb(started, finished, payload)
+        return if Logister.reporting_suppressed?
+
         config = configuration
         return unless config&.capture_sql_breadcrumbs
         return unless payload.is_a?(Hash)

data/lib/logister/sql_subscriber.rb

@@ -29,6 +29,8 @@ module Logister
       private
 
       def handle_sql_event(started, finished, payload)
+        return if Logister.reporting_suppressed?
+
         config = Logister.configuration
 
         # Short-circuit as cheaply as possible when metrics are disabled so

data/lib/logister/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Logister
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/lib/logister.rb

@@ -1,5 +1,6 @@
 require_relative 'logister/version'
 require_relative 'logister/configuration'
+require_relative 'logister/reporting_scope'
 require_relative 'logister/client'
 require_relative 'logister/reporter'
 require_relative 'logister/context_helpers'
@@ -23,6 +24,14 @@ module Logister
       @reporter ||= Reporter.new(configuration)
     end
 
+    def suppress_reporting(&block)
+      ReportingScope.suppress(&block)
+    end
+
+    def reporting_suppressed?
+      ReportingScope.suppressed?
+    end
+
     def report_error(exception, **kwargs)
       reporter.report_error(exception, **kwargs)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logister-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Logister
@@ -86,6 +86,7 @@ files:
 - lib/logister/middleware.rb
 - lib/logister/railtie.rb
 - lib/logister/reporter.rb
+- lib/logister/reporting_scope.rb
 - lib/logister/request_subscriber.rb
 - lib/logister/sql_subscriber.rb
 - lib/logister/version.rb