aws-flow 2.0.2 → 2.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OTZjNzcwMDhjZjc5MzZlNjZjOTlmZDgxYjQzMmNlZmVkOWE1YTFhZA==
+    YzZjOTA1Y2MzMjE0MTg0N2I2ZjAwMjQ0ZjY0NDBhNGQ1YjhjMTA1NQ==
   data.tar.gz: !binary |-
-    NzNhZDZlZmI5Y2JiMGU1OTY2NjEwNGIzZDEwZTJjNDAyYTVhMmVkNQ==
+    MzI3ZjhmNTE4ZTZhNWFkOTc2NGFiYTgxYjhlN2JiMDNmYWIwYmUwYw==
 SHA512:
   metadata.gz: !binary |-
-    N2U0N2RjOWIzYWExM2JmMzI2ZDc2NjgyNzNmNjA0OThlZjcyNGM2YTQwNDEy
-    NTg5ZTVlZTU3MmYwMjU5NzA3NzgyNzUwOWE2ZGMwNmU1YzE1MWE1Njk3MjBh
-    ODBjM2I5NjMyNWM5MGExYWE2NjdiMGM5MjA5NTQ2YTY1OGZiZTQ=
+    Mzc5NDdjMzcyMGZlNmZmODQ1YTMxYzU5ZTU2MjVhZDZhZjcyMWZmZjMzZDU0
+    ODgyNmU3ZjdlZDk5MDc1MWYyMDVlY2IzZjk4NGFlN2Q2NDkwYTI1YjAxOWFl
+    M2Q0NDQ3MDI3NTkyNzZiNTZiNGM5ZDYwNGZiMDM2MDhhMjRlMGQ=
   data.tar.gz: !binary |-
-    ODFiYmQyY2NmNTA0MTg0OGIzOGI0Y2Q5ZTUyZmVjNWE1ZTBhMDI5MzQ1OThl
-    NDNjNDhhN2U2ODNjYWU1ZGQ1MTM2NDkyNDJjNDlhYmEzYTcwNzFlOWQzOGQ0
-    ZDg5NTMzYmI2OWE4NmExMTEzZjZjMzA4ZTVhZTBmM2MxZjk4MmE=
+    Njk4Y2ZkMzUxNGY5ZGI3MjA1NGI2YTQ5N2QwYTBlZDFiMzU3ZWIxZDIxOGZl
+    NjViN2YyZjE3ODgzZjBjMGNhYzA2YjU5MTllODI5ODdiMjFkZjQ4M2QzYTM1
+    NzZhNmFmNTYxM2E2MTMyMTQyOGI5NjY5OTU0N2I0YzBiZGI3N2Q=

data/Rakefile

@@ -17,19 +17,19 @@ require "rspec/core/rake_task"
 
 desc "Run unit tests"
 RSpec::Core::RakeTask.new(:unit_tests) do |spec|
-  spec.rspec_opts = ['--color', '--format nested']
+  spec.rspec_opts = ['--color', '--format nested', '--profile']
   spec.pattern = 'spec/**/unit/*.rb'
 end
 
 desc "Run integration tests"
 RSpec::Core::RakeTask.new(:integration_tests) do |spec|
-  spec.rspec_opts = ['--color', '--format nested']
+  spec.rspec_opts = ['--color', '--format nested', '--profile']
   spec.pattern = 'spec/**/integration/*.rb'
 end
 
 desc "Run all tests"
 RSpec::Core::RakeTask.new(:all_tests) do |spec|
-  spec.rspec_opts = ['--color', '--format nested']
+  spec.rspec_opts = ['--color', '--format nested', '--profile']
   spec.pattern = 'spec/**/*.rb'
 end
 

data/lib/aws/decider/activity_definition.rb

@@ -69,16 +69,21 @@ module AWS
             result = @instance.send(@activity_method, *ruby_input)
           end
         rescue Exception => e
-          #TODO we need the proper error handling here
           raise e if e.is_a? CancellationException
-          raise ActivityFailureException.new(e.message, @converter.dump(e))
+
+          # Check if serialized exception violates the 32k limit and truncate it
+          reason, converted_failure = AWS::Flow::Utilities::check_and_truncate_exception(e, @converter)
+
+          # Wrap the exception that we got into an ActivityFailureException so
+          # that the task poller can handle it properly.
+          raise ActivityFailureException.new(reason, converted_failure)
         ensure
           @instance._activity_execution_context = nil
         end
         converted_result = @converter.dump(result)
         # We are going to have to convert this object into a string to submit it, and that's where the 32k limit will be enforced, so it's valid to turn the object to a string and check the size of the result
-        if converted_result.to_s.size > 32768
-          return @converter.dump("The result was too large, so we could not serialize it correctly. You can find the full result in the ActivityTaskPoller logs."), result, true
+        if converted_result.to_s.size > FlowConstants::DATA_LIMIT
+          return converted_result, result, true
         end
         return converted_result, result, false
       end

data/lib/aws/decider/async_decider.rb

@@ -278,27 +278,16 @@ module AWS
       def make_fail_decision(decision_id, failure)
         decision_type = "FailWorkflowExecution"
 
-        # Sizes taken from
-        # http://docs.aws.amazon.com/amazonswf/latest/apireference/API_FailWorkflowExecutionDecisionAttributes.html
-        #reason = failure.reason if (failure.respond_to? :reason)
-        max_response_size = 32768
-        truncation_overhead = 8000
-        reason ||= failure.message.slice(0, 255)
-        detail_size = max_response_size - truncation_overhead
-
-        # If you don't have details, you must be some other type of
-        # exception. We can't do anything exceedingly clever, so lets just get
-        # the stack trace and pop that out.
-        details = failure.details if (failure.respond_to? :details)
-        details ||= failure.backtrace.join("")
-        new_details = details[0..(max_response_size - truncation_overhead)]
-        if details.length > (max_response_size - truncation_overhead)
-          new_details += "->->->->->THIS BACKTRACE WAS TRUNCATED"
-        end
-        # details.unshift(reason)
-        # details = details.join("\n")
-
-        fail_workflow_execution_decision_attributes = {:reason => reason, :details => new_details}
+        # Get the reason from the failure. Or get the message if a
+        # CancellationException is initialized without a reason. Fall back to
+        # a default string if nothing is provided
+        reason = failure.reason || failure.message || "Workflow failure did not provide any reason."
+        # Get the details from the failure. Or get the backtrace if a
+        # CancellationException is initialized without a details. Fall back to
+        # a default string if nothing is provided
+        details = failure.details || failure.backtrace.to_s || "Workflow failure did not provide any details."
+
+        fail_workflow_execution_decision_attributes = { reason: reason, details: details }
         decision = {:decision_type => decision_type, :fail_workflow_execution_decision_attributes => fail_workflow_execution_decision_attributes}
         CompleteWorkflowStateMachine.new(decision_id, decision)
 
@@ -352,7 +341,7 @@ module AWS
             else
               @decision_helper[decision_id] = make_completion_decision(decision_id, {
                                                                          :decision_type => "CompleteWorkflowExecution",
-                                                                         :complete_workflow_execution_decision_attributes => {:result => @result.get}})
+                                                                         :complete_workflow_execution_decision_attributes => {:result => @result.get }})
             end
           end
         end

data/lib/aws/decider/executor.rb

@@ -158,7 +158,7 @@ module AWS
           if status.success?
             @log.debug "Child process #{pid} exited successfully"
           else
-            @log.error "Child process #{pid} exited with non-zero status code"
+            @log.error "Child process #{pid} exited with non-zero status code: #{status}"
           end
 
           # Reap

data/lib/aws/decider/flow_defaults.rb

@@ -96,6 +96,20 @@ module AWS
         attr_reader :exponential_retry_maximum_retry_interval_seconds, :exponential_retry_retry_expiration_seconds, :exponential_retry_backoff_coefficient, :exponential_retry_maximum_attempts, :exponential_retry_function, :default_data_converter, :exponential_retry_exceptions_to_include, :exponential_retry_exceptions_to_exclude, :jitter_function, :should_jitter, :exponential_retry_initial_retry_interval, :use_worker_task_list
       end
 
+      # Sizes taken from
+      # http://docs.aws.amazon.com/amazonswf/latest/apireference/API_FailWorkflowExecutionDecisionAttributes.html
+      DATA_LIMIT = 32768
+
+      # Number of chars that can fit in FlowException's reason
+      REASON_LIMIT = 256
+      # Number of chars that can fit in FlowException's details. Same as
+      # DATA_LIMIT
+      DETAILS_LIMIT = DATA_LIMIT
+      # This is the truncation overhead for serialization.
+      TRUNCATION_OVERHEAD = 8000
+      # Truncation string added to the end of a trucated string"
+      TRUNCATED = "[TRUNCATED]"
+
       INFINITY = -1
       RETENTION_DEFAULT = 7
       NUM_OF_WORKERS_DEFAULT = 1

data/lib/aws/decider/task_poller.rb

@@ -64,19 +64,40 @@ module AWS
           @logger.info Utilities.workflow_task_to_debug_string("Got decision task", task)
 
           task_completed_request = @handler.handle_decision_task(task)
-          @logger.debug "Response to the task will be #{task_completed_request}"
+          @logger.debug "Response to the task will be #{task_completed_request.inspect}"
+
           if !task_completed_request[:decisions].empty? && (task_completed_request[:decisions].first.keys.include?(:fail_workflow_execution_decision_attributes))
             fail_hash = task_completed_request[:decisions].first[:fail_workflow_execution_decision_attributes]
             reason = fail_hash[:reason]
             details = fail_hash[:details]
-            @logger.debug "#{reason}, #{details}"
           end
-          @service.respond_decision_task_completed(task_completed_request)
+
+          begin
+            @service.respond_decision_task_completed(task_completed_request)
+          rescue AWS::SimpleWorkflow::Errors::ValidationException => e
+            if e.message.include? "failed to satisfy constraint: Member must have length less than or equal to"
+              # We want to ensure that the WorkflowWorker doesn't just sit around and
+              # time the workflow out. If there is a validation failure possibly
+              # because of large inputs to child workflows/activities or large custom
+              # exceptions we should fail the workflow with some minimal details.
+              task_completed_request[:decisions] = [
+                {
+                  decision_type: "FailWorkflowExecution",
+                  fail_workflow_execution_decision_attributes: {
+                    reason: Utilities.validation_error_string("Workflow"),
+                    details: "AWS::SimpleWorkflow::Errors::ValidationException"
+                  }
+                }
+              ]
+              @service.respond_decision_task_completed(task_completed_request)
+            end
+            @logger.error "#{task.workflow_type.inspect} failed with exception: #{e.inspect}"
+          end
           @logger.info Utilities.workflow_task_to_debug_string("Finished executing task", task)
         rescue AWS::SimpleWorkflow::Errors::UnknownResourceFault => e
-          @logger.error "Error in the poller, #{e.class}, #{e}"
+          @logger.error "Error in the poller, #{e.inspect}"
         rescue Exception => e
-          @logger.error "Error in the poller, #{e.class}, #{e}"
+          @logger.error "Error in the poller, #{e.inspect}"
         end
       end
     end
@@ -135,19 +156,23 @@ module AWS
         begin
           context = ActivityExecutionContext.new(@service, @domain, task)
           unless activity_implementation = @activity_definition_map[activity_type]
-            raise "This activity worker was told to work on activity type #{activity_type.name}.#{activity_type.version}, but this activity worker only knows how to work on #{@activity_definition_map.keys.map(&:name).join' '}"
+            raise "This activity worker was told to work on activity type "\
+              "#{activity_type.inspect}, but this activity worker only knows "\
+              "how to work on #{@activity_definition_map.keys.map(&:name).join' '}"
           end
 
           output, original_result, too_large = activity_implementation.execute(task.input, context)
 
-           @logger.debug "Responding on task_token #{task.task_token} for task #{task}."
+           @logger.debug "Responding on task_token #{task.task_token.inspect}."
           if too_large
-            @logger.error "Activity #{activity_type.name}.#{activity_type.version} failed: The output of this activity was too large (greater than 2^15), and therefore aws-flow could not return it to SWF. aws-flow is now attempting to mark this activity as failed. For reference, the result was #{original_result}"
+            @logger.error "#{task.activity_type.inspect} failed: "\
+              "#{Utilities.validation_error_string_partial("Activity")} For "\
+              "reference, the result was #{original_result}"
 
             respond_activity_task_failed_with_retry(
               task.task_token,
-              "An activity cannot send a response with a result larger than 32768 characters. Please reduce the response size. A truncated prefix output is included in the details field.",
-              output
+              Utilities.validation_error_string("Activity"),
+              ""
             )
           elsif ! activity_implementation.execution_options.manual_completion
             @service.respond_activity_task_completed(
@@ -156,15 +181,13 @@ module AWS
             )
           end
         rescue ActivityFailureException => e
-          @logger.error "Activity #{activity_type.name}.#{activity_type.version} with input #{task.input} failed with exception #{e}."
-
+          @logger.error "#{task.activity_type.inspect} failed with exception: #{e.inspect}."
           respond_activity_task_failed_with_retry(
             task.task_token,
             e.message,
             e.details
           )
         end
-        #TODO all the completion stuffs
       end
 
       # Responds to the decider that the activity task has failed, and attempts
@@ -208,7 +231,28 @@ module AWS
       #   is cancelled.
       #
       def respond_activity_task_canceled(task_token, message)
-        @service.respond_activity_task_canceled({:task_token => task_token, :details => message})
+
+        begin
+          @service.respond_activity_task_canceled(
+            :task_token => task_token,
+            :details => message
+          )
+        rescue AWS::SimpleWorkflow::Errors::ValidationException => e
+          if e.message.include? "failed to satisfy constraint: Member must have length less than or equal to"
+            # We want to ensure that the ActivityWorker doesn't just sit
+            # around and time the activity out. If there is a validation failure
+            # possibly because of large custom exceptions we should fail the
+            # activity task with some minimal details
+            respond_activity_task_failed_with_retry(
+              task_token,
+              Utilities.validation_error_string("Activity"),
+              "AWS::SimpleWorkflow::Errors::ValidationException"
+            )
+          end
+          @logger.error "respond_activity_task_canceled call failed with "\
+            "exception: #{e.inspect}"
+        end
+
       end
 
       # Responds to the decider that the activity task has failed. No retry is
@@ -231,7 +275,28 @@ module AWS
       #
       def respond_activity_task_failed(task_token, reason, details)
         @logger.debug "The task token to be reported on is #{task_token}"
-        @service.respond_activity_task_failed(:task_token => task_token, :reason => reason.to_s, :details => details.to_s)
+
+        begin
+          @service.respond_activity_task_failed(
+            task_token: task_token,
+            reason: reason.to_s,
+            details: details.to_s
+          )
+        rescue AWS::SimpleWorkflow::Errors::ValidationException => e
+          if e.message.include? "failed to satisfy constraint: Member must have length less than or equal to"
+            # We want to ensure that the ActivityWorker doesn't just sit
+            # around and time the activity out. If there is a validation failure
+            # possibly because of large custom exceptions we should fail the
+            # activity task with some minimal details
+            respond_activity_task_failed_with_retry(
+              task.task_token,
+              Utilities.validation_error_string("Activity"),
+              "AWS::SimpleWorkflow::Errors::ValidationException"
+            )
+          end
+          @logger.error "respond_activity_task_failed call failed with "\
+            "exception: #{e.inspect}"
+        end
       end
 
       # Processes the specified activity task.
@@ -263,18 +328,17 @@ module AWS
           begin
             execute(task)
           rescue CancellationException => e
-            @logger.error "Got an error, #{e.message}, while executing #{task.activity_type.name}."
+            @logger.error "#{task.activity_type.inspect} failed with exception: #{e.inspect}"
             respond_activity_task_canceled_with_retry(task.task_token, e.message)
           rescue Exception => e
-            @logger.error "Got an error, #{e.message}, while executing #{task.activity_type.name}. Full stack trace: #{e.backtrace}"
+            @logger.error "#{task.activity_type.inspect} failed with exception: #{e.inspect}"
             respond_activity_task_failed_with_retry(task.task_token, e.message, e.backtrace)
-            #Do rescue stuff
           ensure
             @poll_semaphore.release
           end
         rescue Exception => e
           semaphore_needs_release = true
-          @logger.error "Got into the other error mode: #{e}"
+          @logger.error "Error in the poller, exception: #{e.inspect}. stacktrace: #{e.backtrace}"
           raise e
         ensure
           @poll_semaphore.release if semaphore_needs_release
@@ -307,7 +371,7 @@ module AWS
             @logger.info Utilities.activity_task_to_debug_string("Got activity task", task)
           end
         rescue Exception => e
-          @logger.error "Error in the poller, #{e.class}, #{e}"
+          @logger.error "Error in the poller, #{e.inspect}"
           @poll_semaphore.release
           return false
         end

data/lib/aws/decider/utilities.rb

@@ -40,6 +40,20 @@ module AWS
         return "#{message} #{task.activity_type.name}.#{task.activity_type.version} with input: #{task.input} and task_token: #{task.task_token}"
       end
 
+      # The following two methods are used to generate an error string when
+      # response size of a workflow or activity is greater than 32k.
+      def self.validation_error_string_partial(infix)
+        str = infix.downcase == "workflow" ? "A" : "An"
+        str += " #{infix} cannot send a response with data larger than "\
+          "#{FlowConstants::DATA_LIMIT} characters. Please limit the size of the "\
+          "response."
+        str
+      end
+
+      def self.validation_error_string(infix)
+        "#{self.validation_error_string_partial(infix)} You can look at the "\
+          "#{infix} Worker logs to see the original response."
+      end
 
       # @api private
       def self.drill_on_future(future)
@@ -73,6 +87,78 @@ module AWS
         client_options
       end
 
+      # @api private
+      # This method is used to truncate Activity and Workflow exceptions to
+      # fit them into responses to the SWF service.
+      def self.check_and_truncate_exception error, converter
+
+        # serialize the exception so that we can check the actual size of the
+        # payload.
+        converted_failure = converter.dump(error)
+        # get the reason/message of the exception
+        reason = error.message
+
+        # truncate the reason if needed and add a smaller version of the
+        # truncation string at the end
+        if reason.size > FlowConstants::REASON_LIMIT
+          # saving some space at the end to add the truncation string
+          reason = reason.slice(0, FlowConstants::REASON_LIMIT - FlowConstants::TRUNCATED.size)
+          reason += FlowConstants::TRUNCATED
+        end
+
+        if converted_failure.to_s.size > FlowConstants::DETAILS_LIMIT
+          detail_limit = FlowConstants::DETAILS_LIMIT - (reason.size + FlowConstants::TRUNCATION_OVERHEAD)
+          # Get the exception details if the exception is from the flow family of
+          # exceptions
+          details = error.details if error.respond_to? :details
+          # If you don't have details, you must be some other type of
+          # exception. We can't do anything exceedingly clever, so lets just get
+          # the stack trace and pop that out.
+          details ||= error.backtrace.join unless error.backtrace.nil?
+          details ||= ""
+
+          # If the exception was indeed a flow family of exceptions, then details
+          # inside would most likely be another exception. Instead of digging for
+          # more exceptions inside this one, let's just get all the information
+          # from this class and put it in a string so that we can truncate and
+          # serialize it.
+          if details.is_a? Exception
+            details = "exception.class=#{details.class}|exception.message=#{details.message}|exception.backtrace=#{details.backtrace}"
+            if details.respond_to? :details
+              details += "|exception.details=#{details.details}"
+            end
+          end
+
+          # truncate the details if needed and add truncation string at the end
+          if details.size > detail_limit
+            # saving some space at the end to add the truncation string
+            details = details.slice(0, detail_limit - FlowConstants::TRUNCATED.size)
+            details += FlowConstants::TRUNCATED
+          end
+
+          # Here we generate a new exception with the reason and details that we
+          # got above. We are using the 'exception' factory method instead of
+          # initializing it directly because Flow Exceptions' constructors are not
+          # uniform and could require 2..4 arguments. Whereas a regular ruby
+          # exception only requires 0..1. Other custom exceptions could require
+          # arbitrary number of arguments.
+          new_exception = error.exception(reason)
+          if new_exception.respond_to? :details
+            new_exception.details = details
+          else
+            new_exception.set_backtrace(details)
+          end
+          converted_failure = converter.dump(new_exception)
+
+        end
+
+        # Return back both - reason and exception so that the caller doesn't
+        # need to check whether this exception responds to :reason or not, i.e.
+        # whether this is a flow exception or a regular ruby exception
+        [reason, converted_failure]
+
+      end
+
 
       # @api private
       def self.interpret_block_for_options(option_class, block, use_defaults = false)

data/lib/aws/decider/version.rb

@@ -16,7 +16,7 @@
 module AWS
   module Flow
     def self.version
-      "2.0.2"
+      "2.1.0"
     end
   end
 end

data/lib/aws/decider/workflow_client.rb

@@ -346,10 +346,10 @@ module AWS
         client_options = Utilities::client_options_from_method_name(method_name, @options)
         options = Utilities::merge_all_options(client_options, options)
 
-        @converter ||= YAMLDataConverter.new
+        @data_converter = options[:data_converter]
         # Basically, we want to avoid the special "NoInput, but allow stuff like nil in"
         if ! (input.class <= NoInput || input.empty?)
-          options[:input] = @converter.dump input
+          options[:input] = @data_converter.dump input
         end
         if @workflow_class.nil?
           execution_method = @options.execution_method

data/lib/aws/decider/workflow_definition.rb

@@ -50,15 +50,32 @@ module AWS
               method_output.set(@instance.send(@workflow_method, *ruby_input))
             end
           end
-          t.rescue(Exception) do |error|
-            @failure = WorkflowException.new(error.message, @converter.dump(error))
-            #TODO error handling stuff
+          t.rescue(Exception) do |e|
+
+            # Check if serialized exception violates the 32k limit and truncate it
+            reason, converted_failure = AWS::Flow::Utilities::check_and_truncate_exception(e, @converter)
+
+            # Wrap the exception that we got into a WorkflowException so that it
+            # can be handled correctly.
+
+            @failure = WorkflowException.new(reason, converted_failure)
           end
           t.ensure do
             raise @failure if @failure
-            result.set(@converter.dump method_output.get)
+            # We are going to have to convert this object into a string to submit it,
+            # and that's where the 32k limit will be enforced, so it's valid to turn
+            # the object to a string and check the size of the result
+            output = @converter.dump method_output.get
+
+            if output.to_s.size > FlowConstants::DATA_LIMIT
+              raise WorkflowException.new(
+                Utilities.validation_error_string_partial("Workflow"),
+                ""
+              )
+            end
+            result.set(output)
+          end
           end
-        end
         return result
       end
 

data/lib/aws/flow/flow_utils.rb

@@ -25,6 +25,7 @@ module AWS
         def initialize(reason = nil, details = nil)
           @reason = reason
           @details = details
+          super(reason)
         end
       end
 

data/lib/aws/runner.rb

@@ -194,7 +194,7 @@ module AWS
           task_list = expand_task_list(w['task_list'])
 
           # create a worker
-          worker = ActivityWorker.new(swf.client, domain, task_list, *w['activities']) {{ max_workers: fork_count }}
+          worker = ActivityWorker.new(swf.client, domain, task_list, *w['activities']) {{ execution_workers: fork_count }}
           add_implementations(worker, w, {config_key: 'activity_classes',
                      clazz: AWS::Flow::Activities})
 

data/spec/aws/decider/integration/activity_spec.rb

@@ -189,12 +189,11 @@ describe Activities do
 
       activity :run_activity1, :run_activity2, :run_activity3, :run_activity4 do
         {
-          default_task_heartbeat_timeout: 60,
           version: "1.0",
           default_task_list: "large_activity_task_list",
-          default_task_schedule_to_close_timeout: 10,
-          default_task_schedule_to_start_timeout: 5,
-          default_task_start_to_close_timeout: 5,
+          default_task_schedule_to_close_timeout: 60,
+          default_task_schedule_to_start_timeout: 30,
+          default_task_start_to_close_timeout: 30,
           exponential_retry: {
             retries_per_exception: {
               ActivityTaskTimedOutException => Float::INFINITY,

data/spec/aws/decider/integration/integration_spec.rb

@@ -191,29 +191,288 @@ describe "RubyFlowDecider" do
     @my_workflow_client = workflow_client(@domain.client, @domain) { { from_class: @workflow_class } }
   end
 
-  it "ensures that an activity returning more than 32k data fails the activity" do
-    general_test(:task_list => "ActivityTaskLargeOutput", :class_name => "ActivityTaskLargeOutput")
-    @activity_class.class_eval do
-      def run_activity1
-        # Make sure we return something that's over 32k. Note this won't
-        # necessarily work with all converters, as it's pretty trivially
-        # compressible
-        return ":" + "a" * 33000
+  describe "Workflow/Activity return values/exceptions" do
+    it "ensures that an activity returning more than 32k data fails the activity" do
+      general_test(:task_list => "ActivityTaskLargeOutput", :class_name => "ActivityTaskLargeOutput")
+      @activity_class.class_eval do
+        def run_activity1
+          # Make sure we return something that's over 32k. Note this won't
+          # necessarily work with all converters, as it's pretty trivially
+          # compressible
+          return ":" + "a" * 33000
+        end
       end
+      workflow_execution = @my_workflow_client.start_execution
+      @worker.run_once
+      @activity_worker.run_once
+      @worker.run_once
+      wait_for_execution(workflow_execution)
+      history_events = workflow_execution.events.map(&:event_type)
+      # Previously, it would time out, as the failure would include the original
+      # large output that killed the completion and failure call. Thus, we need to
+      # check that we fail the ActivityTask.
+      history_events.should include "ActivityTaskFailed"
+
+      workflow_execution.events.to_a.last.attributes.details.should_not =~ /Psych/
+      workflow_execution.events.to_a.last.attributes.reason.should == Utilities.validation_error_string("Activity")
+      history_events.last.should == "WorkflowExecutionFailed"
+    end
+
+    it "ensures that an activity returning an exception of size more than 32k fails the activity correctly and truncates the message" do
+      general_test(:task_list => "ActivityTaskExceptionLargeOutput", :class_name => "ActivityTaskExceptionLargeOutput")
+      @activity_class.class_eval do
+        def run_activity1
+          raise  ":" + "a" * 33000
+        end
+      end
+      workflow_execution = @my_workflow_client.start_execution
+      @worker.run_once
+      @activity_worker.run_once
+      @worker.run_once
+      wait_for_execution(workflow_execution)
+      history_events = workflow_execution.events.map(&:event_type)
+      # Previously, it would time out, as the failure would include the original
+      # large output that killed the completion and failure call. Thus, we need to
+      # check that we fail the ActivityTask.
+      history_events.should include "ActivityTaskFailed"
+
+      workflow_execution.events.to_a.last.attributes.details.should_not =~ /Psych/
+      history_events.last.should == "WorkflowExecutionFailed"
+      workflow_execution.events.to_a.last.attributes.reason.should include("[TRUNCATED]")
+      details = workflow_execution.events.to_a.last.attributes.details
+      exception = FlowConstants.default_data_converter.load(details)
+      exception.class.should == AWS::Flow::ActivityTaskFailedException
+    end
+
+    it "ensures that an activity returning a Cancellation Exception of size more than 32k fails the activity" do
+      general_test(:task_list => "ActivityTaskCancellationExceptionLargeOutput", :class_name => "ActivityTaskCancellationExceptionLargeOutput")
+      @activity_class.class_eval do
+        def run_activity1
+          raise  CancellationException.new("a" * 33000)
+        end
+      end
+      workflow_execution = @my_workflow_client.start_execution
+      @worker.run_once
+      @activity_worker.run_once
+      @worker.run_once
+      wait_for_execution(workflow_execution)
+      history_events = workflow_execution.events.map(&:event_type)
+      history_events.should include "ActivityTaskFailed"
+
+      history_events.last.should == "WorkflowExecutionFailed"
+      event = workflow_execution.events.to_a.select { |x| x.event_type == "ActivityTaskFailed"}
+      event.first.attributes.reason.should == Utilities.validation_error_string("Activity")
+      event.first.attributes.details.should == "AWS::SimpleWorkflow::Errors::ValidationException"
+    end
+
+    it "ensures that a workflow output > 32k fails the workflow" do
+      general_test(:task_list => "WorkflowOutputTooLarge", :class_name => "WorkflowOutputTooLarge")
+      @workflow_class.class_eval do
+        def entry_point
+          return ":" + "a" * 33000
+        end
+      end
+      workflow_execution = @my_workflow_client.start_execution
+      @worker.run_once
+      wait_for_execution(workflow_execution)
+      last_event = workflow_execution.events.to_a.last
+      last_event.event_type.should == "WorkflowExecutionFailed"
+      last_event.attributes.reason.should == Utilities.validation_error_string_partial("Workflow")
+    end
+
+    it "ensures that a workflow exception details > 32k fails the workflow correctly and truncates the details" do
+      general_test(:task_list => "WorkflowExceptionDetailsTooLarge", :class_name => "WorkflowExceptionDetailsTooLarge")
+      @workflow_class.class_eval do
+        def entry_point
+          e = RuntimeError.new("a")
+          e.set_backtrace("a"*25769)
+          raise e
+        end
+      end
+      workflow_execution = @my_workflow_client.start_execution
+      @worker.run_once
+      wait_for_execution(workflow_execution)
+      last_event = workflow_execution.events.to_a.last
+      last_event.event_type.should == "WorkflowExecutionFailed"
+      details = workflow_execution.events.to_a.last.attributes.details
+      exception = FlowConstants.default_data_converter.load(details)
+      exception.class.should == RuntimeError
+      exception.backtrace.first.should include ("[TRUNCATED]")
+    end
+
+    it "ensures that a workflow exception message > 256 characters fails the workflow correctly and truncates the message" do
+      general_test(:task_list => "WorkflowExceptionMessageTooLarge", :class_name => "WorkflowExceptionMessageTooLarge")
+      @workflow_class.class_eval do
+        def entry_point
+          raise  "a" * 257
+        end
+      end
+      workflow_execution = @my_workflow_client.start_execution
+      @worker.run_once
+      wait_for_execution(workflow_execution)
+      last_event = workflow_execution.events.to_a.last
+      last_event.event_type.should == "WorkflowExecutionFailed"
+      workflow_execution.events.to_a.last.attributes.reason.should include("[TRUNCATED]")
+      details = workflow_execution.events.to_a.last.attributes.details
+      exception = FlowConstants.default_data_converter.load(details)
+      exception.class.should == RuntimeError
+    end
+
+
+    it "ensures that a respond_decision_task_completed call with response > 32k that we can't truncate fails the workflow correctly" do
+      class CustomException < FlowException
+        def initialize(reason, details)
+          @something = "a"*50000
+          super(reason, details)
+        end
+      end
+      general_test(:task_list => "CustomWorkflowExceptionTooLarge", :class_name => "CustomWorkflowExceptionTooLarge")
+      @workflow_class.class_eval do
+        def entry_point
+          raise  CustomException.new("asdf", "sdf")
+        end
+      end
+      workflow_execution = @my_workflow_client.start_execution
+      @worker.run_once
+      wait_for_execution(workflow_execution)
+      last_event = workflow_execution.events.to_a.last
+      last_event.event_type.should == "WorkflowExecutionFailed"
+      workflow_execution.events.to_a.last.attributes.reason.should == Utilities.validation_error_string("Workflow")
+    end
+
+    it "ensures that an activity input > 32k data fails the workflow" do
+      general_test(:task_list => "ActivityTaskLargeInput", :class_name => "ActivityTaskLargeInput")
+      @workflow_class.class_eval do
+        def entry_point
+          activity.run_activity1("A"*50000)
+        end
+      end
+      workflow_execution = @my_workflow_client.start_execution
+      worker = WorkflowWorker.new(@domain.client, @domain, "ActivityTaskLargeInput", @workflow_class)
+      worker.register
+      worker.run_once
+      wait_for_execution(workflow_execution)
+      last_event = workflow_execution.events.to_a.last
+      last_event.event_type.should == "WorkflowExecutionFailed"
+      last_event.attributes.reason.should == Utilities.validation_error_string("Workflow")
+      last_event.attributes.details.should == "AWS::SimpleWorkflow::Errors::ValidationException"
+    end
+
+
+    it "ensures that a child workflow input > 32k fails the workflow" do
+      general_test(:task_list => "ChildWorkflowInputTooLarge", :class_name => "ChildWorkflowInputTooLarge")
+      @workflow_class.class_eval do
+        workflow(:child) do
+          {
+            version: "1.0",
+            default_execution_start_to_close_timeout: 300,
+            default_task_list: "ChildWorkflowInputTooLarge",
+            prefix_name: "ChildWorkflowInputTooLargeWorkflow"
+          }
+        end
+        def entry_point
+          child_client = AWS::Flow::workflow_client(nil, nil) { { from_class: "ChildWorkflowInputTooLargeWorkflow" } }
+          child_client.child("A"*50000)
+        end
+        def child(input); end
+      end
+
+      worker = WorkflowWorker.new(@domain.client, @domain, "ChildWorkflowInputTooLarge", @workflow_class)
+      worker.register
+      workflow_execution = @my_workflow_client.start_execution
+      worker.run_once
+
+      wait_for_execution(workflow_execution)
+      last_event = workflow_execution.events.to_a.last
+      last_event.event_type.should == "WorkflowExecutionFailed"
+      workflow_execution.events.to_a.last.attributes.reason.should == Utilities.validation_error_string("Workflow")
+      workflow_execution.events.to_a.last.attributes.details.should == "AWS::SimpleWorkflow::Errors::ValidationException"
+    end
+
+
+
+    it "ensures that a child workflow exception > 32k fails the workflow correctly and truncates the stacktrace" do
+      general_test(:task_list => "ChildWorkflowExceptionTooLarge", :class_name => "ChildWorkflowExceptionTooLarge")
+      @workflow_class.class_eval do
+        workflow(:child) do
+          {
+            version: "1.0",
+            default_execution_start_to_close_timeout: 300,
+            default_task_list: "ChildWorkflowExceptionTooLarge",
+            prefix_name: "ChildWorkflowExceptionTooLargeWorkflow"
+          }
+        end
+        def entry_point
+          child_client = AWS::Flow::workflow_client(nil, nil) { { from_class: "ChildWorkflowExceptionTooLargeWorkflow" } }
+          child_client.child
+        end
+        def child
+          raise  ":" + "a" * 33000
+        end
+      end
+
+      worker = WorkflowWorker.new(@domain.client, @domain, "ChildWorkflowExceptionTooLarge", @workflow_class)
+      worker.register
+      workflow_execution = @my_workflow_client.start_execution
+      worker.run_once
+      worker.run_once
+      worker.run_once
+      worker.run_once
+
+      wait_for_execution(workflow_execution)
+      last_event = workflow_execution.events.to_a.last
+      last_event.event_type.should == "WorkflowExecutionFailed"
+      workflow_execution.events.to_a.last.attributes.reason.should include("[TRUNCATED]")
+      details = workflow_execution.events.to_a.last.attributes.details
+      exception = FlowConstants.default_data_converter.load(details)
+      exception.class.should == AWS::Flow::ChildWorkflowFailedException
+      exception.cause.class.should == RuntimeError
+    end
+
+
+    it "ensures that a child child workflow exception > 32k fails the workflow correctly and truncates the stacktrace" do
+      general_test(:task_list => "ChildChildWorkflowExceptionTooLarge", :class_name => "ChildChildWorkflowExceptionTooLarge")
+      @workflow_class.class_eval do
+        workflow(:child, :child_1) do
+          {
+            version: "1.0",
+            default_execution_start_to_close_timeout: 300,
+            default_task_list: "ChildChildWorkflowExceptionTooLarge",
+            prefix_name: "ChildChildWorkflowExceptionTooLargeWorkflow"
+          }
+        end
+        def entry_point
+          child_client = AWS::Flow::workflow_client(nil, nil) { { from_class: "ChildChildWorkflowExceptionTooLargeWorkflow" } }
+          child_client.child
+        end
+        def child
+          child_1_client = AWS::Flow::workflow_client(nil, nil) { { from_class: "ChildChildWorkflowExceptionTooLargeWorkflow" } }
+          child_1_client.child_1
+        end
+        def child_1
+          raise  ":" + "a" * 33000
+        end
+      end
+      worker = WorkflowWorker.new(@domain.client, @domain, "ChildChildWorkflowExceptionTooLarge", @workflow_class)
+      worker.register
+      workflow_execution = @my_workflow_client.start_execution
+      worker.run_once
+      worker.run_once
+      worker.run_once
+      worker.run_once
+      worker.run_once
+      worker.run_once
+      worker.run_once
+
+      wait_for_execution(workflow_execution)
+      last_event = workflow_execution.events.to_a.last
+      last_event.event_type.should == "WorkflowExecutionFailed"
+      workflow_execution.events.to_a.last.attributes.reason.should include("[TRUNCATED]")
+      details = workflow_execution.events.to_a.last.attributes.details
+      exception = FlowConstants.default_data_converter.load(details)
+      exception.class.should == AWS::Flow::ChildWorkflowFailedException
+      exception.cause.class.should == AWS::Flow::ChildWorkflowFailedException
     end
-    workflow_execution = @my_workflow_client.start_execution
-    @worker.run_once
-    @activity_worker.run_once
-    @worker.run_once
-    wait_for_execution(workflow_execution)
-    history_events = workflow_execution.events.map(&:event_type)
-    # Previously, it would time out, as the failure would include the original
-    # large output that killed the completion and failure call. Thus, we need to
-    # check that we fail the ActivityTask.
-    history_events.should include "ActivityTaskFailed"
-
-    workflow_execution.events.to_a.last.attributes.details.should_not =~ /Psych/
-    history_events.last.should == "WorkflowExecutionFailed"
   end
 
   it "ensures that activities can be processed with different configurations" do
@@ -508,7 +767,7 @@ describe "RubyFlowDecider" do
         def entry_point
           domain = get_test_domain
           wf = AWS::Flow.workflow_client(domain.client, domain) { { from_class: "FooBar" } }
-          wf.start_execution("foo")
+          wf.start_execution
         end
       end
       workflow_execution = @my_workflow_client.start_execution
@@ -517,6 +776,7 @@ describe "RubyFlowDecider" do
       @worker.run_once
       child_worker.run_once
       @worker.run_once
+      @worker.run_once
       wait_for_execution(workflow_execution)
       workflow_execution.events.map(&:event_type).last.should == "WorkflowExecutionFailed"
       # Make sure this is actually caused by a child workflow failed
@@ -732,16 +992,17 @@ describe "RubyFlowDecider" do
       general_test(:task_list => "exponential_retry_key", :class_name => "ExponentialRetryKey")
       @workflow_class.class_eval do
         def entry_point
-          activity.reconfigure(:run_activity1) {
+          activity.run_activity1  do
             {
               :exponential_retry => {:maximum_attempts => 1},
-              :default_task_schedule_to_start_timeout => 5}
-          }
-          activity.run_activity1
+              :schedule_to_start_timeout => 1
+            }
+          end
         end
       end
+      worker = WorkflowWorker.new(@domain.client, @domain, "exponential_retry_key", @workflow_class)
       workflow_execution = @my_workflow_client.start_execution
-      4.times { @worker.run_once }
+      4.times { worker.run_once }
       wait_for_execution(workflow_execution)
       workflow_execution.events.to_a.last.event_type.should == "WorkflowExecutionFailed"
     end

data/spec/aws/decider/unit/decider_spec.rb

@@ -1232,6 +1232,7 @@ describe "FakeHistory" do
     #workflow_execution = my_workflow.start_execution
     swf_client.trace.first[:decisions].first[:decision_type].should == "CompleteWorkflowExecution"
   end
+
 end
 
 describe "Misc tests" do
@@ -1283,3 +1284,258 @@ describe "Misc tests" do
   end
 end
 
+describe "Workflow/Activity return values/exceptions" do
+  it "ensures that a workflow exception message > 32k fails the workflow correctly and truncates the message" do
+
+    class WorkflowOutputTooLarge
+      extend Workflows
+      workflow(:entry_point) do
+        {
+          version: "1.0",
+          default_execution_start_to_close_timeout: 600,
+        }
+      end
+
+      def entry_point
+        raise "a"*33000
+      end
+    end
+
+    class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
+      def get_decision_task
+        TestHistoryWrapper.new($workflow_type, FakeWorkflowExecution.new(nil, nil),
+                               FakeEvents.new(["WorkflowExecutionStarted",
+                                               "DecisionTaskScheduled",
+                                               "DecisionTaskStarted",
+        ]))
+      end
+    end
+
+    $workflow_type = FakeWorkflowType.new(nil, "WorkflowOutputTooLarge.entry_point", "1.0")
+    swf_client = FakeServiceClient.new
+    domain = FakeDomain.new($workflow_type)
+    client = AWS::Flow::workflow_client(swf_client, domain) { { from_class: "WorkflowOutputTooLarge" } }
+
+    task_list = "WorkflowsOutputTooLarge"
+
+    client.start_execution
+    worker = SynchronousWorkflowWorker.new(swf_client, domain, task_list, WorkflowOutputTooLarge)
+    worker.start
+
+    swf_client.trace.first[:decisions].first[:decision_type].should == "FailWorkflowExecution"
+
+    reason = swf_client.trace.first[:decisions].first[:fail_workflow_execution_decision_attributes][:reason]
+    details = swf_client.trace.first[:decisions].first[:fail_workflow_execution_decision_attributes][:details]
+    reason.should include("TRUNCATED")
+    exception = FlowConstants.default_data_converter.load(details)
+    exception.class.should == RuntimeError
+    exception.message.should == "a"*245+"[TRUNCATED]"
+  end
+
+  it "ensures that a workflow backtrace > 32k fails the workflow correctly and truncates the backtrace" do
+
+    class WorkflowOutputTooLarge
+      extend Workflows
+      workflow(:entry_point) do
+        {
+          version: "1.0",
+          default_execution_start_to_close_timeout: 600,
+        }
+      end
+
+      def entry_point
+        a = StandardError.new("SIMULATION")
+        a.set_backtrace("a"*33000)
+        raise a
+      end
+    end
+
+    class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
+      def get_decision_task
+        TestHistoryWrapper.new($workflow_type, FakeWorkflowExecution.new(nil, nil),
+                               FakeEvents.new(["WorkflowExecutionStarted",
+                                               "DecisionTaskScheduled",
+                                               "DecisionTaskStarted",
+        ]))
+      end
+    end
+
+    $workflow_type = FakeWorkflowType.new(nil, "WorkflowOutputTooLarge.entry_point", "1.0")
+    swf_client = FakeServiceClient.new
+    domain = FakeDomain.new($workflow_type)
+    client = AWS::Flow::workflow_client(swf_client, domain) { { from_class: "WorkflowOutputTooLarge" } }
+
+    task_list = "WorkflowsOutputTooLarge"
+
+    client.start_execution
+    worker = SynchronousWorkflowWorker.new(swf_client, domain, task_list, WorkflowOutputTooLarge)
+    worker.start
+
+    reason = swf_client.trace.first[:decisions].first[:fail_workflow_execution_decision_attributes][:reason]
+    details = swf_client.trace.first[:decisions].first[:fail_workflow_execution_decision_attributes][:details]
+    exception = FlowConstants.default_data_converter.load(details)
+    exception.class.should == StandardError
+    exception.message.should == "SIMULATION"
+    exception.backtrace.first.should include("[TRUNCATED]")
+    swf_client.trace.first[:decisions].first[:decision_type].should == "FailWorkflowExecution"
+  end
+
+  it "ensures that a workflow output > 32k fails the workflow correctly" do
+
+    class WorkflowOutputTooLarge
+      extend Workflows
+      workflow(:entry_point) do
+        {
+          version: "1.0",
+          default_execution_start_to_close_timeout: 600,
+        }
+      end
+
+      def entry_point
+        return "a"*33000
+      end
+    end
+
+    class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
+      def get_decision_task
+        TestHistoryWrapper.new($workflow_type, FakeWorkflowExecution.new(nil, nil),
+                               FakeEvents.new(["WorkflowExecutionStarted",
+                                               "DecisionTaskScheduled",
+                                               "DecisionTaskStarted",
+        ]))
+      end
+    end
+
+    $workflow_type = FakeWorkflowType.new(nil, "WorkflowOutputTooLarge.entry_point", "1.0")
+    swf_client = FakeServiceClient.new
+    domain = FakeDomain.new($workflow_type)
+    client = AWS::Flow::workflow_client(swf_client, domain) { { from_class: "WorkflowOutputTooLarge" } }
+
+    task_list = "WorkflowsOutputTooLarge"
+
+    client.start_execution
+    worker = SynchronousWorkflowWorker.new(swf_client, domain, task_list, WorkflowOutputTooLarge)
+    worker.start
+    swf_client.trace.first[:decisions].first[:decision_type].should == "FailWorkflowExecution"
+  end
+
+
+  it "ensures that child workflows returning exceptions > 32k get wrapped correctly" do
+
+    class ChildWorkflowOutputTooLargeTestWorkflow
+      extend Workflows
+      workflow(:entry_point, :child) do
+        {
+          version: "1.0",
+          default_execution_start_to_close_timeout: 600,
+        }
+      end
+
+      def entry_point
+        $my_workflow_client.child { { workflow_id: "child_workflow_test" }}
+      end
+      def child; end
+    end
+    class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
+      def get_decision_task
+        fake_workflow_type = FakeWorkflowType.new(nil, "ChildWorkflowOutputTooLargeTestWorkflow.entry_point", "1.0")
+        TestHistoryWrapper.new(fake_workflow_type, FakeWorkflowExecution.new(nil, nil),
+                               FakeEvents.new(["WorkflowExecutionStarted",
+                                               "DecisionTaskScheduled",
+                                               "DecisionTaskStarted",
+                                               "DecisionTaskCompleted",
+                                               ["StartChildWorkflowExecutionInitiated", {:workflow_id => "child_workflow_test"}],
+                                               ["ChildWorkflowExecutionStarted", {:workflow_execution => FakeWorkflowExecution.new("1", "child_workflow_test"), :workflow_id => "child_workflow_test"}],
+                                               "DecisionTaskScheduled",
+                                               "DecisionTaskStarted",
+                                               ["ChildWorkflowExecutionFailed", {:workflow_execution => FakeWorkflowExecution.new("1", "child_workflow_test"), :workflow_id => "child_workflow_test", :workflow_type => fake_workflow_type, :reason => "a"*245+"[TRUNCATED]", :details => "SIMULATED"}],
+                                               "DecisionTaskScheduled",
+                                               "DecisionTaskStarted",
+        ]))
+      end
+    end
+    workflow_type = FakeWorkflowType.new(nil, "ChildWorkflowOutputTooLargeTestWorkflow.entry_point", "1")
+
+    domain = FakeDomain.new(workflow_type)
+    swf_client = FakeServiceClient.new
+    $my_workflow_client  = workflow_client(swf_client, domain) { { from_class: "ChildWorkflowOutputTooLargeTestWorkflow" } }
+
+    task_list = "ChildWorkflowOutputTooLargeTestWorkflow"
+
+    $my_workflow_client.start_execution
+    worker = SynchronousWorkflowWorker.new(swf_client, domain, task_list, ChildWorkflowOutputTooLargeTestWorkflow)
+    worker.start
+    swf_client.trace.first[:decisions].first[:decision_type].should == "FailWorkflowExecution"
+    reason = swf_client.trace.first[:decisions].first[:fail_workflow_execution_decision_attributes][:reason]
+    details = swf_client.trace.first[:decisions].first[:fail_workflow_execution_decision_attributes][:details]
+    reason.should include("TRUNCATED")
+    exception = FlowConstants.default_data_converter.load(details)
+    exception.class.should == AWS::Flow::ChildWorkflowFailedException
+    exception.reason.should == "a"*245+"[TRUNCATED]"
+    exception.details.should == "SIMULATED"
+  end
+
+  it "ensures that activities returning exceptions > 32k get wrapped correctly" do
+
+    class ActivityExceptionTooLargeActivity
+      extend Activities
+      activity(:activity_a) do
+        {
+          version: "1.0"
+        }
+      end
+      def activity_a; end
+    end
+    class ActivityExceptionTooLargeTestWorkflow
+      extend Workflows
+      workflow(:entry_point) do
+        {
+          version: "1.0",
+          default_execution_start_to_close_timeout: 600,
+        }
+      end
+
+      activity_client(:client) { { from_class: "ActivityExceptionTooLargeActivity" } }
+      def entry_point
+        client.activity_a
+      end
+    end
+    class SynchronousWorkflowTaskPoller < WorkflowTaskPoller
+      def get_decision_task
+        fake_workflow_type = FakeWorkflowType.new(nil, "ActivityExceptionTooLargeTestWorkflow.entry_point", "1.0")
+        TestHistoryWrapper.new(fake_workflow_type, FakeWorkflowExecution.new(nil, nil),
+                               FakeEvents.new(["WorkflowExecutionStarted",
+                                               "DecisionTaskScheduled",
+                                               "DecisionTaskStarted",
+                                               "DecisionTaskCompleted",
+                                               ["ActivityTaskScheduled", {:activity_id => "Activity1"}],
+                                               "ActivityTaskStarted",
+                                               ["ActivityTaskFailed", scheduled_event_id: 5, activity_id: "Activity1", reason: "a"*245+"[TRUNCATED]", details: "SIMULATED"],
+                                               "DecisionTaskScheduled",
+                                               "DecisionTaskStarted",
+        ]))
+      end
+    end
+    workflow_type = FakeWorkflowType.new(nil, "ActivityExceptionTooLargeTestWorkflow.entry_point", "1")
+
+    domain = FakeDomain.new(workflow_type)
+    swf_client = FakeServiceClient.new
+    $my_workflow_client  = workflow_client(swf_client, domain) { { from_class: "ActivityExceptionTooLargeTestWorkflow" } }
+
+    task_list = "ActivityExceptionTooLargeTestWorkflow"
+
+    $my_workflow_client.start_execution
+    worker = SynchronousWorkflowWorker.new(swf_client, domain, task_list, ActivityExceptionTooLargeTestWorkflow)
+    worker.start
+    swf_client.trace.first[:decisions].first[:decision_type].should == "FailWorkflowExecution"
+    reason = swf_client.trace.first[:decisions].first[:fail_workflow_execution_decision_attributes][:reason]
+    details = swf_client.trace.first[:decisions].first[:fail_workflow_execution_decision_attributes][:details]
+    reason.should include("TRUNCATED")
+    exception = FlowConstants.default_data_converter.load(details)
+    exception.class.should == AWS::Flow::ActivityTaskFailedException
+    exception.reason.should == "a"*245+"[TRUNCATED]"
+    exception.details.should == "SIMULATED"
+  end
+
+end
+

data/spec/aws/decider/unit/workflow_client_spec.rb

@@ -75,6 +75,29 @@ describe WorkflowClient do
         client.workflow_b
       end
 
+      it "ensures workflow client uses user supplied data_converter" do
+        class FooWorkflow
+          extend AWS::Flow::Workflows
+          workflow :foo_workflow do
+            { version: "1.0" }
+          end
+        end
+        class FooDataConverter; end
+
+        swf = double(AWS::SimpleWorkflow)
+        domain = double(AWS::SimpleWorkflow::Domain)
+
+        swf.stub(:start_workflow_execution).and_return({"runId" => "111"})
+        domain.stub(:name)
+        array = []
+        domain.stub(:workflow_executions).and_return(array)
+        array.stub(:at)
+
+        client = AWS::Flow::workflow_client(swf, domain) { { from_class: "WorkflowClientTestWorkflow" } }
+        expect_any_instance_of(FooDataConverter).to receive(:dump)
+        client.start_execution(:foo_workflow, "some_input") { { data_converter: FooDataConverter.new } }
+      end
+
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-flow
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Michael Steger, Paritosh Mohan, Jacques Thomas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-30 00:00:00.000000000 Z
+date: 2014-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-v1