kgrift 1.3.108

data/KGrift/knewton_grifts/registration_info_grifts.rb

@@ -0,0 +1,23 @@
+def print_goals_for_registration_report registration_id, goal_id=nil
+  reg = get_registration registration_id
+
+  goals = get_goals reg['learning_instance_id']
+
+  if goal_id
+    goals = goals.select{|g| g['id'] == goal_id}
+  end
+
+  puts " "
+  puts "===================="
+  puts "Learning instance: #{reg['learning_instance_id']}"
+  puts ""
+  goals.each do |goal|
+    puts "--------------------"
+    puts "active: #{check_if_activated(reg['learning_instance_id'], registration_id, goal['id'])}"
+    puts "#{goal.to_yaml}"
+    puts " "
+
+  end
+
+  return ''
+end

data/KGrift/knewton_grifts/report_grifts.rb

@@ -0,0 +1,122 @@
+# Generic methods for writing some reports
+# The reports that can be made are:
+# - all_requests_report  - a simple csv noting some details about every request
+# - requests by endpoint - compiles response time stats about each endpoint that has been used
+#
+
+require 'fileutils'
+
+# construct a path to the report directory, and ensure it exists
+def report_dir
+  report_dir = File.join(Dir.pwd, 'reports')
+  FileUtils.mkdir_p report_dir
+  report_dir
+end
+
+# write a csv that lists all requests
+def write_all_requests_report filename=nil
+  # default the filename to reports/all_requests.csv
+  filename = File.join(report_dir, 'all_requests.csv') unless filename
+
+  requests = metrics_all_requests
+  Log.info "Writing all #{requests.length} requests report to filename: #{filename}"
+
+  columns = [:service, :method, :path, :status, :duration_ms, :end_time]
+  fmt_str = '%-8.8s,%-8.8s,%-61.60s,%-8.8s,%-12.12s,%-28.28s'
+  File.open(filename, 'w') do |output|
+    output.puts(fmt_str % columns)
+    requests.each do |data|
+      output.puts(fmt_str % data.to_a)
+    end
+  end
+  Log.debug "Done writing all request report"
+  filename
+end
+
+
+# write a csv that lists all unique endpoints
+# and for each endpoint, some stats about response time
+def write_metrics_by_endpoint_report filename=nil
+  filename = File.join(report_dir, 'metrics_by_endpoint.csv') unless filename
+
+  requests = metrics_all_requests
+
+  # now compile the list of requests into a list of specific endoints that were hit
+  # this means substituting specific IDs in requests paths with the string ':id'
+  metrics_by_endpoint = {}
+  requests.each do |sample|
+    method = sample.method.upcase  # GET, POST, PUT, etc...
+    path = sample.path.gsub(/\?.*$/,'') # the path, chop off query params
+
+    #replace uuids with :id
+    path.gsub!(/[0-9a-f\-]{36}/,':id')
+    #replace any url path component with a capital letter, number or % to :id
+    path.gsub!(/[^\/]+[A-Z0-9% ][^\/]+/,':id')
+
+    endpoint = "#{'%-7s' % method} #{path}"
+
+    metrics_by_endpoint[endpoint] ||= {
+      durations: [],
+      count: 0
+    }
+    metrics_by_endpoint[endpoint][:count] += 1
+    metrics_by_endpoint[endpoint][:durations] << sample.duration_ms
+  end
+
+  Log.info "Writing metrics by endpoint report for #{metrics_by_endpoint.length} endpoints to filename: #{filename}"
+  File.open(filename, 'w') do |output|
+    columns = [:endpoint, :count, :mean_duration, :median_duration, :standard_deviation, :min_duration, :percentile_95, :max_duration]
+    fmt_str = '%-80s' + columns[1..-1].inject(''){|s, c| s + ",%-#{c.length+1}s"}
+    output.puts fmt_str % columns
+
+    metrics_by_endpoint.each_pair do |endpoint, data|
+      durations = data[:durations].sort
+      output.puts fmt_str % [endpoint, data[:count], durations.mean.to_i, durations[durations.length/2], durations.sample_standard_deviation.to_i, durations.first, durations.percentile(0.95).to_i, durations.last]
+    end
+  end
+
+  Log.debug "Done writing metrics by endpoint report"
+  filename
+end
+
+
+# MONKEY PATCH ARRAY:
+# methods for doing basic stats calculations on Arrays
+# used in above metrics_by_endpoint_report method
+class ::Array
+  def sum
+    self.inject(:+).to_f
+  end
+
+  def mean
+    return 0.0 if self.length < 1
+    self.sum / self.length.to_f
+  end
+
+  def sample_standard_deviation
+    #unless we have at least 2 items in list, std dev is 0 by convention
+    return 0.0 if self.length < 2
+
+    mean = self.mean
+    sum = self.inject(0.0) { |acc, i| acc + ((i - mean)**2) }
+
+    Math.sqrt( sum / (self.length - 1))
+  end
+
+  def standard_error_of_the_mean
+    return 0.0 if self.length < 2
+    (self.sample_standard_deviation / Math.sqrt(self.length))
+  end
+
+  def percentile(percentile)
+    return 0.0 if self.length < 1
+    return self[0] if self.length < 2
+    values_sorted = self.sort
+    k = (percentile*(values_sorted.length-1)+1).floor - 1
+    f = (percentile*(values_sorted.length-1)+1).modulo(1)
+    return values_sorted[k] + (f * (values_sorted[k+1] - values_sorted[k]))
+  end
+end
+
+
+

data/KGrift/knewton_grifts/shell_command_grifts.rb

@@ -0,0 +1,21 @@
+"""
+This file contains methods that are used to deal with
+shell commands.
+
+Nothing should really be using these anymore (it is a holdover
+from how test data used to be managed.)  Nonetheless, its possible
+some client of kgrift is out there using this, so its being kept around
+
+"""
+
+class ::ShellCommandFailed < Exception; end
+
+def execute_shell_command cmd_string
+  Log.debug "Executing shell command:\n\t#{cmd_string}"
+  output = %x(#{cmd_string} 2>&1).strip #catch stderr so we can log it properly, strip whitespace to make processing easier
+  Log.debug "Shell command returned:\n\t#{output}"
+  raise ShellCommandFailed.new("Shell cmd failed.\nCommand: #{cmd_string}\nOutput: #{output}") unless $?.success?
+  output
+end
+
+

data/KGrift/knewton_grifts/student_flow_grifts.rb

@@ -0,0 +1,560 @@
+#
+# Student flow grifts is all about emulating different kinds of student flows for a given goal
+#
+
+#based on a source learning instance and goal
+#copy the goal to a new learning instance
+#and send student events per some algorithmn
+# To run multiple goals for a single student, call with the goal_id
+# parameter set to nil and goal_id_list: [ <list of ids> ]
+def copy_and_complete_goal learning_instance_id, goal_id, source_env=nil, options={}
+  options ={
+    :target_score_override => nil,
+    :days_from_now_override => nil,
+    :goal_id_list => nil,
+    :wait_after_init => false,
+    :force_metrics => true,
+    :taxon_id => nil
+  }.merge(options)
+  if goal_id
+    puts "Initializing goal bot.  Will copy and complete learning instance '#{learning_instance_id}' and goal '#{goal_id}'"
+  else
+    puts "Initializing goal bot.  Will copy and complete learning instance '#{learning_instance_id}' and goals '#{options[:goal_id_list]}'"
+  end
+
+  set_account :knerd
+  copy_data = copy_learning_instance 'source_environment' => source_env,
+                                     'learning_instance_id' => learning_instance_id,
+                                     'goal_id' => goal_id,
+                                     'goal_id_list' => options[:goal_id_list],
+                                     'goal_target_score_override' => options[:target_score_override],
+                                     'goal_days_from_now_override' => options[:days_from_now_override],
+                                     'force_metrics' => options[:force_metrics]
+  learning_instance = copy_data['learning_instance']
+  learning_instance_id = learning_instance['id']
+  graph_id = get_learning_instance(learning_instance_id)['graph_id']
+
+  test_student_profile = add_new_student_to_learning_instance learning_instance_id
+  registration_id = test_student_profile['registration_id']
+
+  if goal_id
+    goal = copy_data['goal']
+    goal_id = goal['id']
+    activate_registration_on_goal learning_instance_id, registration_id, goal_id
+    puts "Successfully copied learning instance and goal and created a fresh registration.\n - Learning instance id: #{learning_instance_id}\n - Goal id: #{goal_id}\n - registration id: #{registration_id}\n\n"
+    puts "Initialization complete\n"
+
+    # Wait to give user a chance to send events to canary
+    if options[:wait_after_init]
+      puts "Hit return key to start sending events"
+      STDIN.gets
+    end
+
+    to_return = complete_goal registration_id, goal_id, options
+  elsif options[:goal_id_list]
+    goal_list = copy_data['goal_list']
+    goal_id_list = goal_list.collect { |goal| goal['id'] }
+    goal_id_list.each { |goal_id| activate_registration_on_goal learning_instance_id, registration_id, goal_id }
+    puts "Successfully copied learning instance and goals and created a fresh registration.\n - Learning instance id: #{learning_instance_id}\n - Goal ids: #{goal_id_list}\n - registration id: #{registration_id}\n\n"
+    puts "Initialization complete\n"
+
+    # Wait to give user a chance to send events to canary
+    if options[:wait_after_init]
+      puts "Hit return key to start sending events"
+      STDIN.gets
+    end
+
+    to_return = goal_id_list.collect { |goal_id| complete_goal registration_id, goal_id, options }
+  end
+  to_return
+end
+
+def goal_bot_with_pause learning_instance_id, goal_id, source_env=nil, options={}
+  options = { :wait_after_init => true }.merge(options)
+  copy_and_complete_goal learning_instance_id, goal_id, source_env, options
+end
+
+def complete_goal registration_id, goal_id, options={}
+  default_options = {
+    :max_cycles => 100,
+    :starting_event_threshold => 0.00,
+    :event_threshold_multiplier => 0.96,
+    :event_selection_mode => :pick_top_recommended,
+    :initial_event_behavior => :send_focus_event,
+    :concept_level_thresholds => nil, #this is a file with per-concept data
+    :concept_thresholds => nil, #this is a data structure with per-concept data
+    :num_fails_before_success => 0,
+    :pause_after_sending_event => 6,  # increased from 5 to 6 due to reduced rate limit
+    :target_score_override => nil,
+    :days_from_now_override => nil,
+    :goal_id_list => nil,
+    :wait_after_init => false,
+    :force_metrics => true,
+    :taxon_id => nil
+  }
+
+  options.keys.each do |k|
+      if !default_options.keys.include?(k)
+          raise "Invalid option #{k} passed to complete_goal (NOTE: options are symbols)"
+      end
+  end
+
+  options= default_options.merge(options)
+
+  registration_id = registration_id
+  goal_id = goal_id
+  taxon_id = options[:taxon_id]
+
+  set_account :knerd
+  registration = get_registration(registration_id)
+  account_id = registration['account_id']
+  learning_instance = get_learning_instance(get_registration(registration_id)['learning_instance_id'])
+  learning_instance_id = learning_instance['id']
+  goal = get_goal learning_instance['id'], goal_id
+  metrics_enabled_goal = goal['metrics_enabled']
+  graph = get_graph_and_cache_it learning_instance['graph_id']
+
+  if !metrics_enabled_goal
+      puts "WARNING: Goal doesn't have metrics_enabled, will NOT be getting ANY metrics."
+  end
+
+  cycle_num ||= 0
+  event_num ||= 0
+  mod_ids_sent ||= []
+  event_bodies_sent ||= []
+
+  cur_event_threshold = options[:starting_event_threshold]
+  num_fails_before_success = options[:num_fails_before_success]
+
+  # Get concept-level thresholds from a file
+  concept_thresholds = []
+  if options[:concept_level_thresholds] != nil
+    File.open(options[:concept_level_thresholds]) do |f|
+      f.each_line do |line|
+        line_array = line.split
+        concept_thresh = {'id'=> line_array[0],
+              'current_threshold' => line_array[1].to_f,
+              'threshold_multiplier' => line_array[2].to_f,
+              'num_fails_before_success' => line_array[3].to_i,
+            }
+        concept_thresholds << concept_thresh
+      end
+    end
+  # Or get concept-level thresholds straight from a datastructure
+  elsif options[:concept_thresholds] != nil
+    concept_thresholds = options[:concept_thresholds]
+  end
+
+  results = {
+      "readiness_forecasts" => {
+          "learning_instance_id" => learning_instance_id,
+          "registrations" => [
+              "registration_id" => registration_id,
+              "goals" => [
+                  {
+                      "goal_id" => goal_id,
+                      "readiness_forecasts" => []
+                  }
+              ]
+          ]
+      },
+      "expected_score" => {
+          "learning_instance_id" => learning_instance_id,
+          "registrations" => [
+              "registration_id" => registration_id,
+              "goals" => [
+                  {
+                      "goal_id" => goal_id,
+                      "target_modules" => []
+                  }
+              ]
+          ]
+      },
+      "proficiency" => {
+          "learning_instance_id" => learning_instance_id,
+          "accounts" => [
+              "account_id" => account_id,
+              "taxons" => [
+                  {
+                      "taxon_id" => taxon_id,
+                      "proficiencies" => []
+                  }
+              ]
+          ]
+      }
+  }
+
+  time_format_string = "%Y-%m-%dT%H:%M:%S"
+  current_recommendation = nil
+  current_readiness_forecast = nil
+  current_expected_score = nil
+  current_proficiency = nil
+  start_date = Time.now.strftime(time_format_string)
+
+  readiness_forecasts = []
+  expected_scores = Hash.new {|h, k| h[k] = []}
+  proficiencies = []
+
+  loop do
+    if cycle_num > options[:max_cycles]
+      puts "WARNING: goal did not complete after #{options[:max_cycles]} adaptive cycles"
+      break
+    end
+
+    event_bodies = send_events_for_recommendation current_recommendation,
+                   registration_id, goal, graph,
+                   (options.merge incorrect_threshold: cur_event_threshold,
+                    concept_thresholds: concept_thresholds,
+                    num_fails_before_success: num_fails_before_success)
+
+    if event_bodies.is_a? Array
+      event_bodies_sent += event_bodies
+      mod_ids = event_bodies.map{|eb| eb['module_id']}
+      mod_ids_sent += mod_ids
+      event_num += mod_ids.length
+    end
+
+    puts "\n=====================\nAdaptive cycle number #{cycle_num}\n"
+    current_recommendation = get_next_recommendation_in_flow registration_id, goal_id, current_recommendation, options
+    puts "Got new recommendation:\n#{current_recommendation.to_yaml}\n"
+
+    cur_event_threshold *= options[:event_threshold_multiplier]
+    concept_thresholds.map{|c| c['current_threshold'] *= c['threshold_multiplier']}
+
+    current_recommendation['module_ids'].each do |rec_mod_id|
+      if mod_ids_sent.include? rec_mod_id
+        puts "WARNING: recommendation includes a module we have sent an event for: #{rec_mod_id}"
+        #todo add this to an errors array
+      end
+    end
+
+    if metrics_enabled_goal
+        # use an eventually here to poll until a full payload is returned
+        current_readiness_forecast = nil
+        eventually timeout: 60, interval: 5 do
+          current_readiness_forecast = kapi.post "v0/registrations/#{registration_id}/metrics/readiness-forecast/rows", {"goal_ids"=>[goal_id]}
+          # in order to test if analytics has computed something yet, see if we can reference what we want.
+          # If we can't, throw an ExpectationError which causes eventually to try again (until timeout)
+          begin
+            current_readiness_forecast["rows"][0]["date"]
+          rescue Exception => e
+            raise ExpectationError.new('Analytics has not yet returned a readiness forcast')
+          end
+        end
+        current_readiness_forecast["rows"][0]["date"] = Time.now.strftime(time_format_string)
+        readiness_forecasts << current_readiness_forecast["rows"][0]["readiness_forecasts"][0]
+        puts "Got new readiness forecast:\n#{current_readiness_forecast.to_yaml}\n"
+
+        current_expected_score = nil
+        eventually timeout: 60, interval: 5 do
+          current_expected_score = kapi.get "v0/registrations/#{registration_id}/metrics/expected-score?goal_id=#{goal_id}"
+          begin
+            current_expected_score["goals"][0]["target_modules"]
+          rescue Exception => e
+            raise ExpectationError.new('Analytics has not yet returned an expected score')
+          end
+        end
+        current_expected_score["goals"][0]["target_modules"].each { |value|
+            value["expected_scores"][0]["estimate_date"] = Time.now.strftime(time_format_string)
+            expected_scores[value["module_id"]] << value["expected_scores"][0]
+        }
+        puts "Got new expected score:\n#{current_expected_score.to_yaml}\n"
+
+        if taxon_id != nil
+            current_proficiency = nil
+            eventually timeout: 60, interval: 5 do
+              current_proficiency = kapi.post "v0/accounts/#{account_id}/metrics/proficiency/rows", {"taxon_ids"=>[taxon_id]}
+              begin
+                current_proficiency["rows"][0]["proficiencies"][0]
+              rescue Exception => e
+                raise ExpectationError.new('Analytics has not yet returned a proficiency')
+              end
+            end
+            current_proficiency["rows"][0]["date"] = Time.now.strftime(time_format_string)
+            proficiencies << current_proficiency["rows"][0]
+            puts "Got new current_proficiency:\n#{current_proficiency['rows'].to_yaml}\n"
+        end
+
+    end
+
+    if current_recommendation['module_ids'].empty?
+      puts "Got empty rec set after sending #{mod_ids_sent.length} events; #{cycle_num} adaptive cycles\n"
+      puts "Mod IDs we sent: #{mod_ids_sent.join(', ')}\n"
+      break
+    end
+
+    cycle_num += 1
+    puts "\n--------------------\n"
+
+  end
+
+  if metrics_enabled_goal
+      results["readiness_forecasts"]["registrations"][0]["goals"][0]["readiness_forecasts"] = readiness_forecasts
+      expected_scores.each { |module_id, expected_score_values|
+          results["expected_score"]["registrations"][0]["goals"][0]["target_modules"] << {
+              "module_id" => module_id,
+              "expected_scores" => expected_score_values
+          }
+      }
+      results["proficiency"]["accounts"][0]["taxons"][0]["proficiencies"] = proficiencies.map{ |proficiency|
+          {
+              "relative_estimate" => proficiency["proficiencies"][0]["relative_estimate"],
+              "estimate_status" => proficiency["proficiencies"][0]["estimate_status"],
+              "confidence" => proficiency["proficiencies"][0]["conf"],
+              "estimate_date" => proficiency["date"]
+          }
+      }
+
+      test_data = {
+          "learner_registrations" => {
+              "student_1" => {
+                  "id" => registration_id
+              }
+          },
+          "taxon_temp_id_to_id" => {
+          },
+          "goals" => {
+              "goal_1" => {
+                  "id" => goal_id
+              }
+          },
+          "start_date" => start_date,
+          "end_date" => Time.now.strftime(time_format_string),
+          "learning_instance" => {
+              "id" => learning_instance_id
+          }
+      }
+
+      write_yaml test_data, results
+  end
+
+  response = {
+    'goal_id' => goal_id,
+    'registration_id' => registration_id,
+    'adaptive_cycles' => cycle_num,
+    'event_count' => event_num,
+    'module_ids_sent' => mod_ids_sent,
+    'event_bodies_sent' => event_bodies_sent,
+    'expected_scores' => expected_scores,
+    'readiness_forecasts' => readiness_forecasts,
+    'proficiencies' => results["proficiency"]["accounts"][0]["taxons"][0]["proficiencies"]
+  }
+  Log.debug "Goal did complete. Details:\n#{response.to_yaml}\n"
+  response
+end
+
+
+def send_events_for_recommendation current_recommendation, registration_id, goal, graph, options={}
+
+  #the first event we send shall be a random one from the goal
+  module_id = if current_recommendation
+                case options[:event_selection_mode]
+                when :pick_top_recommended
+                  current_recommendation['module_ids'].first
+                when :pick_random_recommended
+                  current_recommendation['module_ids'].sample
+                else
+                  goal['recommendable_modules'].sample['module_id']
+                end
+              else
+                #this is the first event sent
+                case options[:initial_event_behavior]
+                when :send_focus_event
+                  :focus
+                when :random_recommendable_module
+                  goal['recommendable_modules'].sample['module_id']
+                else
+                  nil
+                end
+              end
+
+  return if module_id.nil?
+
+  if module_id == :focus
+    puts "sending focus event for registration #{registration_id} and goal #{goal['id']}"
+    send_focus_event registration_id, goal['id']
+    # Sleep after focus event to ensure new rec
+    sleep options[:pause_after_sending_event]
+    return nil
+  end
+
+  module_id = internalize_module_id graph, module_id
+
+  node_type = get_node_type graph, module_id
+
+  puts "Following recommendation for module: #{module_id} #{node_type}"
+  atom_ids = case node_type
+             when 'atom'
+               [module_id]
+             when 'bndl'
+               [module_id] + graph['edges'].select{|e| e['type'] == 'contains' and e['start'] == module_id}.map{|e| e['end']}
+             end
+
+  puts "Will send events for these modules: #{atom_ids.join(', ')}"
+
+  event_bodies = []
+  atom_ids.each do |atom|
+
+    concepts = find_associated_concept_ids graph, atom
+
+    # Use the concept threshold for the recommended concept, if applicable
+    # In the unexpected event that there are multiple concepts, use the threshold for the first
+    current_concept_threshold = options[:concept_thresholds].find{|con| con['id'] == concepts[0]}
+    if current_concept_threshold != nil
+      options[:incorrect_threshold] = current_concept_threshold['current_threshold']
+      options[:num_fails_before_success] = current_concept_threshold['num_fails_before_success']
+    end
+
+    event_body = nil
+
+    content_types = get_content_types graph, atom
+    event_type = nil
+    if content_types.include? 'assessment'
+      event_type = :graded
+    elsif content_types.include? 'instructional'
+      event_type = :ungraded
+    end
+
+    options[:is_correct] = true
+    if (rand < options[:incorrect_threshold])
+      options[:is_correct] = false
+    end
+
+    if event_type != nil
+
+      event_bodies << generate_and_send_event(registration_id, atom, event_type, options)
+      sleep options[:pause_after_sending_event]
+
+      if not options[:is_correct] and options[:num_fails_before_success] > 0
+
+        # we already failed once, so let's fail n-1 more times, then succeed
+        num_more_fails_before_success = options[:num_fails_before_success] - 1
+        puts "-------\n"
+        puts "Student will fail #{num_more_fails_before_success} more times before succeeding\n"
+        puts "-------\n\n"
+
+        for i in 1..num_more_fails_before_success do
+          sleep options[:pause_after_sending_event] # wait a bit before sending off the next event
+          event_bodies << generate_and_send_event(registration_id, atom, event_type, options)
+        end
+
+        #student gets is correct!
+        options[:is_correct] = true
+        sleep options[:pause_after_sending_event] # wait a bit before sending off the next event
+        event_bodies << generate_and_send_event(registration_id, atom, event_type, options)
+
+      end
+
+    end
+  end
+  event_bodies
+end
+
+def generate_and_send_event registration_id=nil, atom=nil, event_type=:graded, options={}
+  event_body = generate_event_body(event_type, options).merge({'module_id' => atom})
+  puts "sending #{event_type} for registration #{registration_id}:\n#{event_body.to_yaml}\n"
+  if event_type == :graded
+    send_graded_event registration_id, nil, event_body
+  else
+    send_ungraded_event registration_id, nil, event_body
+  end
+  return event_body
+end
+
+#return a generated event body, either randomly or according to the is_correct options
+def generate_event_body type=:graded, options={}
+  options = {
+    :incorrect_threshold => 0.00,
+    :is_correct => nil,
+  }.merge(options)
+  #puts "Current incorrect probability threshold: #{cur_event_threshold}"
+
+  # If user doesn't pass a correctness option, randomly determine correctness
+  if options[:is_correct] == nil
+    if (rand < options[:incorrect_threshold])
+      options[:is_correct] = false
+    else
+      options[:is_correct] = true
+    end
+  end
+
+  rand_fields = case type
+                when :graded
+                  if (options[:is_correct])
+                    #the correct case
+                    { 'is_correct' => true, 'score' => 1.0, 'response' => rand(1000).to_s }
+                  else
+                    #the incorrect case
+                    { 'is_correct' => false, 'score' => 0.0, 'response' => rand(1000).to_s }
+                  end
+
+                else
+                  {}
+                end
+
+  # calculate a more "realistic" duration based off the sleep between events time
+  duration = rand(1000)
+  if options[:pause_after_sending_event] != nil
+      total_time = options[:pause_after_sending_event] * 1000
+      duration = (0.6 * total_time + rand(0.3 * total_time)).to_int
+  end
+  calculated_fields = { 'duration' => duration }
+
+  const_fields = { 'is_complete' => true, 'interaction_end_time' => datetime}
+  return rand_fields.merge(calculated_fields).merge(const_fields)
+end
+
+def get_next_recommendation_in_flow registration_id, goal_id, current_recommendation=nil, options={}
+  options = {
+    :new_rec_timeout => 30,
+  }.merge(options)
+
+  eventually timeout: options[:new_rec_timeout] do
+    recommendation = get_recommendation registration_id, goal_id
+    if (!current_recommendation) or (recommendation['recommendation_id'] != current_recommendation['recommendation_id'])
+      current_recommendation = recommendation
+    else
+      raise ExpectationError.new("RecService did not return new recommendation within #{options[:new_rec_timeout]}")
+    end
+  end
+  current_recommendation
+end
+
+def write_yaml test_data, results
+    #Setup output directory for current run
+    output_dir = "reports/goalbot_data"
+    FileUtils.mkpath output_dir
+
+    yaml_data = {}
+    yaml_data['students'] = {}
+    yaml_data['env'] = grifter_configuration[:environment].to_s
+    test_data['learner_registrations'].keys.each do |student_name|
+        yaml_data['students'][student_name] = test_data['learner_registrations'][student_name]['id']
+    end
+    yaml_data['taxons'] = {}
+    test_data['taxon_temp_id_to_id'].keys.each do |key|
+        yaml_data['taxons'][test_data['taxon_temp_id_to_name'][key]] = test_data['taxon_temp_id_to_id'][key]
+    end
+    yaml_data['taxon_ids'] = {}
+    test_data['taxon_temp_id_to_id'].keys.each do |key|
+        yaml_data['taxon_ids'][test_data['taxon_temp_id_to_id'][key]] = test_data['taxon_temp_id_to_name'][key]
+    end
+    yaml_data['taxon_temp_ids'] = test_data['taxon_temp_id_to_id']
+    yaml_data['taxon_ids_to_temp'] = test_data['taxon_temp_id_to_id'].invert
+    yaml_data['goals'] = {}
+    test_data['goals'].keys.each do |key|
+        yaml_data['goals'][key] = test_data['goals'][key]['id']
+    end
+    yaml_data['start_date'] = test_data['start_date']
+    yaml_data['end_date'] = test_data['end_date']
+    yaml_data['learning_instance'] = test_data['learning_instance']['id']
+    yaml_data['results'] = results
+
+    output_file = "#{output_dir}/goalbot_run_#{yaml_data['env']}_#{DateTime.now}.yml.gz"
+
+    Log.info "Writing run data to #{output_file}"
+    Zlib::GzipWriter.open(output_file) {|f| f.write YAML::dump(yaml_data) }
+end
+
+alias :goal_bot :copy_and_complete_goal
+alias :get_new_recommendation :get_next_recommendation_in_flow