end_point_blank 0.6.1 → 0.13.0

data/lib/end_point_blank/writers/delayed_writer.rb

@@ -16,14 +16,46 @@ module EndPointBlank
     module DelayedWriter
       MAX_QUEUE_SIZE = 1000
       WARN_THROTTLE_SECONDS = 30
+      # Payloads per outbound request. One request per payload would multiply
+      # the host application's outbound traffic by its own request rate; the
+      # drain exists to amortise that.
+      BATCH_SIZE = 6
       # Fallback thread count used when Configuration#worker_count is unset,
       # preserving the previously-hardcoded pool size.
       DEFAULT_WORKER_COUNT = 2
+      # Applied after a worker iteration raises, doubling with each consecutive
+      # failure up to the cap. Surviving a defect must not mean retrying as fast
+      # as the CPU allows: a persistent failure should read as a slow, loud
+      # retry, not as a silent hot loop.
+      WORKER_BACKOFF_SECONDS = 0.1
+      MAX_WORKER_BACKOFF_SECONDS = 30
+
+      # sc-376: eager, so `queue`/`enqueue_mutex` are never nil for any
+      # worker thread. Every real includer (RequestWriter, ResponseWriter,
+      # ExceptionWriter, LogWriter) calls `super()` here before
+      # `start_threads`, so this always runs first, single-threaded, before
+      # any worker exists. An includer whose `initialize` skips `super`
+      # (some of this module's own specs, deliberately) never reaches this;
+      # `queue`/`enqueue_mutex` fall back to lazy `||=` for those.
+      def initialize
+        @queue = Queue.new
+        @enqueue_mutex = Mutex.new
+      end
 
       def direct_writer
         @direct_writer ||= DirectWriter.new(url)
       end
 
+      # `@queue ||= Queue.new` is a read, a nil check, then a write -- not
+      # atomic. Two threads racing this before either assigns could each
+      # allocate their own Queue, and the loser's is an orphan nothing will
+      # ever read from again. In production only this class's own worker
+      # threads could ever race here (every writer is a Singleton whose
+      # `initialize`, and so `super()` above, completes before any caller
+      # can reach `enqueue`), and `initialize` above now sets `@queue`
+      # before `start_threads` spawns a single one of them. The `||=` stays
+      # only as a fallback for an includer that skips this module's
+      # `initialize` entirely -- see the comment there.
       def queue
         @queue ||= Queue.new
       end
@@ -36,27 +68,7 @@ module EndPointBlank
         @threads = []
 
         worker_count.times do
-          @threads << Thread.new do
-            loop do
-              payload = queue.pop
-              payloads = [payload]
-              while (payload = pop_additional)
-                payloads << payload
-              end
-
-              payloads.compact!
-              while payloads.any?
-                list = payloads[0..5]
-                response = direct_writer.write(list)
-                if response.status < 299
-                  on_success(response) if respond_to?(:on_success)
-                elsif respond_to?(:on_failure)
-                  on_failure(response)
-                end
-                payloads -= list
-              end
-            end
-          end
+          @threads << Thread.new { run_worker }
         end
       end
 
@@ -78,8 +90,106 @@ module EndPointBlank
         EndPointBlank.logger.warn(message)
       end
 
+      # Logs a delivery or worker-loop error, through the same seam. Everything
+      # a worker recovers from goes through here: recovering quietly would trade
+      # one silent failure for another.
+      def log_error(message)
+        EndPointBlank.logger.error(message)
+      end
+
       private
 
+      # The body of a worker thread.
+      #
+      # A thread that dies here takes every future payload in the process with
+      # it - silently, until a restart - which is far worse than losing the
+      # batch in flight. So the loop catches every StandardError, says what it
+      # caught, and carries on.
+      #
+      # What it deliberately does not catch is anything outside StandardError:
+      # SystemExit, Interrupt, SignalException, NoMemoryError. Those mean the
+      # process itself is going down or is already broken, and a telemetry
+      # worker has no business arguing with that.
+      def run_worker
+        consecutive_failures = 0
+
+        loop do
+          drain_once
+          consecutive_failures = 0
+        rescue StandardError => e
+          consecutive_failures += 1
+          note_worker_error(e, consecutive_failures)
+          sleep(worker_backoff(consecutive_failures))
+        end
+      end
+
+      # Blocks for the next payload, then takes everything else already waiting
+      # so a burst leaves as a few batches rather than one request per payload.
+      #
+      # The batches are cut by position, and that is the point. This used to
+      # take a prefix and then remove it with `payloads -= list`, and Array#-
+      # removes every element *equal to* one in the batch rather than the ones
+      # actually sent: seven byte-identical payloads with a batch size of six
+      # meant six delivered and all seven gone. Nothing counted the loss and the
+      # queue drained normally, so it read as if nothing had happened.
+      #
+      # Equal payloads are ordinary, not exotic. Payloads are hashes, and two
+      # requests to the same endpoint from the same application in the same
+      # environment differ only in high-cardinality fields; `sent_at` at
+      # millisecond precision is not a reliable discriminator at ingest volumes.
+      # Slicing by index makes equality irrelevant rather than merely handled.
+      def drain_once
+        payloads = [queue.pop]
+        while (payload = pop_additional)
+          payloads << payload
+        end
+
+        payloads.compact!
+        payloads.each_slice(BATCH_SIZE) { |list| deliver_batch(list) }
+      end
+
+      def deliver_batch(list)
+        response = direct_writer.write(list)
+        return note_unanswered(list) if response.nil?
+
+        if response.status < 299
+          on_success(response) if respond_to?(:on_success)
+        elsif respond_to?(:on_failure)
+          on_failure(response)
+        end
+      end
+
+      # nil is what Commands::Http returns once its retries are exhausted. It is
+      # not a status - it is the absence of an answer - so it is reported rather
+      # than compared: on_failure hears about it with nil, meaning "nothing
+      # answered", and the batch it cost us is named in the log either way.
+      def note_unanswered(list)
+        log_error(
+          "[EndPointBlank] no response from #{url} after retries; " \
+          "#{list.size} payload(s) in that batch are lost"
+        )
+        on_failure(nil) if respond_to?(:on_failure)
+      end
+
+      def note_worker_error(error, consecutive_failures)
+        log_error(
+          "[EndPointBlank] send worker recovered from #{error.class}: #{error.message} " \
+          "(consecutive failure #{consecutive_failures}); the batch in flight is lost, " \
+          "retrying in #{worker_backoff(consecutive_failures).round(1)}s at #{Array(error.backtrace).first}"
+        )
+      end
+
+      def worker_backoff(consecutive_failures)
+        [
+          WORKER_BACKOFF_SECONDS * (2**(consecutive_failures - 1)),
+          MAX_WORKER_BACKOFF_SECONDS
+        ].min
+      end
+
+      # Same shape and same fallback rationale as `queue` above, and worse in
+      # kind if it ever raced: two threads synchronizing on *different* Mutex
+      # objects are not synchronized at all, so the critical section in
+      # `enqueue_one` would silently stop being one.
       def enqueue_mutex
         @enqueue_mutex ||= Mutex.new
       end

data/lib/end_point_blank/writers/direct_writer.rb

@@ -10,7 +10,7 @@ module EndPointBlank
       end
 
       def write(list)
-        auth = EndPointBlank::Authorization.header
+        auth = EndPointBlank::Authorization.intake_header
         EndPointBlank::Commands::Http.post(@url, auth, { payload: list })
       end
     end

data/lib/end_point_blank/writers/exception_writer.rb

@@ -12,6 +12,7 @@ module EndPointBlank
       attr_reader :url
 
       def initialize
+        super()
         @url = EndPointBlank::Configuration.instance.errors_url
         start_threads
       end
@@ -20,10 +21,18 @@ module EndPointBlank
         instance.write(exception)
       end
 
+      # Builds an error payload with or without an in-flight request. `env` is
+      # nil whenever an exception is reported from outside `EnvStore`'s scope
+      # (a background job, a worker, a boot-time failure) -- that is precisely
+      # the case this method exists to handle, not an edge case to special-case
+      # away. `Rack::Request.new(env)` was built unconditionally here even
+      # though nothing about an error report requires a request: version
+      # detection (Commands::VersionFinder) reads request params/path and is
+      # meaningless without one, so it is skipped rather than attempted and
+      # rescued. Its result was never even merged into the returned hash, so
+      # skipping it changes nothing for the in-request case either.
       def payload(exception)
         env = ::EndPointBlank::Rack::EnvStore.get
-        request = ::Rack::Request.new(env)
-        version = Commands::VersionFinder.new.find(request)
         {
           app_name: app_name,
           uuid: request_uuid(env),

data/lib/end_point_blank/writers/log_writer.rb

@@ -12,6 +12,7 @@ module EndPointBlank
       attr_reader :url
 
       def initialize
+        super()
         @url = EndPointBlank::Configuration.instance.logs_url
         start_threads
       end
@@ -61,7 +62,6 @@ module EndPointBlank
             stamped_http_method: rack_req.request_method
           )
         end
-        puts "Writing log: #{json}"
         enqueue(json)
       end
     end

data/lib/end_point_blank/writers/request_writer.rb

@@ -12,6 +12,7 @@ module EndPointBlank
       attr_reader :url
 
       def initialize
+        super()
         @url = EndPointBlank::Configuration.instance.requests_url
         start_threads
       end

data/lib/end_point_blank/writers/response_writer.rb

@@ -12,6 +12,7 @@ module EndPointBlank
       attr_reader :url
 
       def initialize
+        super()
         @url = EndPointBlank::Configuration.instance.responses_url
         start_threads
       end

data/lib/end_point_blank/writers/shared.rb

@@ -1,8 +1,17 @@
+require "securerandom"
+
 module EndPointBlank
   module Writers
     module Shared
       attr_accessor :url
 
+      # Where a minted request_uuid is cached on the Rack env, when the env
+      # carries no request id of its own. Distinct from
+      # "action_dispatch.request_id" so a later Rails middleware that sets
+      # the real key is never shadowed by ours -- we only ever read that key
+      # first and fall back to this one.
+      GENERATED_UUID_KEY = "end_point_blank.generated_request_uuid".freeze
+
       def configuration
         Configuration.instance
       end
@@ -24,11 +33,33 @@ module EndPointBlank
       end
 
       # Rails' ActionDispatch::Request#uuid simply reads this same Rack env
-      # key, so this is behavior-preserving when running under Rails, and
-      # gracefully returns nil when it isn't (plain Rack / Sinatra), instead
-      # of requiring actionpack's ActionDispatch::Request to be loaded.
+      # key, so reading it directly is behavior-preserving when running under
+      # Rails, without requiring actionpack's ActionDispatch::Request to be
+      # loaded.
+      #
+      # Outside Rails (plain Rack / Sinatra) nothing sets that key. Falling
+      # through to nil there used to be described as "graceful", but it is
+      # not: intake requires `uuid` on every error/log/request/response row
+      # and refuses the ones that lack it, so a nil uuid is a silently
+      # dropped row, not a tolerated one. Minting a fresh uuid instead means
+      # the row still lands -- correlating with nothing is strictly better
+      # than not existing.
+      #
+      # The mint is cached back onto `env`, not just returned. RequestWriter
+      # and ResponseWriter both call this with the *same* env object for one
+      # HTTP request -- EnvStore hands back whatever `set/1` was given at the
+      # top of the middleware, unchanged, for the life of the request. Without
+      # caching, each writer's call under plain Rack would mint its own fresh
+      # uuid, and the request row and the response row for a single
+      # interaction would carry two different, unrelated ids -- silently
+      # defeating the one thing these columns exist for. When `env` is nil
+      # (an exception reported with no request in flight at all) there is no
+      # shared object to cache onto and nothing to correlate across, so a
+      # standalone mint every time is correct.
       def request_uuid(env)
-        env && env["action_dispatch.request_id"]
+        return SecureRandom.uuid unless env
+
+        env["action_dispatch.request_id"] || (env[GENERATED_UUID_KEY] ||= SecureRandom.uuid)
       end
 
       def apply_masking(payload, record_type)

data/lib/end_point_blank.rb

@@ -34,6 +34,9 @@ require_relative "end_point_blank/middleware/rack/report_interaction"
 require_relative "end_point_blank/rack/env_store"
 require_relative "end_point_blank/rack/headers"
 require_relative "end_point_blank/unauthorized_error"
+require_relative "end_point_blank/token_unavailable_error"
+require_relative "end_point_blank/configuration_error"
+require_relative "end_point_blank/management"
 if defined?(::Rails)
   require_relative "end_point_blank/rails/authenticated"
   require_relative "end_point_blank/rails/authorized"
@@ -44,10 +47,245 @@ end
 module EndPointBlank
   class Error < StandardError; end
 
-  # Your code goes here...
+  # Serializes {EndPointBlank.configure} calls end to end -- both the block
+  # and the commit -- so two calls can never overlap. Without this, two
+  # calls that both succeed could overlap: the second one can start while
+  # the first is still running, so both build their candidate from the same
+  # starting snapshot. Whichever one finishes last still decides what to
+  # write by diffing its own candidate against that same snapshot, not
+  # against whatever {Configuration} holds live by the time it actually
+  # commits (see {apply_configure_changes}) -- so its own change still looks
+  # like a change relative to its now-stale snapshot, and it writes that
+  # value over whatever the other call already committed, with no error.
+  # See {EndPointBlank.configure}.
+  @configure_mutex = Mutex.new
+
+  # Applies a block of configuration changes to the shared {Configuration}
+  # instance atomically: either every assignment the block makes through
+  # its block argument succeeds, or none of them are kept.
+  #
+  # The block receives a detached copy of the configuration, not the live
+  # singleton. Only the fields whose value on that copy differs from an
+  # independent deep copy taken before the block ran are written onto the
+  # live singleton afterward, and only once the block returns normally.
+  # That makes the atomicity structural rather than a rollback: if the
+  # block raises -- any exception, not only StandardError -- nothing is
+  # written at all. This also covers a field the block sets for the very
+  # first time (e.g. client_id on a fresh boot, before
+  # {Configuration#initialize} has ever assigned it): the assignment lands
+  # on the copy and is discarded with it.
+  #
+  # The yielded object (c, by convention) is valid only for the duration of
+  # the block. Once configure returns -- whether the block returned
+  # normally or raised -- it is frozen, and every String, Array or Hash
+  # value it holds is first replaced with its own frozen deep copy (see
+  # {freeze_candidate}). A write made through a reference to it retained
+  # past the block always raises FrozenError: a reassignment
+  # (`saved.app_name = "x"`) because the candidate itself is frozen, and an
+  # in-place edit (`saved.masking_rules << rule`, `saved.app_name << "x"`,
+  # editing a rule Hash in place) because the value it points to is frozen
+  # too, not just the candidate. Every field that gets committed is also
+  # written as a fresh copy, not the candidate's own object (see
+  # {apply_configure_changes}), so the live {Configuration} never ends up
+  # aliasing anything the candidate still holds.
+  #
+  # Inside the block, a read that bypasses the block argument -- e.g.
+  # Configuration.instance.app_name, or EndPointBlank.logger right after
+  # `c.logger = new_logger` earlier in the same block -- still returns the
+  # value from before this configure call started, not what the block has
+  # set on c so far: nothing is written to the live singleton until the
+  # block returns normally and the commit runs.
+  #
+  # Committing only the fields the block actually changed, rather than
+  # every field, matters because the live singleton can change out from
+  # under a configure call that never touches a given field -- a direct
+  # `Configuration.instance.some_field = ...` outside configure, or
+  # `EndPointBlank.logger=`, is not covered by {@configure_mutex}. Writing
+  # every field back unconditionally would silently revert that kind of
+  # concurrent change as soon as this call's block returned, even though
+  # this call never touched the field itself.
+  #
+  # String, Array and Hash values -- including {Configuration#masking_rules}
+  # and the Hashes in it -- are deep-copied, so an in-place edit
+  # (`c.masking_rules.first[:regex] << "|.*"`, `c.app_name << "-staging"`,
+  # `c.masking_rules << rule`) changes only the block's copy, never the
+  # live value, unless and until that field is committed. Assigning one of
+  # these fields through c copies the assigned value too, rather than
+  # storing the object itself: after `c.masking_rules = rules`, mutating
+  # the `rules` array the caller passed in no longer reaches the live
+  # config, whether that mutation happens while the block is still running
+  # or afterward. Objects the caller owns and hands in by reference --
+  # {Configuration#logger}, {Configuration#mask_hook},
+  # {Configuration#version_finder} -- are not String/Array/Hash, so they
+  # are copied by reference like any other field, both while the block
+  # runs and afterward through a retained c; EndPointBlank.configure
+  # cannot and does not roll back mutation the caller performs on those
+  # objects themselves, whether through c or directly.
+  #
+  # This is generic over every field {Configuration} has now or gains
+  # later (including a future sc-1265 cache_ttl upper bound): it copies
+  # every instance variable, so no new setter needs to be added here for
+  # its validation to be atomic.
+  #
+  # Calls are serialized with a module-level Mutex held across both the
+  # block and the commit (see {@configure_mutex}), so two calls from
+  # different threads can never interleave their reads and writes: the
+  # second one always starts from whatever the first one left behind,
+  # whether the first succeeded or raised. The lock only orders
+  # configure-against-configure; a reader elsewhere that is not going
+  # through configure can still observe the commit loop's writes one field
+  # at a time while it runs.
+  #
+  # Because Ruby's Mutex is not reentrant, calling EndPointBlank.configure
+  # again from inside a configure block, on the same thread, raises {Error}
+  # rather than running -- configure blocks are not meant to nest. A block
+  # that starts a different thread, has that thread call configure, and
+  # then joins it will hang instead of raising, since that thread is
+  # genuinely waiting on a lock this thread holds.
+  #
+  # @raise whatever the block raises, or {Error} if called while a
+  #   configure call is already in progress on the same thread; the live
+  #   configuration is left exactly as it was before the call
   def self.configure(&block)
-    yield Configuration.instance
+    raise Error, "EndPointBlank.configure cannot be called from inside a configure block" if @configure_mutex.owned?
+
+    @configure_mutex.synchronize { configure_and_commit(&block) }
+  end
+
+  # Builds the candidate and comparison snapshot for the current live
+  # +config+, runs +block+ against the candidate, and commits the result --
+  # freezing the candidate once the block returns, whether it succeeded or
+  # raised (see {EndPointBlank.configure}). Must only be called while
+  # {@configure_mutex} is held.
+  def self.configure_and_commit(&block)
+    config = Configuration.instance
+    original = configure_snapshot_for(config)
+    candidate = configure_candidate_for(config)
+
+    begin
+      block.call(candidate)
+      apply_configure_changes(config, original, candidate)
+    ensure
+      freeze_candidate(candidate)
+    end
+  end
+  private_class_method :configure_and_commit
+
+  # Deep-copies every current instance variable of +config+ into a Hash
+  # keyed by ivar name (see {configure_deep_dup}), so the result shares no
+  # mutable object with +config+. {EndPointBlank.configure} calls this
+  # twice per call -- once directly, for the comparison snapshot, and once
+  # more via {configure_candidate_for}, for the copy the block mutates --
+  # so an in-block edit to one can never be mistaken for "unchanged" by
+  # comparing it back to the other.
+  def self.configure_snapshot_for(config)
+    config.instance_variables.each_with_object({}) do |ivar, memo|
+      memo[ivar] = configure_deep_dup(config.instance_variable_get(ivar))
+    end
+  end
+  private_class_method :configure_snapshot_for
+
+  # Recursively duplicates plain data (String, Array, Hash). Every other
+  # value -- Integer, Symbol, true/false/nil, and an object the caller owns
+  # and handed in by reference such as {Configuration#logger},
+  # {Configuration#mask_hook} or {Configuration#version_finder} -- is
+  # returned as-is, since none of those can be edited in place through
+  # {Configuration}'s documented API the way a String or a rule Hash can.
+  def self.configure_deep_dup(value)
+    case value
+    when String then value.dup
+    when Array then value.map { |element| configure_deep_dup(element) }
+    when Hash
+      value.each_with_object({}) { |(k, v), memo| memo[configure_deep_dup(k)] = configure_deep_dup(v) }
+    else
+      value
+    end
+  end
+  private_class_method :configure_deep_dup
+
+  # Recursively duplicates and freezes plain data (String, Array, Hash), the
+  # same shape {configure_deep_dup} walks. The copy is built first and
+  # frozen after, so this never freezes +value+ itself, only the new copy --
+  # a caller who still holds +value+ (e.g. the Array they passed to
+  # `c.masking_rules = rules`) keeps a fully mutable object; only the copy
+  # {freeze_candidate} puts on the frozen candidate is locked. Every other
+  # value -- Integer, Symbol, true/false/nil, and an object the caller owns
+  # and handed in by reference such as {Configuration#logger},
+  # {Configuration#mask_hook} or {Configuration#version_finder} -- is
+  # returned as-is, unfrozen, exactly as {configure_deep_dup} leaves it.
+  def self.configure_deep_freeze(value)
+    case value
+    when String then value.dup.freeze
+    when Array then value.map { |element| configure_deep_freeze(element) }.freeze
+    when Hash
+      value.each_with_object({}) do |(k, v), memo|
+        memo[configure_deep_freeze(k)] = configure_deep_freeze(v)
+      end.freeze
+    else
+      value
+    end
+  end
+  private_class_method :configure_deep_freeze
+
+  # Builds the detached copy {EndPointBlank.configure} yields to its block:
+  # a bare {Configuration} instance -- built with
+  # `Configuration.send(:allocate)` since {Configuration} is a Singleton
+  # and its `.new`/`.allocate` are private -- carrying its own independent
+  # deep copy of +config+'s current ivars, so it stays a private scratch
+  # object, not a second singleton, and mutating it can never reach
+  # +config+.
+  def self.configure_candidate_for(config)
+    candidate = Configuration.send(:allocate)
+    configure_snapshot_for(config).each { |ivar, value| candidate.instance_variable_set(ivar, value) }
+    candidate
+  end
+  private_class_method :configure_candidate_for
+
+  # Locks down +candidate+ once the block is done with it (see
+  # {configure_and_commit}). Freezing +candidate+ alone only blocks a
+  # *reassignment* through a reference to it retained past the block
+  # (`saved.app_name = "x"`); it does nothing to the Array, Hash or String
+  # objects its ivars point to, so an in-place edit through that same
+  # reference (`saved.masking_rules << rule`, `saved.app_name << "x"`,
+  # editing a rule Hash in place) would return normally and silently never
+  # reach the live config -- the same failure {apply_configure_changes}
+  # committing a fresh copy already prevents, one level down. Each ivar is
+  # therefore replaced with its own {configure_deep_freeze} copy before
+  # +candidate+ itself is frozen, so every one of those in-place edits
+  # raises FrozenError too. This replaces the ivar's value on +candidate+,
+  # not on the value itself: the object the caller handed to +candidate+
+  # (e.g. via `c.masking_rules = rules`) is never frozen in place, so it
+  # stays fully mutable for the caller's own further use.
+  def self.freeze_candidate(candidate)
+    candidate.instance_variables.each do |ivar|
+      candidate.instance_variable_set(ivar, configure_deep_freeze(candidate.instance_variable_get(ivar)))
+    end
+    candidate.freeze
+  end
+  private_class_method :freeze_candidate
+
+  # Writes onto the live +config+ only the ivars whose value on +candidate+
+  # differs from +original+, the independent deep copy taken before the
+  # block ran. A field the block never touched is left exactly as +config+
+  # has it now, even if something else changed it while the block was
+  # running. Only reached after the block has returned normally.
+  #
+  # Commits a fresh {configure_deep_dup} of the value, not +candidate+'s own
+  # object: when the block assigns a String, Array or Hash straight through
+  # (`c.masking_rules = mine`), +candidate+'s ivar *is* the caller's own
+  # object at this point -- {freeze_candidate} has not run yet -- so
+  # committing it as-is would make the live +config+ literally the same
+  # object as +mine+, and the caller mutating +mine+ afterward (`mine <<
+  # rule`, no retained +candidate+ needed at all) would reach +config+
+  # directly -- bypassing {@configure_mutex} and any validation entirely,
+  # silently.
+  def self.apply_configure_changes(config, original, candidate)
+    candidate.instance_variables.each do |ivar|
+      value = candidate.instance_variable_get(ivar)
+      config.instance_variable_set(ivar, configure_deep_dup(value)) unless value == original[ivar]
+    end
   end
+  private_class_method :apply_configure_changes
 
   # Defaults to stderr, not stdout. This logger belongs to a library running
   # inside someone else's process: anything it writes to stdout lands in the

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: end_point_blank
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.13.0
 platform: ruby
 authors:
 - Robert A. Lasch
 bindir: exe
 cert_chain: []
-date: 2026-08-14 00:00:00.000000000 Z
+date: 2026-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: excon
@@ -79,9 +79,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.0
-description: EndPointBlank client library for Ruby. A framework-agnostic core runs
-  in plain Ruby / Sinatra, with Rails supported as an auto-loaded adapter. Provides
-  API endpoint tracking, authorization, and error/request/response/log reporting.
+description: 'Ruby and Rails SDK for EndPointBlank: authorize service-to-service (machine-to-machine)
+  API calls, report endpoint versions, and see which clients still call deprecated
+  API versions before you sunset them. A framework-agnostic core runs in plain Ruby
+  / Sinatra, with Rails supported as an auto-loaded adapter.'
 email:
 - rlasch@gmail.com
 executables: []
@@ -115,10 +116,24 @@ files:
 - lib/end_point_blank/commands/route_pattern_finder.rb
 - lib/end_point_blank/commands/version_finder.rb
 - lib/end_point_blank/configuration.rb
+- lib/end_point_blank/configuration_error.rb
 - lib/end_point_blank/deprecation_headers.rb
 - lib/end_point_blank/fast_json_truncator.rb
 - lib/end_point_blank/log_entry.rb
-- lib/end_point_blank/loggers/logger.rb
+- lib/end_point_blank/management.rb
+- lib/end_point_blank/management/client.rb
+- lib/end_point_blank/management/configuration.rb
+- lib/end_point_blank/management/error.rb
+- lib/end_point_blank/management/error_codes.rb
+- lib/end_point_blank/management/idempotency_key.rb
+- lib/end_point_blank/management/page.rb
+- lib/end_point_blank/management/resources/api_packages.rb
+- lib/end_point_blank/management/resources/applications.rb
+- lib/end_point_blank/management/resources/base.rb
+- lib/end_point_blank/management/resources/clients.rb
+- lib/end_point_blank/management/retry_policy.rb
+- lib/end_point_blank/management/transport.rb
+- lib/end_point_blank/management/url_path.rb
 - lib/end_point_blank/masking.rb
 - lib/end_point_blank/middleware/rack/report_interaction.rb
 - lib/end_point_blank/rack/env_store.rb
@@ -129,6 +144,8 @@ files:
 - lib/end_point_blank/rails/versioned.rb
 - lib/end_point_blank/session_configuration.rb
 - lib/end_point_blank/string_truncator.rb
+- lib/end_point_blank/target_url.rb
+- lib/end_point_blank/token_unavailable_error.rb
 - lib/end_point_blank/unauthorized_error.rb
 - lib/end_point_blank/version.rb
 - lib/end_point_blank/writers/delayed_writer.rb
@@ -141,13 +158,15 @@ files:
 - lib/end_point_blank/xml_truncator.rb
 - sig/end_point_blank_rack.rbs
 - test.sh
-homepage: https://github.com/EndPointBlank/end_point_blank_rails
+homepage: https://endpointblank.com
 licenses:
 - Nonstandard
 metadata:
   allowed_push_host: https://rubygems.org
-  homepage_uri: https://github.com/EndPointBlank/end_point_blank_rails
+  homepage_uri: https://endpointblank.com
   source_code_uri: https://github.com/EndPointBlank/end_point_blank_rails
+  documentation_uri: https://endpointblank.com/docs/sdk-setup
+  bug_tracker_uri: https://github.com/EndPointBlank/end_point_blank_rails/issues
   changelog_uri: https://github.com/EndPointBlank/end_point_blank_rails/releases
 rdoc_options: []
 require_paths:
@@ -165,6 +184,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.2
 specification_version: 4
-summary: Ruby/Rails client for EndPointBlank — endpoint tracking, authorization, and
-  error/request/response/log reporting.
+summary: 'Ruby and Rails SDK for EndPointBlank: authorize service-to-service API calls,
+  report endpoint versions, and see which clients still call deprecated API versions.'
 test_files: []