solid_objects 0.14.2 → 0.14.4

data/lib/solid_objects/instrumentation.rb

@@ -6,5 +6,38 @@ module SolidObjects
     def instrument(event, **payload, &block)
       ActiveSupport::Notifications.instrument("solid_objects.#{event}", payload, &block)
     end
+
+    # @rbs (Symbol, **untyped) -> void
+    def instrument_after_commit(event, **payload)
+      instrument(event, **payload)
+    rescue => error
+      report_instrumentation_failure(event, error)
+    end
+
+    private
+
+    # @rbs (Symbol, Exception) -> void
+    def report_instrumentation_failure(event, error)
+      instrument(
+        :"instrumentation.failed",
+        instrumentation_event: "solid_objects.#{event}",
+        error_class: error.class.name
+      )
+    rescue => failure
+      log_instrumentation_failure(event, failure)
+    end
+
+    # @rbs (Symbol, Exception) -> void
+    def log_instrumentation_failure(event, error)
+      SolidObjects.configuration.logger.error(
+        {
+          event: "solid_objects.instrumentation.failed",
+          instrumentation_event: "solid_objects.#{event}",
+          error_class: error.class.name
+        }
+      )
+    rescue
+      nil
+    end
   end
 end

data/lib/solid_objects/serialization.rb

@@ -4,17 +4,26 @@ module SolidObjects
   module Serialization
     MAX_NESTING = 100
 
+    Dumped = Data.define(:value, :byte_size)
+
     class << self
       # @rbs (untyped, ?max_bytes: Integer?) -> untyped
       def dump(value, max_bytes: nil)
+        return normalize(value) unless max_bytes
+
+        dump_with_byte_size(value, max_bytes:).value
+      end
+
+      # @rbs (untyped, ?max_bytes: Integer?) -> Dumped
+      def dump_with_byte_size(value, max_bytes: nil)
         normalized = normalize(value)
-        encoded = JSON.generate(normalized, max_nesting: MAX_NESTING)
+        byte_size = JSON.generate(normalized, max_nesting: MAX_NESTING).bytesize
 
-        if max_bytes && encoded.bytesize > max_bytes
+        if max_bytes && byte_size > max_bytes
           raise PayloadTooLarge, "serialized value exceeds #{max_bytes} bytes"
         end
 
-        normalized
+        Dumped.new(value: normalized, byte_size:)
       rescue JSON::GeneratorError, EncodingError => error
         raise InvalidPayload, error.message
       end
@@ -28,7 +37,14 @@ module SolidObjects
 
       # @rbs (untyped) -> untyped
       def deep_copy(value)
-        JSON.parse(JSON.generate(normalize(value), max_nesting: MAX_NESTING))
+        deep_copy_with_byte_size(value).value
+      end
+
+      # @rbs (untyped) -> Dumped
+      def deep_copy_with_byte_size(value)
+        encoded = JSON.generate(normalize(value), max_nesting: MAX_NESTING)
+
+        Dumped.new(value: JSON.parse(encoded), byte_size: encoded.bytesize)
       rescue JSON::GeneratorError, JSON::ParserError, EncodingError => error
         raise InvalidPayload, error.message
       end
@@ -60,7 +76,11 @@ module SolidObjects
         raise InvalidPayload, "serialized value is nested too deeply" if depth > MAX_NESTING
 
         case value
-        when nil, true, false, String, Integer
+        when nil, true, false, Integer
+          value
+        when String
+          raise InvalidPayload, "strings must hold valid #{value.encoding} bytes" unless value.valid_encoding?
+
           value
         when Float
           raise InvalidPayload, "non-finite numbers are not supported" unless value.finite?
@@ -89,7 +109,7 @@ module SolidObjects
 
       # @rbs (untyped) -> String
       def normalize_key(key)
-        return key if key.is_a?(String)
+        return normalize(key) if key.is_a?(String)
         return key.to_s if key.is_a?(Symbol)
 
         raise InvalidPayload, "JSON object keys must be strings or symbols"

data/lib/solid_objects/state.rb

@@ -52,6 +52,11 @@ module SolidObjects
       Serialization.deep_copy(data)
     end
 
+    # @rbs () -> Serialization::Dumped
+    def to_h_with_byte_size
+      Serialization.deep_copy_with_byte_size(data)
+    end
+
     # @rbs (Symbol | String) -> untyped
     def fetch(name)
       key = name.to_s

data/lib/solid_objects/version.rb

@@ -1,5 +1,5 @@
 # rbs_inline: enabled
 
 module SolidObjects
-  VERSION = "0.14.2"
+  VERSION = "0.14.4"
 end

data/sig/generated/lib/solid_objects/configuration.rbs

@@ -2,7 +2,7 @@
 
 module SolidObjects
   class Configuration
-    @table_name_prefix: String
+    @process_alive_threshold: Float
 
     @shutdown_timeout: Float
 
@@ -60,6 +60,8 @@ module SolidObjects
 
     @transmission_actor_type_resolver: Proc
 
+    @table_name_prefix: String
+
     @polling_interval: Float
 
     @idle_polling_interval: Float
@@ -84,6 +86,8 @@ module SolidObjects
 
     @max_state_bytes: Integer
 
+    @warn_state_bytes: Integer
+
     @max_result_bytes: Integer
 
     @max_attempts: Integer
@@ -94,8 +98,6 @@ module SolidObjects
 
     @process_heartbeat_interval: Float
 
-    @process_alive_threshold: Float
-
     attr_accessor table_name_prefix: untyped
 
     attr_accessor polling_interval: untyped
@@ -122,6 +124,8 @@ module SolidObjects
 
     attr_accessor max_state_bytes: untyped
 
+    attr_accessor warn_state_bytes: untyped
+
     attr_accessor max_result_bytes: untyped
 
     attr_accessor max_attempts: untyped

data/sig/generated/lib/solid_objects/executor.rbs

@@ -24,14 +24,20 @@ module SolidObjects
     # @rbs (MessageContext) -> untyped
     def invoke_actor: (MessageContext) -> untyped
 
-    # @rbs (Hash[String, untyped]) -> void
-    def ensure_query_did_not_mutate_state!: (Hash[String, untyped]) -> void
+    # @rbs (Hash[String, untyped], Hash[String, untyped]) -> void
+    def ensure_query_did_not_mutate_state!: (Hash[String, untyped], Hash[String, untyped]) -> void
 
     # @rbs (Hash[String, untyped], Hash[String, untyped]) -> Hash[String, untyped]
     def changed_observables: (Hash[String, untyped], Hash[String, untyped]) -> Hash[String, untyped]
 
-    # @rbs (untyped, Hash[String, untyped], state_changed: bool) -> void
-    def complete: (untyped, Hash[String, untyped], state_changed: bool) -> void
+    # @rbs (untyped, Hash[String, untyped], state_after: Serialization::Dumped, state_changed: bool) -> void
+    def complete: (untyped, Hash[String, untyped], state_after: Serialization::Dumped, state_changed: bool) -> void
+
+    # @rbs (Integer) -> void
+    def ensure_state_fits!: (Integer) -> void
+
+    # @rbs (Integer) -> void
+    def report_large_state: (Integer) -> void
 
     # @rbs (Array[Actor::CommitActionIntent]) -> void
     def execute_commit_actions: (Array[Actor::CommitActionIntent]) -> void

data/sig/generated/lib/solid_objects/instrumentation.rbs

@@ -4,5 +4,16 @@ module SolidObjects
   module Instrumentation
     # @rbs (Symbol, **untyped) { (Hash[Symbol, untyped]) -> untyped } -> untyped
     def instrument: (Symbol, **untyped) { (Hash[Symbol, untyped]) -> untyped } -> untyped
+
+    # @rbs (Symbol, **untyped) -> void
+    def instrument_after_commit: (Symbol, **untyped) -> void
+
+    private
+
+    # @rbs (Symbol, Exception) -> void
+    def report_instrumentation_failure: (Symbol, Exception) -> void
+
+    # @rbs (Symbol, Exception) -> void
+    def log_instrumentation_failure: (Symbol, Exception) -> void
   end
 end

data/sig/generated/lib/solid_objects/serialization.rbs

@@ -4,15 +4,34 @@ module SolidObjects
   module Serialization
     MAX_NESTING: ::Integer
 
+    class Dumped < Data
+      attr_reader value(): untyped
+
+      attr_reader byte_size(): untyped
+
+      def self.new: (untyped value, untyped byte_size) -> instance
+                  | (value: untyped, byte_size: untyped) -> instance
+
+      def self.members: () -> [ :value, :byte_size ]
+
+      def members: () -> [ :value, :byte_size ]
+    end
+
     # @rbs (untyped, ?max_bytes: Integer?) -> untyped
     def self.dump: (untyped, ?max_bytes: Integer?) -> untyped
 
+    # @rbs (untyped, ?max_bytes: Integer?) -> Dumped
+    def self.dump_with_byte_size: (untyped, ?max_bytes: Integer?) -> Dumped
+
     # @rbs (untyped) -> untyped
     def self.load: (untyped) -> untyped
 
     # @rbs (untyped) -> untyped
     def self.deep_copy: (untyped) -> untyped
 
+    # @rbs (untyped) -> Dumped
+    def self.deep_copy_with_byte_size: (untyped) -> Dumped
+
     # @rbs (untyped) -> untyped
     def self.readonly_copy: (untyped) -> untyped
 

data/sig/generated/lib/solid_objects/state.rbs

@@ -45,6 +45,9 @@ module SolidObjects
     # @rbs () -> Hash[String, untyped]
     def to_h: () -> Hash[String, untyped]
 
+    # @rbs () -> Serialization::Dumped
+    def to_h_with_byte_size: () -> Serialization::Dumped
+
     # @rbs (Symbol | String) -> untyped
     def fetch: (Symbol | String) -> untyped
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solid_objects
 version: !ruby/object:Gem::Version
-  version: 0.14.2
+  version: 0.14.4
 platform: ruby
 authors:
 - Lucas Carlson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-25 00:00:00.000000000 Z
+date: 2026-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actioncable
@@ -323,6 +323,7 @@ files:
 - benchmark/idle_polling.rb
 - benchmark/processing.rb
 - benchmark/query_count.rb
+- benchmark/state_size.rb
 - benchmark/support.rb
 - benchmark/sync_latency.rb
 - config/routes.rb