temporalio 0.3.0-x86_64-linux → 0.4.0-x86_64-linux

data/lib/temporalio/internal/worker/workflow_worker.rb

@@ -33,11 +33,48 @@ module Temporalio
           end
         end
 
-        def initialize(worker:, bridge_worker:, workflow_definitions:)
-          @executor = worker.options.workflow_executor
+        def self.bridge_workflow_failure_exception_type_options(
+          workflow_failure_exception_types:,
+          workflow_definitions:
+        )
+          as_fail = workflow_failure_exception_types.any? do |t|
+            t.is_a?(Class) && t >= Workflow::NondeterminismError
+          end
+          as_fail_for_types = workflow_definitions.values.map do |defn|
+            next unless defn.failure_exception_types.any? { |t| t.is_a?(Class) && t >= Workflow::NondeterminismError }
 
-          payload_codec = worker.options.client.data_converter.payload_codec
-          @workflow_payload_codec_thread_pool = worker.options.workflow_payload_codec_thread_pool
+            # If they tried to do this on a dynamic workflow and haven't already set worker-level option, warn
+            unless defn.name || as_fail
+              warn('Note, dynamic workflows cannot trap non-determinism errors, so worker-level ' \
+                   'workflow_failure_exception_types should be set to capture that if that is the intention')
+            end
+            defn.name
+          end.compact
+          [as_fail, as_fail_for_types]
+        end
+
+        def initialize(
+          bridge_worker:,
+          namespace:,
+          task_queue:,
+          workflow_definitions:,
+          workflow_executor:,
+          logger:,
+          data_converter:,
+          metric_meter:,
+          workflow_interceptors:,
+          disable_eager_activity_execution:,
+          illegal_workflow_calls:,
+          workflow_failure_exception_types:,
+          workflow_payload_codec_thread_pool:,
+          unsafe_workflow_io_enabled:,
+          debug_mode:,
+          on_eviction: nil
+        )
+          @executor = workflow_executor
+
+          payload_codec = data_converter.payload_codec
+          @workflow_payload_codec_thread_pool = workflow_payload_codec_thread_pool
           if !Fiber.current_scheduler && payload_codec && !@workflow_payload_codec_thread_pool
             raise ArgumentError, 'Must have workflow payload codec thread pool if providing codec and not using fibers'
           end
@@ -55,29 +92,31 @@ module Temporalio
           @state = State.new(
             workflow_definitions:,
             bridge_worker:,
-            logger: worker.options.logger,
-            metric_meter: worker.options.client.connection.options.runtime.metric_meter,
-            data_converter: worker.options.client.data_converter,
-            deadlock_timeout: worker.options.debug_mode ? nil : 2.0,
+            logger:,
+            metric_meter:,
+            data_converter:,
+            deadlock_timeout: debug_mode ? nil : 2.0,
             # TODO(cretz): Make this more performant for the default set?
             illegal_calls: WorkflowInstance::IllegalCallTracer.frozen_validated_illegal_calls(
-              worker.options.illegal_workflow_calls || {}
+              illegal_workflow_calls || {}
             ),
-            namespace: worker.options.client.namespace,
-            task_queue: worker.options.task_queue,
-            disable_eager_activity_execution: worker.options.disable_eager_activity_execution,
-            workflow_interceptors: worker._workflow_interceptors,
-            workflow_failure_exception_types: worker.options.workflow_failure_exception_types.map do |t|
+            namespace:,
+            task_queue:,
+            disable_eager_activity_execution:,
+            workflow_interceptors:,
+            workflow_failure_exception_types: workflow_failure_exception_types.map do |t|
               unless t.is_a?(Class) && t < Exception
                 raise ArgumentError, 'All failure types must classes inheriting Exception'
               end
 
               t
-            end.freeze
+            end.freeze,
+            unsafe_workflow_io_enabled:
           )
+          @state.on_eviction = on_eviction if on_eviction
 
           # Validate worker
-          @executor._validate_worker(worker, @state)
+          @executor._validate_worker(self, @state)
         end
 
         def handle_activation(runner:, activation:, decoded:)
@@ -147,12 +186,14 @@ module Temporalio
         class State
           attr_reader :workflow_definitions, :bridge_worker, :logger, :metric_meter, :data_converter, :deadlock_timeout,
                       :illegal_calls, :namespace, :task_queue, :disable_eager_activity_execution,
-                      :workflow_interceptors, :workflow_failure_exception_types
+                      :workflow_interceptors, :workflow_failure_exception_types, :unsafe_workflow_io_enabled
+
+          attr_writer :on_eviction
 
           def initialize(
             workflow_definitions:, bridge_worker:, logger:, metric_meter:, data_converter:, deadlock_timeout:,
             illegal_calls:, namespace:, task_queue:, disable_eager_activity_execution:,
-            workflow_interceptors:, workflow_failure_exception_types:
+            workflow_interceptors:, workflow_failure_exception_types:, unsafe_workflow_io_enabled:
           )
             @workflow_definitions = workflow_definitions
             @bridge_worker = bridge_worker
@@ -166,6 +207,7 @@ module Temporalio
             @disable_eager_activity_execution = disable_eager_activity_execution
             @workflow_interceptors = workflow_interceptors
             @workflow_failure_exception_types = workflow_failure_exception_types
+            @unsafe_workflow_io_enabled = unsafe_workflow_io_enabled
 
             @running_workflows = {}
             @running_workflows_mutex = Mutex.new
@@ -182,8 +224,9 @@ module Temporalio
             instance
           end
 
-          def evict_running_workflow(run_id)
+          def evict_running_workflow(run_id, cache_remove_job)
             @running_workflows_mutex.synchronize { @running_workflows.delete(run_id) }
+            @on_eviction&.call(run_id, cache_remove_job)
           end
 
           def evict_all

data/lib/temporalio/runtime/metric_buffer.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Temporalio
+  class Runtime
+    # Metric buffer for use with a runtime to capture metrics. Only one metric buffer can be associated with a runtime
+    # and {retrieve_updates} cannot be called before the runtime is created. Once runtime created, users should
+    # regularly call {retrieve_updates} to drain the buffer.
+    #
+    # @note WARNING: It is important that the buffer size is set to a high number and that {retrieve_updates} is called
+    #   regularly to drain the buffer. If the buffer is full, metric updates will be dropped and an error will be
+    #   logged.
+    class MetricBuffer
+      # Enumerates for the duration format.
+      module DurationFormat
+        # Durations are millisecond integers.
+        MILLISECONDS = :milliseconds
+
+        # Durations are second floats.
+        SECONDS = :seconds
+      end
+
+      Update = Data.define(:metric, :value, :attributes)
+
+      # Metric buffer update.
+      #
+      # @note WARNING: The constructor of this class should not be invoked by users and may change in incompatible ways
+      #   in the future.
+      #
+      # @!attribute metric
+      #   @return [Metric] Metric for this update. For performance reasons, this is created lazily on first use and is
+      #     the same object each time an update on this metric exists.
+      # @!attribute value
+      #   @return [Integer, Float] Metric value for this update.
+      # @!attribute attributes
+      #   @return [Hash{String => String, Integer, Float, Boolean}] Attributes for this value as a frozen hash.
+      #     For performance reasons this is sometimes the same hash if the attribute set is reused at a metric level.
+      class Update # rubocop:disable Lint/EmptyClass
+        # DEV NOTE: This class is instantiated inside Rust, be careful changing it.
+      end
+
+      Metric = Data.define(:name, :description, :unit, :kind)
+
+      # Metric definition present on an update.
+      #
+      # @!attribute name
+      #   @return [String] Name of the metric.
+      # @!attribute description
+      #   @return [String, nil] Description of the metric if any.
+      # @!attribute unit
+      #   @return [String, nil] Unit of the metric if any.
+      # @!attribute kind
+      #   @return [:counter, :histogram, :gauge] Kind of the metric.
+      class Metric # rubocop:disable Lint/EmptyClass
+        # DEV NOTE: This class is instantiated inside Rust, be careful changing it.
+      end
+
+      # Create a metric buffer with the given size.
+      #
+      # @note WARNING: It is important that the buffer size is set to a high number and is drained regularly. See
+      #   {MetricBuffer} warning.
+      #
+      # @param buffer_size [Integer] Maximum size of the buffer before metrics will be dropped.
+      # @param duration_format [DurationFormat] How durations are represented.
+      def initialize(buffer_size, duration_format: DurationFormat::MILLISECONDS)
+        @buffer_size = buffer_size
+        @duration_format = duration_format
+        @runtime = nil
+      end
+
+      # Drain the buffer and return all metric updates.
+      #
+      # @note WARNING: It is important that this is called regularly. See {MetricBuffer} warning.
+      #
+      # @return [Array<Update>] Updates since last time this was called.
+      def retrieve_updates
+        raise 'Attempting to retrieve updates before runtime created' unless @runtime
+
+        @runtime._core_runtime.retrieve_buffered_metrics(@duration_format == DurationFormat::SECONDS)
+      end
+
+      # @!visibility private
+      def _buffer_size
+        @buffer_size
+      end
+
+      # @!visibility private
+      def _set_runtime(runtime)
+        raise 'Metric buffer already attached to a runtime' if @runtime
+
+        @runtime = runtime
+      end
+    end
+  end
+end

data/lib/temporalio/runtime.rb

@@ -4,6 +4,7 @@ require 'temporalio/internal/bridge'
 require 'temporalio/internal/bridge/runtime'
 require 'temporalio/internal/metric'
 require 'temporalio/metric'
+require 'temporalio/runtime/metric_buffer'
 
 module Temporalio
   # Runtime for Temporal Ruby SDK.
@@ -107,6 +108,7 @@ module Temporalio
     MetricsOptions = Data.define(
       :opentelemetry,
       :prometheus,
+      :buffer,
       :attach_service_name,
       :global_tags,
       :metric_prefix
@@ -116,10 +118,13 @@ module Temporalio
     #
     # @!attribute opentelemetry
     #   @return [OpenTelemetryMetricsOptions, nil] OpenTelemetry options if using OpenTelemetry. This is mutually
-    #     exclusive with +prometheus+.
+    #     exclusive with `prometheus` and `buffer`.
     # @!attribute prometheus
     #   @return [PrometheusMetricsOptions, nil] Prometheus options if using Prometheus. This is mutually exclusive with
-    #     +opentelemetry+.
+    #     `opentelemetry` and `buffer`.
+    # @!attribute buffer
+    #   @return [MetricBuffer, nil] Metric buffer to send all metrics to. This is mutually exclusive with `prometheus`
+    #     and `opentelemetry`.
     # @!attribute attach_service_name
     #   @return [Boolean] Whether to put the service_name on every metric.
     # @!attribute global_tags
@@ -130,19 +135,26 @@ module Temporalio
       # Create metrics options. Either `opentelemetry` or `prometheus` required, but not both.
       #
       # @param opentelemetry [OpenTelemetryMetricsOptions, nil] OpenTelemetry options if using OpenTelemetry. This is
-      #   mutually exclusive with `prometheus`.
+      #   mutually exclusive with `prometheus` and `buffer`.
       # @param prometheus [PrometheusMetricsOptions, nil] Prometheus options if using Prometheus. This is mutually
-      #   exclusive with `opentelemetry`.
+      #   exclusive with `opentelemetry` and `buffer`.
+      # @param buffer [MetricBuffer, nil] Metric buffer to send all metrics to. This is mutually exclusive with
+      #   `prometheus` and `opentelemetry`.
       # @param attach_service_name [Boolean] Whether to put the service_name on every metric.
       # @param global_tags [Hash<String, String>, nil] Resource tags to be applied to all metrics.
       # @param metric_prefix [String, nil] Prefix to put on every Temporal metric. If unset, defaults to `temporal_`.
       def initialize(
         opentelemetry: nil,
         prometheus: nil,
+        buffer: nil,
         attach_service_name: true,
         global_tags: nil,
         metric_prefix: nil
       )
+        if [opentelemetry, prometheus, buffer].count { |v| !v.nil? } > 1
+          raise 'Can only have one of opentelemetry, prometheus, or buffer'
+        end
+
         super
       end
 
@@ -152,6 +164,7 @@ module Temporalio
         Internal::Bridge::Runtime::MetricsOptions.new(
           opentelemetry: opentelemetry&._to_bridge,
           prometheus: prometheus&._to_bridge,
+          buffered_with_size: buffer&._buffer_size,
           attach_service_name:,
           global_tags:,
           metric_prefix:
@@ -164,7 +177,9 @@ module Temporalio
       :headers,
       :metric_periodicity,
       :metric_temporality,
-      :durations_as_seconds
+      :durations_as_seconds,
+      :http,
+      :histogram_bucket_overrides
     )
 
     # Options for exporting metrics to OpenTelemetry.
@@ -181,6 +196,11 @@ module Temporalio
     # @!attribute durations_as_seconds
     #   @return [Boolean] Whether to use float seconds instead of integer milliseconds for durations, default is
     #     +false+.
+    # @!attribute http
+    #   @return [Boolean] True if the protocol is HTTP, false if gRPC (the default).
+    # @!attribute histogram_bucket_overrides
+    #   @return [Hash<String, Array<Numeric>>, nil] Override default histogram buckets. Key of the hash it the metric
+    #     name, value is an array of floats for the set of buckets.
     class OpenTelemetryMetricsOptions
       # OpenTelemetry metric temporality.
       module MetricTemporality
@@ -196,12 +216,17 @@ module Temporalio
       # @param metric_temporality [MetricTemporality] How frequently metrics should be exported.
       # @param durations_as_seconds [Boolean] Whether to use float seconds instead of integer milliseconds for
       #   durations.
+      # @param http [Boolean] True if the protocol is HTTP, false if gRPC (the default).
+      # @param histogram_bucket_overrides [Hash<String, Array<Numeric>>, nil] Override default histogram buckets. Key of
+      #   the hash it the metric name, value is an array of floats for the set of buckets.
       def initialize(
         url:,
         headers: nil,
         metric_periodicity: nil,
         metric_temporality: MetricTemporality::CUMULATIVE,
-        durations_as_seconds: false
+        durations_as_seconds: false,
+        http: false,
+        histogram_bucket_overrides: nil
       )
         super
       end
@@ -218,7 +243,9 @@ module Temporalio
                                     when MetricTemporality::DELTA then true
                                     else raise 'Unrecognized metric temporality'
                                     end,
-          durations_as_seconds:
+          durations_as_seconds:,
+          http:,
+          histogram_bucket_overrides:
         )
       end
     end
@@ -227,7 +254,8 @@ module Temporalio
       :bind_address,
       :counters_total_suffix,
       :unit_suffix,
-      :durations_as_seconds
+      :durations_as_seconds,
+      :histogram_bucket_overrides
     )
 
     # Options for exporting metrics to Prometheus.
@@ -240,6 +268,9 @@ module Temporalio
     #   @return [Boolean] If `true`, all histograms will include the unit in their name as a suffix.
     # @!attribute durations_as_seconds
     #   @return [Boolean] Whether to use float seconds instead of integer milliseconds for durations.
+    # @!attribute histogram_bucket_overrides
+    #   @return [Hash<String, Array<Numeric>>, nil] Override default histogram buckets. Key of the hash it the metric
+    #     name, value is an array of floats for the set of buckets.
     class PrometheusMetricsOptions
       # Create Prometheus options.
       #
@@ -248,11 +279,14 @@ module Temporalio
       # @param unit_suffix [Boolean] If `true`, all histograms will include the unit in their name as a suffix.
       # @param durations_as_seconds [Boolean] Whether to use float seconds instead of integer milliseconds for
       #   durations.
+      # @param histogram_bucket_overrides [Hash<String, Array<Numeric>>, nil] Override default histogram buckets. Key of
+      #   the hash it the metric name, value is an array of floats for the set of buckets.
       def initialize(
         bind_address:,
         counters_total_suffix: false,
         unit_suffix: false,
-        durations_as_seconds: false
+        durations_as_seconds: false,
+        histogram_bucket_overrides: nil
       )
         super
       end
@@ -264,7 +298,8 @@ module Temporalio
           bind_address:,
           counters_total_suffix:,
           unit_suffix:,
-          durations_as_seconds:
+          durations_as_seconds:,
+          histogram_bucket_overrides:
         )
       end
     end
@@ -295,6 +330,9 @@ module Temporalio
     #
     # @param telemetry [TelemetryOptions] Telemetry options to set.
     def initialize(telemetry: TelemetryOptions.new)
+      # Set runtime on the buffer which will fail if the buffer is used on another runtime
+      telemetry.metrics&.buffer&._set_runtime(self)
+
       @core_runtime = Internal::Bridge::Runtime.new(
         Internal::Bridge::Runtime::Options.new(telemetry: telemetry._to_bridge)
       )

data/lib/temporalio/search_attributes.rb

@@ -251,6 +251,14 @@ module Temporalio
       @raw_hash.length
     end
 
+    # Check equality.
+    #
+    # @param other [SearchAttributes] To compare.
+    # @return [Boolean] Whether equal.
+    def ==(other)
+      other.is_a?(SearchAttributes) && @raw_hash == other._raw_hash
+    end
+
     alias size length
 
     # Return a new search attributes collection with updates applied.
@@ -280,6 +288,11 @@ module Temporalio
       end
     end
 
+    # @!visibility private
+    def _raw_hash
+      @raw_hash
+    end
+
     # @!visibility private
     def _to_proto
       Api::Common::V1::SearchAttributes.new(indexed_fields: _to_proto_hash)

data/lib/temporalio/testing/activity_environment.rb

@@ -13,8 +13,8 @@ module Temporalio
     # cancellation can be set, users create this for each activity that is run. There is no real performance penalty for
     # creating an environment for every run.
     class ActivityEnvironment
-      # @return [Activity::Info] The activity info used by default. This is frozen, but can be dup'd and mutated to pass
-      #   in to {initialize}.
+      # @return [Activity::Info] The activity info used by default. This is frozen, but `with` can be used to make a new
+      #   instance with changes to pass in to {initialize}.
       def self.default_info
         @default_info ||= Activity::Info.new(
           activity_id: 'test',
@@ -34,12 +34,13 @@ module Temporalio
           workflow_namespace: 'default',
           workflow_run_id: 'test-run',
           workflow_type: 'test'
-        ).freeze
+        )
       end
 
       # Create a test environment for activities.
       #
-      # @param info [Activity::Info] Value for {Activity::Context#info}.
+      # @param info [Activity::Info] Value for {Activity::Context#info}. Users should not try to instantiate this
+      #   themselves, but rather use `with` on {default_info}.
       # @param on_heartbeat [Proc(Array), nil] Proc that is called with all heartbeat details when
       #   {Activity::Context#heartbeat} is called.
       # @param cancellation [Cancellation] Value for {Activity::Context#cancellation}.
@@ -47,6 +48,9 @@ module Temporalio
       # @param payload_converter [Converters::PayloadConverter] Value for {Activity::Context#payload_converter}.
       # @param logger [Logger] Value for {Activity::Context#logger}.
       # @param activity_executors [Hash<Symbol, Worker::ActivityExecutor>] Executors that activities can run within.
+      # @param metric_meter [Metric::Meter, nil] Value for {Activity::Context#metric_meter}, or nil to raise when
+      #   called.
+      # @param client [Client, nil] Value for {Activity::Context#client}, or nil to raise when called.
       def initialize(
         info: ActivityEnvironment.default_info,
         on_heartbeat: nil,
@@ -54,7 +58,9 @@ module Temporalio
         worker_shutdown_cancellation: Cancellation.new,
         payload_converter: Converters::PayloadConverter.default,
         logger: Logger.new(nil),
-        activity_executors: Worker::ActivityExecutor.defaults
+        activity_executors: Worker::ActivityExecutor.defaults,
+        metric_meter: nil,
+        client: nil
       )
         @info = info
         @on_heartbeat = on_heartbeat
@@ -63,6 +69,8 @@ module Temporalio
         @payload_converter = payload_converter
         @logger = logger
         @activity_executors = activity_executors
+        @metric_meter = metric_meter
+        @client = client
       end
 
       # Run an activity and returns its result or raises its exception.
@@ -80,14 +88,18 @@ module Temporalio
           Activity::Context._current_executor = executor
           executor.set_activity_context(defn, Context.new(
                                                 info: @info.dup,
+                                                instance:
+                                                  defn.instance.is_a?(Proc) ? defn.instance.call : defn.instance,
                                                 on_heartbeat: @on_heartbeat,
                                                 cancellation: @cancellation,
                                                 worker_shutdown_cancellation: @worker_shutdown_cancellation,
                                                 payload_converter: @payload_converter,
-                                                logger: @logger
+                                                logger: @logger,
+                                                metric_meter: @metric_meter,
+                                                client: @client
                                               ))
           queue.push([defn.proc.call(*args), nil])
-        rescue Exception => e # rubocop:disable Lint/RescueException Intentionally capturing all exceptions
+        rescue Exception => e # rubocop:disable Lint/RescueException -- Intentionally capturing all exceptions
           queue.push([nil, e])
         ensure
           executor.set_activity_context(defn, nil)
@@ -102,28 +114,44 @@ module Temporalio
 
       # @!visibility private
       class Context < Activity::Context
-        attr_reader :info, :cancellation, :worker_shutdown_cancellation, :payload_converter, :logger
+        attr_reader :info, :instance, :cancellation, :worker_shutdown_cancellation, :payload_converter, :logger
 
         def initialize( # rubocop:disable Lint/MissingSuper
-          info: ActivityEnvironment.default_info,
-          on_heartbeat: nil,
-          cancellation: Cancellation.new,
-          worker_shutdown_cancellation: Cancellation.new,
-          payload_converter: Converters::PayloadConverter.default,
-          logger: Logger.new(nil)
+          info:,
+          instance:,
+          on_heartbeat:,
+          cancellation:,
+          worker_shutdown_cancellation:,
+          payload_converter:,
+          logger:,
+          metric_meter:,
+          client:
         )
           @info = info
+          @instance = instance
           @on_heartbeat = on_heartbeat
           @cancellation = cancellation
           @worker_shutdown_cancellation = worker_shutdown_cancellation
           @payload_converter = payload_converter
           @logger = logger
+          @metric_meter = metric_meter
+          @client = client
         end
 
         # @!visibility private
         def heartbeat(*details)
           @on_heartbeat&.call(details)
         end
+
+        # @!visibility private
+        def metric_meter
+          @metric_meter or raise 'No metric meter configured in this test environment'
+        end
+
+        # @!visibility private
+        def client
+          @client or raise 'No client configured in this test environment'
+        end
       end
 
       private_constant :Context

data/lib/temporalio/testing/workflow_environment.rb

@@ -10,6 +10,7 @@ require 'temporalio/converters'
 require 'temporalio/internal/bridge/testing'
 require 'temporalio/internal/proto_utils'
 require 'temporalio/runtime'
+require 'temporalio/search_attributes'
 require 'temporalio/version'
 
 module Temporalio
@@ -34,8 +35,10 @@ module Temporalio
       # @param default_workflow_query_reject_condition [WorkflowQueryRejectCondition, nil] Default rejection condition
       #   for the client.
       # @param ip [String] IP to bind to.
-      # @param port [Integer, nil] Port to bind on, or +nil+ for random.
+      # @param port [Integer, nil] Port to bind on, or `nil` for random.
       # @param ui [Boolean] If +true+, also starts the UI.
+      # @param ui_port [Integer, nil] Port to bind on if `ui` is true, or `nil` for random.
+      # @param search_attributes [Array<SearchAttributes::Key>] Search attributes to make available on start.
       # @param runtime [Runtime] Runtime for the server and client.
       # @param dev_server_existing_path [String, nil] Existing CLI path to use instead of downloading and caching to
       #   tmp.
@@ -46,6 +49,8 @@ module Temporalio
       # @param dev_server_download_version [String] Version of dev server to download and cache.
       # @param dev_server_download_dest_dir [String, nil] Where to download. Defaults to tmp.
       # @param dev_server_extra_args [Array<String>] Any extra arguments for the CLI dev server.
+      # @param dev_server_download_ttl [Float, nil] How long the automatic download should be cached for. If nil, cached
+      #   indefinitely.
       #
       # @yield [environment] If a block is given, it is called with the environment and upon complete the environment is
       #   shutdown.
@@ -62,6 +67,8 @@ module Temporalio
         ip: '127.0.0.1',
         port: nil,
         ui: false, # rubocop:disable Naming/MethodParameterName
+        ui_port: nil,
+        search_attributes: [],
         runtime: Runtime.default,
         dev_server_existing_path: nil,
         dev_server_database_filename: nil,
@@ -70,8 +77,18 @@ module Temporalio
         dev_server_download_version: 'default',
         dev_server_download_dest_dir: nil,
         dev_server_extra_args: [],
+        dev_server_download_ttl: nil,
         &
       )
+        # Add search attribute args
+        unless search_attributes.empty?
+          dev_server_extra_args += search_attributes.flat_map do |key|
+            raise 'Search attribute must be Key' unless key.is_a?(SearchAttributes::Key)
+
+            ['--search-attribute', "#{key.name}=#{SearchAttributes::IndexedValueType::PROTO_NAMES[key.type]}"]
+          end
+        end
+
         server_options = Internal::Bridge::Testing::EphemeralServer::StartDevServerOptions.new(
           existing_path: dev_server_existing_path,
           sdk_name: 'sdk-ruby',
@@ -83,9 +100,11 @@ module Temporalio
           port:,
           database_filename: dev_server_database_filename,
           ui:,
+          ui_port: ui ? ui_port : nil,
           log_format: dev_server_log_format,
           log_level: dev_server_log_level,
-          extra_args: dev_server_extra_args
+          extra_args: dev_server_extra_args,
+          download_ttl: dev_server_download_ttl
         )
         _with_core_server(
           core_server: Internal::Bridge::Testing::EphemeralServer.start_dev_server(
@@ -122,6 +141,8 @@ module Temporalio
       # @param test_server_download_version [String] Version of test server to download and cache.
       # @param test_server_download_dest_dir [String, nil] Where to download. Defaults to tmp.
       # @param test_server_extra_args [Array<String>] Any extra arguments for the test server.
+      # @param test_server_download_ttl [Float, nil] How long the automatic download should be cached for. If nil,
+      #   cached indefinitely.
       #
       # @yield [environment] If a block is given, it is called with the environment and upon complete the environment is
       #   shutdown.
@@ -140,6 +161,7 @@ module Temporalio
         test_server_download_version: 'default',
         test_server_download_dest_dir: nil,
         test_server_extra_args: [],
+        test_server_download_ttl: nil,
         &
       )
         server_options = Internal::Bridge::Testing::EphemeralServer::StartTestServerOptions.new(
@@ -149,7 +171,8 @@ module Temporalio
           download_version: test_server_download_version,
           download_dest_dir: test_server_download_dest_dir,
           port:,
-          extra_args: test_server_extra_args
+          extra_args: test_server_extra_args,
+          download_ttl: test_server_download_ttl
         )
         _with_core_server(
           core_server: Internal::Bridge::Testing::EphemeralServer.start_test_server(

data/lib/temporalio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Temporalio
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/lib/temporalio/worker/interceptor.rb

@@ -206,6 +206,7 @@ module Temporalio
           :activity,
           :args,
           :task_queue,
+          :summary,
           :schedule_to_close_timeout,
           :schedule_to_start_timeout,
           :start_to_close_timeout,
@@ -270,6 +271,8 @@ module Temporalio
           :args,
           :id,
           :task_queue,
+          :static_summary,
+          :static_details,
           :cancellation,
           :cancellation_type,
           :parent_close_policy,