solid_objects 0.16.1 → 0.17.1

data/lib/solid_objects/payload_broadcast.rb

@@ -2,7 +2,6 @@
 
 module SolidObjects
   class PayloadBroadcast
-    MAXIMUM_PAYLOAD_BYTES = 1_048_576
     REVISION_OBSERVABLE = "solid_objects.revision"
 
     # @rbs @snapshot: ActorSnapshot
@@ -42,7 +41,7 @@ module SolidObjects
     def rendered_payload(handler)
       payload = Serialization.dump(
         evaluated_payload(handler),
-        max_bytes: MAXIMUM_PAYLOAD_BYTES
+        max_bytes: SolidObjects.configuration.max_payload_bytes
       )
       return payload if payload.is_a?(Hash) || payload.is_a?(Array)
 
@@ -56,10 +55,12 @@ module SolidObjects
     # unaffected.
     # @rbs (ActorDefinition::Handler) -> untyped
     def evaluated_payload(handler)
-      actor = snapshot.actor
-      actor.instance_exec(actor, authorization_context, &handler.block)
+      actor = snapshot.build_actor
+      actor.read_projection("payload.#{name}") do
+        actor.instance_exec(actor, authorization_context, &handler.block)
+      end
     rescue NameError => error
-      raise unless class_level_receiver?(error)
+      raise unless class_level_receiver?(error, actor)
 
       raise InvalidPayloadBroadcast,
         "payload broadcast #{name.inspect} called #{error.name.inspect} on the " \
@@ -70,9 +71,9 @@ module SolidObjects
     # Distinguishes a block that relied on the old class-level receiver from an
     # ordinary typo, so the one behaviour change reports itself instead of
     # surfacing as an unexplained NameError.
-    # @rbs (NameError[untyped]) -> bool
-    def class_level_receiver?(error)
-      error.receiver.equal?(snapshot.actor) &&
+    # @rbs (NameError[BasicObject], Actor?) -> bool
+    def class_level_receiver?(error, actor)
+      error.receiver.equal?(actor) &&
         snapshot.actor_class.respond_to?(error.name)
     rescue ArgumentError, NameError
       false

data/lib/solid_objects/reference.rb

@@ -16,6 +16,25 @@ module SolidObjects
       freeze
     end
 
+    # @rbs (?limit: Integer, ?authorization_context: untyped) -> actor_diagnostics
+    def diagnostics(limit: 100, authorization_context: nil)
+      Diagnostics.new(self).summary(limit:, authorization_context:)
+    end
+
+    # @rbs (?authorization_context: untyped) { (portable_event) -> void } -> Proc
+    def observe(authorization_context: nil, &block)
+      Diagnostics.new(self).observe(authorization_context:, &block)
+    end
+
+    # @rbs (String, ?authorization_context: untyped) { (portable_event) -> void } -> Proc
+    def on(name, authorization_context: nil, &block)
+      raise ArgumentError, "an actor observer requires a block" unless block
+
+      observe(authorization_context:) do |event|
+        block.call(event) if event.fetch("name") == "solid_objects.#{name}"
+      end
+    end
+
     # @rbs (?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped) -> OperationDispatcher
     def async(available_at: nil, idempotency_key: nil, authorization_context: nil)
       OperationDispatcher.new(

data/lib/solid_objects/reminder_scheduler.rb

@@ -166,9 +166,14 @@ module SolidObjects
       mailbox.announce(message)
       SolidObjects.instrument(
         :"reminder.enqueued",
+        instance_id: reminder.instance_id,
+        message_id: message.id,
+        attempt: message.attempt_count,
+        lateness_milliseconds: [ (((now || database_adapter.database_now) - reminder.next_run_at) * 1000).round, 0 ].max,
         reminder_id: reminder.id,
         actor_type: reminder.actor_type,
         actor_id: reminder.actor_id,
+        operation: reminder.operation,
         occurrence: reminder.occurrence
       )
       MessageReference.from_message(message)

data/lib/solid_objects/state_snapshot.rb

@@ -10,6 +10,7 @@ module SolidObjects
       actor_snapshot = ActorSnapshot.new(reference)
       @actor_class = actor_snapshot.actor_class
       @data = Serialization.readonly_copy(actor_snapshot.actor.state.to_h)
+      SolidObjects.instrument(:"snapshot.read", actor_type: reference.actor_type, actor_id: reference.actor_id, instance_id: actor_snapshot.instance_id.zero? ? nil : actor_snapshot.instance_id, revision: actor_snapshot.revision)
     end
 
     # @rbs () -> Hash[String, untyped]

data/lib/solid_objects/supervisor.rb

@@ -97,8 +97,7 @@ module SolidObjects
         rescue => error
           SolidObjects.instrument(
             :"supervisor.monitor_failed",
-            error_class: error.class.name,
-            error_message: error.message
+            error_class: error.class.name
           )
         end
         sleep SolidObjects.configuration.supervisor_monitor_interval
@@ -161,8 +160,7 @@ module SolidObjects
           failures += 1
           SolidObjects.instrument(
             :"supervisor.retention_failed",
-            error_class: error.class.name,
-            error_message: error.message
+            error_class: error.class.name
           )
         end
         wait_for_next_retention(failures)
@@ -220,8 +218,7 @@ module SolidObjects
     rescue => error
       SolidObjects.instrument(
         :"supervisor.redrive_failed",
-        error_class: error.class.name,
-        error_message: error.message
+        error_class: error.class.name
       )
       false
     end

data/lib/solid_objects/synchronous_invocation.rb

@@ -78,27 +78,7 @@ module SolidObjects
 
     # @rbs (Message) -> untyped
     def completed_result(message)
-      raise_rejection(message) if message.rejected?
-      if message.dead?
-        raise MessageFailed.new(
-          "actor message failed permanently",
-          message_id: message.id,
-          details: message.error || {}
-        )
-      end
-
-      Serialization.readonly_copy(message.result)
-    end
-
-    # @rbs (Message) -> bot
-    def raise_rejection(message)
-      rejection = message.rejection
-      raise Rejected.new(
-        code: rejection.fetch("code"),
-        message: rejection.fetch("message"),
-        details: rejection.fetch("details"),
-        message_id: message.id
-      )
+      message.result!
     end
 
     # @rbs () -> ProcessRegistry

data/lib/solid_objects/telemetry.rb

@@ -0,0 +1,137 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  module Telemetry
+    FIELDS = %w[
+      activationGeneration activationOwnerId actorId actorType ageMilliseconds attempt broadcastId
+      broadcastWorkers byteCount code commitAction component componentCount count currentIntervalMilliseconds
+      deliveryMode depth durationMilliseconds effectId effectName effectWorkers errorName failureCount
+      generation idlePollingIntervalMilliseconds incarnation instanceId intervalMilliseconds
+      latenessMilliseconds messageId name nextRunAt occurrence operation outboxKind outcome ownerId payload
+      phase pollingIntervalMilliseconds previousIntervalMilliseconds previousRunAt processId processKind
+      reason reminderId reminderSchedulers requestId retryable revision role sequence status thresholdBytes
+      timeoutMilliseconds truncated waitingOn workers
+    ].freeze #: Array[String]
+    ALIASES = {
+      "errorClass" => "errorName",
+      "stateRevision" => "revision",
+      "durationMs" => "durationMilliseconds",
+      "commitActionName" => "commitAction",
+      "payloadName" => "payload"
+    }.freeze #: Hash[String, String]
+
+    class << self
+      # @rbs (Effect | Broadcast) -> void
+      def outbox(record)
+        return unless SolidObjects.configuration.instrumentation || ActiveSupport::Notifications.notifier.listening?("solid_objects.outbox.age")
+
+        instance = record.instance
+        SolidObjects.instrument(
+          :"outbox.age",
+          instance_id: record.instance_id,
+          actor_type: instance.actor_type,
+          actor_id: instance.actor_id,
+          message_id: record.message_id,
+          attempt: record.attempt_count,
+          outbox_kind: record.is_a?(Effect) ? "effect" : "broadcast",
+          age_milliseconds: [ ((SolidObjects.database_adapter.database_now - record.available_at) * 1000).round, 0 ].max,
+          **outbox_identity(record)
+        )
+      rescue
+        nil
+      end
+
+      # @rbs (Symbol, Hash[Symbol, Object]) -> void
+      def emit(name, payload)
+        observer = SolidObjects.configuration.instrumentation
+        return unless observer
+
+        deliver(observer, event(name, payload))
+      rescue
+        nil
+      end
+
+      # @rbs (event_observer, portable_event) -> void
+      def deliver(observer, event)
+        observer.call(event)
+      rescue => error
+        log_delivery_failure(event.fetch("name"), error)
+      end
+
+      # @rbs (Symbol, Hash[Symbol, Object]) -> portable_event
+      def event(name, payload)
+        attributes = safe_attributes(payload)
+        adapter = DatabaseAdapter.family(Record.connection).to_s
+        event_name = "solid_objects.#{name}"
+        labels = { "event" => event_name, "adapter" => adapter, "actorType" => attributes["actorType"].to_s }
+        metrics = [ { "name" => "solid_objects.events", "kind" => "counter", "unit" => "1", "value" => 1, "labels" => labels } ]
+        [
+          [ "durationMilliseconds", "solid_objects.duration", "histogram", "ms" ],
+          [ "latenessMilliseconds", "solid_objects.reminder.lateness", "histogram", "ms" ],
+          [ "ageMilliseconds", "solid_objects.outbox.age", "histogram", "ms" ],
+          [ "depth", "solid_objects.mailbox.depth", "gauge", "1" ]
+        ].each do |field, metric, kind, unit|
+          value = attributes[field]
+          next unless value.is_a?(Numeric) && value.finite?
+
+          metrics << { "name" => metric, "kind" => kind, "unit" => unit, "value" => [ value, 0 ].max, "labels" => labels }
+        end
+        Serialization.readonly_copy(
+          "schemaVersion" => 1,
+          "name" => event_name,
+          "occurredAt" => Time.now.utc.iso8601(3),
+          "adapter" => adapter,
+          "actorType" => attributes["actorType"]&.to_s,
+          "actorId" => attributes["actorId"]&.to_s,
+          "incarnation" => (attributes["incarnation"] || attributes["instanceId"])&.to_s,
+          "revision" => attributes["revision"]&.to_s,
+          "messageId" => attributes["messageId"]&.to_s,
+          "attempt" => attributes.fetch("attempt", 0),
+          "attributes" => attributes,
+          "metrics" => metrics
+        )
+      end
+
+      # @rbs (Hash[Symbol, Object]) -> Hash[String, telemetry_value]
+      def safe_attributes(payload)
+        payload.each_with_object({}) do |(key, value), attributes|
+          value = value.to_s if key == :reason && value.is_a?(Symbol)
+          if %i[previous_interval current_interval].include?(key) && value.is_a?(Numeric)
+            attributes["#{key.to_s.camelize(:lower)}Milliseconds"] = (value * 1000).round
+            next
+          end
+          name = key.to_s.camelize(:lower)
+          name = ALIASES.fetch(name, name)
+          next unless FIELDS.include?(name)
+          next unless value.nil? || value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false
+
+          value = value.camelize(:lower) if name == "waitingOn" && value.is_a?(String)
+          value = value.to_s if !value.nil? && (name.end_with?("Id") || %w[revision sequence generation activationGeneration].include?(name))
+          attributes[name] = value
+        end
+      end
+
+      private
+
+      # @rbs (Effect | Broadcast) -> Hash[Symbol, String | Integer]
+      def outbox_identity(record)
+        return { effect_id: record.effect_id, effect_name: record.name } if record.is_a?(Effect)
+
+        { broadcast_id: record.broadcast_id, revision: record.message.sequence }
+      end
+
+      # @rbs (String, Exception) -> void
+      def log_delivery_failure(event_name, error)
+        SolidObjects.configuration.logger.error(
+          {
+            event: "solid_objects.instrumentation.failed",
+            instrumentation_event: event_name,
+            error_class: error.class.name
+          }
+        )
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/solid_objects/version.rb

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

data/lib/solid_objects/wake_up_adapters/postgresql.rb

@@ -145,8 +145,7 @@ module SolidObjects
           :"wake_up.failed",
           adapter: "postgresql",
           operation: operation.to_s,
-          error_class: error.class.name,
-          error_message: error.message
+          error_class: error.class.name
         )
       end
     end

data/lib/solid_objects/wake_up_adapters/redis.rb

@@ -208,8 +208,7 @@ module SolidObjects
           :"wake_up.failed",
           adapter: "redis",
           operation: operation.to_s,
-          error_class: error.class.name,
-          error_message: error.message
+          error_class: error.class.name
         )
       end
     end

data/lib/solid_objects/worker.rb

@@ -69,8 +69,7 @@ module SolidObjects
       SolidObjects.configuration.logger.error(
         event: "solid_objects.worker.error",
         process_id: process_registry.process_record&.id,
-        error_class: error.class.name,
-        error_message: error.message
+        error_class: error.class.name
       )
       0
     end

data/lib/solid_objects.rb

@@ -16,6 +16,8 @@ require "solid_objects/sync_deadline"
 require "solid_objects/callable_keywords"
 require "solid_objects/configuration"
 require "solid_objects/instrumentation"
+require "solid_objects/telemetry"
+require "solid_objects/diagnostics"
 require "solid_objects/log_subscriber"
 require "solid_objects/serialization"
 require "solid_objects/context"
@@ -67,6 +69,7 @@ require "solid_objects/effect_payload"
 require "solid_objects/effect_recovery_coordinator"
 require "solid_objects/process_heartbeat"
 require "solid_objects/commit_action_registry"
+require "solid_objects/observer_registry"
 require "solid_objects/lease"
 require "solid_objects/lease_renewer"
 # The reminder scheduler and the effect executor enqueue through the mailbox,
@@ -139,6 +142,11 @@ module SolidObjects
       commit_action_registry.register(name, handler)
     end
 
+    # @rbs () -> ObserverRegistry
+    def observer_registry
+      @observer_registry ||= ObserverRegistry.new
+    end
+
     # @rbs () -> Client
     def client
       require "solid_objects/client"
@@ -203,6 +211,8 @@ module SolidObjects
       @caller_process = nil
       @effect_registry = EffectRegistry.new
       @commit_action_registry = CommitActionRegistry.new
+      @observer_registry&.clear
+      @observer_registry = ObserverRegistry.new
       @dead_letters = nil
       @redrives = nil
       @administration = nil

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

@@ -348,6 +348,12 @@ module SolidObjects
     # @rbs () -> void
     def discard_intents: () -> void
 
+    # @rbs () -> Integer
+    def intent_count: () -> Integer
+
+    # @rbs [Result] (String) { () -> Result } -> Result
+    def read_projection: [Result] (String) { () -> Result } -> Result
+
     private
 
     attr_reader effect_intents: untyped
@@ -360,6 +366,9 @@ module SolidObjects
 
     attr_reader outbound_message_intents: untyped
 
+    # @rbs () -> Array[Array[Hash[Symbol, Object]]]
+    def intent_snapshot: () -> Array[Array[Hash[Symbol, Object]]]
+
     # @rbs (String) { () -> untyped } -> untyped
     def guard_application_writes: (String) { () -> untyped } -> untyped
 

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

@@ -7,6 +7,9 @@ module SolidObjects
     # @rbs () -> void
     def subscribed: () -> void
 
+    # @rbs () -> void
+    def unsubscribed: () -> void
+
     private
 
     attr_reader reference: untyped

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

@@ -12,6 +12,8 @@ module SolidObjects
 
     @revision: Integer
 
+    @state_data: Hash[String, json_value]
+
     @observable_values: Hash[String, untyped]?
 
     @observable_value_cache: Hash[String, untyped]
@@ -35,11 +37,14 @@ module SolidObjects
     # @rbs (Symbol | String) -> untyped
     def observable_value: (Symbol | String) -> untyped
 
+    # @rbs () -> Actor
+    def build_actor: () -> Actor
+
     private
 
     attr_reader instance: untyped
 
-    # @rbs () -> Actor
-    def build_actor: () -> Actor
+    # @rbs () -> Hash[String, json_value]
+    def migrated_state: () -> Hash[String, json_value]
   end
 end

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

@@ -16,6 +16,9 @@ module SolidObjects
     # @rbs (MessageReference, timeout: Numeric, ?authorization_context: untyped) -> untyped
     def wait: (MessageReference, timeout: Numeric, ?authorization_context: untyped) -> untyped
 
+    # @rbs (MessageReference, ?authorization_context: untyped) -> Message
+    def read_message: (MessageReference, ?authorization_context: untyped) -> Message
+
     # @rbs (?reference: Reference?, ?request_id: String?, ?idempotency_key: String?, ?authorization_context: untyped) -> MessageReference?
     def find_by: (?reference: Reference?, ?request_id: String?, ?idempotency_key: String?, ?authorization_context: untyped) -> MessageReference?
 

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

@@ -2,7 +2,7 @@
 
 module SolidObjects
   class Configuration
-    @transmission_actor_type_resolver: Proc
+    @reminder_scheduler_count: Integer
 
     @broadcast_worker_count: Integer
 
@@ -36,6 +36,8 @@ module SolidObjects
 
     @table_name_prefix: String
 
+    @transmission_actor_type_resolver: Proc
+
     @administration_identity: Proc
 
     @authorize_transmission: Proc
@@ -64,9 +66,9 @@ module SolidObjects
 
     @logger: untyped
 
-    @connects_to: Hash[Symbol, untyped]?
+    @instrumentation: event_observer?
 
-    @reminder_scheduler_count: Integer
+    @connects_to: Hash[Symbol, untyped]?
 
     @polling_interval: Float
 
@@ -214,6 +216,8 @@ module SolidObjects
 
     attr_accessor transmission_actor_type_resolver: untyped
 
+    attr_accessor instrumentation: event_observer?
+
     # @rbs @additional_components: Array[untyped]
     attr_reader additional_components: untyped
 

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

@@ -0,0 +1,25 @@
+# Generated from lib/solid_objects/diagnostics.rb with RBS::Inline
+
+module SolidObjects
+  class Diagnostics
+    # @rbs @reference: Reference
+    # @rbs (Reference) -> void
+    def initialize: (Reference) -> void
+
+    # @rbs (?limit: Integer, ?authorization_context: untyped) -> actor_diagnostics
+    def summary: (?limit: Integer, ?authorization_context: untyped) -> actor_diagnostics
+
+    # @rbs (?authorization_context: untyped) { (portable_event) -> void } -> Proc
+    def observe: (?authorization_context: untyped) { (portable_event) -> void } -> Proc
+
+    private
+
+    attr_reader reference: Reference
+
+    # @rbs (Symbol, ?authorization_context: untyped) -> void
+    def authorize!: (Symbol, ?authorization_context: untyped) -> void
+
+    # @rbs (Array[Time?], now: Time, limit: Integer) -> diagnostic_summary
+    def summarize: (Array[Time?], now: Time, limit: Integer) -> diagnostic_summary
+  end
+end

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

@@ -7,6 +7,9 @@ module SolidObjects
   class NonRetryableError < Error
   end
 
+  class QueryMutatedState < NonRetryableError
+  end
+
   class UnsupportedDatabase < Error
   end
 

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

@@ -4,6 +4,8 @@ module SolidObjects
   class Executor
     @completion_transaction: untyped
 
+    @started_at: Float
+
     @message: Message
 
     @activation: Activation
@@ -26,8 +28,8 @@ module SolidObjects
     # @rbs (MessageContext) -> untyped
     def invoke_actor: (MessageContext) -> untyped
 
-    # @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, json_value], Hash[String, json_value]) -> void
+    def ensure_query_is_read_only!: (Hash[String, json_value], Hash[String, json_value]) -> void
 
     # @rbs (Hash[String, untyped], Hash[String, untyped]) -> Hash[String, untyped]
     def changed_observables: (Hash[String, untyped], Hash[String, untyped]) -> Hash[String, untyped]
@@ -103,6 +105,12 @@ module SolidObjects
     # @rbs (message: Message, error_details: Hash[String, untyped], now: Time) -> DeadLetter
     def create_dead_letter: (message: Message, error_details: Hash[String, untyped], now: Time) -> DeadLetter
 
+    # @rbs () -> bool
+    def recovery_message?: () -> bool
+
+    # @rbs () -> (Integer | Float)
+    def elapsed_milliseconds: () -> (Integer | Float)
+
     # @rbs () -> Hash[Symbol, untyped]
     def instrumentation_payload: () -> Hash[Symbol, untyped]
   end

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

@@ -28,14 +28,14 @@ module SolidObjects
     # @rbs (id: Integer, request_id: String, actor_type: String, actor_id: String, sequence: Integer) -> void
     def initialize: (id: Integer, request_id: String, actor_type: String, actor_id: String, sequence: Integer) -> void
 
-    # @rbs () -> String
-    def status: () -> String
+    # @rbs (?authorization_context: untyped) -> String
+    def status: (?authorization_context: untyped) -> String
 
-    # @rbs () -> untyped
-    def result: () -> untyped
+    # @rbs (?authorization_context: untyped) -> json_value
+    def result: (?authorization_context: untyped) -> json_value
 
-    # @rbs () -> Outcome
-    def outcome: () -> Outcome
+    # @rbs (?authorization_context: untyped) -> Outcome
+    def outcome: (?authorization_context: untyped) -> Outcome
 
     # @rbs (?timeout: Numeric, ?authorization_context: untyped) -> untyped
     def wait: (?timeout: Numeric, ?authorization_context: untyped) -> untyped

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

@@ -0,0 +1,29 @@
+# Generated from lib/solid_objects/observer_registry.rb with RBS::Inline
+
+module SolidObjects
+  class ObserverRegistry
+    MAXIMUM_OBSERVERS: ::Integer
+
+    @subscriptions: Array[Object]
+
+    @mutex: Mutex
+
+    # @rbs () -> void
+    def initialize: () -> void
+
+    # @rbs () { (ActiveSupport::Notifications::Event) -> void } -> Proc
+    def subscribe: () { (ActiveSupport::Notifications::Event) -> void } -> Proc
+
+    # @rbs () -> void
+    def clear: () -> void
+
+    private
+
+    attr_reader subscriptions: Array[Object]
+
+    attr_reader mutex: Mutex
+
+    # @rbs (Object) -> void
+    def unsubscribe: (Object) -> void
+  end
+end

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

@@ -2,8 +2,6 @@
 
 module SolidObjects
   class PayloadBroadcast
-    MAXIMUM_PAYLOAD_BYTES: ::Integer
-
     REVISION_OBSERVABLE: ::String
 
     @snapshot: ActorSnapshot
@@ -39,8 +37,8 @@ module SolidObjects
     # Distinguishes a block that relied on the old class-level receiver from an
     # ordinary typo, so the one behaviour change reports itself instead of
     # surfacing as an unexplained NameError.
-    # @rbs (NameError[untyped]) -> bool
-    def class_level_receiver?: (NameError[untyped]) -> bool
+    # @rbs (NameError[BasicObject], Actor?) -> bool
+    def class_level_receiver?: (NameError[BasicObject], Actor?) -> bool
 
     # @rbs () -> void
     def authorize!: () -> void

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

@@ -13,6 +13,15 @@ module SolidObjects
     # @rbs (actor_type: String, actor_id: String) -> void
     def initialize: (actor_type: String, actor_id: String) -> void
 
+    # @rbs (?limit: Integer, ?authorization_context: untyped) -> actor_diagnostics
+    def diagnostics: (?limit: Integer, ?authorization_context: untyped) -> actor_diagnostics
+
+    # @rbs (?authorization_context: untyped) { (portable_event) -> void } -> Proc
+    def observe: (?authorization_context: untyped) { (portable_event) -> void } -> Proc
+
+    # @rbs (String, ?authorization_context: untyped) { (portable_event) -> void } -> Proc
+    def on: (String, ?authorization_context: untyped) { (portable_event) -> void } -> Proc
+
     # @rbs (?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped) -> OperationDispatcher
     def async: (?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped) -> OperationDispatcher
 

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

@@ -24,9 +24,6 @@ module SolidObjects
     # @rbs (Message) -> untyped
     def completed_result: (Message) -> untyped
 
-    # @rbs (Message) -> bot
-    def raise_rejection: (Message) -> bot
-
     # @rbs () -> ProcessRegistry
     def process_registry: () -> ProcessRegistry