temporalio 0.0.1 → 0.1.0

data/lib/temporalio/connection.rb

@@ -0,0 +1,86 @@
+require 'temporalio/bridge'
+require 'temporalio/bridge/connect_options'
+require 'temporalio/bridge/tls_options'
+require 'temporalio/connection/tls_options'
+require 'temporalio/connection/test_service'
+require 'temporalio/connection/workflow_service'
+require 'temporalio/errors'
+require 'temporalio/runtime'
+require 'uri'
+
+module Temporalio
+  # A connection to the Temporal server. It provides gRPC level communication to a Temporal server.
+  #
+  # Connections are usually used through either a {Temporalio::Client} or a {Temporalio::Worker}.
+  # It may also be used to perform gRPC requests to the server (see {#workflow_service}).
+  class Connection
+    # @api private
+    attr_reader :core_connection
+
+    # @param address [String | nil] `host[:port]` for the Temporal server. Defaults to `localhost:7233`.
+    # @param tls [Temporalio::Connection::TlsOptions | nil] TLS/mTLS options for the connection.
+    #   By default, TLS is disabled.
+    # @param metadata [Hash | nil] gRPC metadata (ie. HTTP headers) to send with each request to the server. Optional.
+    # @param retry_config [Temporalio::Connection::RetryConfig | nil] gRPC retry configuration to use by default on this
+    #   connection.
+    def initialize(
+      address = nil,
+      tls: nil,
+      metadata: nil,
+      retry_config: nil
+    )
+      host, port = parse_url(address)
+
+      runtime = Temporalio::Runtime.instance
+
+      @core_connection = Temporalio::Bridge::Connection.connect(
+        runtime.core_runtime,
+        Temporalio::Bridge::ConnectOptions.new(
+          url: tls ? "https://#{host}:#{port}" : "http://#{host}:#{port}",
+          tls: tls && Temporalio::Bridge::TlsOptions.new(
+            server_root_ca_cert: tls.server_root_ca_cert,
+            client_cert: tls.client_cert,
+            client_private_key: tls.client_private_key,
+            server_name_override: tls.server_name_override,
+          ),
+          metadata: metadata,
+          retry_config: retry_config && Temporalio::Bridge::RetryConfig.new(
+            initial_interval_millis: retry_config.initial_interval_millis,
+            randomization_factor: retry_config.randomization_factor,
+            multiplier: retry_config.multiplier,
+            max_interval_millis: retry_config.max_interval_millis,
+            max_elapsed_time_millis: retry_config.max_elapsed_time_millis,
+            max_retries: retry_config.max_retries,
+          ),
+          client_version: Temporalio::VERSION,
+        ),
+      )
+    end
+
+    # Get an object for making WorkflowService RPCs.
+    #
+    # @return [Temporalio::Connection::WorkflowService]
+    def workflow_service
+      @workflow_service ||= Temporalio::Connection::WorkflowService.new(core_connection)
+    end
+
+    # Get an object for making TestService RPCs.
+    #
+    # @return [Temporalio::Connection::TestService]
+    def test_service
+      @test_service ||= Temporalio::Connection::TestService.new(core_connection)
+    end
+
+    private
+
+    def parse_url(url)
+      url ||= 'localhost:7233'
+
+      # Turn this into a valid URI before parsing
+      uri = URI.parse(url.include?('://') ? url : "//#{url}")
+      raise Temporalio::Error, 'Target host as URL with scheme are not supported' if uri.scheme
+
+      [uri.host || 'localhost', uri.port || 7233]
+    end
+  end
+end

data/lib/{temporal → temporalio}/data_converter.rb

@@ -1,30 +1,60 @@
 require 'temporal/api/common/v1/message_pb'
-require 'temporal/errors'
+require 'temporalio/errors'
+require 'temporalio/failure_converter'
+require 'temporalio/payload_converter'
 
-module Temporal
+module Temporalio
   class DataConverter
-    class MissingPayload < Temporal::Error; end
-
-    def initialize(payload_converter:, payload_codecs:, failure_converter:)
+    class MissingPayload < Temporalio::Error; end
+
+    # Initialize a new data converter with optional payload converter, codecs and failure converter.
+    #
+    # @param payload_converter [Temporalio::PayloadConverter::Base] A custom payload converter for
+    #   converting Ruby values to/from protos. See {Temporalio::PayloadConverter::Base} for the
+    #   interface definition.
+    # @param payload_codecs [Array<Temporalio::PayloadCodec::Base>] A list of payload codecs to
+    #   transform payload protos. See {Temporalio::PayloadCodec::Base} for the interface definition.
+    # @param failure_converter [Temporalio::FailureConverter::Base] A custom failure converter for
+    #   converting Exceptions to/from protos. See {Temporalio::FailureConverter::Base} for the
+    #   interface definition.
+    #
+    # @see https://docs.temporal.io/concepts/what-is-a-data-converter for more information on
+    #   payload converters and codecs.
+    def initialize(
+      payload_converter: Temporalio::PayloadConverter::DEFAULT,
+      payload_codecs: [],
+      failure_converter: Temporalio::FailureConverter::DEFAULT
+    )
       @payload_converter = payload_converter
       @payload_codecs = payload_codecs
       @failure_converter = failure_converter
     end
 
+    def to_payload(value)
+      payload = value_to_payload(value)
+      encoded_payload = encode([payload]).first
+      raise MissingPayload, 'Payload Codecs returned no payloads' unless encoded_payload
+
+      encoded_payload
+    end
+
+    def to_payload_array(data)
+      return [] if data.nil? || Array(data).empty?
+
+      payloads = Array(data).map { |value| value_to_payload(value) }
+      encode(payloads)
+    end
+
     def to_payloads(data)
       return if data.nil? || Array(data).empty?
 
-      payloads = Array(data).map { |value| to_payload(value) }
-      Temporal::Api::Common::V1::Payloads.new(payloads: encode(payloads))
+      payloads = Array(data).map { |value| value_to_payload(value) }
+      Temporalio::Api::Common::V1::Payloads.new(payloads: encode(payloads))
     end
 
     def to_payload_map(data)
       data.to_h do |key, value|
-        payload = to_payload(value)
-        encoded_payload = encode([payload]).first
-        raise MissingPayload, 'Payload Codecs returned no payloads' unless encoded_payload
-
-        [key.to_s, encoded_payload]
+        [key.to_s, to_payload(value)]
       end
     end
 
@@ -33,25 +63,36 @@ module Temporal
       encode_failure(failure)
     end
 
+    def from_payload(payload)
+      decoded_payload = decode([payload]).first
+      raise MissingPayload, 'Payload Codecs returned no payloads' unless decoded_payload
+
+      payload_to_value(decoded_payload)
+    end
+
+    def from_payload_array(payloads)
+      return [] if payloads.empty?
+
+      decode(payloads)
+        .map { |payload| payload_to_value(payload) }
+    end
+
     def from_payloads(payloads)
       return unless payloads
 
       decode(payloads.payloads)
-        .map { |payload| from_payload(payload) }
+        .map { |payload| payload_to_value(payload) }
     end
 
     def from_payload_map(payload_map)
       return unless payload_map
 
       # Protobuf's Hash isn't compatible with the native Hash, ignore rubocop here
-      # rubocop:disable Style/MapToHash
+      # rubocop:disable Style/MapToHash, Style/HashTransformValues
       payload_map.map do |key, payload|
-        decoded_payload = decode([payload]).first
-        raise MissingPayload, 'Payload Codecs returned no payloads' unless decoded_payload
-
-        [key, from_payload(decoded_payload)]
+        [key, from_payload(payload)]
       end.to_h
-      # rubocop:enable Style/MapToHash
+      # rubocop:enable Style/MapToHash, Style/HashTransformValues
     end
 
     def from_failure(failure)
@@ -65,6 +106,14 @@ module Temporal
 
     attr_reader :payload_converter, :payload_codecs, :failure_converter
 
+    def value_to_payload(value)
+      payload_converter.to_payload(value)
+    end
+
+    def payload_to_value(payload)
+      payload_converter.from_payload(payload)
+    end
+
     def encode(payloads)
       return [] unless payloads
 
@@ -85,14 +134,6 @@ module Temporal
       payloads
     end
 
-    def to_payload(data)
-      payload_converter.to_payload(data)
-    end
-
-    def from_payload(payload)
-      payload_converter.from_payload(payload)
-    end
-
     def encode_failure(failure)
       failure = failure.dup
 
@@ -100,19 +141,19 @@ module Temporal
       failure.cause = failure.cause ? encode_failure(failure.cause) : nil
 
       if failure.application_failure_info
-        failure.application_failure_info.details = Temporal::Api::Common::V1::Payloads.new(
+        failure.application_failure_info.details = Temporalio::Api::Common::V1::Payloads.new(
           payloads: encode(failure.application_failure_info.details&.payloads).to_a,
         )
       elsif failure.timeout_failure_info
-        failure.timeout_failure_info.last_heartbeat_details = Temporal::Api::Common::V1::Payloads.new(
+        failure.timeout_failure_info.last_heartbeat_details = Temporalio::Api::Common::V1::Payloads.new(
           payloads: encode(failure.timeout_failure_info.last_heartbeat_details&.payloads).to_a,
         )
       elsif failure.canceled_failure_info
-        failure.canceled_failure_info.details = Temporal::Api::Common::V1::Payloads.new(
+        failure.canceled_failure_info.details = Temporalio::Api::Common::V1::Payloads.new(
           payloads: encode(failure.canceled_failure_info.details&.payloads).to_a,
         )
       elsif failure.reset_workflow_failure_info
-        failure.reset_workflow_failure_info.last_heartbeat_details = Temporal::Api::Common::V1::Payloads.new(
+        failure.reset_workflow_failure_info.last_heartbeat_details = Temporalio::Api::Common::V1::Payloads.new(
           payloads: encode(failure.reset_workflow_failure_info.last_heartbeat_details&.payloads).to_a,
         )
       end
@@ -127,19 +168,19 @@ module Temporal
       failure.cause = failure.cause ? decode_failure(failure.cause) : nil
 
       if failure.application_failure_info
-        failure.application_failure_info.details = Temporal::Api::Common::V1::Payloads.new(
+        failure.application_failure_info.details = Temporalio::Api::Common::V1::Payloads.new(
           payloads: decode(failure.application_failure_info.details&.payloads).to_a,
         )
       elsif failure.timeout_failure_info
-        failure.timeout_failure_info.last_heartbeat_details = Temporal::Api::Common::V1::Payloads.new(
+        failure.timeout_failure_info.last_heartbeat_details = Temporalio::Api::Common::V1::Payloads.new(
           payloads: decode(failure.timeout_failure_info.last_heartbeat_details&.payloads).to_a,
         )
       elsif failure.canceled_failure_info
-        failure.canceled_failure_info.details = Temporal::Api::Common::V1::Payloads.new(
+        failure.canceled_failure_info.details = Temporalio::Api::Common::V1::Payloads.new(
           payloads: decode(failure.canceled_failure_info.details&.payloads).to_a,
         )
       elsif failure.reset_workflow_failure_info
-        failure.reset_workflow_failure_info.last_heartbeat_details = Temporal::Api::Common::V1::Payloads.new(
+        failure.reset_workflow_failure_info.last_heartbeat_details = Temporalio::Api::Common::V1::Payloads.new(
           payloads: decode(failure.reset_workflow_failure_info.last_heartbeat_details&.payloads).to_a,
         )
       end

data/lib/{temporal → temporalio}/error/failure.rb

@@ -1,11 +1,11 @@
 # TODO: Figure out the hierarchy
-require 'temporal/errors'
+require 'temporalio/errors'
 
-module Temporal
+module Temporalio
   class Error
     # Base for runtime failures during workflow/activity execution.
     class Failure < Error
-      # @return [Temporal::Api::Failure::V1::Failure, nil] Original proto failure
+      # @return [Temporalio::Api::Failure::V1::Failure, nil] Original proto failure
       attr_reader :raw
 
       def initialize(message, raw: nil, cause: nil)
@@ -46,7 +46,7 @@ module Temporal
 
     # Error raised on workflow/activity timeout.
     class TimeoutError < Failure
-      # @return [Symbol] Type of timeout error. Refer to {Temporal::TimeoutType}.
+      # @return [Symbol] Type of timeout error. Refer to {Temporalio::TimeoutType}.
       attr_reader :type
 
       # @return [Array<any>] Last heartbeat details if this is for an activity heartbeat.
@@ -119,7 +119,7 @@ module Temporal
       # @return [String] Activity ID for this error.
       attr_reader :activity_id
 
-      # @return [Symbol] Retry state for this error. Refer to {Temporal::RetryState}.
+      # @return [Symbol] Retry state for this error. Refer to {Temporalio::RetryState}.
       attr_reader :retry_state
 
       def initialize(
@@ -164,7 +164,7 @@ module Temporal
       # @return [Integer] Started event ID for this error.
       attr_reader :started_event_id
 
-      # @return [Symbol] Retry state for this error. Refer to {Temporal::RetryState}.
+      # @return [Symbol] Retry state for this error. Refer to {Temporalio::RetryState}.
       attr_reader :retry_state
 
       def initialize(

data/lib/{temporal → temporalio}/error/workflow_failure.rb

@@ -1,9 +1,11 @@
-require 'temporal/errors'
+require 'temporalio/errors'
 
-module Temporal
+module Temporalio
   class Error
     # Used as a wrapper to perserve failure hierarchy in nested calls
     # i.e. WorkflowFailure(ActivityError(WorkflowFailure(CancelledError)))
+    #
+    # @api private
     class WorkflowFailure < Error
       attr_reader :cause
 

data/lib/{temporal → temporalio}/errors.rb

@@ -1,4 +1,4 @@
-module Temporal
+module Temporalio
   # Superclass for all Temporal errors
   class Error < StandardError
     # Superclass for RPC and proto related errors
@@ -18,5 +18,23 @@ module Temporal
         @status = status
       end
     end
+
+    # Superclass for internal errors
+    class Internal < Error; end
+
+    class WorkerShutdown < Internal; end
+
+    # This error is used within the SDK to communicate Activity cancellations
+    # (and whether it was requested by server or not)
+    class ActivityCancelled < Internal
+      def initialize(reason, by_request)
+        super(reason)
+        @by_request = by_request
+      end
+
+      def by_request?
+        @by_request
+      end
+    end
   end
 end

data/lib/{temporal → temporalio}/failure_converter/base.rb

@@ -1,21 +1,21 @@
-module Temporal
+module Temporalio
   module FailureConverter
     # @abstract Use this Interface for implementing your failure converter.
     class Base
       # Convert an Error object to a proto Failure.
       #
       # @param _error [Exception] An Error to be converter.
-      # @param _payload_converter [Temporal::PayloadConverter::Base] A payload converter.
+      # @param _payload_converter [Temporalio::PayloadConverter::Base] A payload converter.
       #
-      # @return [Temporal::Api::Failure::V1::Failure]
+      # @return [Temporalio::Api::Failure::V1::Failure]
       def to_failure(_error, _payload_converter)
         raise NoMethodError, 'must implement #to_failure'
       end
 
       # Convert an proto Failure object to an Error.
       #
-      # @param _failure [Temporal::Api::Failure::V1::Failure] A proto Failure to be converted.
-      # @param _payload_converter [Temporal::PayloadConverter::Base] A payload converter.
+      # @param _failure [Temporalio::Api::Failure::V1::Failure] A proto Failure to be converted.
+      # @param _payload_converter [Temporalio::PayloadConverter::Base] A payload converter.
       #
       # @return [Exception]
       def from_failure(_failure, _payload_converter)

data/lib/{temporal → temporalio}/failure_converter/basic.rb

@@ -1,12 +1,17 @@
 require 'temporal/api/common/v1/message_pb'
 require 'temporal/api/failure/v1/message_pb'
-require 'temporal/error/failure'
-require 'temporal/failure_converter/base'
-require 'temporal/retry_state'
-require 'temporal/timeout_type'
+require 'temporalio/error/failure'
+require 'temporalio/failure_converter/base'
+require 'temporalio/retry_state'
+require 'temporalio/timeout_type'
 
-module Temporal
+module Temporalio
   module FailureConverter
+    # A default implementation of a FailureConverter.
+    #
+    # Use {Temporalio::DataConverter} for the set of helper method for interaction with converters.
+    #
+    # @api private
     class Basic < Base
       def initialize(encode_common_attributes: false)
         super()
@@ -15,25 +20,25 @@ module Temporal
       end
 
       def to_failure(error, payload_converter)
-        return error.raw if error.is_a?(Temporal::Error::Failure) && error.raw
+        return error.raw if error.is_a?(Temporalio::Error::Failure) && error.raw
 
         failure =
           case error
-          when Temporal::Error::ApplicationError
+          when Temporalio::Error::ApplicationError
             to_application_failure(error, payload_converter)
-          when Temporal::Error::TimeoutError
+          when Temporalio::Error::TimeoutError
             to_timeout_failure(error, payload_converter)
-          when Temporal::Error::CancelledError
+          when Temporalio::Error::CancelledError
             to_cancelled_failure(error, payload_converter)
-          when Temporal::Error::TerminatedError
+          when Temporalio::Error::TerminatedError
             to_terminated_failure(error, payload_converter)
-          when Temporal::Error::ServerError
+          when Temporalio::Error::ServerError
             to_server_failure(error, payload_converter)
-          when Temporal::Error::ResetWorkflowError
+          when Temporalio::Error::ResetWorkflowError
             to_reset_workflow_failure(error, payload_converter)
-          when Temporal::Error::ActivityError
+          when Temporalio::Error::ActivityError
             to_activity_failure(error, payload_converter)
-          when Temporal::Error::ChildWorkflowError
+          when Temporalio::Error::ChildWorkflowError
             to_child_workflow_execution_failure(error, payload_converter)
           else
             to_generic_failure(error, payload_converter)
@@ -41,7 +46,8 @@ module Temporal
 
         failure.message = error.message
         failure.stack_trace = error.backtrace&.join("\n") || ''
-        failure.cause = to_failure(error.cause, payload_converter) if error.cause
+        # RBS: StandardError fallback is only needed to satisfy steep - https://github.com/soutaro/steep/issues/477
+        failure.cause = to_failure(error.cause || StandardError.new, payload_converter) if error.cause
 
         if encode_common_attributes?
           failure.encoded_attributes = payload_converter.to_payload(
@@ -102,7 +108,7 @@ module Temporal
         return if data.nil? || Array(data).empty?
 
         payloads = Array(data).map { |value| payload_converter.to_payload(value) }
-        Temporal::Api::Common::V1::Payloads.new(payloads: payloads)
+        Temporalio::Api::Common::V1::Payloads.new(payloads: payloads)
       end
 
       def from_payloads(payloads, payload_converter)
@@ -130,8 +136,8 @@ module Temporal
       end
 
       def to_application_failure(error, payload_converter)
-        Temporal::Api::Failure::V1::Failure.new(
-          application_failure_info: Temporal::Api::Failure::V1::ApplicationFailureInfo.new(
+        Temporalio::Api::Failure::V1::Failure.new(
+          application_failure_info: Temporalio::Api::Failure::V1::ApplicationFailureInfo.new(
             type: error.type,
             non_retryable: error.non_retryable,
             details: to_payloads(error.details, payload_converter),
@@ -140,84 +146,84 @@ module Temporal
       end
 
       def to_timeout_failure(error, payload_converter)
-        Temporal::Api::Failure::V1::Failure.new(
-          timeout_failure_info: Temporal::Api::Failure::V1::TimeoutFailureInfo.new(
-            timeout_type: Temporal::TimeoutType.to_raw(error.type),
+        Temporalio::Api::Failure::V1::Failure.new(
+          timeout_failure_info: Temporalio::Api::Failure::V1::TimeoutFailureInfo.new(
+            timeout_type: Temporalio::TimeoutType.to_raw(error.type),
             last_heartbeat_details: to_payloads(error.last_heartbeat_details, payload_converter),
           ),
         )
       end
 
       def to_cancelled_failure(error, payload_converter)
-        Temporal::Api::Failure::V1::Failure.new(
-          canceled_failure_info: Temporal::Api::Failure::V1::CanceledFailureInfo.new(
+        Temporalio::Api::Failure::V1::Failure.new(
+          canceled_failure_info: Temporalio::Api::Failure::V1::CanceledFailureInfo.new(
             details: to_payloads(error.details, payload_converter),
           ),
         )
       end
 
       def to_terminated_failure(_error, _payload_converter)
-        Temporal::Api::Failure::V1::Failure.new(
-          terminated_failure_info: Temporal::Api::Failure::V1::TerminatedFailureInfo.new,
+        Temporalio::Api::Failure::V1::Failure.new(
+          terminated_failure_info: Temporalio::Api::Failure::V1::TerminatedFailureInfo.new,
         )
       end
 
       def to_server_failure(error, _payload_converter)
-        Temporal::Api::Failure::V1::Failure.new(
-          server_failure_info: Temporal::Api::Failure::V1::ServerFailureInfo.new(
+        Temporalio::Api::Failure::V1::Failure.new(
+          server_failure_info: Temporalio::Api::Failure::V1::ServerFailureInfo.new(
             non_retryable: error.non_retryable,
           ),
         )
       end
 
       def to_reset_workflow_failure(error, payload_converter)
-        Temporal::Api::Failure::V1::Failure.new(
-          reset_workflow_failure_info: Temporal::Api::Failure::V1::ResetWorkflowFailureInfo.new(
+        Temporalio::Api::Failure::V1::Failure.new(
+          reset_workflow_failure_info: Temporalio::Api::Failure::V1::ResetWorkflowFailureInfo.new(
             last_heartbeat_details: to_payloads(error.last_heartbeat_details, payload_converter),
           ),
         )
       end
 
       def to_activity_failure(error, _payload_converter)
-        Temporal::Api::Failure::V1::Failure.new(
-          activity_failure_info: Temporal::Api::Failure::V1::ActivityFailureInfo.new(
+        Temporalio::Api::Failure::V1::Failure.new(
+          activity_failure_info: Temporalio::Api::Failure::V1::ActivityFailureInfo.new(
             scheduled_event_id: error.scheduled_event_id,
             started_event_id: error.started_event_id,
             identity: error.identity,
-            activity_type: Temporal::Api::Common::V1::ActivityType.new(name: error.activity_name || ''),
+            activity_type: Temporalio::Api::Common::V1::ActivityType.new(name: error.activity_name || ''),
             activity_id: error.activity_id,
-            retry_state: Temporal::RetryState.to_raw(error.retry_state),
+            retry_state: Temporalio::RetryState.to_raw(error.retry_state),
           ),
         )
       end
 
       def to_child_workflow_execution_failure(error, _payload_converter)
-        Temporal::Api::Failure::V1::Failure.new(
+        Temporalio::Api::Failure::V1::Failure.new(
           child_workflow_execution_failure_info:
-            Temporal::Api::Failure::V1::ChildWorkflowExecutionFailureInfo.new(
+            Temporalio::Api::Failure::V1::ChildWorkflowExecutionFailureInfo.new(
               namespace: error.namespace,
-              workflow_execution: Temporal::Api::Common::V1::WorkflowExecution.new(
+              workflow_execution: Temporalio::Api::Common::V1::WorkflowExecution.new(
                 workflow_id: error.workflow_id || '',
                 run_id: error.run_id || '',
               ),
-              workflow_type: Temporal::Api::Common::V1::WorkflowType.new(name: error.workflow_name || ''),
+              workflow_type: Temporalio::Api::Common::V1::WorkflowType.new(name: error.workflow_name || ''),
               initiated_event_id: error.initiated_event_id,
               started_event_id: error.started_event_id,
-              retry_state: Temporal::RetryState.to_raw(error.retry_state),
+              retry_state: Temporalio::RetryState.to_raw(error.retry_state),
             ),
         )
       end
 
       def to_generic_failure(error, _payload_converter)
-        Temporal::Api::Failure::V1::Failure.new(
-          application_failure_info: Temporal::Api::Failure::V1::ApplicationFailureInfo.new(
+        Temporalio::Api::Failure::V1::Failure.new(
+          application_failure_info: Temporalio::Api::Failure::V1::ApplicationFailureInfo.new(
             type: error.class.name,
           ),
         )
       end
 
       def from_application_failure(failure, failure_info, cause, payload_converter)
-        Temporal::Error::ApplicationError.new(
+        Temporalio::Error::ApplicationError.new(
           failure.message || 'Application error',
           type: failure_info.type,
           details: from_payloads(failure_info.details, payload_converter),
@@ -228,9 +234,9 @@ module Temporal
       end
 
       def from_timeout_failure(failure, failure_info, cause, payload_converter)
-        Temporal::Error::TimeoutError.new(
+        Temporalio::Error::TimeoutError.new(
           failure.message || 'Timeout',
-          type: Temporal::TimeoutType.from_raw(failure_info.timeout_type),
+          type: Temporalio::TimeoutType.from_raw(failure_info.timeout_type),
           last_heartbeat_details: from_payloads(failure_info.last_heartbeat_details, payload_converter),
           raw: failure,
           cause: cause,
@@ -238,7 +244,7 @@ module Temporal
       end
 
       def from_cancelled_failure(failure, failure_info, cause, payload_converter)
-        Temporal::Error::CancelledError.new(
+        Temporalio::Error::CancelledError.new(
           failure.message || 'Cancelled',
           details: from_payloads(failure_info.details, payload_converter),
           raw: failure,
@@ -247,7 +253,7 @@ module Temporal
       end
 
       def from_terminated_failure(failure, _failure_info, cause, _payload_converter)
-        Temporal::Error::TerminatedError.new(
+        Temporalio::Error::TerminatedError.new(
           failure.message || 'Terminated',
           raw: failure,
           cause: cause,
@@ -255,7 +261,7 @@ module Temporal
       end
 
       def from_server_failure(failure, failure_info, cause, _payload_converter)
-        Temporal::Error::ServerError.new(
+        Temporalio::Error::ServerError.new(
           failure.message || 'Server error',
           non_retryable: failure_info.non_retryable,
           raw: failure,
@@ -264,7 +270,7 @@ module Temporal
       end
 
       def from_reset_workflow_failure(failure, failure_info, cause, payload_converter)
-        Temporal::Error::ResetWorkflowError.new(
+        Temporalio::Error::ResetWorkflowError.new(
           failure.message || 'Reset workflow error',
           last_heartbeat_details: from_payloads(failure_info.last_heartbeat_details, payload_converter),
           raw: failure,
@@ -273,21 +279,21 @@ module Temporal
       end
 
       def from_activity_failure(failure, failure_info, cause, _payload_converter)
-        Temporal::Error::ActivityError.new(
+        Temporalio::Error::ActivityError.new(
           failure.message || 'Activity error',
           scheduled_event_id: failure_info.scheduled_event_id,
           started_event_id: failure_info.started_event_id,
           identity: failure_info.identity,
           activity_name: failure_info.activity_type&.name,
           activity_id: failure_info.activity_id,
-          retry_state: Temporal::RetryState.from_raw(failure_info.retry_state),
+          retry_state: Temporalio::RetryState.from_raw(failure_info.retry_state),
           raw: failure,
           cause: cause,
         )
       end
 
       def from_child_workflow_execution_failure(failure, failure_info, cause, _payload_converter)
-        Temporal::Error::ChildWorkflowError.new(
+        Temporalio::Error::ChildWorkflowError.new(
           failure.message || 'Child workflow error',
           namespace: failure_info.namespace,
           workflow_id: failure_info.workflow_execution&.workflow_id,
@@ -295,14 +301,14 @@ module Temporal
           workflow_name: failure_info.workflow_type&.name,
           initiated_event_id: failure_info.initiated_event_id,
           started_event_id: failure_info.started_event_id,
-          retry_state: Temporal::RetryState.from_raw(failure_info.retry_state),
+          retry_state: Temporalio::RetryState.from_raw(failure_info.retry_state),
           raw: failure,
           cause: cause,
         )
       end
 
       def from_generic_failure(failure, cause, _payload_converter)
-        Temporal::Error::Failure.new(
+        Temporalio::Error::Failure.new(
           failure.message || 'Failure error',
           raw: failure,
           cause: cause,