where_is_waldo 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b49938f0c49191db60463517da2d41115da11af0f7bb1c62f27065bb4598afc5
-  data.tar.gz: a247e74c4c86bb2e3188ad1f6b1b057d890b5daba01442ae0b2fd4b25786b60a
+  metadata.gz: 29833d47ae21a1aa5a1882e515152ddde9f7201eb9754cff81545495a0cd6d63
+  data.tar.gz: e7d41c790a9abbd4f3bdbd3ced6db38ce335629c189c0bd6404c40ce3874f82d
 SHA512:
-  metadata.gz: 740783e4a9a19df3895bb62f113ff711f2d1815101e086388d604194beec71fe996803de241e0370f5685aa3d07f0ec5f1b4eff90fe654d19dd3f4cf9ac70436
-  data.tar.gz: be170741d609ae6d904c2f29a73637139d71f17bd4d54dfed6a2a8c6c9a3662f0624131c690d5af11a8c6676774bff4c149f9a17134b5bb72080f676c475e7bb
+  metadata.gz: f7634cd0688c8f56bb3292ae1f8c9db9146d1775552afb7f7801a5c898a97ab257bdbb80aa012c3a7ef79bfdd714bce7c1bb9a9c486d859e2f7bff5dd70891cc
+  data.tar.gz: 59335dc215e4666a577294fd9f383cd178102bf1c8f649b0bf30a738ec63be5078e0d541cb3f6d11b6ed9765b561fa45c17665fdc2fb4a8f8df23f59fc486815

data/CHANGELOG.md

@@ -3,6 +3,53 @@
 Notable changes to where_is_waldo. Format loosely follows
 [Keep a Changelog](https://keepachangelog.com/).
 
+## 0.1.4
+
+### Fixed
+
+- **Roster reads now route through the configured adapter.** Previously
+  `Roster.states_for` (which powers `state_for`, `snapshot`, `members_for`,
+  every roster delta) queried the `Presence` ActiveRecord model directly.
+  Under `adapter = :redis`, writes went to Redis but reads hit an empty (or
+  absent) database table — presence dots stayed grey no matter how many
+  heartbeats came in. `Roster` now calls `PresenceService.sessions_for_subjects`
+  which delegates to whichever adapter is configured, so writes and reads
+  share one store on every adapter.
+
+### Added
+
+- `Adapters::Base#sessions_for_subjects(subject_ids, timeout:)` — bulk-read
+  live sessions grouped by subject id, with a correct-but-unoptimized default
+  implementation that fans out over `sessions_for_subject`. `DatabaseAdapter`
+  overrides it with a single bulk query (`Presence.where(subject_col => ids)`
+  + `includes(:subject)`); `RedisAdapter` overrides with per-subject reads
+  filtered by heartbeat threshold. Timeout defaults to `config.timeout`.
+- `PresenceService.sessions_for_subjects` — public delegate so callers stay
+  off the adapter directly.
+- `Configuration#suppress_presence_proc` — callable that decides, per
+  connection, whether to skip presence registration for that subscriber.
+  Receives the ActionCable connection; returns truthy to suppress. A
+  suppressed subscriber still subscribes normally (streams from
+  `where_is_waldo:subject:<id>`, receives broadcasts, can invoke channel
+  actions) — they just don't register a Presence row / heartbeat / roster
+  transition. Use for cases where the WebSocket session is legitimate but
+  shouldn't be counted as "the subject is present" (e.g. support-user
+  impersonation tabs).
+
+  ```ruby
+  config.suppress_presence_proc = ->(connection) {
+    connection.request.session[:su_user].present?
+  }
+  ```
+
+### Changed
+
+- `Roster.aggregate` / `session_level` / `platform` now consume presence
+  hashes (`session[:tab_visible]`, `session[:metadata]`) — matching the
+  shape every adapter already returned — instead of ActiveRecord `Presence`
+  method calls. No behavior change for callers; existing per-device and
+  per-subject aggregation semantics preserved.
+
 ## 0.1.3
 
 ### Fixed

data/README.md

@@ -120,6 +120,16 @@ WhereIsWaldo.configure do |config|
   config.roster_org = ->(user) { user.account }
   config.roster_members = ->(org) { org.users.active }
 
+  # Optional: skip presence registration for specific connections while
+  # keeping them subscribed for broadcasts. Return truthy to suppress. The
+  # subscriber still streams from where_is_waldo:subject:<id> and receives
+  # WhereIsWaldo.broadcast_to messages — they just don't count as present.
+  # Typical use: support-user impersonation tabs shouldn't light up as the
+  # impersonated user in teammates' rosters.
+  config.suppress_presence_proc = ->(connection) {
+    connection.request.session[:su_user].present?
+  }
+
   # Redis adapter
   # config.redis_client = Redis.new(url: ENV["REDIS_URL"])
 end

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/app/channels/where_is_waldo/presence_channel.rb

@@ -5,6 +5,13 @@ module WhereIsWaldo
     def subscribed
       stream_from subject_stream
 
+      # The subject_stream subscription above is unconditional: even when the
+      # subscriber's presence is suppressed (see suppress_presence_proc), the
+      # tab is a legitimate consumer of WhereIsWaldo.broadcast_to signaling
+      # and shouldn't be cut off from messages just because it doesn't count
+      # as "present."
+      return if presence_suppressed?
+
       register_presence
 
       # Seed the local transition gate, resolve the roster delivery strategy for
@@ -16,6 +23,8 @@ module WhereIsWaldo
     end
 
     def unsubscribed
+      return if presence_suppressed?
+
       WhereIsWaldo.disconnect(session_id: waldo_session_id)
 
       # Recompute the subject's aggregate (they may still be present in another
@@ -24,6 +33,8 @@ module WhereIsWaldo
     end
 
     def heartbeat(data)
+      return if presence_suppressed?
+
       data = data.with_indifferent_access
 
       tab_visible = data[:tab_visible] != false
@@ -48,6 +59,22 @@ module WhereIsWaldo
 
     private
 
+    # Memoized per-subscription. Host apps configure suppress_presence_proc
+    # to gate WHICH subscriptions register presence — e.g. a support-user
+    # impersonation tab is a legitimate WS consumer but shouldn't count as
+    # the impersonated subject being "here." Nil proc → default behavior
+    # (presence always registered).
+    def presence_suppressed?
+      # Ivars are @wiw_-prefixed throughout this channel to avoid clobbering
+      # host-app ActionCable state; keep the prefix over the cop's rename.
+      # rubocop:disable Naming/MemoizedInstanceVariableName
+      return @wiw_presence_suppressed if defined?(@wiw_presence_suppressed)
+
+      proc = WhereIsWaldo.config.suppress_presence_proc
+      @wiw_presence_suppressed = proc ? !!proc.call(connection) : false
+      # rubocop:enable Naming/MemoizedInstanceVariableName
+    end
+
     def register_presence
       WhereIsWaldo.connect(
         session_id: waldo_session_id,

data/app/services/where_is_waldo/adapters/base_adapter.rb

@@ -44,6 +44,25 @@ module WhereIsWaldo
         raise NotImplementedError
       end
 
+      # Get live sessions for many subjects in one call, grouped by subject id.
+      # Subjects with no live sessions are omitted from the returned hash.
+      # Adapters should override for efficiency; this default is a correct but
+      # unoptimized fan-out over `sessions_for_subject`.
+      # @param subject_ids [Array<Integer/String>] Subject identifiers
+      # @param timeout [Integer, nil] Seconds threshold; sessions with
+      #   `last_heartbeat` older than `Time.current - timeout` are excluded
+      # @return [Hash{Integer/String => Array<Hash>}] subject_id => sessions
+      def sessions_for_subjects(subject_ids, timeout: nil)
+        ids = Array(subject_ids).compact.uniq
+        return {} if ids.empty?
+
+        threshold = Time.current - (timeout || default_timeout)
+        ids.each_with_object({}) do |sid, memo|
+          live = sessions_for_subject(sid).select { |s| s[:last_heartbeat] && s[:last_heartbeat] >= threshold }
+          memo[sid] = live if live.any?
+        end
+      end
+
       # Get session status
       # @param session_id [String] Session identifier
       # @return [Hash, nil] Presence record or nil

data/app/services/where_is_waldo/adapters/database_adapter.rb

@@ -77,6 +77,17 @@ module WhereIsWaldo
         scope.map(&:as_presence_hash)
       end
 
+      def sessions_for_subjects(subject_ids, timeout: nil)
+        ids = Array(subject_ids).compact.uniq
+        return {} if ids.empty?
+
+        threshold = (timeout || default_timeout).seconds.ago
+        scope = Presence.where(subject_column => ids).where("last_heartbeat > ?", threshold)
+        scope = scope.includes(:subject) if config.subject_class_constant
+        scope.group_by { |row| row[subject_column] }
+             .transform_values { |rows| rows.map(&:as_presence_hash) }
+      end
+
       def session_status(session_id)
         scope = Presence.where(session_column => session_id)
         scope = scope.includes(:subject) if config.subject_class_constant

data/app/services/where_is_waldo/adapters/redis_adapter.rb

@@ -2,7 +2,9 @@
 
 module WhereIsWaldo
   module Adapters
-    class RedisAdapter < BaseAdapter
+    # Redis backing needs more plumbing (keying, TTLs, pipelines) than the
+    # DB adapter, so it legitimately runs past the default class-length limit.
+    class RedisAdapter < BaseAdapter # rubocop:disable Metrics/ClassLength
       def connect(session_id:, subject_id:, metadata: {})
         now = Time.current.to_i
 
@@ -93,6 +95,23 @@ module WhereIsWaldo
         end
       end
 
+      def sessions_for_subjects(subject_ids, timeout: nil)
+        ids = Array(subject_ids).compact.uniq
+        return {} if ids.empty?
+
+        threshold = Time.current.to_i - (timeout || default_timeout)
+        ids.each_with_object({}) do |sid, memo|
+          session_ids = redis.smembers(subject_sessions_key(sid))
+          live = session_ids.filter_map do |cid|
+            data = get_presence_data(cid)
+            next unless data && data["last_heartbeat"].to_i >= threshold
+
+            build_presence_hash(data)
+          end
+          memo[sid] = live if live.any?
+        end
+      end
+
       def session_status(session_id)
         data = get_presence_data(session_id)
         return nil unless data

data/app/services/where_is_waldo/presence_service.rb

@@ -74,6 +74,15 @@ module WhereIsWaldo
       # @return [Array<Hash>] Presence records
       delegate :sessions_for_subject, to: :adapter
 
+      # Get live sessions for many subjects in one call, grouped by subject id.
+      # Preferred over calling `sessions_for_subject` per id when the caller
+      # already has an id list (e.g. roster aggregation) — adapters can (and do)
+      # implement this as a bulk read.
+      # @param subject_ids [Array<Integer/String>] Subject identifiers
+      # @param timeout [Integer, nil] Seconds threshold (defaults to config.timeout)
+      # @return [Hash{Integer/String => Array<Hash>}] subject_id => sessions
+      delegate :sessions_for_subjects, to: :adapter
+
       # Get status of a specific session
       # @param session_id [String] Session identifier
       # @return [Hash, nil] Presence record or nil

data/app/services/where_is_waldo/roster.rb

@@ -165,25 +165,24 @@ module WhereIsWaldo
 
       private
 
-      # Aggregate state for many subjects in one query, keyed by subject id.
+      # Aggregate state for many subjects in one adapter call, keyed by
+      # subject id. Routes through PresenceService so it matches whichever
+      # adapter is configured — reading Presence directly would only work on
+      # `:database`, but the roster snapshot needs to see whatever the writer
+      # sees under `:redis` too.
       def states_for(subject_ids, timeout: nil)
         ids = Array(subject_ids).compact.uniq
         return {} if ids.empty?
 
-        threshold = (timeout || WhereIsWaldo.config.timeout).seconds.ago
-        subject_col = Presence.subject_column
-
-        rows = Presence.where(subject_col => ids)
-                       .where("last_heartbeat > ?", threshold)
-                       .to_a
-
-        rows.group_by { |row| row[subject_col] }
-            .transform_values { |sessions| aggregate(sessions) }
+        WhereIsWaldo::PresenceService
+          .sessions_for_subjects(ids, timeout: timeout)
+          .transform_values { |sessions| aggregate(sessions) }
       end
 
       # Reduce a subject's live sessions to per-device statuses plus an overall
       # roll-up. Sessions are grouped by platform (so several browser tabs form
       # one "web" status); the overall status is the highest across platforms.
+      # @param sessions [Array<Hash>] presence hashes from the adapter
       # @return [Hash] { status: "active", devices: { "web" => "active", ... } }
       def aggregate(sessions)
         devices = sessions.group_by { |s| platform(s) }
@@ -204,13 +203,13 @@ module WhereIsWaldo
       # a hidden tab / backgrounded app is :background; a visible/foreground
       # session is :active when working, else :idle.
       def session_level(session)
-        return :background unless session.tab_visible
+        return :background unless session[:tab_visible]
 
-        session.subject_active ? :active : :idle
+        session[:subject_active] ? :active : :idle
       end
 
       def platform(session)
-        meta = session.metadata
+        meta = session[:metadata]
         value = meta && (meta["platform"] || meta[:platform])
         (value.presence || DEFAULT_PLATFORM).to_s
       end

data/lib/where_is_waldo/configuration.rb

@@ -32,6 +32,23 @@ module WhereIsWaldo
     # :authenticate_proc - proc to authenticate connection, receives request
     attr_accessor :channel_name, :authenticate_proc
 
+    # :suppress_presence_proc - callable that decides, per connection, whether
+    #   to SKIP presence registration for that subscriber. Receives the
+    #   ActionCable connection (host apps can read session/cookies/env off it,
+    #   e.g. via `connection.request`). Returns truthy to suppress.
+    #
+    # A suppressed subscriber still subscribes normally — they receive
+    # broadcasts to `where_is_waldo:subject:<id>` (WhereIsWaldo.broadcast_to*
+    # signaling) and any other Waldo capability — they just don't register a
+    # Presence row / heartbeat / roster transition. Use for cases where the
+    # WebSocket session is legitimate but shouldn't be counted as "the subject
+    # is present", e.g. support-user impersonation tabs.
+    #
+    #   config.suppress_presence_proc = ->(connection) {
+    #     connection.request.session[:su_user].present?
+    #   }
+    attr_accessor :suppress_presence_proc
+
     # Default audience resolver for the Broadcastable concern. A lambda that,
     # given a record, returns the AR scope to broadcast to (e.g. that record's
     # account members). Set once per app to match its container, e.g.:
@@ -106,6 +123,7 @@ module WhereIsWaldo
       # ActionCable defaults
       @channel_name = "WhereIsWaldo::PresenceChannel"
       @authenticate_proc = nil
+      @suppress_presence_proc = nil
 
       # Broadcastable default audience (set per app)
       @broadcast_audience = nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: where_is_waldo
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Scott Gibson