pug-sh 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3fa18ab593cd55c417d83dc152eb219e7f7d3d5d6053a84abf426ace5028fde
-  data.tar.gz: 9cb0fc72b31991999476f98d1a49a65f707910b7f09020f405ef8fe1e7b81ca6
+  metadata.gz: 8a103a225401b6c59dc03d3c909304b4aea17c4fd8ec267988d0a1cbb09c3ae5
+  data.tar.gz: 39341542bf5cd3e99b453ad057e09207ad4b08023610037998b6956106696806
 SHA512:
-  metadata.gz: 8076f0a24d015d3c1f40cc233cb77e880f913a5bebf0afa2bccbe7ad52acaaee57932c3e89cc85db2f79d146f2c35f0e5e1acf3285e35cb57a5c2e6b5cf8ceef
-  data.tar.gz: a89f4b45abb12e384855e49a142474dcf1c16a0b410fb5b96b6f0fc4a24c30b99388c6b4ac38221113753f641cd1c3392f3b30241871065e6276ae8b5e394412
+  metadata.gz: d2d303d9898809f07c153190bed37ef463261b451ea3c5450d923000f45788b1375864db9d0b3fa035effe6b7d4e8bd1fb79b2616f2ebbb44fae94cb6adc0632
+  data.tar.gz: 00b493cae5fcd45e1645f62b05c46284faa48cf0866549c4777e412c10c5c9b2bc6025e4375551c0b1011ef4c57b6a64807ffac1105466af564c691b352c658f

data/README.md

@@ -31,7 +31,7 @@ pug.track("user_42", "order.completed", amount: 49.0, currency: "USD")
 # Well-known events get their properties type-checked and validated against the event's schema.
 pug.track("user_42", "feature_used", feature_id: "export")
 
-# Identify a profile (never raises; failures are logged).
+# Identify a profile. Like track, it returns at once: identifies are queued and sent in batches.
 pug.identify("user_42", email: "ada@example.com", plan: "pro")
 
 # Reads raise Pug::Error.
@@ -43,73 +43,80 @@ trend = pug.insights.query(
   granularity: :GRANULARITY_DAY,
 )
 
-# Drain on shutdown so no buffered events are lost.
+# Drain on shutdown so no queued events or identifies are lost.
 pug.close
 ```
 
 ## Behaviour
 
 - **Ingestion never raises.** `track` and `identify` validate input client-side and log and drop
-  anything invalid. `track` is non-blocking: a background thread sends events in batches, by size
-  (`max_size`) or interval (`max_wait`).
-- **Delivery is best-effort with retry.** A transient send failure keeps events queued and retries
-  `max_wait` after the failure, but no sooner than a second; a permanent one (a fixed set of
-  client-error Connect codes, plus any non-transport error) dead-letters them via `on_error`.
-  `close` drains and reports anything still undelivered through `on_error` and the log.
-  `on_error` covers buffered `track` events only: `identify` failures are logged, and so are
-  events the server drops from a batch it accepts (`BatchCreateResponse.dropped`), at WARN.
+  anything invalid. Both are non-blocking: background threads, one for events and one for
+  identifies, send them in batches, by size (`max_size`) or interval (`max_wait`). Identifies go
+  out with `BatchIdentify`; a server that predates it gets one `Identify` call each.
+- **Delivery is best-effort with retry.** A transient send failure keeps events and identifies
+  queued and retries `max_wait` after the failure, but no sooner than a second; a permanent one (a
+  fixed set of client-error Connect codes, plus any non-transport error) dead-letters them via
+  `on_error`. `close` drains and reports anything still undelivered through `on_error` and the log.
+  Events the server drops from a batch it accepts (`BatchCreateResponse.dropped`) are logged at
+  WARN.
 - **Reads are request/response and do raise** `Pug::Error`: they run in your control flow, so
   you own retry. They are not auto-retried.
 - **Well-known events** have typed, validated properties; any other `kind` is accepted as a
   custom event with loose properties.
 - **Thread- and fork-safe.** One client can be shared by every thread. A client created before a
-  fork (Puma, Unicorn, Sidekiq) starts empty in each child, with its own sender thread and
-  connections; events buffered in the parent stay with the parent.
+  fork (Puma, Unicorn, Sidekiq) starts empty in each child, with its own sender threads and
+  connections; events and identifies queued in the parent stay with the parent.
 
 ## API
 
 ### `Pug::Client.new(**options)`
 
-| Option     | Type          | Default                     | Description                                                                                                                       |
-| ---------- | ------------- | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
-| `api_key`  | `String`      | none                        | **Required.** Private project key (`prv_…`).                                                                                      |
-| `endpoint` | `String`      | hosted endpoint             | Pug server origin.                                                                                                                |
-| `batch`    | `Hash`        | see below                   | Ingestion buffer: `max_size` (100, capped at 1000), `max_wait` (5 seconds), `max_queue_size` (10,000).                            |
-| `on_error` | callable      | none                        | Dead-letter hook for undeliverable buffered `track` events, called with `(error, events)`.                                        |
-| `logger`   | `Logger`-like | `Logger.new($stderr)`, WARN | Gets the SDK's warnings and errors: anything with public `warn` and `error`, such as `Rails.logger` (wrap an IO in `Logger.new`). |
-| `timeout`  | `Numeric`     | 10                          | Request timeout, in seconds.                                                                                                      |
+| Option     | Type          | Default                     | Description                                                                                                                                 |
+| ---------- | ------------- | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| `api_key`  | `String`      | none                        | **Required.** Private project key (`prv_…`).                                                                                                |
+| `endpoint` | `String`      | hosted endpoint             | Pug server origin.                                                                                                                          |
+| `batch`    | `Hash`        | see below                   | Ingestion buffers, one each for events and identifies: `max_size` (100, capped at 1000), `max_wait` (5 seconds), `max_queue_size` (10,000). |
+| `on_error` | callable      | none                        | Dead-letter hook for queued events and identifies that couldn't be delivered, called with `(error, undelivered)`.                           |
+| `logger`   | `Logger`-like | `Logger.new($stderr)`, WARN | Gets the SDK's warnings and errors: anything with public `warn` and `error`, such as `Rails.logger` (wrap an IO in `Logger.new`).           |
+| `timeout`  | `Numeric`     | 10                          | Request timeout, in seconds.                                                                                                                |
 
 ```ruby
 Pug::Client.new(
   api_key: ENV.fetch("PUG_API_KEY"),
   batch: { max_size: 100, max_wait: 5, max_queue_size: 10_000 },
-  on_error: lambda do |error, events|
-    # dead-letter sink: error is a Pug::QueueOverflowError, a Pug::ClosedError, a Pug::Error
-    # with a permanent Connect code, the transient Pug::Error that failed close's last attempt,
-    # or the exception a bug raised
+  on_error: lambda do |error, undelivered|
+    # dead-letter sink for undelivered.events and undelivered.identifies, one of them empty:
+    # error is a Pug::QueueOverflowError, a Pug::ClosedError, a Pug::Error with a permanent
+    # Connect code, the transient Pug::Error that failed close's last attempt, or the exception a
+    # bug raised
   end,
 )
 ```
 
-`on_error` runs on the background sender thread; on the thread calling `close`, for what it
-reports undelivered; or, when the queue overflows, on the thread that called `track`. It must be
-thread-safe and return promptly. Called from inside it on the sender or the closing thread, `flush`
-and `close` don't wait for what is waiting on `on_error`: they return `false` at once, except that
-`flush` returns `true` while `close` reports. On the overflow path nothing waits on `on_error`, so
-they behave as anywhere else, blocking the thread that called `track`.
+`undelivered` is a `Pug::Undelivered`, whose `events` are `Pug::Proto::Sdk::Events::V1::Event`
+messages and whose `identifies` are the `Pug::Proto::Sdk::Profiles::V1::IdentifyRequest` messages
+`identify` queued.
+
+`on_error` runs on a background sender thread; on the thread calling `close`, for what it reports
+undelivered; or, when a queue overflows, on the thread that called `track` or `identify`. It must
+be thread-safe and return promptly. Called from inside it on a sender thread or the closing thread,
+`flush` and `close` return at once rather than wait, since what they would wait for may itself be
+waiting on `on_error`: `close` returns `false`, and `flush` returns `false` unless it found nothing
+to wait for. On the overflow path nothing waits on `on_error`, so they behave as anywhere else,
+blocking the thread that called `track` or `identify`.
 
 ### Ingestion (never raises)
 
 - `pug.track(distinct_id, kind, properties = nil, options = nil)`: enqueue an event. Non-blocking.
-- `pug.identify(external_id, traits = nil, options = nil)`: create or update a profile. Blocks
-  until the server answers.
-- `pug.flush(timeout: nil)`: send the currently buffered events now and wait for that attempt.
+- `pug.identify(external_id, traits = nil, options = nil)`: enqueue a create-or-update of a
+  profile; its traits are shallow-merged into the stored ones. Non-blocking.
+- `pug.flush(timeout: nil)`: send the queued events and identifies now and wait for that attempt.
   Returns `false` if `timeout` (seconds) passed first. `true` means the attempt finished, not that
-  every event was delivered: a transient failure keeps them queued for a retry.
-- `pug.close(timeout: nil)`: drain and shut down; call on graceful exit so nothing buffered is lost.
-  Returns `false` if `timeout` passed first. Either way, by the time it returns every event it
-  couldn't send has gone to `on_error` and the log, including a batch still being sent when the
-  timeout ran out, which may yet arrive.
+  everything was delivered: a transient failure keeps it queued for a retry.
+- `pug.close(timeout: nil)`: drain and shut down; call on graceful exit so nothing queued is lost.
+  Returns `false` if `timeout` passed first. Either way, by the time it returns every event and
+  identify it couldn't send has gone to `on_error` and the log, including a batch still being sent
+  when the timeout ran out, which may yet arrive.
 
 A `timeout` that isn't a number waits without one, with a warning.
 
@@ -125,11 +132,14 @@ pug.track("user_42", "signup", { plan: "pro", location: "landing" }, location: {
 ```
 
 `track` options: `timestamp` (a `Time`; defaults to now), `session_id` (a UUID overriding the
-client's per-instance session), `location` (the visitor's location; see below).
+client's per-instance session; any other value is ignored with a warning), `location` (the
+visitor's location; see below).
 `identify` options, which work the same way with traits: `anonymous_id` (must start with `anon-`;
 triggers anon→identified merge), `device_id`. Traits must be JSON-serializable, with nested values
 mapped as for properties below; they travel as a protobuf `Struct`, whose numbers are doubles, so
-an integer past 2^53 is refused.
+an integer past 2^53 is refused. A trait holding NaN or Infinity, at any depth, is skipped with a
+warning, and the rest of the identify still goes out. An identify over 900 KiB is dropped with an
+error: the server can't deliver one that large.
 
 Custom properties map by Ruby type:
 

data/lib/pug/batcher.rb

@@ -4,55 +4,97 @@ require_relative "errors"
 require_relative "log"
 
 module Pug
-  # In-memory batching transport. Events accumulate and are sent by a single background thread
-  # on a size or interval trigger, so batches never overlap and go out in order. A transient
-  # failure re-queues them for a retry after max_wait; a permanent one dead-letters them to
-  # on_error, as does close for anything still undelivered.
+  # One sender thread per queue, so batches never overlap and go out in order.
   class Batcher
     DEFAULTS = { max_size: 100, max_wait: 5.0, max_queue_size: 10_000 }.freeze
 
-    # BatchCreateRequest.events is capped at 1000 by the events proto.
-    MAX_BATCH_EVENTS = 1000
+    # The proto cap on BatchCreateRequest.events and BatchIdentifyRequest.identifies.
+    MAX_BATCH_ITEMS = 1000
 
     # The server refuses request bodies over 8 MiB with resource_exhausted, a transient code, so
     # an oversized batch would be retried forever. Half the cap leaves room for the envelope.
     MAX_BATCH_BYTES = 4 * 1024 * 1024
 
-    # Retries wait max_wait but at least this long, or a max_wait of 0 would retry a server that
-    # refuses connections in a tight loop.
+    # Else a max_wait of 0 would retry a refusing server in a tight loop.
     MIN_RETRY_WAIT = 1
 
-    # Retrying can't fix these client errors, nor an error that didn't come from the RPC layer,
-    # which is a bug.
+    # Plus any error not from the RPC layer, which is a bug.
     PERMANENT_CODES = %i[invalid_argument not_found already_exists permission_denied failed_precondition
                          unimplemented unauthenticated].freeze
 
-    Item = Struct.new(:event, :bytesize)
+    Noun = Data.define(:one, :many) do
+      def word(number) = number == 1 ? one : many
+
+      def count(number) = "#{number} #{word(number)}"
+    end
+    EVENTS = Noun.new(one: "event", many: "events")
+    IDENTIFIES = Noun.new(one: "identify", many: "identifies")
+
+    Item = Struct.new(:message, :bytesize)
+
+    # Lets a sink say the first `sent` items arrived, so only the rest is retried.
+    class PartialSendError < StandardError
+      attr_reader :sent
+
+      def initialize(sent)
+        @sent = sent
+        super("failed after delivering #{sent}")
+      end
+    end
 
     def self.permanent?(error)
       !error.is_a?(Error) || error.code.nil? || PERMANENT_CODES.include?(error.code)
     end
 
+    # Idempotent and silent on a resolved config, so a client resolves once for both batchers.
+    def self.resolve(config, log)
+      config = (config || {}).transform_keys(&:to_sym)
+      (config.keys - DEFAULTS.keys).each { |key| log.warn("Ignoring unknown batch option #{key.inspect}") }
+      settings = DEFAULTS.merge(config)
+      max_size = setting(log, :max_size, settings[:max_size], 1)
+      if max_size > MAX_BATCH_ITEMS
+        log.warn("batch.max_size exceeds the #{MAX_BATCH_ITEMS}-item proto cap, clamping to #{MAX_BATCH_ITEMS}.")
+        max_size = MAX_BATCH_ITEMS
+      end
+      { max_size: max_size, max_wait: setting(log, :max_wait, settings[:max_wait], 0),
+        max_queue_size: setting(log, :max_queue_size, settings[:max_queue_size], 1) }
+    end
+
+    def self.setting(log, name, value, min)
+      if min >= 1 && !value.is_a?(Integer)
+        log.warn("batch.#{name} must be an integer, using default.")
+        return DEFAULTS[name]
+      end
+      unless value.is_a?(Numeric) && value.real? && value.finite? && value >= min
+        log.warn("batch.#{name} must be >= #{min}, using default.")
+        return DEFAULTS[name]
+      end
+      value
+    end
+    private_class_method :setting
+
     attr_reader :max_size, :max_wait, :max_queue_size
 
-    def initialize(sink, config, on_error, log)
+    def initialize(sink, config, on_error, log, noun: EVENTS)
       @sink = sink
       @on_error = on_error
       @log = log
-      configure(config)
+      @noun = noun
+      @max_size, @max_wait, @max_queue_size = self.class.resolve(config, log).values_at(*DEFAULTS.keys)
+      @retry_wait = [@max_wait, MIN_RETRY_WAIT].max
       @lock = Mutex.new
       @closed = false
       @closer = nil
       reset
     end
 
-    def enqueue(event, bytesize)
+    def enqueue(message, bytesize)
       dropped = nil
       closed = @lock.synchronize do
         after_fork
         next true if @closed
 
-        @buffer << Item.new(event, bytesize)
+        @buffer << Item.new(message, bytesize)
         dropped = trim
         arm
         @kick = true if @buffer.size >= @max_size && !@backoff
@@ -60,34 +102,49 @@ module Pug
         @wake.signal
         false
       end
-      return dead_letter(ClosedError.new("client is closed"), [event]) if closed
+      return dead_letter(ClosedError.new("client is closed"), [message]) if closed
 
       report_overflow(dropped)
     end
 
-    # Resolves once the attempt it requested has finished, or returns false when timeout (in
-    # seconds) runs out first. A transient failure keeps events queued, so an empty queue is not
-    # guaranteed; close drains.
+    # A transient failure keeps items queued, so this doesn't guarantee an empty queue; close does.
     def flush(timeout: nil)
+      !request_flush.pop(timeout: timeout).nil?
+    end
+
+    # The Queue yields nil at once if the attempt can't be waited for.
+    def request_flush
       waiter = Queue.new
       @lock.synchronize do
         after_fork
-        return true if @stopping || (@buffer.empty? && !@sending && @requests.empty?)
+        return waiter << true if @stopping || (@buffer.empty? && !@sending && @requests.empty?)
         # Called from on_error, which runs on the sender: waiting for it would wait forever.
-        return false if Thread.current.equal?(@thread)
+        return waiter.close if sender?
 
         @requests << waiter
         start
         @wake.signal
       end
-      !waiter.pop(timeout: timeout).nil?
+      waiter
     end
 
-    # Drains the buffer and stops the sender. Returns false when timeout (in seconds) runs out
-    # first; everything still undelivered then is dead-lettered before it returns, including a
-    # batch whose send goes on in the background and may yet succeed.
+    def sender?
+      Thread.current.equal?(@thread)
+    end
+
+    def closing?
+      Thread.current.equal?(@closer) && !@done.closed?
+    end
+
+    # On timeout, everything undelivered is dead-lettered, including a batch still being sent that
+    # may yet arrive.
     def close(timeout: nil)
       deadline = timeout && (monotonic + timeout)
+      finish_close(start_close, deadline)
+    end
+
+    # Split from finish_close so the client can start both drains before waiting on either.
+    def start_close
       first = @lock.synchronize do
         after_fork
         next false if @closed
@@ -97,15 +154,20 @@ module Pug
         disarm
         true
       end
+      @drain = request_flush if first
+      first
+    end
+
+    def finish_close(first, deadline)
       unless first
         # Called from on_error, on the sender or the closing thread: the close underway waits on this call.
-        return false if !@done.closed? && (Thread.current.equal?(@thread) || Thread.current.equal?(@closer))
+        return false if !@done.closed? && (sender? || Thread.current.equal?(@closer))
 
         @done.pop(timeout: remaining(deadline))
         return @done.closed? && @drained
       end
 
-      drained = flush(timeout: remaining(deadline))
+      drained = !@drain.pop(timeout: remaining(deadline)).nil?
       thread = @lock.synchronize do
         @stopping = true
         @wake.signal
@@ -118,38 +180,11 @@ module Pug
       @drained
     end
 
-    # The default would list every buffered event.
+    # The default would list every buffered item.
     def inspect = "#<#{self.class.name}>"
 
     private
 
-    def configure(config)
-      config = (config || {}).transform_keys(&:to_sym)
-      (config.keys - DEFAULTS.keys).each { |key| @log.warn("Ignoring unknown batch option #{key.inspect}") }
-      settings = DEFAULTS.merge(config)
-      @max_size = setting(:max_size, settings[:max_size], 1)
-      if @max_size > MAX_BATCH_EVENTS
-        @log.warn("batch.max_size exceeds the #{MAX_BATCH_EVENTS}-event proto cap, clamping to #{MAX_BATCH_EVENTS}.")
-        @max_size = MAX_BATCH_EVENTS
-      end
-      @max_wait = setting(:max_wait, settings[:max_wait], 0)
-      @retry_wait = [@max_wait, MIN_RETRY_WAIT].max
-      @max_queue_size = setting(:max_queue_size, settings[:max_queue_size], 1)
-    end
-
-    # Counts must be integers; max_wait, in seconds, may be fractional.
-    def setting(name, value, min)
-      if min >= 1 && !value.is_a?(Integer)
-        @log.warn("batch.#{name} must be an integer, using default.")
-        return DEFAULTS[name]
-      end
-      unless value.is_a?(Numeric) && value.real? && value.finite? && value >= min
-        @log.warn("batch.#{name} must be >= #{min}, using default.")
-        return DEFAULTS[name]
-      end
-      value
-    end
-
     def reset
       @buffer = []
       @inflight = nil
@@ -169,7 +204,7 @@ module Pug
     end
 
     # A forked child inherits the buffer but not the sender thread. The parent still owns and
-    # sends those events, so the child starts empty with a sender of its own.
+    # sends those items, so the child starts empty with a sender of its own.
     def after_fork
       reset unless @pid == Process.pid
     end
@@ -178,7 +213,7 @@ module Pug
       return if @thread&.alive?
 
       @thread = Thread.new { run }
-      @thread.name = "pug-batcher"
+      @thread.name = "pug-#{@noun.many}"
       @thread.report_on_exception = false
     end
 
@@ -195,7 +230,8 @@ module Pug
       end
     rescue Exception => e # rubocop:disable Lint/RescueException
       # Nothing else would report it: the thread doesn't, and on_error or a logger may raise anything.
-      @log.error("Event sender stopped unexpectedly; it restarts with the next event: #{Log.describe(e)}")
+      @log.error("#{@noun.one.capitalize} sender stopped unexpectedly; it restarts with the next #{@noun.one}: " \
+                 "#{Log.describe(e)}")
     ensure
       # An idle exit has already handed over to whichever thread starts next, so only a sender
       # that is stopping or crashed answers the pending flushes.
@@ -220,15 +256,14 @@ module Pug
         end
         if @kick
           @kick = false
-          # Stale if the send that set it off has since taken those events, or if a backoff began;
+          # Stale if the send that set it off has since taken those items, or if a backoff began;
           # once closed, close's flush sends.
           return [] if @buffer.size >= @max_size && !@backoff && !@closed
 
           next
         end
         if @deadline.nil?
-          # Idle: nothing is buffered without a timer armed, so the thread exits rather than
-          # holding on to the client, and the next event starts a new one.
+          # Idle: exit rather than hold on to the client; the next item starts a new thread.
           @thread = nil
           return
         end
@@ -239,10 +274,8 @@ module Pug
       end
     end
 
-    # One attempt at what is buffered now, a chunk at a time. Events stay in the buffer until
-    # their chunk is taken, and the chunk being sent is tracked, so a close that runs out of time
-    # can report every event. Stops at the first transient failure, since the rest would likely
-    # fail the same way.
+    # The in-flight chunk is tracked so a timed-out close can report it. Stops at the first
+    # transient failure, since the rest would likely fail the same way.
     def send_buffer
       pending = @lock.synchronize do
         disarm
@@ -261,8 +294,7 @@ module Pug
       @lock.synchronize { @sending = false }
     end
 
-    # Called under the lock: the oldest events, at most limit of them, cut at max_size and
-    # MAX_BATCH_BYTES.
+    # Called under the lock.
     def take_chunk(limit)
       cap = [limit, @max_size].min
       count = 0
@@ -279,15 +311,18 @@ module Pug
     # Not just StandardError: one that ended the thread would strand the chunk. Any error that
     # didn't come from the RPC layer is permanent, so the chunk is dead-lettered.
     def send_chunk(chunk)
-      @sink.call(chunk.map(&:event))
+      @sink.call(chunk.map(&:message))
       nil
     rescue Exception => e # rubocop:disable Lint/RescueException
       e
     end
 
-    # Returns the outcome of a chunk's send. Open, a transient failure re-queues the chunk for a
-    # retry; closed, it dead-letters it and leaves the rest for close to report.
     def settle(chunk, error)
+      undelivered = chunk
+      if error.is_a?(PartialSendError)
+        undelivered = chunk.drop(error.sent)
+        error = error.cause || error
+      end
       outcome, dropped = @lock.synchronize do
         # close ran out of time during the send, and has reported the chunk itself.
         next [:reported] unless @inflight.equal?(chunk)
@@ -296,19 +331,20 @@ module Pug
         if error.nil? then [:sent]
         elsif self.class.permanent?(error) then [:permanent]
         elsif @closed then [:closed]
-        else [:retry, requeue(chunk)]
+        else [:retry, requeue(undelivered)]
         end
       end
-      events = chunk.map(&:event)
+      messages = undelivered.map(&:message)
       case outcome
       when :permanent
-        @log.error("Permanent error, #{events.size} event(s) dropped (will NOT retry): #{Log.describe(error)}")
-        dead_letter(error, events)
+        @log.error("Permanent error, #{@noun.count(messages.size)} dropped (will NOT retry): #{Log.describe(error)}")
+        dead_letter(error, messages)
       when :closed
-        @log.error("Client closed, #{events.size} event(s) dropped after transient error: #{Log.describe(error)}")
-        dead_letter(error, events)
+        @log.error("Client closed, #{@noun.count(messages.size)} dropped after transient error: " \
+                   "#{Log.describe(error)}")
+        dead_letter(error, messages)
       when :retry
-        @log.warn("Transient error sending batch, will retry: #{Log.describe(error)}")
+        @log.warn("Transient error sending #{@noun.count(messages.size)}, will retry: #{Log.describe(error)}")
         report_overflow(dropped)
       end
       outcome
@@ -316,25 +352,26 @@ module Pug
 
     # Called under the lock. The retry is timed from the failure: a timer an enqueue armed during
     # the send could already be due.
-    def requeue(chunk)
-      @buffer.unshift(*chunk)
+    def requeue(items)
+      @buffer.unshift(*items)
       @backoff = true
       disarm
       arm(@retry_wait)
       trim
     end
 
-    # Called under the lock. Drops the oldest events past max_queue_size and returns them.
+    # Called under the lock.
     def trim
       over = @buffer.size - @max_queue_size
-      @buffer.shift(over).map(&:event) if over.positive?
+      @buffer.shift(over).map(&:message) if over.positive?
     end
 
     def report_overflow(dropped)
       return unless dropped
 
-      @log.warn("Queue full, dropping #{dropped.size} oldest event(s)")
-      dead_letter(QueueOverflowError.new("queue overflow: dropped oldest event"), dropped)
+      oldest = "#{dropped.size} oldest #{@noun.word(dropped.size)}"
+      @log.warn("Queue full, dropping #{oldest}")
+      dead_letter(QueueOverflowError.new("queue overflow: dropped #{oldest}"), dropped)
     end
 
     def report_undelivered
@@ -344,14 +381,15 @@ module Pug
         taken
       end
       if inflight
-        @log.error("Close timed out with #{inflight.size} event(s) still being sent, which may yet arrive")
-        dead_letter(ClosedError.new("close timed out with #{inflight.size} event(s) still being sent"),
-                    inflight.map(&:event))
+        sending = "#{@noun.count(inflight.size)} still being sent"
+        @log.error("Close timed out with #{sending}, which may yet arrive")
+        dead_letter(ClosedError.new("close timed out with #{sending}"), inflight.map(&:message))
       end
       return if unsent.empty?
 
-      @log.error("Client closed with #{unsent.size} undelivered event(s), dropped")
-      dead_letter(ClosedError.new("client closed with #{unsent.size} undelivered event(s)"), unsent.map(&:event))
+      undelivered = "#{unsent.size} undelivered #{@noun.word(unsent.size)}"
+      @log.error("Client closed with #{undelivered}, dropped")
+      dead_letter(ClosedError.new("client closed with #{undelivered}"), unsent.map(&:message))
     end
 
     def arm(wait = @max_wait)
@@ -362,14 +400,13 @@ module Pug
       @deadline = nil
     end
 
-    # A raising callback must not abort the sender or a drain: the remaining chunks would be lost
-    # with neither a log nor a callback. NotImplementedError, a common placeholder, is a
-    # ScriptError.
-    def dead_letter(error, events)
-      @on_error&.call(error, events)
+    # A raising callback must not abort the sender or a drain. NotImplementedError, a common
+    # placeholder, is a ScriptError.
+    def dead_letter(error, messages)
+      @on_error&.call(error, messages)
       nil
     rescue StandardError, ScriptError => e
-      @log.error("on_error callback raised; #{events.size} event(s) may be lost: #{Log.describe(e)}")
+      @log.error("on_error callback raised; #{@noun.count(messages.size)} may be lost: #{Log.describe(e)}")
       nil
     end
 

data/lib/pug/client.rb

@@ -13,6 +13,11 @@ require_relative "rpc"
 require_relative "validator"
 
 module Pug
+  # What one failure lost, as on_error receives it. Either list may be empty.
+  Undelivered = Data.define(:events, :identifies) do
+    def initialize(events: [], identifies: []) = super
+  end
+
   class Client
     DEFAULT_ENDPOINT = "https://api.pugs.dev"
     DEFAULT_TIMEOUT = 10
@@ -20,6 +25,9 @@ module Pug
     TRACK_OPTIONS = %w[timestamp session_id location].freeze
     IDENTIFY_OPTIONS = %w[anonymous_id device_id].freeze
 
+    # Each identify is one NATS message, capped at 1 MiB; the margin covers envelope and headers.
+    MAX_IDENTIFY_BYTES = 900 * 1024
+
     class NotSerializable < StandardError; end
     OMITTED = Object.new.freeze
     private_constant :NotSerializable, :OMITTED
@@ -39,7 +47,7 @@ module Pug
       end
       raise ArgumentError, "[Pug SDK] on_error must be callable" unless on_error.nil? || on_error.respond_to?(:call)
       unless on_error.nil? || takes_two?(on_error)
-        raise ArgumentError, "[Pug SDK] on_error must take two arguments, (error, events)"
+        raise ArgumentError, "[Pug SDK] on_error must take two arguments, (error, undelivered)"
       end
       raise ArgumentError, "[Pug SDK] batch must be a Hash" unless batch.nil? || batch.is_a?(Hash)
       unless logger.nil? || %i[warn error].all? { |level| logger.respond_to?(level) }
@@ -56,7 +64,14 @@ module Pug
       @connect = Connect.new(endpoint, api_key, timeout: resolve_timeout(timeout))
       @rpc = RPC.new(@connect)
       @events = EventBuilder.new(@log)
-      @batcher = Batcher.new(method(:send_batch), batch, on_error, @log)
+      # Resolved once, so a bad setting warns once rather than once per queue.
+      batch = Batcher.resolve(batch, @log)
+      on_events = on_error && ->(error, events) { on_error.call(error, Undelivered.new(events:)) }
+      on_identifies = on_error && ->(error, identifies) { on_error.call(error, Undelivered.new(identifies:)) }
+      @event_queue = Batcher.new(method(:send_events), batch, on_events, @log)
+      @identify_queue = Batcher.new(method(:send_identifies), batch, on_identifies, @log, noun: Batcher::IDENTIFIES)
+      @close_lock = Mutex.new
+      @unbatched = false
       @session_id = SecureRandom.uuid_v7
       @closed = false
       @profiles = Profiles.new(@rpc)
@@ -78,13 +93,9 @@ module Pug
       properties, options = split_options(properties, options, keywords, TRACK_OPTIONS, "track")
       return @log.error("track() properties must be a Hash.") unless properties.nil? || properties.is_a?(Hash)
 
-      session_id = options["session_id"]
-      return @log.error("track() session_id must be a String.") unless session_id.nil? || session_id.is_a?(String)
-
-      session_id = @session_id if session_id.nil? || session_id.empty?
-      event, bytesize = @events.build(kind, session_id, distinct_id, properties,
+      event, bytesize = @events.build(kind, session(options["session_id"]), distinct_id, properties,
                                       timestamp: options["timestamp"], location: options["location"])
-      @batcher.enqueue(event, bytesize) if event
+      @event_queue.enqueue(event, bytesize) if event
       nil
     rescue StandardError => e
       @log.error("Unexpected error in track(#{kind.inspect}): #{Log.describe(e)}")
@@ -105,31 +116,42 @@ module Pug
       violations = Validator.validate(request)
       return @log.error("Invalid identify request: #{Validator.format(violations)}") unless violations.empty?
 
-      @rpc.unary(:identify, request)
+      bytesize = RPC::SdkProfilesV1::IdentifyRequest.encode(request).bytesize
+      if bytesize > MAX_IDENTIFY_BYTES
+        return @log.error("Identify #{external_id.inspect} dropped: #{bytesize} bytes is too large to send " \
+                          "(limit #{MAX_IDENTIFY_BYTES})")
+      end
+
+      @identify_queue.enqueue(request, bytesize)
       nil
     rescue NotSerializable => e
       @log.error("identify() traits must be JSON-serializable: #{e.message}")
     rescue StandardError => e
-      @log.error("Failed to identify #{external_id.inspect}: #{Log.describe(e)}")
+      @log.error("Unexpected error in identify(#{external_id.inspect}): #{Log.describe(e)}")
     end
 
     def flush(timeout: nil)
-      @batcher.flush(timeout: wait_timeout(timeout, "flush"))
+      deadline = wait_deadline(timeout, "flush")
+      waiters = queues.map(&:request_flush)
+      waiters.map { |waiter| !waiter.pop(timeout: remaining(deadline)).nil? }.all?
     end
 
+    # Concurrent closes can't each own one queue: the second waits on the first's timeout.
     def close(timeout: nil)
       @closed = true
-      @batcher.close(timeout: wait_timeout(timeout, "close"))
+      deadline = wait_deadline(timeout, "close")
+      firsts = @close_lock.synchronize { queues.map(&:start_close) }
+      queues.zip(firsts).map { |queue, first| queue.finish_close(first, deadline) }.all?
     ensure
       @connect.close
     end
 
-    # The default would print the API key and every buffered event.
+    # The default would print the API key and everything queued.
     def inspect = "#<#{self.class.name}>"
 
     private
 
-    def send_batch(events)
+    def send_events(events)
       response = @rpc.unary(:batch_create, RPC::EventsV1::BatchCreateRequest.new(events: events))
       # A refused event isn't an RPC error, so this is the only sign it was lost.
       return unless response.dropped.positive?
@@ -137,6 +159,39 @@ module Pug
       @log.warn("Server dropped #{response.dropped} of #{events.size} event(s): #{response.dropped_by_reason.to_h}")
     end
 
+    # Falls back to one Identify per item on servers older than BatchIdentify.
+    def send_identifies(identifies)
+      return if !@unbatched && batch_identify(identifies)
+
+      identifies.each_with_index do |identify, sent|
+        @rpc.unary(:identify, identify)
+      rescue StandardError => e
+        raise Batcher::PartialSendError.new(sent), cause: e
+      end
+    end
+
+    def batch_identify(identifies)
+      @rpc.unary(:batch_identify, RPC::SdkProfilesV1::BatchIdentifyRequest.new(identifies: identifies))
+      true
+    rescue Error => e
+      # A server without the route answers 404, which the batcher would treat as permanent.
+      raise unless e.code == :unimplemented
+
+      @log.warn("Server has no BatchIdentify; sending identifies one at a time.")
+      @unbatched = true
+      false
+    end
+
+    # A bad session id costs the event its own session, not the event.
+    def session(session_id)
+      return @session_id if session_id.nil? || session_id == ""
+      return session_id if session_id.is_a?(String) && session_id.ascii_only? && Validator::UUID.match?(session_id)
+
+      @log.warn("Ignoring invalid track session_id #{session_id.inspect}; expected a UUID String. " \
+                "Using the client's session.")
+      @session_id
+    end
+
     def identify_request(external_id, traits, options)
       ids = IDENTIFY_OPTIONS.filter_map do |name|
         value = options[name]
@@ -157,6 +212,15 @@ module Pug
       DEFAULT_TIMEOUT
     end
 
+    def queues = [@event_queue, @identify_queue]
+
+    # From on_error, waiting could deadlock on the other queue's sender, itself in on_error.
+    def wait_deadline(timeout, method)
+      timeout = wait_timeout(timeout, method)
+      timeout = 0 if queues.any? { |queue| queue.sender? || queue.closing? }
+      timeout && (monotonic + timeout)
+    end
+
     # A timeout that isn't a number waits without one, as close must still drain; one already
     # past doesn't wait at all.
     def wait_timeout(timeout, method)
@@ -167,6 +231,14 @@ module Pug
       nil
     end
 
+    def remaining(deadline)
+      deadline && [deadline - monotonic, 0].max
+    end
+
+    def monotonic
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
     # Lambdas and methods check their arity, so one taking fewer arguments would fail every call.
     def takes_two?(callable)
       callable = callable.method(:call) unless callable.is_a?(Proc) || callable.is_a?(Method)
@@ -235,16 +307,33 @@ module Pug
       end
     end
 
-    # A JSON round trip accepts what JSON does (symbol keys, nested arrays) and refuses what a
-    # Struct can't carry, such as NaN. A Struct's numbers are doubles, so an integer past 2^53
-    # would arrive changed.
+    # A Struct's numbers are doubles, so an integer past 2^53 would arrive changed.
     def to_struct(traits)
       ready = EventBuilder.json_ready(camel_case_keys(traits), max_integer: EventBuilder::MAX_SAFE_FLOAT)
-      ::Google::Protobuf::Struct.from_hash(JSON.parse(JSON.generate(ready)))
+      ::Google::Protobuf::Struct.from_hash(JSON.parse(JSON.generate(finite_traits(ready))))
     rescue StandardError => e
       raise NotSerializable, e.message
     end
 
+    # JSON has no NaN or Infinity, so a trait holding one costs only itself.
+    def finite_traits(traits)
+      traits.reject do |key, value|
+        next false if finite_json?(value)
+
+        @log.warn("identify() trait #{key.inspect} is not representable (NaN or Infinity), skipping")
+        true
+      end
+    end
+
+    def finite_json?(value)
+      case value
+      when Float then value.finite?
+      when Hash then value.each_value.all? { |item| finite_json?(item) }
+      when Array then value.all? { |item| finite_json?(item) }
+      else true
+      end
+    end
+
     # Only the top level, as for properties: a nested Hash is as likely data keyed by ids.
     def camel_case_keys(traits)
       given = {}

data/lib/pug/gen/sdk/profiles/v1/profiles_pb.rb

@@ -8,7 +8,7 @@ require_relative '../../../buf/validate/validate_pb'
 require 'google/protobuf/struct_pb'
 
 
-descriptor_data = "\n\x1esdk/profiles/v1/profiles.proto\x12\x0fsdk.profiles.v1\x1a\x1b\x62uf/validate/validate.proto\x1a\x1cgoogle/protobuf/struct.proto\"\xd1\x02\n\x0fIdentifyRequest\x12\xae\x01\n\x0b\x65xternal_id\x18\x01 \x01(\tB\x8c\x01\xbaH\x88\x01\xba\x01\x81\x01\n\x1b\x65xternal_id.reserved_prefix\x12\x41\x65xternal_id must not start with the reserved \'cookieless-\' prefix\x1a\x1f!this.startsWith(\'cookieless-\')\xc8\x01\x01R\nexternalId\x12/\n\x06traits\x18\x02 \x01(\x0b\x32\x17.google.protobuf.StructR\x06traits\x12\x36\n\x0c\x61nonymous_id\x18\x03 \x01(\tB\x13\xbaH\x10r\x0e\x18\xff\x01\x32\t^$|^anon-R\x0b\x61nonymousId\x12$\n\tdevice_id\x18\x04 \x01(\tB\x07\xbaH\x04r\x02\x18$R\x08\x64\x65viceId\"\x12\n\x10IdentifyResponse\"\xe9\x02\n\x16ProfileIdentifyMessage\x12\xb2\x01\n\x0b\x65xternal_id\x18\x01 \x01(\tB\x90\x01\xbaH\x8c\x01r\x02\x10\x01\xba\x01\x81\x01\n\x1b\x65xternal_id.reserved_prefix\x12\x41\x65xternal_id must not start with the reserved \'cookieless-\' prefix\x1a\x1f!this.startsWith(\'cookieless-\')\xc8\x01\x01R\nexternalId\x12/\n\x06traits\x18\x02 \x01(\x0b\x32\x17.google.protobuf.StructR\x06traits\x12)\n\nproject_id\x18\x03 \x01(\tB\n\xbaH\x07r\x02\x10\x01\xc8\x01\x01R\tprojectId\x12!\n\x0c\x61nonymous_id\x18\x04 \x01(\tR\x0b\x61nonymousId\x12\x1b\n\tdevice_id\x18\x05 \x01(\tR\x08\x64\x65viceId2e\n\x12ProfilesSDKService\x12O\n\x08Identify\x12 .sdk.profiles.v1.IdentifyRequest\x1a!.sdk.profiles.v1.IdentifyResponseB\xd6\x01\n\x13\x63om.sdk.profiles.v1B\rProfilesProtoP\x01ZFgithub.com/pug-sh/pug/internal/gen/proto/sdk/profiles/v1;sdkprofilesv1\xa2\x02\x03SPX\xaa\x02\x0fSdk.Profiles.V1\xca\x02\x0fSdk\\Profiles\\V1\xe2\x02\x1bSdk\\Profiles\\V1\\GPBMetadata\xea\x02\x1dPug::Proto::Sdk::Profiles::V1b\x08\x65\x64itionsp\xe8\x07"
+descriptor_data = "\n\x1esdk/profiles/v1/profiles.proto\x12\x0fsdk.profiles.v1\x1a\x1b\x62uf/validate/validate.proto\x1a\x1cgoogle/protobuf/struct.proto\"\xd5\x02\n\x0fIdentifyRequest\x12\xb2\x01\n\x0b\x65xternal_id\x18\x01 \x01(\tB\x90\x01\xbaH\x8c\x01r\x02\x10\x01\xba\x01\x81\x01\n\x1b\x65xternal_id.reserved_prefix\x12\x41\x65xternal_id must not start with the reserved \'cookieless-\' prefix\x1a\x1f!this.startsWith(\'cookieless-\')\xc8\x01\x01R\nexternalId\x12/\n\x06traits\x18\x02 \x01(\x0b\x32\x17.google.protobuf.StructR\x06traits\x12\x36\n\x0c\x61nonymous_id\x18\x03 \x01(\tB\x13\xbaH\x10r\x0e\x18\xff\x01\x32\t^$|^anon-R\x0b\x61nonymousId\x12$\n\tdevice_id\x18\x04 \x01(\tB\x07\xbaH\x04r\x02\x18$R\x08\x64\x65viceId\"\x12\n\x10IdentifyResponse\"c\n\x14\x42\x61tchIdentifyRequest\x12K\n\nidentifies\x18\x01 \x03(\x0b\x32 .sdk.profiles.v1.IdentifyRequestB\t\xbaH\x06\x92\x01\x03\x10\xe8\x07R\nidentifies\"3\n\x15\x42\x61tchIdentifyResponse\x12\x1a\n\x08\x61\x63\x63\x65pted\x18\x01 \x01(\rR\x08\x61\x63\x63\x65pted\"\xe9\x02\n\x16ProfileIdentifyMessage\x12\xb2\x01\n\x0b\x65xternal_id\x18\x01 \x01(\tB\x90\x01\xbaH\x8c\x01r\x02\x10\x01\xba\x01\x81\x01\n\x1b\x65xternal_id.reserved_prefix\x12\x41\x65xternal_id must not start with the reserved \'cookieless-\' prefix\x1a\x1f!this.startsWith(\'cookieless-\')\xc8\x01\x01R\nexternalId\x12/\n\x06traits\x18\x02 \x01(\x0b\x32\x17.google.protobuf.StructR\x06traits\x12)\n\nproject_id\x18\x03 \x01(\tB\n\xbaH\x07r\x02\x10\x01\xc8\x01\x01R\tprojectId\x12!\n\x0c\x61nonymous_id\x18\x04 \x01(\tR\x0b\x61nonymousId\x12\x1b\n\tdevice_id\x18\x05 \x01(\tR\x08\x64\x65viceId2\xc5\x01\n\x12ProfilesSDKService\x12O\n\x08Identify\x12 .sdk.profiles.v1.IdentifyRequest\x1a!.sdk.profiles.v1.IdentifyResponse\x12^\n\rBatchIdentify\x12%.sdk.profiles.v1.BatchIdentifyRequest\x1a&.sdk.profiles.v1.BatchIdentifyResponseB\xd6\x01\n\x13\x63om.sdk.profiles.v1B\rProfilesProtoP\x01ZFgithub.com/pug-sh/pug/internal/gen/proto/sdk/profiles/v1;sdkprofilesv1\xa2\x02\x03SPX\xaa\x02\x0fSdk.Profiles.V1\xca\x02\x0fSdk\\Profiles\\V1\xe2\x02\x1bSdk\\Profiles\\V1\\GPBMetadata\xea\x02\x1dPug::Proto::Sdk::Profiles::V1b\x08\x65\x64itionsp\xe8\x07"
 
 pool = ::Google::Protobuf::DescriptorPool.generated_pool
 pool.add_serialized_file(descriptor_data)
@@ -20,6 +20,8 @@ module Pug
         module V1
           IdentifyRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("sdk.profiles.v1.IdentifyRequest").msgclass
           IdentifyResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("sdk.profiles.v1.IdentifyResponse").msgclass
+          BatchIdentifyRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("sdk.profiles.v1.BatchIdentifyRequest").msgclass
+          BatchIdentifyResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("sdk.profiles.v1.BatchIdentifyResponse").msgclass
           ProfileIdentifyMessage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("sdk.profiles.v1.ProfileIdentifyMessage").msgclass
         end
       end

data/lib/pug/gen/shared/profiles/v1/profiles_pb.rb

@@ -10,7 +10,7 @@ require 'google/protobuf/struct_pb'
 require 'google/protobuf/timestamp_pb'
 
 
-descriptor_data = "\n!shared/profiles/v1/profiles.proto\x12\x12shared.profiles.v1\x1a\x1b\x62uf/validate/validate.proto\x1a\x17\x63ommon/v1/filters.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\'\n\rDeleteRequest\x12\x16\n\x02id\x18\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x01R\x02id\"C\n\x18\x44\x65leteDataSubjectRequest\x12\'\n\x0b\x65xternal_id\x18\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x01R\nexternalId\"t\n\x0e\x44\x65leteResponse\x12\x1d\n\nrequest_id\x18\x01 \x01(\tR\trequestId\x12\x43\n\x06status\x18\x02 \x01(\x0e\x32+.shared.profiles.v1.ComplianceRequestStatusR\x06status\"\x7f\n\x19\x44\x65leteDataSubjectResponse\x12\x1d\n\nrequest_id\x18\x01 \x01(\tR\trequestId\x12\x43\n\x06status\x18\x02 \x01(\x0e\x32+.shared.profiles.v1.ComplianceRequestStatusR\x06status\"B\n\x19GetDeletionRequestRequest\x12%\n\nrequest_id\x18\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x01R\trequestId\"\x81\x03\n\x1aGetDeletionRequestResponse\x12\x1d\n\nrequest_id\x18\x01 \x01(\tR\trequestId\x12\x1f\n\x0b\x65xternal_id\x18\x02 \x01(\tR\nexternalId\x12\x1d\n\nprofile_id\x18\x03 \x01(\tR\tprofileId\x12\x43\n\x06status\x18\x04 \x01(\x0e\x32+.shared.profiles.v1.ComplianceRequestStatusR\x06status\x12+\n\x11\x65vents_identified\x18\x05 \x01(\x03R\x10\x65ventsIdentified\x12=\n\x0crequested_at\x18\x06 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x0brequestedAt\x12=\n\x0c\x63ompleted_at\x18\x07 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x0b\x63ompletedAt\x12\x14\n\x05\x65rror\x18\x08 \x01(\tR\x05\x65rror\"d\n\x16GetByExternalIdRequest\x12\'\n\x0b\x65xternal_id\x18\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x01R\nexternalId\x12!\n\x0cinclude_bots\x18\x02 \x01(\x08R\x0bincludeBots\"P\n\x17GetByExternalIdResponse\x12\x35\n\x07profile\x18\x01 \x01(\x0b\x32\x1b.shared.profiles.v1.ProfileR\x07profile\"G\n\nGetRequest\x12\x16\n\x02id\x18\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x01R\x02id\x12!\n\x0cinclude_bots\x18\x02 \x01(\x08R\x0bincludeBots\"D\n\x0bGetResponse\x12\x35\n\x07profile\x18\x01 \x01(\x0b\x32\x1b.shared.profiles.v1.ProfileR\x07profile\"\x84\x01\n\x0b\x46ilterGroup\x12=\n\x07\x66ilters\x18\x01 \x03(\x0b\x32\x19.common.v1.PropertyFilterB\x08\xbaH\x05\x92\x01\x02\x08\x01R\x07\x66ilters\x12\x36\n\x08operator\x18\x02 \x01(\x0e\x32\x1a.common.v1.LogicalOperatorR\x08operator\"\xe7\x01\n\x0bListRequest\x12\x1d\n\npage_token\x18\x01 \x01(\tR\tpageToken\x12\x44\n\rfilter_groups\x18\x02 \x03(\x0b\x32\x1f.shared.profiles.v1.FilterGroupR\x0c\x66ilterGroups\x12P\n\x16\x66ilter_groups_operator\x18\x03 \x01(\x0e\x32\x1a.common.v1.LogicalOperatorR\x14\x66ilterGroupsOperator\x12!\n\x0cinclude_bots\x18\x04 \x01(\x08R\x0bincludeBots\"o\n\x0cListResponse\x12\x37\n\x08profiles\x18\x01 \x03(\x0b\x32\x1b.shared.profiles.v1.ProfileR\x08profiles\x12&\n\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"\xcb\x03\n\x16ProfileActivitySummary\x12\x39\n\nfirst_seen\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\tfirstSeen\x12\x37\n\tlast_seen\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x08lastSeen\x12!\n\x0ctotal_events\x18\x03 \x01(\x03R\x0btotalEvents\x12\x1c\n\tpageviews\x18\x04 \x01(\x03R\tpageviews\x12\x1a\n\x08sessions\x18\x05 \x01(\x03R\x08sessions\x12\x18\n\x07\x62rowser\x18\x06 \x01(\tR\x07\x62rowser\x12\'\n\x0f\x62rowser_version\x18\x07 \x01(\tR\x0e\x62rowserVersion\x12\x0e\n\x02os\x18\x08 \x01(\tR\x02os\x12\x1d\n\nos_version\x18\t \x01(\tR\tosVersion\x12\x16\n\x06\x64\x65vice\x18\n \x01(\tR\x06\x64\x65vice\x12\x18\n\x07\x63ountry\x18\x0b \x01(\tR\x07\x63ountry\x12\x16\n\x06region\x18\x0c \x01(\tR\x06region\x12\x12\n\x04\x63ity\x18\r \x01(\tR\x04\x63ity\x12\x10\n\x03\x62ot\x18\x0e \x01(\x08R\x03\x62ot\"\xd4\x02\n\x07Profile\x12;\n\x0b\x63reate_time\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\ncreateTime\x12\x1f\n\x0b\x65xternal_id\x18\x02 \x01(\tR\nexternalId\x12\x0e\n\x02id\x18\x03 \x01(\tR\x02id\x12\x37\n\nproperties\x18\x04 \x01(\x0b\x32\x17.google.protobuf.StructR\nproperties\x12\x1d\n\nproject_id\x18\x05 \x01(\tR\tprojectId\x12;\n\x0bupdate_time\x18\x06 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\nupdateTime\x12\x46\n\x08\x61\x63tivity\x18\x07 \x01(\x0b\x32*.shared.profiles.v1.ProfileActivitySummaryR\x08\x61\x63tivity*\xe4\x01\n\x17\x43omplianceRequestStatus\x12)\n%COMPLIANCE_REQUEST_STATUS_UNSPECIFIED\x10\x00\x12%\n!COMPLIANCE_REQUEST_STATUS_PENDING\x10\x01\x12(\n$COMPLIANCE_REQUEST_STATUS_PROCESSING\x10\x02\x12\'\n#COMPLIANCE_REQUEST_STATUS_COMPLETED\x10\x03\x12$\n COMPLIANCE_REQUEST_STATUS_FAILED\x10\x04\x32\xd6\x04\n\x0fProfilesService\x12H\n\x03Get\x12\x1e.shared.profiles.v1.GetRequest\x1a\x1f.shared.profiles.v1.GetResponse\"\x00\x12l\n\x0fGetByExternalId\x12*.shared.profiles.v1.GetByExternalIdRequest\x1a+.shared.profiles.v1.GetByExternalIdResponse\"\x00\x12M\n\x04List\x12\x1f.shared.profiles.v1.ListRequest\x1a .shared.profiles.v1.ListResponse\"\x00\x30\x01\x12Q\n\x06\x44\x65lete\x12!.shared.profiles.v1.DeleteRequest\x1a\".shared.profiles.v1.DeleteResponse\"\x00\x12r\n\x11\x44\x65leteDataSubject\x12,.shared.profiles.v1.DeleteDataSubjectRequest\x1a-.shared.profiles.v1.DeleteDataSubjectResponse\"\x00\x12u\n\x12GetDeletionRequest\x12-.shared.profiles.v1.GetDeletionRequestRequest\x1a..shared.profiles.v1.GetDeletionRequestResponse\"\x00\x42\xe5\x01\n\x16\x63om.shared.profiles.v1B\rProfilesProtoP\x01ZFgithub.com/pug-sh/pug/internal/gen/proto/shared/profiles/v1;profilesv1\xa2\x02\x03SPX\xaa\x02\x12Shared.Profiles.V1\xca\x02\x12Shared\\Profiles\\V1\xe2\x02\x1eShared\\Profiles\\V1\\GPBMetadata\xea\x02 Pug::Proto::Shared::Profiles::V1b\x08\x65\x64itionsp\xe8\x07"
+descriptor_data = "\n!shared/profiles/v1/profiles.proto\x12\x12shared.profiles.v1\x1a\x1b\x62uf/validate/validate.proto\x1a\x17\x63ommon/v1/filters.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\'\n\rDeleteRequest\x12\x16\n\x02id\x18\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x01R\x02id\"C\n\x18\x44\x65leteDataSubjectRequest\x12\'\n\x0b\x65xternal_id\x18\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x01R\nexternalId\"t\n\x0e\x44\x65leteResponse\x12\x1d\n\nrequest_id\x18\x01 \x01(\tR\trequestId\x12\x43\n\x06status\x18\x02 \x01(\x0e\x32+.shared.profiles.v1.ComplianceRequestStatusR\x06status\"\x7f\n\x19\x44\x65leteDataSubjectResponse\x12\x1d\n\nrequest_id\x18\x01 \x01(\tR\trequestId\x12\x43\n\x06status\x18\x02 \x01(\x0e\x32+.shared.profiles.v1.ComplianceRequestStatusR\x06status\"B\n\x19GetDeletionRequestRequest\x12%\n\nrequest_id\x18\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x01R\trequestId\"\x81\x03\n\x1aGetDeletionRequestResponse\x12\x1d\n\nrequest_id\x18\x01 \x01(\tR\trequestId\x12\x1f\n\x0b\x65xternal_id\x18\x02 \x01(\tR\nexternalId\x12\x1d\n\nprofile_id\x18\x03 \x01(\tR\tprofileId\x12\x43\n\x06status\x18\x04 \x01(\x0e\x32+.shared.profiles.v1.ComplianceRequestStatusR\x06status\x12+\n\x11\x65vents_identified\x18\x05 \x01(\x03R\x10\x65ventsIdentified\x12=\n\x0crequested_at\x18\x06 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x0brequestedAt\x12=\n\x0c\x63ompleted_at\x18\x07 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x0b\x63ompletedAt\x12\x14\n\x05\x65rror\x18\x08 \x01(\tR\x05\x65rror\"d\n\x16GetByExternalIdRequest\x12\'\n\x0b\x65xternal_id\x18\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x01R\nexternalId\x12!\n\x0cinclude_bots\x18\x02 \x01(\x08R\x0bincludeBots\"P\n\x17GetByExternalIdResponse\x12\x35\n\x07profile\x18\x01 \x01(\x0b\x32\x1b.shared.profiles.v1.ProfileR\x07profile\"G\n\nGetRequest\x12\x16\n\x02id\x18\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x01R\x02id\x12!\n\x0cinclude_bots\x18\x02 \x01(\x08R\x0bincludeBots\"D\n\x0bGetResponse\x12\x35\n\x07profile\x18\x01 \x01(\x0b\x32\x1b.shared.profiles.v1.ProfileR\x07profile\"\x84\x01\n\x0b\x46ilterGroup\x12=\n\x07\x66ilters\x18\x01 \x03(\x0b\x32\x19.common.v1.PropertyFilterB\x08\xbaH\x05\x92\x01\x02\x08\x01R\x07\x66ilters\x12\x36\n\x08operator\x18\x02 \x01(\x0e\x32\x1a.common.v1.LogicalOperatorR\x08operator\"\xaa\x02\n\x0bListRequest\x12\x1d\n\npage_token\x18\x01 \x01(\tR\tpageToken\x12\x44\n\rfilter_groups\x18\x02 \x03(\x0b\x32\x1f.shared.profiles.v1.FilterGroupR\x0c\x66ilterGroups\x12P\n\x16\x66ilter_groups_operator\x18\x03 \x01(\x0e\x32\x1a.common.v1.LogicalOperatorR\x14\x66ilterGroupsOperator\x12!\n\x0cinclude_bots\x18\x04 \x01(\x08R\x0bincludeBots\x12\x41\n\x04sort\x18\x05 \x01(\x0e\x32#.shared.profiles.v1.ProfileListSortB\x08\xbaH\x05\x82\x01\x02\x10\x01R\x04sort\"o\n\x0cListResponse\x12\x37\n\x08profiles\x18\x01 \x03(\x0b\x32\x1b.shared.profiles.v1.ProfileR\x08profiles\x12&\n\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"\xcb\x03\n\x16ProfileActivitySummary\x12\x39\n\nfirst_seen\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\tfirstSeen\x12\x37\n\tlast_seen\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\x08lastSeen\x12!\n\x0ctotal_events\x18\x03 \x01(\x03R\x0btotalEvents\x12\x1c\n\tpageviews\x18\x04 \x01(\x03R\tpageviews\x12\x1a\n\x08sessions\x18\x05 \x01(\x03R\x08sessions\x12\x18\n\x07\x62rowser\x18\x06 \x01(\tR\x07\x62rowser\x12\'\n\x0f\x62rowser_version\x18\x07 \x01(\tR\x0e\x62rowserVersion\x12\x0e\n\x02os\x18\x08 \x01(\tR\x02os\x12\x1d\n\nos_version\x18\t \x01(\tR\tosVersion\x12\x16\n\x06\x64\x65vice\x18\n \x01(\tR\x06\x64\x65vice\x12\x18\n\x07\x63ountry\x18\x0b \x01(\tR\x07\x63ountry\x12\x16\n\x06region\x18\x0c \x01(\tR\x06region\x12\x12\n\x04\x63ity\x18\r \x01(\tR\x04\x63ity\x12\x10\n\x03\x62ot\x18\x0e \x01(\x08R\x03\x62ot\"\xd4\x02\n\x07Profile\x12;\n\x0b\x63reate_time\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\ncreateTime\x12\x1f\n\x0b\x65xternal_id\x18\x02 \x01(\tR\nexternalId\x12\x0e\n\x02id\x18\x03 \x01(\tR\x02id\x12\x37\n\nproperties\x18\x04 \x01(\x0b\x32\x17.google.protobuf.StructR\nproperties\x12\x1d\n\nproject_id\x18\x05 \x01(\tR\tprojectId\x12;\n\x0bupdate_time\x18\x06 \x01(\x0b\x32\x1a.google.protobuf.TimestampR\nupdateTime\x12\x46\n\x08\x61\x63tivity\x18\x07 \x01(\x0b\x32*.shared.profiles.v1.ProfileActivitySummaryR\x08\x61\x63tivity*\xe4\x01\n\x17\x43omplianceRequestStatus\x12)\n%COMPLIANCE_REQUEST_STATUS_UNSPECIFIED\x10\x00\x12%\n!COMPLIANCE_REQUEST_STATUS_PENDING\x10\x01\x12(\n$COMPLIANCE_REQUEST_STATUS_PROCESSING\x10\x02\x12\'\n#COMPLIANCE_REQUEST_STATUS_COMPLETED\x10\x03\x12$\n COMPLIANCE_REQUEST_STATUS_FAILED\x10\x04*\x9a\x01\n\x0fProfileListSort\x12!\n\x1dPROFILE_LIST_SORT_UNSPECIFIED\x10\x00\x12!\n\x1dPROFILE_LIST_SORT_CREATE_TIME\x10\x01\x12 \n\x1cPROFILE_LIST_SORT_FIRST_SEEN\x10\x02\x12\x1f\n\x1bPROFILE_LIST_SORT_LAST_SEEN\x10\x03\x32\xd6\x04\n\x0fProfilesService\x12H\n\x03Get\x12\x1e.shared.profiles.v1.GetRequest\x1a\x1f.shared.profiles.v1.GetResponse\"\x00\x12l\n\x0fGetByExternalId\x12*.shared.profiles.v1.GetByExternalIdRequest\x1a+.shared.profiles.v1.GetByExternalIdResponse\"\x00\x12M\n\x04List\x12\x1f.shared.profiles.v1.ListRequest\x1a .shared.profiles.v1.ListResponse\"\x00\x30\x01\x12Q\n\x06\x44\x65lete\x12!.shared.profiles.v1.DeleteRequest\x1a\".shared.profiles.v1.DeleteResponse\"\x00\x12r\n\x11\x44\x65leteDataSubject\x12,.shared.profiles.v1.DeleteDataSubjectRequest\x1a-.shared.profiles.v1.DeleteDataSubjectResponse\"\x00\x12u\n\x12GetDeletionRequest\x12-.shared.profiles.v1.GetDeletionRequestRequest\x1a..shared.profiles.v1.GetDeletionRequestResponse\"\x00\x42\xe5\x01\n\x16\x63om.shared.profiles.v1B\rProfilesProtoP\x01ZFgithub.com/pug-sh/pug/internal/gen/proto/shared/profiles/v1;profilesv1\xa2\x02\x03SPX\xaa\x02\x12Shared.Profiles.V1\xca\x02\x12Shared\\Profiles\\V1\xe2\x02\x1eShared\\Profiles\\V1\\GPBMetadata\xea\x02 Pug::Proto::Shared::Profiles::V1b\x08\x65\x64itionsp\xe8\x07"
 
 pool = ::Google::Protobuf::DescriptorPool.generated_pool
 pool.add_serialized_file(descriptor_data)
@@ -36,6 +36,7 @@ module Pug
           ProfileActivitySummary = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("shared.profiles.v1.ProfileActivitySummary").msgclass
           Profile = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("shared.profiles.v1.Profile").msgclass
           ComplianceRequestStatus = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("shared.profiles.v1.ComplianceRequestStatus").enummodule
+          ProfileListSort = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("shared.profiles.v1.ProfileListSort").enummodule
         end
       end
     end

data/lib/pug/rpc.rb

@@ -17,6 +17,8 @@ module Pug
                      EventsV1::BatchCreateResponse],
       identify: ["sdk.profiles.v1.ProfilesSDKService/Identify", SdkProfilesV1::IdentifyRequest,
                  SdkProfilesV1::IdentifyResponse],
+      batch_identify: ["sdk.profiles.v1.ProfilesSDKService/BatchIdentify", SdkProfilesV1::BatchIdentifyRequest,
+                       SdkProfilesV1::BatchIdentifyResponse],
       profiles_get: ["shared.profiles.v1.ProfilesService/Get", ProfilesV1::GetRequest, ProfilesV1::GetResponse],
       profiles_get_by_external_id: ["shared.profiles.v1.ProfilesService/GetByExternalId",
                                     ProfilesV1::GetByExternalIdRequest, ProfilesV1::GetByExternalIdResponse],

data/lib/pug/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pug-sh
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - pug.sh
@@ -117,6 +117,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.21
 specification_version: 4
-summary: Pug server-side SDK for Ruby — event tracking, profile identify, and analytics
-  reads.
+summary: 'Pug server-side SDK for Ruby: event tracking, profile identify, and analytics
+  reads.'
 test_files: []