restate-sdk 0.9.0-aarch64-linux → 0.11.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e2eb5b1db06208811ae8417ecd1239ae9490c99f758a6bee9ed976e7039dec1
-  data.tar.gz: 4fe4be111904001ec7425be6298c2c4d8591164280d38f609a85e2da467d3ebe
+  metadata.gz: e63ec315f5d51fb381c2881bcf59887c4b87759ea862768eb7c19ca1679e126c
+  data.tar.gz: 5e08e3adde55ed23702eb07a4ee39af293aba626f6ade11d1b2397b24eedaa5a
 SHA512:
-  metadata.gz: ad9226b9ae4786d06bb7bd47fcd26ec7c3e75de511b854a78d6f99eb6f8cbd27053ac196bd6a83e70ce7a729da536f8204ce4b0cb0862c44c66cbcf14c355238
-  data.tar.gz: c2de41ab47f9324a9721e21dad91f661268884676c9c276893dc1bb5fe2debba2d74a85a5e894f78455c5eb49037cd66cc97f43803f5f78b07b4576c97483943
+  metadata.gz: fa16f197ba900b69c230c79e29babaa31044c83366a3586387f58f2870b2730129559fa9ed44cea27fb33118e689472f2755dace09f6190f501a434da5294268
+  data.tar.gz: 7b93888914e35d8d4e1cde6d1232030dae6be7d34fef9075afb2c31fdaea71e01ca0e99cfc1d6714758a84152ce08f384e60ea40236ccb682c67bd518360ecd1

data/Cargo.lock

@@ -31,16 +31,14 @@ checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
 name = "bindgen"
-version = "0.69.5"
+version = "0.72.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "271383c67ccabffb7381723dea0672a673f292304fcb45c01cc648c7a8d58088"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
 dependencies = [
  "bitflags",
  "cexpr",
  "clang-sys",
  "itertools 0.12.1",
- "lazy_static",
- "lazycell",
  "proc-macro2",
  "quote",
  "regex",
@@ -278,12 +276,6 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
-[[package]]
-name = "lazycell"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
-
 [[package]]
 name = "libc"
 version = "0.2.183"
@@ -489,18 +481,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.124"
+version = "0.9.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c85c4188462601e2aa1469def389c17228566f82ea72f137ed096f21591bc489"
+checksum = "45ca28513560e56cfb79a62b1fce363c73af170a182024ce880c77ee9429920a"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.124"
+version = "0.9.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "568068db4102230882e6d4ae8de6632e224ca75fe5970f6e026a04e91ed635d3"
+checksum = "ce04b2c55eff3a21aaa623fcc655d94373238e72cac6b3e1a3641ff31649f99a"
 dependencies = [
  "bindgen",
  "lazy_static",
@@ -569,7 +561,7 @@ dependencies = [
 
 [[package]]
 name = "restate_internal"
-version = "0.9.0"
+version = "0.11.0"
 dependencies = [
  "magnus",
  "rb-sys",
@@ -593,9 +585,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-hash"
-version = "1.1.0"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
 
 [[package]]
 name = "rustversion"

data/ext/restate_internal/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "restate_internal"
-version = "0.9.0"
+version = "0.11.0"
 edition = "2021"
 publish = false
 

data/ext/restate_internal/src/lib.rs

@@ -794,6 +794,49 @@ impl RbVM {
             .map_err(core_error_to_magnus)
     }
 
+    // ── Signals ──
+
+    fn sys_signal(&self, signal_name: String) -> Result<u32, Error> {
+        self.vm
+            .borrow_mut()
+            .create_signal_handle(signal_name)
+            .map(Into::into)
+            .map_err(core_error_to_magnus)
+    }
+
+    fn sys_complete_signal_success(
+        &self,
+        target_invocation_id: String,
+        signal_name: String,
+        buffer: RString,
+    ) -> Result<(), Error> {
+        let bytes: Vec<u8> = unsafe { buffer.as_slice().to_vec() };
+        self.vm
+            .borrow_mut()
+            .sys_complete_signal(
+                target_invocation_id,
+                signal_name,
+                NonEmptyValue::Success(bytes.into()),
+            )
+            .map_err(core_error_to_magnus)
+    }
+
+    fn sys_complete_signal_failure(
+        &self,
+        target_invocation_id: String,
+        signal_name: String,
+        failure: &RbFailure,
+    ) -> Result<(), Error> {
+        self.vm
+            .borrow_mut()
+            .sys_complete_signal(
+                target_invocation_id,
+                signal_name,
+                NonEmptyValue::Failure(failure.clone().into()),
+            )
+            .map_err(core_error_to_magnus)
+    }
+
     // ── Cancel invocation ──
 
     fn sys_cancel_invocation(&self, target_invocation_id: String) -> Result<(), Error> {
@@ -1074,6 +1117,15 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
         "sys_cancel_invocation",
         method!(RbVM::sys_cancel_invocation, 1),
     )?;
+    vm_class.define_method("sys_signal", method!(RbVM::sys_signal, 1))?;
+    vm_class.define_method(
+        "sys_complete_signal_success",
+        method!(RbVM::sys_complete_signal_success, 3),
+    )?;
+    vm_class.define_method(
+        "sys_complete_signal_failure",
+        method!(RbVM::sys_complete_signal_failure, 3),
+    )?;
 
     // IdentityVerifier
     let iv_class = internal.define_class("IdentityVerifier", ruby.class_object())?;

data/lib/restate/client.rb

@@ -81,6 +81,33 @@ module Restate
       post_admin("/restate/invocations/#{invocation_id}/kill", nil)
     end
 
+    # ── Introspection queries ──
+
+    # Execute a SQL query against Restate's introspection API (DataFusion).
+    # The admin API exposes system tables (sys_invocation, sys_journal, state,
+    # etc.) that can be queried with standard SQL.
+    #
+    # @param sql [String] a SQL query string
+    # @return [Array<Hash>] rows returned by the query
+    #
+    # @example
+    #   client.execute_query("SELECT id, status FROM sys_invocation LIMIT 10")
+    def execute_query(sql) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      uri = URI("#{@admin_url}/query")
+      request = Net::HTTP::Post.new(uri)
+      request['Content-Type'] = 'application/json'
+      request['Accept'] = 'application/json'
+      @admin_headers.each { |k, v| request[k] = v }
+      request.body = JSON.generate({ query: sql })
+      response = Net::HTTP.start(uri.hostname, uri.port, # steep:ignore ArgumentTypeMismatch
+                                 use_ssl: uri.scheme == 'https',
+                                 open_timeout: 5,
+                                 read_timeout: 30) { |http| http.request(request) }
+      Kernel.raise "Restate query error: #{response.code} #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+      body = response.body
+      body && !body.empty? ? (JSON.parse(body)['rows'] || []) : []
+    end
+
     private
 
     def resolve_name(service)

data/lib/restate/context.rb

@@ -135,6 +135,18 @@ module Restate
     # Reject an awakeable with a terminal failure.
     def reject_awakeable(awakeable_id, message, code: 500); end
 
+    # Wait for a named signal addressed to this invocation.
+    # Returns a DurableFuture that resolves once another invocation calls
+    # +resolve_signal+ or +reject_signal+ with the same name targeting this
+    # invocation's id.
+    def signal(name, serde: JsonSerde); end
+
+    # Send a success value to a named signal on another invocation.
+    def resolve_signal(invocation_id, name, payload, serde: JsonSerde); end
+
+    # Send a terminal failure to a named signal on another invocation.
+    def reject_signal(invocation_id, name, message, code: 500); end
+
     # Request cancellation of another invocation.
     def cancel_invocation(invocation_id); end
 

data/lib/restate/introspection.rb

@@ -0,0 +1,127 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'active_record'
+
+module Restate
+  # Arel table references for Restate's SQL introspection tables.
+  #
+  # Restate exposes a DataFusion-powered SQL endpoint at +/query+ on the admin
+  # API. These tables let you build queries using Arel's composable, type-safe
+  # predicate API — the same one ActiveRecord uses under the hood.
+  #
+  # @example Query running invocations for a service
+  #   i = Restate::Sys::Invocation
+  #   query = i.project(i[:id], i[:status], i[:created_at])
+  #            .where(i[:target_service_name].eq("MyService"))
+  #            .where(i[:status].eq("running"))
+  #            .order(i[:created_at].desc)
+  #            .take(50)
+  #   Restate.query(query)
+  #
+  # @example Join invocations with their journal input
+  #   i = Restate::Sys::Invocation
+  #   j = Restate::Sys::Journal
+  #   query = i.project(i[:id], i[:target], i[:status], j[:entry_json])
+  #            .join(j, Arel::Nodes::OuterJoin)
+  #            .on(j[:id].eq(i[:id]).and(j[:index].eq(0)))
+  #            .where(i[:target_service_name].eq("CrawlPipeline"))
+  #            .order(i[:created_at].desc)
+  #            .take(20)
+  #   Restate.query(query)
+  #
+  # @example Query virtual object state
+  #   s = Restate::Sys::State
+  #   query = s.project(s[:service_name], s[:service_key], s[:key], s[:value_utf8])
+  #            .where(s[:service_name].eq("Counter"))
+  #   Restate.query(query)
+  module Sys
+    Invocation       = Arel::Table.new(:sys_invocation)
+    Journal          = Arel::Table.new(:sys_journal)
+    JournalEvents    = Arel::Table.new(:sys_journal_events)
+    Inbox            = Arel::Table.new(:sys_inbox)
+    KeyedStatus      = Arel::Table.new(:sys_keyed_service_status)
+    Service          = Arel::Table.new(:sys_service)
+    Deployment       = Arel::Table.new(:sys_deployment)
+    Idempotency      = Arel::Table.new(:sys_idempotency)
+    Promise          = Arel::Table.new(:sys_promise)
+    State            = Arel::Table.new(:state)
+  end
+
+  # Minimal quoting adapter for Arel's ToSql visitor. Emits ANSI SQL
+  # (double-quoted identifiers, single-quoted strings) which DataFusion expects.
+  # Allows Arel query generation without an ActiveRecord database connection.
+  #
+  # @!visibility private
+  class DataFusionQuoting
+    def quote_table_name(name)
+      "\"#{name}\""
+    end
+
+    def quote_column_name(name)
+      "\"#{name}\""
+    end
+
+    def quote(value)
+      case value
+      when String then "'#{value.gsub("'", "''")}'"
+      when nil then 'NULL'
+      when true then 'TRUE'
+      when false then 'FALSE'
+      else value.to_s
+      end
+    end
+
+    def schema_cache
+      self
+    end
+
+    def columns_hash(_table)
+      {}
+    end
+
+    def data_source_exists?(_table)
+      true
+    end
+  end
+
+  # Arel visitor that generates ANSI SQL compatible with DataFusion.
+  # Uses DataFusionQuoting for identifier/value quoting without requiring
+  # a live database connection.
+  #
+  # @!visibility private
+  class DataFusionVisitor < Arel::Visitors::ToSql
+    def initialize
+      super(DataFusionQuoting.new)
+    end
+  end
+
+  class << self
+    # Convert an Arel AST to a SQL string without requiring an AR connection.
+    # Uses a standalone visitor that emits ANSI SQL (DataFusion-compatible).
+    #
+    # @param arel [Arel::SelectManager] an Arel query
+    # @return [String] SQL string
+    def arel_to_sql(arel)
+      collector = Arel::Collectors::SQLString.new
+      DataFusionVisitor.new.accept(arel.ast, collector).value
+    end
+
+    # Execute an Arel query or raw SQL string against the Restate admin
+    # introspection API. Returns an array of row hashes.
+    #
+    # @param arel_or_sql [Arel::SelectManager, String] an Arel query or raw SQL
+    # @return [Array<Hash>] rows returned by Restate
+    #
+    # @example With Arel
+    #   i = Restate::Sys::Invocation
+    #   Restate.query(i.project(Arel.star).take(10))
+    #
+    # @example With raw SQL
+    #   Restate.query("SELECT id, status FROM sys_invocation LIMIT 10")
+    def query(arel_or_sql)
+      sql = arel_or_sql.respond_to?(:ast) ? arel_to_sql(arel_or_sql) : arel_or_sql.to_s
+      client.execute_query(sql)
+    end
+  end
+end

data/lib/restate/middleware/deadlock_detection.rb

@@ -0,0 +1,216 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'base64'
+require 'set'
+
+module Restate
+  module Middleware
+    # Detects VirtualObject deadlocks caused by re-entrant calls to a VO whose
+    # exclusive handler is still running higher up the call chain.
+    #
+    # == The problem
+    #
+    # Restate VirtualObjects serialize exclusive handler access per key. If handler A
+    # on VO key "x" calls handler B on the same VO key "x", the call will block
+    # forever — the key is already locked by A. This is a deadlock.
+    #
+    # == How it works
+    #
+    # This middleware tracks which VO keys are held by the current call chain and
+    # propagates that information via a header on every outbound call.
+    #
+    # === Inbound side
+    #
+    # 1. Reads the held-locks header from the incoming request.
+    # 2. If the current handler is an exclusive VO handler targeting a key already
+    #    in the set → deadlock. Raises a {DeadlockError} immediately.
+    # 3. If this handler is an exclusive VO handler, appends its lock to the set
+    #    so further downstream calls propagate it.
+    #
+    # === Outbound side
+    #
+    # Injects the held-locks header into every outbound service call. When
+    # handler metadata is available (the target service class is known), only
+    # raises for exclusive handlers — shared handler calls are safe. Falls
+    # back to raising for any same-service call when metadata is unavailable
+    # (e.g., calling by string name to an external service).
+    #
+    # == Wire format
+    #
+    # Lock entries are encoded as +base64url(service).base64url(key)+ and
+    # separated by commas. Base64url encoding ensures arbitrary service names
+    # and keys (including those containing +.+, +,+, or non-ASCII characters)
+    # are handled correctly.
+    #
+    # == Journal determinism
+    #
+    # The held-locks header is deterministic across replays: its value depends only
+    # on the execution path, which Restate's journal guarantees is identical on
+    # every replay.
+    #
+    # == Usage
+    #
+    #   endpoint = Restate.endpoint(MyVirtualObject)
+    #   endpoint.use(Restate::Middleware::DeadlockDetection::Inbound)
+    #   endpoint.use_outbound(Restate::Middleware::DeadlockDetection::Outbound)
+    #
+    module DeadlockDetection
+      HEADER = 'x-restate-held-locks'
+      ENTRY_SEPARATOR = ','
+      FIELD_SEPARATOR = '.'
+      DEADLOCK_STATUS_CODE = 409
+
+      THREAD_KEY = :restate_held_exclusive_locks
+
+      class << self
+        # Returns the current set of held exclusive locks for this fiber.
+        # Each entry is a two-element array: [service_name, key].
+        #
+        # @return [Set<Array<String>>]
+        def held_locks
+          Thread.current[THREAD_KEY] || Set.new
+        end
+
+        # @param locks [Set<Array<String>>]
+        def held_locks=(locks)
+          Thread.current[THREAD_KEY] = locks
+        end
+
+        # Encodes a [service, key] pair into a wire-safe string.
+        def encode_lock(service, key)
+          b64_svc = Base64.urlsafe_encode64(service, padding: false)
+          b64_key = Base64.urlsafe_encode64(key, padding: false)
+          "#{b64_svc}#{FIELD_SEPARATOR}#{b64_key}"
+        end
+
+        # Decodes a wire-format lock string into [service, key].
+        # Returns nil if the format is invalid.
+        def decode_lock(encoded)
+          parts = encoded.split(FIELD_SEPARATOR, 2)
+          return nil unless parts.length == 2
+
+          svc = Base64.urlsafe_decode64(parts[0]).force_encoding('UTF-8')
+          key = Base64.urlsafe_decode64(parts[1]).force_encoding('UTF-8')
+          [svc, key]
+        rescue ArgumentError
+          nil
+        end
+
+        # Serializes a set of [service, key] lock pairs into a header value.
+        def encode_header(locks)
+          locks.map { |svc, key| encode_lock(svc, key) }.join(ENTRY_SEPARATOR)
+        end
+
+        # Deserializes a header value into a Set of [service, key] pairs.
+        def decode_header(raw)
+          return Set.new if raw.nil? || raw.to_s.empty?
+
+          entries = raw.to_s.split(ENTRY_SEPARATOR).filter_map do |entry|
+            decode_lock(entry.strip)
+          end
+          Set.new(entries)
+        end
+      end
+
+      # Error raised when a deadlock is detected.
+      #
+      # Uses status code 409 (Conflict) to signal that retrying won't help.
+      class DeadlockError < Restate::TerminalError
+        def initialize(message)
+          super(message, status_code: DEADLOCK_STATUS_CODE)
+        end
+      end
+
+      # Inbound middleware that checks for and tracks VO locks.
+      #
+      # Register with: +endpoint.use(Restate::Middleware::DeadlockDetection::Inbound)+
+      #
+      # @example
+      #   endpoint = Restate.endpoint(MyVirtualObject)
+      #   endpoint.use(Restate::Middleware::DeadlockDetection::Inbound)
+      class Inbound
+        def call(handler, ctx)
+          previous = DeadlockDetection.held_locks
+          incoming = parse_locks(ctx)
+          check_and_track_lock!(handler, ctx, incoming)
+          DeadlockDetection.held_locks = incoming
+          yield
+        ensure
+          DeadlockDetection.held_locks = previous
+        end
+
+        private
+
+        def check_and_track_lock!(handler, ctx, incoming)
+          return unless handler.service_tag.kind == 'object'
+          return unless handler.kind == 'exclusive'
+
+          key = ctx.respond_to?(:key) ? ctx.key : nil
+          return unless key
+
+          svc = handler.service_tag.name
+          lock = [svc, key]
+          raise_deadlock!(svc, handler.name, key, incoming) if incoming.include?(lock)
+          incoming << lock
+        end
+
+        def raise_deadlock!(svc, handler_name, key, locks)
+          held = locks.map { |s, k| "#{s}:#{k}" }.join(', ')
+          msg = "Deadlock detected: #{svc}##{handler_name} on key '#{key}' " \
+                'called while an exclusive handler holds the same VO key. ' \
+                "Held locks: #{held}. " \
+                'This call will never complete.'
+          Kernel.raise DeadlockError, msg
+        end
+
+        def parse_locks(ctx)
+          headers = ctx.request.headers
+          raw = headers.is_a?(Hash) ? headers[HEADER] : nil
+          DeadlockDetection.decode_header(raw)
+        end
+      end
+
+      # Outbound middleware that propagates held locks via headers.
+      #
+      # When handler metadata is available (via Thread.current[:restate_outbound_handler_meta]),
+      # shared handler calls are allowed through — only exclusive handlers can deadlock.
+      # When metadata is unavailable (external service called by string name), falls
+      # back to raising for any same-service call.
+      #
+      # Register with: +endpoint.use_outbound(Restate::Middleware::DeadlockDetection::Outbound)+
+      #
+      # @example
+      #   endpoint = Restate.endpoint(MyVirtualObject)
+      #   endpoint.use_outbound(Restate::Middleware::DeadlockDetection::Outbound)
+      class Outbound
+        def call(service, handler, headers)
+          locks = DeadlockDetection.held_locks
+          propagate_and_check!(service, handler, headers, locks) if locks.any?
+          yield
+        end
+
+        private
+
+        def propagate_and_check!(service, handler, headers, locks)
+          headers[HEADER] = DeadlockDetection.encode_header(locks)
+
+          held_lock = locks.find { |svc, _key| svc == service }
+          return unless held_lock
+
+          return if target_shared?
+
+          msg = "Deadlock detected: outbound call to #{service}##{handler} " \
+                "while exclusive lock held on #{held_lock[0]}:#{held_lock[1]}. " \
+                'This call will block forever.'
+          Kernel.raise DeadlockError, msg
+        end
+
+        def target_shared?
+          meta = Thread.current[:restate_outbound_handler_meta]
+          meta&.kind == 'shared'
+        end
+      end
+    end
+  end
+end

data/lib/restate/railtie.rb

@@ -0,0 +1,17 @@
+# typed: false
+# frozen_string_literal: true
+
+module Restate
+  # Rails integration for the Restate SDK. Automatically loads the
+  # introspection module which provides Arel-based query support for
+  # Restate's SQL introspection API (powered by DataFusion).
+  #
+  # When Rails is present, +Restate::Sys+ table constants become available
+  # for building type-safe, composable queries against system tables like
+  # +sys_invocation+, +sys_journal+, and +state+.
+  class Railtie < Rails::Railtie
+    initializer 'restate.introspection' do
+      require_relative 'introspection'
+    end
+  end
+end

data/lib/restate/server_context.rb

@@ -206,7 +206,7 @@ module Restate
       in_serde = resolve_serde(input_serde, handler_meta, :input_serde)
       out_serde = resolve_serde(output_serde, handler_meta, :output_serde)
       parameter = in_serde.serialize(arg)
-      with_outbound_middleware(svc_name, handler_name, headers) do |hdrs|
+      with_outbound_middleware(svc_name, handler_name, headers, handler_meta: handler_meta) do |hdrs|
         call_handle = @vm.sys_call(
           service: svc_name, handler: handler_name, parameter: parameter,
           key: key, idempotency_key: idempotency_key, headers: hdrs
@@ -223,7 +223,7 @@ module Restate
       in_serde = resolve_serde(input_serde, handler_meta, :input_serde)
       parameter = in_serde.serialize(arg)
       delay_ms = delay ? (delay * 1000).to_i : nil
-      with_outbound_middleware(svc_name, handler_name, headers) do |hdrs|
+      with_outbound_middleware(svc_name, handler_name, headers, handler_meta: handler_meta) do |hdrs|
         invocation_id_handle = @vm.sys_send(
           service: svc_name, handler: handler_name, parameter: parameter,
           key: key, delay: delay_ms, idempotency_key: idempotency_key, headers: hdrs
@@ -239,7 +239,7 @@ module Restate
       in_serde = resolve_serde(input_serde, handler_meta, :input_serde)
       out_serde = resolve_serde(output_serde, handler_meta, :output_serde)
       parameter = in_serde.serialize(arg)
-      with_outbound_middleware(svc_name, handler_name, headers) do |hdrs|
+      with_outbound_middleware(svc_name, handler_name, headers, handler_meta: handler_meta) do |hdrs|
         call_handle = @vm.sys_call(
           service: svc_name, handler: handler_name, parameter: parameter,
           key: key, idempotency_key: idempotency_key, headers: hdrs
@@ -256,7 +256,7 @@ module Restate
       in_serde = resolve_serde(input_serde, handler_meta, :input_serde)
       parameter = in_serde.serialize(arg)
       delay_ms = delay ? (delay * 1000).to_i : nil
-      with_outbound_middleware(svc_name, handler_name, headers) do |hdrs|
+      with_outbound_middleware(svc_name, handler_name, headers, handler_meta: handler_meta) do |hdrs|
         invocation_id_handle = @vm.sys_send(
           service: svc_name, handler: handler_name, parameter: parameter,
           key: key, delay: delay_ms, idempotency_key: idempotency_key, headers: hdrs
@@ -298,6 +298,25 @@ module Restate
       @vm.sys_complete_awakeable_failure(awakeable_id, failure)
     end
 
+    # ── Signals ──
+
+    # Wait for a named signal addressed to this invocation. Returns a DurableFuture.
+    def signal(name, serde: JsonSerde)
+      handle = @vm.sys_signal(name)
+      DurableFuture.new(self, handle, serde: serde)
+    end
+
+    # Send a success value to a named signal on another invocation.
+    def resolve_signal(invocation_id, name, payload, serde: JsonSerde)
+      @vm.sys_complete_signal_success(invocation_id, name, serde.serialize(payload))
+    end
+
+    # Send a terminal failure to a named signal on another invocation.
+    def reject_signal(invocation_id, name, message, code: 500)
+      failure = Failure.new(code: code, message: message)
+      @vm.sys_complete_signal_failure(invocation_id, name, failure)
+    end
+
     # ── Promises (Workflow API) ──
 
     # Gets a durable promise value, blocking until resolved.
@@ -472,18 +491,25 @@ module Restate
     # Runs outbound middleware chain (Sidekiq client middleware pattern).
     # Each middleware gets +call(service, handler, headers)+ and must +yield+
     # to continue the chain. The block at the end performs the actual VM call.
-    def with_outbound_middleware(service, handler, headers, &action)
-      if @outbound_middleware.empty?
-        action.call(headers)
-      else
-        h = headers || {}
-        chain = ->(hdrs) { action.call(hdrs) }
-        @outbound_middleware.reverse_each do |mw|
-          prev = chain
-          chain = ->(hdrs) { mw.call(service, handler, hdrs) { prev.call(hdrs) } }
-        end
-        chain.call(h)
+    #
+    # The optional +handler_meta+ (a Handler struct from resolve_call_target)
+    # is exposed via Thread.current[:restate_outbound_handler_meta] so that
+    # middleware can inspect the target handler's kind without changing the
+    # middleware interface.
+    def with_outbound_middleware(service, handler, headers, handler_meta: nil, &action)
+      return action.call(headers) if @outbound_middleware.empty?
+
+      h = headers || {}
+      previous_meta = Thread.current[:restate_outbound_handler_meta]
+      Thread.current[:restate_outbound_handler_meta] = handler_meta
+      chain = ->(hdrs) { action.call(hdrs) }
+      @outbound_middleware.reverse_each do |mw|
+        prev = chain
+        chain = ->(hdrs) { mw.call(service, handler, hdrs) { prev.call(hdrs) } }
       end
+      chain.call(h)
+    ensure
+      Thread.current[:restate_outbound_handler_meta] = previous_meta
     end
 
     # ── Call target resolution ──

data/lib/restate/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Restate
-  VERSION = '0.9.0'
+  VERSION = '0.11.0'
 end

data/lib/restate/vm.rb

@@ -223,6 +223,19 @@ module Restate
       @vm.sys_cancel_invocation(invocation_id)
     end
 
+    def sys_signal(name)
+      @vm.sys_signal(name)
+    end
+
+    def sys_complete_signal_success(invocation_id, name, value)
+      @vm.sys_complete_signal_success(invocation_id, name, value)
+    end
+
+    def sys_complete_signal_failure(invocation_id, name, failure)
+      native_failure = Internal::Failure.new(failure.code, failure.message, nil)
+      @vm.sys_complete_signal_failure(invocation_id, name, native_failure)
+    end
+
     private
 
     def map_do_progress(result)

data/lib/restate.rb

@@ -18,6 +18,8 @@ require_relative 'restate/endpoint'
 require_relative 'restate/service_proxy'
 require_relative 'restate/config'
 require_relative 'restate/client'
+require_relative 'restate/middleware/deadlock_detection'
+require_relative 'restate/railtie' if defined?(Rails::Railtie)
 
 # Restate Ruby SDK — build resilient applications with durable execution.
 #
@@ -240,6 +242,23 @@ module Restate # rubocop:disable Metrics/ModuleLength
     fetch_context!.reject_awakeable(awakeable_id, message, code: code)
   end
 
+  # ── Signals ──
+
+  # Wait for a named signal addressed to this invocation. Returns a DurableFuture.
+  def signal(name, serde: JsonSerde)
+    fetch_context!.signal(name, serde: serde)
+  end
+
+  # Send a success value to a named signal on another invocation.
+  def resolve_signal(invocation_id, name, payload, serde: JsonSerde)
+    fetch_context!.resolve_signal(invocation_id, name, payload, serde: serde)
+  end
+
+  # Send a terminal failure to a named signal on another invocation.
+  def reject_signal(invocation_id, name, message, code: 500)
+    fetch_context!.reject_signal(invocation_id, name, message, code: code)
+  end
+
   # ── Promises (Workflow only) ──
 
   # Get a durable promise value, blocking until resolved.

data/sig/restate.rbs

@@ -8,6 +8,8 @@ module Restate
   def self.configure: () { (Config) -> void } -> void
   def self.config: () -> Config
   def self.client: () -> Client
+  def self.query: (untyped arel_or_sql) -> Array[Hash[String, untyped]]
+  def self.arel_to_sql: (untyped arel) -> String
 
   # ── Durable execution ──
 
@@ -42,6 +44,12 @@ module Restate
   def self.resolve_awakeable: (String awakeable_id, untyped payload, ?serde: untyped) -> void
   def self.reject_awakeable: (String awakeable_id, String message, ?code: Integer) -> void
 
+  # ── Signals ──
+
+  def self.signal: (String name, ?serde: untyped) -> DurableFuture
+  def self.resolve_signal: (String invocation_id, String name, untyped payload, ?serde: untyped) -> void
+  def self.reject_signal: (String invocation_id, String name, String message, ?code: Integer) -> void
+
   # ── Promises ──
 
   def self.promise: (String name, ?serde: untyped) -> untyped
@@ -118,6 +126,7 @@ module Restate
     def reject_awakeable: (String awakeable_id, String message, ?code: Integer) -> void
     def cancel_invocation: (String invocation_id) -> void
     def kill_invocation: (String invocation_id) -> void
+    def execute_query: (String sql) -> Array[Hash[String, untyped]]
 
     private
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restate-sdk
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.11.0
 platform: aarch64-linux
 authors:
 - Restate Developers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-03-23 00:00:00.000000000 Z
+date: 2026-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -54,7 +54,6 @@ files:
 - ext/restate_internal/extconf.rb
 - ext/restate_internal/src/lib.rs
 - lib/restate.rb
-- lib/restate/3.2/restate_internal.so
 - lib/restate/3.3/restate_internal.so
 - lib/restate/3.4/restate_internal.so
 - lib/restate/4.0/restate_internal.so
@@ -66,6 +65,9 @@ files:
 - lib/restate/endpoint.rb
 - lib/restate/errors.rb
 - lib/restate/handler.rb
+- lib/restate/introspection.rb
+- lib/restate/middleware/deadlock_detection.rb
+- lib/restate/railtie.rb
 - lib/restate/serde.rb
 - lib/restate/server.rb
 - lib/restate/server_context.rb
@@ -91,7 +93,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
   - - "<"
     - !ruby/object:Gem::Version
       version: 4.1.dev