cable_room 0.7.0.beta2 → 0.8.0.beta1

data/lib/cable_room/placement.rb

@@ -1,260 +0,0 @@
-require 'concurrent'
-require 'active_support/inflector'
-
-module CableRoom
-  # The host side of provisioning. A `create: true` membership publishes a provision request on
-  # `Bus.provision_channel`; every Host runs one Placement, which hears every request and decides
-  # whether this host should be the one to start the room.
-  #
-  # The decision is a race weighted by load. Each host waits `provision_delay_ms` for every room
-  # it already runs (plus up to one room's worth of jitter, to break ties), then tries to take the
-  # room's Redlock through `Host#ensure_room`. The lightest host wakes first and usually wins;
-  # everyone else finds the lock held and does nothing. A host that is draining or shut down never
-  # claims. The same code runs in :inline and :remote — the only difference is which process the
-  # Host lives in.
-  #
-  # Requests arrive on the Bus subscriber thread, which must stay quick, so `handle` only checks
-  # and schedules; the wait and the claim run later on the Host's worker pool via a timer. That way
-  # a long wait never blocks other Bus traffic, and a slow room startup never blocks another claim.
-  #
-  # Specs make the race deterministic by passing `jitter: -> { 0 }` (or any callable returning
-  # 0..1) and a small `provision_delay_ms`; `delay_for(load)` is the only place the numbers meet.
-  class Placement
-    # Raised (and reported, never propagated) for a request this host can't act on: not a hash, an
-    # unknown room class, a class that isn't a Room, or a key that won't deserialize.
-    class InvalidRequest < ArgumentError; end
-
-    REQUEST_TYPE = "provision".freeze
-
-    attr_reader :host, :channel
-
-    # `jitter` returns a Float in 0..1 (defaults to `rand`); `executor` is where the claim runs
-    # (defaults to the Host's worker pool); `config` defaults to `CableRoom.config`.
-    def initialize(host, jitter: nil, executor: nil, config: nil)
-      @host = host
-      @jitter = jitter || -> { Kernel.rand }
-      @executor = executor
-      @config = config
-      @channel = Bus.provision_channel
-
-      @mutex = Mutex.new
-      @idle = ConditionVariable.new
-      @pending = {} # room identity => the scheduled claim, so one host never queues two claims for one room
-      @running = false # subscribed to the channel
-      @stopped = false # `stop` was called; no claim may go through until `start` again
-      @handle = nil
-    end
-
-    # Subscribe to the provision channel on the Host's inbound transport. Blocks until the Bus
-    # confirms, so a request published after this returns is heard. Calling it again while running
-    # re-subscribes (harmless; the Bus replaces the handler), which lets a Host re-arm its listener.
-    def start
-      @mutex.synchronize do
-        @running = true
-        @stopped = false
-      end
-      @handle = host.inbound.subscribe(channel) { |request| handle(request) }
-      self
-    end
-
-    # Stop hearing requests and drop every claim still waiting on its timer. Waits (up to `wait`
-    # seconds) for a claim that is already mid-attempt to finish, so nothing starts a room after
-    # this returns. The unsubscribe blocks until Redis confirms it, which doubles as a barrier: a
-    # request published before the stop has either been handled or is gone for good.
-    def stop(wait: 5)
-      was_running, handle = @mutex.synchronize do
-        @stopped = true
-        [@running, @handle].tap do
-          @running = false
-          @handle = nil
-        end
-      end
-
-      host.inbound.unsubscribe(channel, handle) if was_running
-
-      # A cancelled timer never runs its block (and so never runs the `finish` in it), so forget
-      # it here. A claim that already started keeps its entry until it finishes; wait for those.
-      tasks = @mutex.synchronize { @pending.to_a }
-      tasks.each { |room_id, task| finish(room_id) if task.cancel }
-      wait_idle(timeout: wait)
-      self
-    end
-
-    def running?
-      @mutex.synchronize { @running }
-    end
-
-    def stopped?
-      @mutex.synchronize { @stopped }
-    end
-
-    # How many claims are waiting on their timer or mid-attempt right now.
-    def pending_count
-      @mutex.synchronize { @pending.size }
-    end
-
-    def idle?
-      pending_count.zero?
-    end
-
-    # Block until every scheduled claim has finished (won, lost, or been cancelled). Returns true,
-    # or false if `timeout` passes first. Specs use this to observe a losing host give up.
-    def wait_idle(timeout: 5)
-      deadline = monotonic_now + timeout
-      @mutex.synchronize do
-        until @pending.empty?
-          remaining = deadline - monotonic_now
-          return false if remaining <= 0
-          @idle.wait(@mutex, remaining)
-        end
-      end
-      true
-    end
-
-    # One request off the Bus. Runs on the subscriber thread, so it does only the cheap checks
-    # (is this a room we know, do we already run it, are we allowed to claim) and then schedules
-    # the delayed claim. Returns the scheduled task, or nil when there is nothing to do.
-    def handle(request)
-      room_class, room_key = parse(request)
-      room_id = room_class.room_port_key(room_key)
-
-      return skip(room_id, "placement is stopped") if stopped?
-      return skip(room_id, "host is shutting down") if host.shutdown?
-      return skip(room_id, "host is draining") if host.draining?
-      return skip(room_id, "already running here") if running_here?(room_id)
-
-      load = host.open_rooms_count
-      delay = delay_for(load)
-
-      # A handoff request gets a claim of its own even while a member's plain request for the
-      # same room is pending: the plain claim may have lost the lock to the old host moments
-      # before it let go, and the handoff must not be skipped for it. The lock keeps them safe.
-      pending_key = request["handoff"] == true ? "#{room_id} (handoff)" : room_id
-
-      @mutex.synchronize do
-        return skip(room_id, "a claim is already pending here") if @pending.key?(pending_key)
-
-        task = Concurrent::ScheduledTask.new(delay, executor: executor) do
-          begin
-            claim(room_class, room_key, room_id, request, delay: delay, load: load)
-          ensure
-            finish(pending_key)
-          end
-        end
-        @pending[pending_key] = task
-        task.execute
-      end
-    rescue InvalidRequest => e
-      CableRoom.report_error(e, placement: self, request: request)
-      nil
-    end
-
-    # Seconds to wait before racing for a room, given how many rooms this host already runs:
-    # `provision_delay_ms × (load + jitter)`, jitter in 0..1. A host with more rooms always waits
-    # longer than one with fewer, and the jitter only decides the order between hosts with the same
-    # load. A host running nothing waits at most one `provision_delay_ms`.
-    def delay_for(load)
-      base = config.provision_delay_ms / 1000.0
-      base * (load + @jitter.call.to_f)
-    end
-
-    private
-
-    # The claim itself, after the delay, on the worker pool. Re-checks the cheap conditions first,
-    # since the world may have moved while we waited, then races for the Redlock. Losing is
-    # normal — it means a lighter host got there first — so it's only a debug line.
-    def claim(room_class, room_key, room_id, request, delay:, load:)
-      return if stopped?
-      return if host.shutdown? || host.draining?
-      return if running_here?(room_id)
-
-      payload = {
-        host: host,
-        room_class: room_class,
-        room_key: room_key,
-        delay: delay,
-        open_rooms: load,
-        request: request,
-      }
-
-      claimed = ActiveSupport::Notifications.instrument("provision_claimed.cable_room", payload) do |notification|
-        # `handoff: true` (with a `reason`) is a draining host offering a room to its peers. The
-        # race is the same — the lock decides — but the winner rebuilds the room from the offered
-        # snapshot and replays what the old host relayed instead of starting it from scratch (see
-        # CableRoom::Migration.adopt). A plain request starts the room fresh. A handoff request
-        # carries no `tenant` of its own -- the snapshot it adopts from carries it instead (see
-        # Room::Snapshotting#_snapshot), so `ensure_room` only needs it for the fresh-start path.
-        handoff = request["handoff"] == true
-        notification[:handoff] = handoff
-        notification[:claimed] = host.ensure_room(room_class, room_key, handoff_only: handoff, tenant: request["tenant"])
-      end
-
-      if claimed
-        logger.info "Claimed #{room_id} after #{(delay * 1000).round}ms with #{load} room(s) open"
-      else
-        logger.debug "Lost the race for #{room_id}: another host holds its lock"
-      end
-    rescue => e
-      logger.error "Failed to claim #{room_id}: #{e.class}: #{e.message}"
-      CableRoom.report_error(e, placement: self, room_class: room_class, room_key: room_key, request: request)
-    end
-
-    def finish(room_id)
-      @mutex.synchronize do
-        @pending.delete(room_id)
-        @idle.broadcast if @pending.empty?
-      end
-    end
-
-    def skip(room_id, why)
-      logger.debug "Ignoring provision request for #{room_id}: #{why}"
-      nil
-    end
-
-    def running_here?(room_id)
-      host.runners.any? { |runner| runner.room_class.room_port_key(runner.key) == room_id }
-    end
-
-    # Turn a decoded Bus message into a Room class and a key. Only `Room::Base` descendants may be
-    # provisioned: the class name comes off the wire, and `constantize` on an arbitrary string is
-    # not something a request should be able to do.
-    def parse(request)
-      raise InvalidRequest, "provision request must be a Hash (got #{request.class})" unless request.is_a?(Hash)
-
-      type = request["type"]
-      raise InvalidRequest, "expected a #{REQUEST_TYPE.inspect} request (got #{type.inspect})" unless type == REQUEST_TYPE
-
-      name = request["room_class"]
-      klass = name.is_a?(String) ? ActiveSupport::Inflector.safe_constantize(name) : nil
-      unless klass.is_a?(Class) && klass < Room::Base
-        raise InvalidRequest, "#{name.inspect} is not a CableRoom::Room::Base subclass"
-      end
-
-      [klass, deserialize_key(request["room_key"])]
-    end
-
-    # Keys travel the way `extra` does (ActiveJob's argument serializer), so a record key comes
-    # back as the record and a string comes back as a string.
-    def deserialize_key(serialized)
-      ::ActiveJob::Arguments.deserialize(Array(serialized)).first
-    rescue StandardError => e
-      raise InvalidRequest, "room_key can't be deserialized: #{e.class}: #{e.message}"
-    end
-
-    def executor
-      @executor || host.worker_pool.executor
-    end
-
-    def config
-      @config || CableRoom.config
-    end
-
-    def logger
-      host.logger
-    end
-
-    def monotonic_now
-      Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    end
-  end
-end

data/lib/cable_room/room/snapshotting.rb

@@ -1,82 +0,0 @@
-module CableRoom
-  module Room
-    # The room's side of a migration: turning itself into a CableRoom::Snapshot and coming back
-    # from one. The gem carries what it owns (ports, tags, users, reaper deadlines); a Room can
-    # carry its own state too with two optional hooks:
-    #
-    #   class QuizRoom < CableRoom::Room::Base
-    #     def snapshot_state
-    #       { question_id: @question.id, answers: @answers }   # JSON only; records by id
-    #     end
-    #
-    #     def restore_state(state)
-    #       @question = Question.find(state[:question_id])      # indifferent access: :key or "key"
-    #       @answers = state[:answers]
-    #     end
-    #   end
-    #
-    # A room that defines `restore_state` gets it instead of `startup` when it's restored, with
-    # whatever `snapshot_state` returned (nil if the room that was snapshotted had no
-    # `snapshot_state`). A room without `restore_state` just runs `startup` again and rebuilds its
-    # state the way it did the first time. Either way the `before_startup`/`after_startup`
-    # callbacks run as usual, except that the gem does not broadcast `room_opened`: the members
-    # were there the whole time and never saw the room go away. `restored?` tells a callback which
-    # case it's in.
-    module Snapshotting
-      extend ActiveSupport::Concern
-
-      # True for a room that was rebuilt from a snapshot rather than started fresh.
-      def restored?
-        @_restored == true
-      end
-
-      private
-
-      # Build the snapshot (see CableRoom::Snapshot for the shape). Only meaningful once the room
-      # is frozen: nothing else may be touching its state while this reads it.
-      def _snapshot
-        document = {
-          version: Snapshot::VERSION,
-          room_class: self.class.name,
-          key: Snapshot.serialize_argument(key),
-          # Carried forward so the host that adopts this room (Host#restore_room) gets the same
-          # tenant this one was given at provisioning, instead of falling back to a guess (see
-          # Runner#initialize). nil for a room that was never given one either.
-          tenant: @runner.tenant,
-          port_clients: _snapshot_port_clients,
-          user_state: _snapshot_user_state,
-          reaper_state: _snapshot_reaper_state,
-          app_state: _snapshot_app_state,
-        }
-
-        ActiveSupport::Notifications.instrument("room_snapshotted.cable_room", { room: self }) do
-          Snapshot.round_trip(document)
-        end
-      end
-
-      def _snapshot_app_state
-        return nil unless respond_to?(:snapshot_state, true)
-
-        state = snapshot_state
-        Snapshot.assert_json!(state, room: self)
-        state
-      end
-
-      # Rebuild from `snapshot`: gem state first, quietly (no port_connected or user_joined
-      # callbacks, since none of it is new), then the startup chain with `restore_state` in place
-      # of `startup`. Runs where `_startup` would, before the runner starts the periodic timers.
-      def _restore(snapshot)
-        snapshot = Snapshot.validate!(snapshot)
-        @_restored = true
-
-        _restore_port_clients(snapshot["port_clients"])
-        _restore_user_state(snapshot["user_state"])
-        _restore_reaper_state(snapshot["reaper_state"])
-
-        app_state = snapshot["app_state"]
-        app_state = app_state.with_indifferent_access if app_state.is_a?(Hash)
-        _startup(restoring: true, app_state: app_state)
-      end
-    end
-  end
-end

data/lib/cable_room/room_harness.rb

@@ -1,168 +0,0 @@
-require "cable_room"
-require "active_support/tagged_logging"
-
-module CableRoom
-  # Builds a Room without a Host, a live pubsub subscription, or a Redis lock, so the parts of a
-  # Room that are pure logic (authorization, port scoping, callbacks, reaping) can be tested
-  # directly and synchronously. Anything that needs real message delivery belongs in an e2e spec.
-  #
-  # Not loaded by `require "cable_room"` -- an app (or this gem's own suite) opts in with
-  # `require "cable_room/room_harness"`, typically from spec_helper.
-  #
-  # Stands in for CableRoom::Host::Runner.
-  class StubRoomRunner
-    attr_reader :logger, :state, :shutdown_reason, :watchdog_pings, :tenant
-
-    def initialize(tenant: nil)
-      @logger = ActiveSupport::TaggedLogging.new(Logger.new(IO::NULL))
-      @state = :started
-      @watchdog_pings = 0
-      @timers = []
-      @tenant = tenant
-    end
-
-    def ping_watchdog
-      @watchdog_pings += 1
-    end
-
-    # Record streams rather than subscribing, so startup can run without a live pubsub. There is
-    # nothing to wait for, so `on_live` runs at once.
-    def subscribe(stream, on_live: nil, &blk)
-      streams[stream] = blk
-      on_live&.call
-    end
-
-    def unsubscribe(stream)
-      streams.delete(stream)
-    end
-
-    def streams
-      @streams ||= {}
-    end
-
-    # Feed a message to whatever the room streamed from this port, the way pubsub would
-    def deliver_to_stream(stream, message)
-      streams.fetch(stream).call(message)
-    end
-
-    def initiate_shutdown(reason)
-      @shutdown_reason = reason
-      @state = :shutting_down
-    end
-
-    def stop!
-      @state = :dead
-    end
-
-    # Run inline so specs stay synchronous
-    def post_work(**_kwargs, &blk)
-      blk.call
-    end
-
-    # Record timers rather than scheduling them, so specs can fire them on demand
-    def start_periodic_timer(callback, every:)
-      timer = StubTimer.new(callback, every)
-      @timers << timer
-      timer
-    end
-
-    def timers
-      @timers.reject(&:shutdown?)
-    end
-
-    class StubTimer
-      attr_reader :interval
-
-      def initialize(callback, interval)
-        @callback = callback
-        @interval = interval
-        @shutdown = false
-      end
-
-      def fire!
-        @callback.call
-      end
-
-      def shutdown
-        @shutdown = true
-      end
-
-      def shutdown?
-        @shutdown
-      end
-    end
-  end
-
-  module RoomHarness
-    # A fully-initialized Room backed by a StubRoomRunner. Pass `started: true` to run the
-    # startup callbacks (which is what registers reaper timers and the inbound stream). Pass
-    # `tenant:` the way a member's provision request would (see RoomMembership#initialize) for a
-    # Room whose logic needs Apartment scoped correctly -- this switches into it for the duration
-    # of startup, the way PandaPal's ActionCable::Server::Worker hook does in production for a
-    # real Runner, so a Room can't tell the difference from here.
-    def build_room(room_class, key: "harness-key", started: false, tenant: nil)
-      runner = StubRoomRunner.new(tenant: tenant)
-      room = room_class.allocate
-      room.send(:initialize, runner, key)
-      runner.define_singleton_method(:room) { room }
-      with_room_tenant(runner) { room.send(:_startup) } if started
-      room
-    end
-
-    # A Room rebuilt from `snapshot` on a fresh StubRoomRunner, the way Host#restore_room would
-    # build it: gem state restored, then the startup chain with `restore_state` in place of
-    # `startup`. Pass the class explicitly so a spec reads as "restore a FooRoom", even though the
-    # snapshot names it too. `tenant` comes off the snapshot itself, same as Host#restore_room.
-    def restore_room(room_class, snapshot)
-      runner = StubRoomRunner.new(tenant: snapshot["tenant"])
-      room = room_class.allocate
-      room.send(:initialize, runner, Snapshot.key_for(snapshot))
-      runner.define_singleton_method(:room) { room }
-      with_room_tenant(runner) { room.send(:_restore, snapshot) }
-      room
-    end
-
-    def stub_runner_for(room)
-      room.instance_variable_get(:@runner)
-    end
-
-    # Push a message through the same callback chain the real stream handler uses.
-    # Returns false when authorization halted the chain, otherwise :handled.
-    def deliver(room, message)
-      message = message.deep_stringify_keys if message.is_a?(Hash)
-      Room.current_message = message
-      with_room_tenant(stub_runner_for(room)) do
-        room.send(:run_callbacks, :receive_message) do
-          room.send(:handle_received_message, message)
-          :handled
-        end
-      end
-    ensure
-      Room.current_message = nil
-    end
-
-    # Register a port on the room the way a real RoomMembership would, returning its token.
-    def connect_port(room, token: SecureRandom.hex(16), tags: [], as: nil)
-      message = { type: 'port_connected', mtok: token, tags: tags }
-      message[:extra] = ::ActiveJob::Arguments.serialize([{ as: as }]) if as
-      deliver(room, message)
-      token
-    end
-
-    def port_client(room, token)
-      room.send(:resolve_client_port, token)
-    end
-
-    private
-
-    # Stands in for PandaPal's ActionCable::Server::Worker hook, which is what actually switches
-    # Apartment before a Host thread's DB calls in production. A Room without a `tenant` (a
-    # single-tenant app, or a spec that doesn't need one) gets no-op behavior; the gem itself
-    # stays Apartment-optional either way.
-    def with_room_tenant(runner, &blk)
-      return blk.call unless runner.tenant && defined?(Apartment)
-
-      Apartment::Tenant.switch(runner.tenant, &blk)
-    end
-  end
-end

data/lib/cable_room/snapshot.rb

@@ -1,136 +0,0 @@
-module CableRoom
-  # The gem-owned picture of a running room, as one JSON document, so a room can be rebuilt on
-  # another host with its members none the wiser. `take` produces it from a frozen room (see
-  # Host::Runner#freeze!); `Host#restore_room` consumes it. Version 1 looks like this (string
-  # keys, because it has been through JSON):
-  #
-  #   {
-  #     "version"      => 1,
-  #     "room_class"   => "QuizRoom",
-  #     "key"          => <room key>,                # ActiveJob-serialized, so a record key travels as a GlobalID
-  #     "port_clients" => [
-  #       {
-  #         "token"        => "3f9a...",
-  #         "tags"         => ["admin"],
-  #         "as"           => <user or nil>,         # ActiveJob-serialized (GlobalID for records)
-  #         "last_seen_at" => "2026-08-27T18:02:11.123456Z",
-  #         "metadata"     => { ... }                # everything else on the PortClient: what `extra:`
-  #       }                                          # merged in, plus anything the room set on it
-  #     ],
-  #     "user_state"   => [{ "user" => <user>, "port_tokens" => ["3f9a..."] }],
-  #     "reaper_state" => [{ "key" => "idle", "index" => 0, "last_keep_at" => "<ISO8601>" | nil }],
-  #     "app_state"    => <whatever the Room's snapshot_state returned, or nil>
-  #   }
-  #
-  # `reaper_state` carries wall-clock times, not remaining durations, so a room restored on
-  # another host keeps the same deadline it had. `app_state` has to be JSON: plain hashes,
-  # arrays, strings, numbers, booleans, and nil. We check that here, at snapshot time, because a
-  # value that JSON would quietly turn into something else (a Time into a string, a record into
-  # its attributes) is a bug that would otherwise only show up in `restore_state` on some other
-  # machine.
-  module Snapshot
-    VERSION = 1
-
-    class Error < StandardError; end
-
-    # `snapshot_state` returned something JSON can't carry faithfully.
-    class NotSerializable < Error; end
-
-    # The snapshot was written by a gem version this one doesn't understand.
-    class UnknownVersion < Error; end
-
-    # The snapshot doesn't name a room class this process knows.
-    class UnknownRoomClass < Error; end
-
-    class << self
-      # The snapshot of `room`, already round-tripped through JSON, so what you get back is
-      # exactly what a restore will see after a trip through Redis.
-      def take(room)
-        room.send(:_snapshot)
-      end
-
-      # Check a snapshot before anything is built from it. Returns the snapshot with string keys,
-      # so callers can read it the same way whether it came straight from `take` or from Redis.
-      def validate!(snapshot)
-        snapshot = snapshot.to_h.deep_stringify_keys
-        version = snapshot["version"]
-        unless version == VERSION
-          raise UnknownVersion, "Snapshot version #{version.inspect} isn't supported (this gem writes version #{VERSION})"
-        end
-
-        snapshot
-      end
-
-      def room_class_for(snapshot)
-        name = snapshot["room_class"]
-        klass = name.to_s.safe_constantize
-        unless klass.is_a?(Class) && klass <= Room::Base
-          raise UnknownRoomClass, "Snapshot names #{name.inspect}, which isn't a CableRoom::Room::Base subclass here"
-        end
-        klass
-      end
-
-      def key_for(snapshot)
-        deserialize_argument(snapshot["key"])
-      end
-
-      # Encode and decode the whole document, so the result is the post-JSON shape (string keys,
-      # ISO8601 times) rather than the Ruby objects the room held.
-      def round_trip(document)
-        ActiveSupport::JSON.decode(ActiveSupport::JSON.encode(document))
-      end
-
-      # Walk `value` and raise NotSerializable at the first thing JSON can't carry unchanged. Hash
-      # keys may be symbols (they come back as strings, and restore_state gets an indifferent-access
-      # hash); symbol *values* are refused because they'd come back as plain strings.
-      def assert_json!(value, room:, path: "app_state")
-        case value
-        when nil, true, false, String, Integer
-          nil
-        when Float
-          raise_not_serializable(room, path, "#{value} isn't a finite number") unless value.finite?
-        when Hash
-          value.each do |k, v|
-            unless k.is_a?(String) || k.is_a?(Symbol)
-              raise_not_serializable(room, path, "has a #{k.class} key (#{k.inspect}); JSON object keys must be strings")
-            end
-            assert_json!(v, room: room, path: "#{path}[#{k.inspect}]")
-          end
-        when Array
-          value.each_with_index { |v, i| assert_json!(v, room: room, path: "#{path}[#{i}]") }
-        when Symbol
-          raise_not_serializable(room, path, "is the Symbol #{value.inspect}; JSON has no symbols, so restore_state would get a String back. Use a string")
-        else
-          raise_not_serializable(room, path, "is a #{value.class}, which JSON can't carry. Reduce it to hashes, arrays, strings, numbers, booleans, and nil (records by id)")
-        end
-      end
-
-      # Room keys and users go through the same serializer members use on the wire
-      # (RoomMembership#transmit_port_connected), so a record travels as its GlobalID and
-      # strings, numbers, and symbols come back as themselves.
-      def serialize_argument(value)
-        ::ActiveJob::Arguments.serialize([value]).first
-      end
-
-      def deserialize_argument(value)
-        ::ActiveJob::Arguments.deserialize([value]).first
-      end
-
-      def encode_time(time)
-        time&.getutc&.iso8601(6)
-      end
-
-      def decode_time(value)
-        return nil if value.blank?
-        value.is_a?(Time) ? value : Time.iso8601(value)
-      end
-
-      private
-
-      def raise_not_serializable(room, path, detail)
-        raise NotSerializable,
-          "#{room.class.name}[#{room.key.inspect}]: snapshot_state returned something that isn't JSON: #{path} #{detail}"
-      end
-    end
-  end
-end