restate-sdk 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc64f400fa1b48565474c9cc26c8bde6742e58b0c02f5090c0f633e16fd2b354
-  data.tar.gz: 7d72ad638b4dd6742c149d5314e8c67de919d198362d4a29e65d78da24146898
+  metadata.gz: 0fdc1d0db30055117693522a2f51fc194ed403a53b6069b2a69181c859b0e9f9
+  data.tar.gz: c39fde762f884f79335330428ba8e9d2bc07b86ba77b12d268db1cd727660cab
 SHA512:
-  metadata.gz: 6180be88c64766e8537a59ce16c22ff591d9a0b6620301668b0c7759b981f2344a9d04f9e6d896b08a569168cd517e29e9202c69947f1311410911c1c2190f85
-  data.tar.gz: bfaa1a28cbfdbeafa95a10a428e7e0b7f17ebc033e0c28659ffeec059c980c4f1635827f40a799e517ccf31c6d143bd342fb6fdfa4b70f6f8dd9709d383af7a9
+  metadata.gz: 2f460e546e7fb00ca7b6319e55374a52a944c58fcd3b0f0f399a62342e12d420280934473d0360d73d26be7dfd525cec7c4bfa831e198d90cb088ff6855351a1
+  data.tar.gz: 14361197f0c9bf7b798637d4a4e617d8438fdc46c433670eca069de100772e2126f8a0a41b27f0a7a283227f452c056aef8fce6efdaf0d60e5b86ef88a4fd1eb

data/Cargo.lock

@@ -569,7 +569,7 @@ dependencies = [
 
 [[package]]
 name = "restate_internal"
-version = "0.8.0"
+version = "0.9.0"
 dependencies = [
  "magnus",
  "rb-sys",

data/ext/restate_internal/Cargo.toml

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

data/lib/restate/endpoint.rb

@@ -4,7 +4,7 @@
 module Restate
   # Container for registered services. Bind services here, then create the Rack app.
   class Endpoint
-    attr_reader :services, :identity_keys, :middleware
+    attr_reader :services, :identity_keys, :middleware, :outbound_middleware
 
     attr_accessor :protocol
 
@@ -13,6 +13,7 @@ module Restate
       @protocol = nil
       @identity_keys = []
       @middleware = []
+      @outbound_middleware = []
     end
 
     # Bind one or more services to this endpoint.
@@ -48,29 +49,25 @@ module Restate
       self
     end
 
-    # Add handler-level middleware.
+    # Add inbound (server) middleware.
     #
-    # Middleware wraps every handler invocation with access to the handler metadata
-    # and context. Use it for tracing, metrics, logging, error reporting, etc.
+    # Inbound middleware wraps every handler invocation, like
+    # {https://github.com/sidekiq/sidekiq/wiki/Middleware Sidekiq server middleware}.
     #
     # A middleware is a class whose instances respond to +call(handler, ctx)+.
     # Use +yield+ inside +call+ to invoke the next middleware or the handler.
     # The return value of +yield+ is the handler's return value.
     #
-    # This follows the same pattern as {https://github.com/sidekiq/sidekiq/wiki/Middleware Sidekiq middleware}.
-    #
     # @example OpenTelemetry tracing
-    #   class OpenTelemetryMiddleware
+    #   class TracingMiddleware
     #     def call(handler, ctx)
-    #       tracer.in_span(handler.name, attributes: {
-    #         'restate.service' => handler.service_tag.name,
-    #         'restate.invocation_id' => ctx.request.id
-    #       }) do
-    #         yield
+    #       extracted = OpenTelemetry.propagation.extract(ctx.request.headers)
+    #       OpenTelemetry::Context.with_current(extracted) do
+    #         tracer.in_span(handler.name) { yield }
     #       end
     #     end
     #   end
-    #   endpoint.use(OpenTelemetryMiddleware)
+    #   endpoint.use(TracingMiddleware)
     #
     # @example Metrics
     #   class MetricsMiddleware
@@ -84,30 +81,53 @@ module Restate
     #   end
     #   endpoint.use(MetricsMiddleware)
     #
-    # @example Middleware with configuration
-    #   class AuthMiddleware
-    #     def initialize(api_key:)
-    #       @api_key = api_key
+    # @param klass [Class] middleware class (will be instantiated by the SDK)
+    # @param args [Array] positional arguments for the middleware constructor
+    # @param kwargs [Hash] keyword arguments for the middleware constructor
+    # @return [self]
+    def use(klass, *args, **kwargs)
+      @middleware << instantiate_middleware(klass, args, kwargs)
+      self
+    end
+
+    # Add outbound (client) middleware.
+    #
+    # Outbound middleware wraps every outgoing service call and send, like
+    # {https://github.com/sidekiq/sidekiq/wiki/Middleware Sidekiq client middleware}.
+    #
+    # A middleware is a class whose instances respond to +call(service, handler, headers)+.
+    # The +headers+ hash is mutable — modify it to attach headers to the outgoing
+    # request. Use +yield+ to continue the chain.
+    #
+    # Note: Restate automatically propagates inbound headers to outbound calls.
+    # Outbound middleware is for injecting *new* headers that aren't on the
+    # original request (e.g., tenant IDs from fiber-local storage, authorization
+    # tokens for specific target services).
+    #
+    # @example Propagate tenant ID to all outgoing calls
+    #   class TenantOutboundMiddleware
+    #     def call(_service, _handler, headers)
+    #       headers['x-tenant-id'] = Thread.current[:tenant_id]
+    #       yield
     #     end
+    #   end
+    #   endpoint.use_outbound(TenantOutboundMiddleware)
     #
-    #     def call(handler, ctx)
-    #       raise Restate::TerminalError.new('unauthorized', status_code: 401) unless valid?(ctx)
+    # @example Log all outgoing calls
+    #   class OutboundLogger
+    #     def call(service, handler, headers)
+    #       logger.info("Calling #{service}/#{handler}")
     #       yield
     #     end
     #   end
-    #   endpoint.use(AuthMiddleware, api_key: 'secret')
+    #   endpoint.use_outbound(OutboundLogger)
     #
     # @param klass [Class] middleware class (will be instantiated by the SDK)
     # @param args [Array] positional arguments for the middleware constructor
     # @param kwargs [Hash] keyword arguments for the middleware constructor
     # @return [self]
-    def use(klass, *args, **kwargs)
-      instance = if kwargs.empty?
-                   klass.new(*args)
-                 else
-                   klass.new(*args, **kwargs)
-                 end
-      @middleware << instance
+    def use_outbound(klass, *args, **kwargs)
+      @outbound_middleware << instantiate_middleware(klass, args, kwargs)
       self
     end
 
@@ -116,5 +136,15 @@ module Restate
       require_relative 'server'
       Server.new(self)
     end
+
+    private
+
+    def instantiate_middleware(klass, args, kwargs)
+      if kwargs.empty?
+        klass.new(*args)
+      else
+        klass.new(*args, **kwargs)
+      end
+    end
   end
 end

data/lib/restate/server.rb

@@ -193,7 +193,8 @@ module Restate
         invocation: invocation,
         send_output: send_output,
         input_queue: input_queue,
-        middleware: @endpoint.middleware
+        middleware: @endpoint.middleware,
+        outbound_middleware: @endpoint.outbound_middleware
       )
 
       # Spawn the handler as an async task so the response body can stream

data/lib/restate/server_context.rb

@@ -23,7 +23,8 @@ module Restate
 
     attr_reader :vm, :invocation
 
-    def initialize(vm:, handler:, invocation:, send_output:, input_queue:, middleware: [])
+    def initialize(vm:, handler:, invocation:, send_output:, input_queue:, middleware: [],
+                   outbound_middleware: [])
       @vm = vm
       @handler = handler
       @invocation = invocation
@@ -32,6 +33,7 @@ module Restate
       @run_coros_to_execute = {}
       @attempt_finished_event = AttemptFinishedEvent.new
       @middleware = middleware
+      @outbound_middleware = outbound_middleware
     end
 
     # ── Main entry point ──
@@ -204,12 +206,14 @@ 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)
-      call_handle = @vm.sys_call(
-        service: svc_name, handler: handler_name, parameter: parameter,
-        key: key, idempotency_key: idempotency_key, headers: headers
-      )
-      DurableCallFuture.new(self, call_handle.result_handle, call_handle.invocation_id_handle,
-                            output_serde: out_serde)
+      with_outbound_middleware(svc_name, handler_name, headers) do |hdrs|
+        call_handle = @vm.sys_call(
+          service: svc_name, handler: handler_name, parameter: parameter,
+          key: key, idempotency_key: idempotency_key, headers: hdrs
+        )
+        DurableCallFuture.new(self, call_handle.result_handle, call_handle.invocation_id_handle,
+                              output_serde: out_serde)
+      end
     end
 
     # Sends a one-way invocation to a Restate service handler (fire-and-forget).
@@ -219,11 +223,13 @@ 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
-      invocation_id_handle = @vm.sys_send(
-        service: svc_name, handler: handler_name, parameter: parameter,
-        key: key, delay: delay_ms, idempotency_key: idempotency_key, headers: headers
-      )
-      SendHandle.new(self, invocation_id_handle)
+      with_outbound_middleware(svc_name, handler_name, headers) 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
+        )
+        SendHandle.new(self, invocation_id_handle)
+      end
     end
 
     # Durably calls a handler on a Restate virtual object, keyed by +key+.
@@ -233,12 +239,14 @@ 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)
-      call_handle = @vm.sys_call(
-        service: svc_name, handler: handler_name, parameter: parameter,
-        key: key, idempotency_key: idempotency_key, headers: headers
-      )
-      DurableCallFuture.new(self, call_handle.result_handle, call_handle.invocation_id_handle,
-                            output_serde: out_serde)
+      with_outbound_middleware(svc_name, handler_name, headers) do |hdrs|
+        call_handle = @vm.sys_call(
+          service: svc_name, handler: handler_name, parameter: parameter,
+          key: key, idempotency_key: idempotency_key, headers: hdrs
+        )
+        DurableCallFuture.new(self, call_handle.result_handle, call_handle.invocation_id_handle,
+                              output_serde: out_serde)
+      end
     end
 
     # Sends a one-way invocation to a Restate virtual object handler (fire-and-forget).
@@ -248,11 +256,13 @@ 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
-      invocation_id_handle = @vm.sys_send(
-        service: svc_name, handler: handler_name, parameter: parameter,
-        key: key, delay: delay_ms, idempotency_key: idempotency_key, headers: headers
-      )
-      SendHandle.new(self, invocation_id_handle)
+      with_outbound_middleware(svc_name, handler_name, headers) 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
+        )
+        SendHandle.new(self, invocation_id_handle)
+      end
     end
 
     # Durably calls a handler on a Restate workflow, keyed by +key+.
@@ -332,22 +342,26 @@ module Restate
 
     # Durably calls a handler using raw bytes (no serialization). Useful for proxying.
     def generic_call(service, handler, arg, key: nil, idempotency_key: nil, headers: nil)
-      call_handle = @vm.sys_call(
-        service: service, handler: handler, parameter: arg,
-        key: key, idempotency_key: idempotency_key, headers: headers
-      )
-      DurableCallFuture.new(self, call_handle.result_handle, call_handle.invocation_id_handle,
-                            output_serde: nil)
+      with_outbound_middleware(service, handler, headers) do |hdrs|
+        call_handle = @vm.sys_call(
+          service: service, handler: handler, parameter: arg,
+          key: key, idempotency_key: idempotency_key, headers: hdrs
+        )
+        DurableCallFuture.new(self, call_handle.result_handle, call_handle.invocation_id_handle,
+                              output_serde: nil)
+      end
     end
 
     # Sends a one-way invocation using raw bytes (no serialization). Useful for proxying.
     def generic_send(service, handler, arg, key: nil, delay: nil, idempotency_key: nil, headers: nil)
       delay_ms = delay ? (delay * 1000).to_i : nil
-      invocation_id_handle = @vm.sys_send(
-        service: service, handler: handler, parameter: arg,
-        key: key, delay: delay_ms, idempotency_key: idempotency_key, headers: headers
-      )
-      SendHandle.new(self, invocation_id_handle)
+      with_outbound_middleware(service, handler, headers) do |hdrs|
+        invocation_id_handle = @vm.sys_send(
+          service: service, handler: handler, parameter: arg,
+          key: key, delay: delay_ms, idempotency_key: idempotency_key, headers: hdrs
+        )
+        SendHandle.new(self, invocation_id_handle)
+      end
     end
 
     # ── Request metadata ──
@@ -453,6 +467,25 @@ module Restate
       end
     end
 
+    # ── Outbound middleware ──
+
+    # 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)
+      end
+    end
+
     # ── Call target resolution ──
 
     # Resolves a service+handler pair from class/symbol or string/string.

data/lib/restate/version.rb

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

data/sig/restate.rbs

@@ -138,13 +138,19 @@ module Restate
     attr_reader identity_keys: Array[String]
     attr_accessor protocol: String?
     attr_reader middleware: Array[untyped]
+    attr_reader outbound_middleware: Array[untyped]
     def initialize: () -> void
     def bind: (*untyped svcs) -> self
     def streaming_protocol: () -> self
     def request_response_protocol: () -> self
     def identity_key: (String key) -> self
     def use: (untyped klass, *untyped args, **untyped kwargs) -> self
+    def use_outbound: (untyped klass, *untyped args, **untyped kwargs) -> self
     def app: () -> untyped
+
+    private
+
+    def instantiate_middleware: (untyped klass, Array[untyped] args, Hash[Symbol, untyped] kwargs) -> untyped
   end
 
   # ── Service proxies ──

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: restate-sdk
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Restate Developers