temporalio 0.3.0 → 0.4.0

data/lib/temporalio/client.rb

@@ -8,10 +8,13 @@ require 'temporalio/client/connection'
 require 'temporalio/client/interceptor'
 require 'temporalio/client/schedule'
 require 'temporalio/client/schedule_handle'
+require 'temporalio/client/with_start_workflow_operation'
 require 'temporalio/client/workflow_execution'
 require 'temporalio/client/workflow_execution_count'
 require 'temporalio/client/workflow_handle'
 require 'temporalio/client/workflow_query_reject_condition'
+require 'temporalio/client/workflow_update_handle'
+require 'temporalio/client/workflow_update_wait_stage'
 require 'temporalio/common_enums'
 require 'temporalio/converters'
 require 'temporalio/error'
@@ -155,7 +158,7 @@ module Temporalio
         default_workflow_query_reject_condition:
       ).freeze
       # Initialize interceptors
-      @impl = interceptors.reverse_each.reduce(Internal::Client::Implementation.new(self)) do |acc, int|
+      @impl = interceptors.reverse_each.reduce(Internal::Client::Implementation.new(self)) do |acc, int| # steep:ignore
         int.intercept_client(acc)
       end
     end
@@ -191,6 +194,12 @@ module Temporalio
     # @param args [Array<Object>] Arguments to the workflow.
     # @param id [String] Unique identifier for the workflow execution.
     # @param task_queue [String] Task queue to run the workflow on.
+    # @param static_summary [String, nil] Fixed single-line summary for this workflow execution that may appear in
+    #   CLI/UI. This can be in single-line Temporal markdown format. This is currently experimental.
+    # @param static_details [String, nil] Fixed details for this workflow execution that may appear in CLI/UI. This can
+    #   be in Temporal markdown format and can be multiple lines. This is a fixed value on the workflow that cannot be
+    #   updated. For details that can be updated, use {Workflow.current_details=} within the workflow. This is currently
+    #   experimental.
     # @param execution_timeout [Float, nil] Total workflow execution timeout in seconds including retries and continue
     #   as new.
     # @param run_timeout [Float, nil] Timeout of a single workflow run in seconds.
@@ -217,6 +226,8 @@ module Temporalio
       *args,
       id:,
       task_queue:,
+      static_summary: nil,
+      static_details: nil,
       execution_timeout: nil,
       run_timeout: nil,
       task_timeout: nil,
@@ -231,10 +242,12 @@ module Temporalio
       rpc_options: nil
     )
       @impl.start_workflow(Interceptor::StartWorkflowInput.new(
-                             workflow:,
+                             workflow: Workflow::Definition._workflow_type_from_workflow_parameter(workflow),
                              args:,
                              workflow_id: id,
                              task_queue:,
+                             static_summary:,
+                             static_details:,
                              execution_timeout:,
                              run_timeout:,
                              task_timeout:,
@@ -257,6 +270,12 @@ module Temporalio
     # @param args [Array<Object>] Arguments to the workflow.
     # @param id [String] Unique identifier for the workflow execution.
     # @param task_queue [String] Task queue to run the workflow on.
+    # @param static_summary [String, nil] Fixed single-line summary for this workflow execution that may appear in
+    #   CLI/UI. This can be in single-line Temporal markdown format. This is currently experimental.
+    # @param static_details [String, nil] Fixed details for this workflow execution that may appear in CLI/UI. This can
+    #   be in Temporal markdown format and can be multiple lines. This is a fixed value on the workflow that cannot be
+    #   updated. For details that can be updated, use {Workflow.current_details=} within the workflow. This is currently
+    #   experimental.
     # @param execution_timeout [Float, nil] Total workflow execution timeout in seconds including retries and continue
     #   as new.
     # @param run_timeout [Float, nil] Timeout of a single workflow run in seconds.
@@ -284,6 +303,8 @@ module Temporalio
       *args,
       id:,
       task_queue:,
+      static_summary: nil,
+      static_details: nil,
       execution_timeout: nil,
       run_timeout: nil,
       task_timeout: nil,
@@ -302,6 +323,8 @@ module Temporalio
         *args,
         id:,
         task_queue:,
+        static_summary:,
+        static_details:,
         execution_timeout:,
         run_timeout:,
         task_timeout:,
@@ -334,6 +357,106 @@ module Temporalio
       WorkflowHandle.new(client: self, id: workflow_id, run_id:, result_run_id: run_id, first_execution_run_id:)
     end
 
+    # Start an update, possibly starting the workflow at the same time if it doesn't exist (depending upon ID conflict
+    # policy). Note that in some cases this may fail but the workflow will still be started, and the handle can then be
+    # retrieved on the start workflow operation.
+    #
+    # @param update [Workflow::Definition::Update, Symbol, String] Update definition or name.
+    # @param args [Array<Object>] Update arguments.
+    # @param start_workflow_operation [WithStartWorkflowOperation] Required with-start workflow operation. This must
+    #   have an `id_conflict_policy` set.
+    # @param wait_for_stage [WorkflowUpdateWaitStage] Required stage to wait until returning. ADMITTED is not
+    #   currently supported. See https://docs.temporal.io/workflows#update for more details.
+    # @param id [String] ID of the update.
+    # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+    #
+    # @return [WorkflowUpdateHandle] The update handle.
+    # @raise [Error::WorkflowAlreadyStartedError] Workflow already exists and conflict/reuse policy does not allow.
+    # @raise [Error::WorkflowUpdateRPCTimeoutOrCanceledError] This update call timed out or was canceled. This doesn't
+    #   mean the update itself was timed out or canceled, and this doesn't mean the workflow did not start.
+    # @raise [Error::RPCError] RPC error from call.
+    def start_update_with_start_workflow(
+      update,
+      *args,
+      start_workflow_operation:,
+      wait_for_stage:,
+      id: SecureRandom.uuid,
+      rpc_options: nil
+    )
+      @impl.start_update_with_start_workflow(
+        Interceptor::StartUpdateWithStartWorkflowInput.new(
+          update_id: id,
+          update: Workflow::Definition::Update._name_from_parameter(update),
+          args:,
+          wait_for_stage:,
+          start_workflow_operation:,
+          headers: {},
+          rpc_options:
+        )
+      )
+    end
+
+    # Start an update, possibly starting the workflow at the same time if it doesn't exist (depending upon ID conflict
+    # policy), and wait for update result. This is a shortcut for {start_update_with_start_workflow} +
+    # {WorkflowUpdateHandle.result}.
+    #
+    # @param update [Workflow::Definition::Update, Symbol, String] Update definition or name.
+    # @param args [Array<Object>] Update arguments.
+    # @param start_workflow_operation [WithStartWorkflowOperation] Required with-start workflow operation. This must
+    #   have an `id_conflict_policy` set.
+    # @param id [String] ID of the update.
+    # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+    #
+    # @return [Object] Successful update result.
+    # @raise [Error::WorkflowUpdateFailedError] If the update failed.
+    # @raise [Error::WorkflowAlreadyStartedError] Workflow already exists and conflict/reuse policy does not allow.
+    # @raise [Error::WorkflowUpdateRPCTimeoutOrCanceledError] This update call timed out or was canceled. This doesn't
+    #   mean the update itself was timed out or canceled, and this doesn't mean the workflow did not start.
+    # @raise [Error::RPCError] RPC error from call.
+    def execute_update_with_start_workflow(
+      update,
+      *args,
+      start_workflow_operation:,
+      id: SecureRandom.uuid,
+      rpc_options: nil
+    )
+      start_update_with_start_workflow(
+        update,
+        *args,
+        start_workflow_operation:,
+        wait_for_stage: WorkflowUpdateWaitStage::COMPLETED,
+        id:,
+        rpc_options:
+      ).result
+    end
+
+    # Send a signal, possibly starting the workflow at the same time if it doesn't exist.
+    #
+    # @param signal [Workflow::Definition::Signal, Symbol, String] Signal definition or name.
+    # @param args [Array<Object>] Signal arguments.
+    # @param start_workflow_operation [WithStartWorkflowOperation] Required with-start workflow operation. This may not
+    #   support all `id_conflict_policy` options.
+    # @param rpc_options [RPCOptions, nil] Advanced RPC options.
+    #
+    # @return [WorkflowHandle] A workflow handle to the workflow.
+    # @raise [Error::WorkflowAlreadyStartedError] Workflow already exists and conflict/reuse policy does not allow.
+    # @raise [Error::RPCError] RPC error from call.
+    def signal_with_start_workflow(
+      signal,
+      *args,
+      start_workflow_operation:,
+      rpc_options: nil
+    )
+      @impl.signal_with_start_workflow(
+        Interceptor::SignalWithStartWorkflowInput.new(
+          signal: Workflow::Definition::Signal._name_from_parameter(signal),
+          args:,
+          start_workflow_operation:,
+          rpc_options:
+        )
+      )
+    end
+
     # List workflows.
     #
     # @param query [String, nil] A Temporal visibility list filter.

data/lib/temporalio/contrib/open_telemetry.rb

@@ -0,0 +1,470 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'opentelemetry' # This import will intentionally fail if the user does not have OTel gem available
+require 'temporalio/client/interceptor'
+require 'temporalio/converters/payload_converter'
+require 'temporalio/worker/interceptor'
+
+module Temporalio
+  module Contrib
+    module OpenTelemetry
+      # Tracing interceptor to add OpenTelemetry traces to clients, activities, and workflows.
+      class TracingInterceptor
+        include Client::Interceptor
+        include Worker::Interceptor::Activity
+        include Worker::Interceptor::Workflow
+
+        # @return [OpenTelemetry::Trace::Tracer] Tracer in use.
+        attr_reader :tracer
+
+        # Create interceptor.
+        #
+        # @param tracer [OpenTelemetry::Trace::Tracer] Tracer to use.
+        # @param header_key [String] Temporal header name to serialize spans to/from. Most users should not change this.
+        # @param propagator [Object] Propagator to use. Most users should not change this.
+        # @param always_create_workflow_spans [Boolean] When false, the default, spans are only created in workflows
+        #   when an overarching span from the client is present. In cases of starting a workflow elsewhere, e.g. CLI or
+        #   schedules, a client-created span is not present and workflow spans will not be created. Setting this to true
+        #   will create spans in workflows no matter what, but there is a risk of them being orphans since they may not
+        #   have a parent span after replaying.
+        def initialize(
+          tracer,
+          header_key: '_tracer-data',
+          propagator: ::OpenTelemetry::Context::Propagation::CompositeTextMapPropagator.compose_propagators(
+            [
+              ::OpenTelemetry::Trace::Propagation::TraceContext::TextMapPropagator.new,
+              ::OpenTelemetry::Baggage::Propagation::TextMapPropagator.new
+            ]
+          ),
+          always_create_workflow_spans: false
+        )
+          @tracer = tracer
+          @header_key = header_key
+          @propagator = propagator
+          @always_create_workflow_spans = always_create_workflow_spans
+        end
+
+        # @!visibility private
+        def intercept_client(next_interceptor)
+          ClientOutbound.new(self, next_interceptor)
+        end
+
+        # @!visibility private
+        def intercept_activity(next_interceptor)
+          ActivityInbound.new(self, next_interceptor)
+        end
+
+        # @!visibility private
+        def intercept_workflow(next_interceptor)
+          WorkflowInbound.new(self, next_interceptor)
+        end
+
+        # @!visibility private
+        def _apply_context_to_headers(headers, context: ::OpenTelemetry::Context.current)
+          carrier = {}
+          @propagator.inject(carrier, context:)
+          headers[@header_key] = carrier unless carrier.empty?
+        end
+
+        # @!visibility private
+        def _attach_context(headers)
+          context = _context_from_headers(headers)
+          ::OpenTelemetry::Context.attach(context) if context
+        end
+
+        # @!visibility private
+        def _context_from_headers(headers)
+          carrier = headers[@header_key]
+          @propagator.extract(carrier) if carrier.is_a?(Hash) && !carrier.empty?
+        end
+
+        # @!visibility private
+        def _with_started_span(
+          name:,
+          kind:,
+          attributes: nil,
+          outbound_input: nil
+        )
+          tracer.in_span(name, attributes:, kind:) do
+            _apply_context_to_headers(outbound_input.headers) if outbound_input
+            yield
+          end
+        end
+
+        # @!visibility private
+        def _always_create_workflow_spans
+          @always_create_workflow_spans
+        end
+
+        # @!visibility private
+        class ClientOutbound < Client::Interceptor::Outbound
+          def initialize(root, next_interceptor)
+            super(next_interceptor)
+            @root = root
+          end
+
+          # @!visibility private
+          def start_workflow(input)
+            @root._with_started_span(
+              name: "StartWorkflow:#{input.workflow}",
+              kind: :client,
+              attributes: { 'temporalWorkflowID' => input.workflow_id },
+              outbound_input: input
+            ) { super }
+          end
+
+          # @!visibility private
+          def start_update_with_start_workflow(input)
+            @root._with_started_span(
+              name: "UpdateWithStartWorkflow:#{input.update}",
+              kind: :client,
+              attributes: { 'temporalWorkflowID' => input.start_workflow_operation.options.id,
+                            'temporalUpdateID' => input.update_id },
+              outbound_input: input
+            ) do
+              # Also add to start headers
+              if input.headers[@header_key]
+                input.start_workflow_operation.options.headers[@header_key] = input.headers[@header_key]
+              end
+              super
+            end
+          end
+
+          # @!visibility private
+          def signal_with_start_workflow(input)
+            @root._with_started_span(
+              name: "SignalWithStartWorkflow:#{input.workflow}",
+              kind: :client,
+              attributes: { 'temporalWorkflowID' => input.start_workflow_operation.options.id },
+              outbound_input: input
+            ) do
+              # Also add to start headers
+              if input.headers[@header_key]
+                input.start_workflow_operation.options.headers[@header_key] = input.headers[@header_key]
+              end
+              super
+            end
+          end
+
+          # @!visibility private
+          def signal_workflow(input)
+            @root._with_started_span(
+              name: "SignalWorkflow:#{input.signal}",
+              kind: :client,
+              attributes: { 'temporalWorkflowID' => input.workflow_id },
+              outbound_input: input
+            ) { super }
+          end
+
+          # @!visibility private
+          def query_workflow(input)
+            @root._with_started_span(
+              name: "QueryWorkflow:#{input.query}",
+              kind: :client,
+              attributes: { 'temporalWorkflowID' => input.workflow_id },
+              outbound_input: input
+            ) { super }
+          end
+
+          # @!visibility private
+          def start_workflow_update(input)
+            @root._with_started_span(
+              name: "StartWorkflowUpdate:#{input.update}",
+              kind: :client,
+              attributes: { 'temporalWorkflowID' => input.workflow_id, 'temporalUpdateID' => input.update_id },
+              outbound_input: input
+            ) { super }
+          end
+        end
+
+        # @!visibility private
+        class ActivityInbound < Worker::Interceptor::Activity::Inbound
+          def initialize(root, next_interceptor)
+            super(next_interceptor)
+            @root = root
+          end
+
+          # @!visibility private
+          def execute(input)
+            @root._attach_context(input.headers)
+            info = Activity::Context.current.info
+            @root._with_started_span(
+              name: "RunActivity:#{info.activity_type}",
+              kind: :server,
+              attributes: {
+                'temporalWorkflowID' => info.workflow_id,
+                'temporalRunID' => info.workflow_run_id,
+                'temporalActivityID' => info.activity_id
+              }
+            ) { super }
+          end
+        end
+
+        # @!visibility private
+        class WorkflowInbound < Worker::Interceptor::Workflow::Inbound
+          def initialize(root, next_interceptor)
+            super(next_interceptor)
+            @root = root
+          end
+
+          # @!visibility private
+          def init(outbound)
+            # Set root on storage
+            Temporalio::Workflow.storage[:__temporal_opentelemetry_tracing_interceptor] = @root
+            super(WorkflowOutbound.new(@root, outbound))
+          end
+
+          # @!visibility private
+          def execute(input)
+            @root._attach_context(Temporalio::Workflow.info.headers)
+            Workflow.with_completed_span("RunWorkflow:#{Temporalio::Workflow.info.workflow_type}", kind: :server) do
+              super
+            ensure
+              Workflow.completed_span(
+                "CompleteWorkflow:#{Temporalio::Workflow.info.workflow_type}",
+                kind: :internal,
+                exception: $ERROR_INFO # steep:ignore
+              )
+            end
+          end
+
+          # @!visibility private
+          def handle_signal(input)
+            @root._attach_context(Temporalio::Workflow.info.headers)
+            Workflow.with_completed_span(
+              "HandleSignal:#{input.signal}",
+              links: _links_from_headers(input.headers),
+              kind: :server
+            ) do
+              super
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              Workflow.completed_span("FailHandleSignal:#{input.signal}", kind: :internal, exception: e)
+              raise
+            end
+          end
+
+          # @!visibility private
+          def handle_query(input)
+            @root._attach_context(Temporalio::Workflow.info.headers)
+            Workflow.with_completed_span(
+              "HandleQuery:#{input.query}",
+              links: _links_from_headers(input.headers),
+              kind: :server,
+              even_during_replay: true
+            ) do
+              super
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              Workflow.completed_span(
+                "FailHandleQuery:#{input.query}",
+                kind: :internal,
+                exception: e,
+                even_during_replay: true
+              )
+              raise
+            end
+          end
+
+          # @!visibility private
+          def validate_update(input)
+            @root._attach_context(Temporalio::Workflow.info.headers)
+            Workflow.with_completed_span(
+              "ValidateUpdate:#{input.update}",
+              attributes: { 'temporalUpdateID' => input.id },
+              links: _links_from_headers(input.headers),
+              kind: :server,
+              even_during_replay: true
+            ) do
+              super
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              Workflow.completed_span(
+                "FailValidateUpdate:#{input.update}",
+                attributes: { 'temporalUpdateID' => input.id },
+                kind: :internal,
+                exception: e,
+                even_during_replay: true
+              )
+              raise
+            end
+          end
+
+          # @!visibility private
+          def handle_update(input)
+            @root._attach_context(Temporalio::Workflow.info.headers)
+            Workflow.with_completed_span(
+              "HandleUpdate:#{input.update}",
+              attributes: { 'temporalUpdateID' => input.id },
+              links: _links_from_headers(input.headers),
+              kind: :server
+            ) do
+              super
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              Workflow.completed_span(
+                "FailHandleUpdate:#{input.update}",
+                attributes: { 'temporalUpdateID' => input.id },
+                kind: :internal,
+                exception: e
+              )
+              raise
+            end
+          end
+
+          # @!visibility private
+          def _links_from_headers(headers)
+            context = @root._context_from_headers(headers)
+            span = ::OpenTelemetry::Trace.current_span(context) if context
+            if span && span != ::OpenTelemetry::Trace::Span::INVALID
+              [::OpenTelemetry::Trace::Link.new(span.context)]
+            else
+              []
+            end
+          end
+        end
+
+        # @!visibility private
+        class WorkflowOutbound < Worker::Interceptor::Workflow::Outbound
+          def initialize(root, next_interceptor)
+            super(next_interceptor)
+            @root = root
+          end
+
+          # @!visibility private
+          def execute_activity(input)
+            _apply_span_to_headers(input.headers,
+                                   Workflow.completed_span("StartActivity:#{input.activity}", kind: :client))
+            super
+          end
+
+          # @!visibility private
+          def execute_local_activity(input)
+            _apply_span_to_headers(input.headers,
+                                   Workflow.completed_span("StartActivity:#{input.activity}", kind: :client))
+            super
+          end
+
+          # @!visibility private
+          def initialize_continue_as_new_error(input)
+            # Just apply the current context to headers
+            @root._apply_context_to_headers(input.error.headers)
+            super
+          end
+
+          # @!visibility private
+          def signal_child_workflow(input)
+            _apply_span_to_headers(input.headers,
+                                   Workflow.completed_span("SignalChildWorkflow:#{input.signal}", kind: :client))
+            super
+          end
+
+          # @!visibility private
+          def signal_external_workflow(input)
+            _apply_span_to_headers(input.headers,
+                                   Workflow.completed_span("SignalExternalWorkflow:#{input.signal}", kind: :client))
+            super
+          end
+
+          # @!visibility private
+          def start_child_workflow(input)
+            _apply_span_to_headers(input.headers,
+                                   Workflow.completed_span("StartChildWorkflow:#{input.workflow}", kind: :client))
+            super
+          end
+
+          # @!visibility private
+          def _apply_span_to_headers(headers, span)
+            @root._apply_context_to_headers(headers, context: ::OpenTelemetry::Trace.context_with_span(span)) if span
+          end
+        end
+
+        private_constant :ClientOutbound
+        private_constant :ActivityInbound
+        private_constant :WorkflowInbound
+        private_constant :WorkflowOutbound
+      end
+
+      # Contains workflow methods that can be used for OpenTelemetry.
+      module Workflow
+        # Create a completed span and execute block with the span set on the context.
+        #
+        # @param name [String] Span name.
+        # @param attributes [Hash] Span attributes. These will have workflow and run ID automatically added.
+        # @param links [Array, nil] Span links.
+        # @param kind [Symbol, nil] Span kind.
+        # @param exception [Exception, nil] Exception to record on the span.
+        # @param even_during_replay [Boolean] Set to true to record this span even during replay. Most users should
+        #   never set this.
+        # @yield Block to call. It is UNSAFE to expect any parameters in this block.
+        # @return [Object] Result of the block.
+        def self.with_completed_span(
+          name,
+          attributes: {},
+          links: nil,
+          kind: nil,
+          exception: nil,
+          even_during_replay: false
+        )
+          span = completed_span(name, attributes:, links:, kind:, exception:, even_during_replay:)
+          if span
+            ::OpenTelemetry::Trace.with_span(span) do # rubocop:disable Style/ExplicitBlockArgument
+              # Yield with no parameters
+              yield
+            end
+          else
+            yield
+          end
+        end
+
+        # Create a completed span only if not replaying (or `even_during_replay` is true).
+        #
+        # @note WARNING: It is UNSAFE to rely on the result of this method as it may be different/absent on replay.
+        #
+        # @param name [String] Span name.
+        # @param attributes [Hash] Span attributes. These will have workflow and run ID automatically added.
+        # @param links [Array, nil] Span links.
+        # @param kind [Symbol, nil] Span kind.
+        # @param exception [Exception, nil] Exception to record on the span.
+        # @param even_during_replay [Boolean] Set to true to record this span even during replay. Most users should
+        #   never set this.
+        # @return [OpenTelemetry::Trace::Span, nil] Span if one was created. WARNING: It is UNSAFE to use this value.
+        def self.completed_span(
+          name,
+          attributes: {},
+          links: nil,
+          kind: nil,
+          exception: nil,
+          even_during_replay: false
+        )
+          # Get root interceptor, which also checks if in workflow
+          root = Temporalio::Workflow.storage[:__temporal_opentelemetry_tracing_interceptor] #: TracingInterceptor?
+          raise 'Tracing interceptor not configured' unless root
+
+          # Do nothing if replaying and not wanted during replay
+          return nil if !even_during_replay && Temporalio::Workflow::Unsafe.replaying?
+
+          # If there is no span on the context and the user hasn't opted in to always creating, do not create. This
+          # prevents orphans if there was no span originally created from the client start-workflow call.
+          if ::OpenTelemetry::Trace.current_span == ::OpenTelemetry::Trace::Span::INVALID &&
+             !root._always_create_workflow_spans
+            return nil
+          end
+
+          # Create attributes, adding user-defined ones
+          attributes = { 'temporalWorkflowID' => Temporalio::Workflow.info.workflow_id,
+                         'temporalRunID' => Temporalio::Workflow.info.run_id }.merge(attributes)
+
+          # Create span, which has to be done with illegal call disabling because OTel asks for full exception message
+          # which uses error highlighting and such which accesses File#path
+          Temporalio::Workflow::Unsafe.illegal_call_tracing_disabled do
+            time = Temporalio::Workflow.now
+            timestamp = (time.to_i * 1_000_000_000) + time.nsec
+            span = root.tracer.start_span(name, attributes:, links:, start_timestamp: timestamp, kind:) # steep:ignore
+            # Record exception if present
+            span.record_exception(exception) if exception
+            # Finish the span (returns self)
+            span.finish(end_timestamp: timestamp)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/error.rb

@@ -124,6 +124,7 @@ module Temporalio
 
       def create_grpc_status
         return Api::Common::V1::GrpcStatus.new(code: @code) unless @raw_grpc_status
+        return @raw_grpc_status if @raw_grpc_status.is_a?(Api::Common::V1::GrpcStatus)
 
         Api::Common::V1::GrpcStatus.decode(@raw_grpc_status)
       end

data/lib/temporalio/internal/bridge/api/activity_task/activity_task.rb

@@ -10,7 +10,7 @@ require 'temporalio/api/common/v1/message'
 require 'temporalio/internal/bridge/api/common/common'
 
 
-descriptor_data = "\n3temporal/sdk/core/activity_task/activity_task.proto\x12\x15\x63oresdk.activity_task\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a$temporal/api/common/v1/message.proto\x1a%temporal/sdk/core/common/common.proto\"\x8d\x01\n\x0c\x41\x63tivityTask\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12-\n\x05start\x18\x03 \x01(\x0b\x32\x1c.coresdk.activity_task.StartH\x00\x12/\n\x06\x63\x61ncel\x18\x04 \x01(\x0b\x32\x1d.coresdk.activity_task.CancelH\x00\x42\t\n\x07variant\"\xed\x06\n\x05Start\x12\x1a\n\x12workflow_namespace\x18\x01 \x01(\t\x12\x15\n\rworkflow_type\x18\x02 \x01(\t\x12\x45\n\x12workflow_execution\x18\x03 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x13\n\x0b\x61\x63tivity_id\x18\x04 \x01(\t\x12\x15\n\ractivity_type\x18\x05 \x01(\t\x12\x45\n\rheader_fields\x18\x06 \x03(\x0b\x32..coresdk.activity_task.Start.HeaderFieldsEntry\x12.\n\x05input\x18\x07 \x03(\x0b\x32\x1f.temporal.api.common.v1.Payload\x12:\n\x11heartbeat_details\x18\x08 \x03(\x0b\x32\x1f.temporal.api.common.v1.Payload\x12\x32\n\x0escheduled_time\x18\t \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x42\n\x1e\x63urrent_attempt_scheduled_time\x18\n \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x30\n\x0cstarted_time\x18\x0b \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x0f\n\x07\x61ttempt\x18\x0c \x01(\r\x12<\n\x19schedule_to_close_timeout\x18\r \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x16start_to_close_timeout\x18\x0e \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x34\n\x11heartbeat_timeout\x18\x0f \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x0cretry_policy\x18\x10 \x01(\x0b\x32#.temporal.api.common.v1.RetryPolicy\x12\x10\n\x08is_local\x18\x11 \x01(\x08\x1aT\n\x11HeaderFieldsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12.\n\x05value\x18\x02 \x01(\x0b\x32\x1f.temporal.api.common.v1.Payload:\x02\x38\x01\"E\n\x06\x43\x61ncel\x12;\n\x06reason\x18\x01 \x01(\x0e\x32+.coresdk.activity_task.ActivityCancelReason*X\n\x14\x41\x63tivityCancelReason\x12\r\n\tNOT_FOUND\x10\x00\x12\r\n\tCANCELLED\x10\x01\x12\r\n\tTIMED_OUT\x10\x02\x12\x13\n\x0fWORKER_SHUTDOWN\x10\x03\x42\x32\xea\x02/Temporalio::Internal::Bridge::Api::ActivityTaskb\x06proto3"
+descriptor_data = "\n3temporal/sdk/core/activity_task/activity_task.proto\x12\x15\x63oresdk.activity_task\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a$temporal/api/common/v1/message.proto\x1a%temporal/sdk/core/common/common.proto\"\x8d\x01\n\x0c\x41\x63tivityTask\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12-\n\x05start\x18\x03 \x01(\x0b\x32\x1c.coresdk.activity_task.StartH\x00\x12/\n\x06\x63\x61ncel\x18\x04 \x01(\x0b\x32\x1d.coresdk.activity_task.CancelH\x00\x42\t\n\x07variant\"\xa1\x07\n\x05Start\x12\x1a\n\x12workflow_namespace\x18\x01 \x01(\t\x12\x15\n\rworkflow_type\x18\x02 \x01(\t\x12\x45\n\x12workflow_execution\x18\x03 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x13\n\x0b\x61\x63tivity_id\x18\x04 \x01(\t\x12\x15\n\ractivity_type\x18\x05 \x01(\t\x12\x45\n\rheader_fields\x18\x06 \x03(\x0b\x32..coresdk.activity_task.Start.HeaderFieldsEntry\x12.\n\x05input\x18\x07 \x03(\x0b\x32\x1f.temporal.api.common.v1.Payload\x12:\n\x11heartbeat_details\x18\x08 \x03(\x0b\x32\x1f.temporal.api.common.v1.Payload\x12\x32\n\x0escheduled_time\x18\t \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x42\n\x1e\x63urrent_attempt_scheduled_time\x18\n \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x30\n\x0cstarted_time\x18\x0b \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x0f\n\x07\x61ttempt\x18\x0c \x01(\r\x12<\n\x19schedule_to_close_timeout\x18\r \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x16start_to_close_timeout\x18\x0e \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x34\n\x11heartbeat_timeout\x18\x0f \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x0cretry_policy\x18\x10 \x01(\x0b\x32#.temporal.api.common.v1.RetryPolicy\x12\x32\n\x08priority\x18\x12 \x01(\x0b\x32 .temporal.api.common.v1.Priority\x12\x10\n\x08is_local\x18\x11 \x01(\x08\x1aT\n\x11HeaderFieldsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12.\n\x05value\x18\x02 \x01(\x0b\x32\x1f.temporal.api.common.v1.Payload:\x02\x38\x01\"E\n\x06\x43\x61ncel\x12;\n\x06reason\x18\x01 \x01(\x0e\x32+.coresdk.activity_task.ActivityCancelReason*X\n\x14\x41\x63tivityCancelReason\x12\r\n\tNOT_FOUND\x10\x00\x12\r\n\tCANCELLED\x10\x01\x12\r\n\tTIMED_OUT\x10\x02\x12\x13\n\x0fWORKER_SHUTDOWN\x10\x03\x42\x32\xea\x02/Temporalio::Internal::Bridge::Api::ActivityTaskb\x06proto3"
 
 pool = Google::Protobuf::DescriptorPool.generated_pool
 pool.add_serialized_file(descriptor_data)