munger.rb

munger.rb

require 'json'

NODE_FILE = '/Users/nwest/Documents/node-benchmark/results.json'
HARMONY_FILE = '/Users/nwest/Documents/node-harmony-benchmark/results.json'
BABEL_FILE = '/Users/nwest/Documents/babel-node-benchmark/results.json'

def get_json_latency(result_set)
  latencies = result_set["rawData"]["json"]["hapi"].map { |run| run.fetch("latencyAvg") }
  latencies.map { |latency_string| latency_string.gsub("ms", "").to_f }.reduce(&:+) / latencies.length
end

def get_json_rps(result_set)
  rpses = result_set["rawData"]["json"]["hapi"].map { |run| run.fetch("totalRequests") }
  rpses.reduce(&:+) / rpses.length
end

def get_plaintext_latency(result_set)
  latencies = result_set["rawData"]["plaintext"]["hapi"].map { |run| run.fetch("latencyAvg", "100") }
  latencies.map { |latency_string| latency_string.gsub("ms", "").to_f }.reduce(&:+) / latencies.length
end

def get_plaintext_rps(result_set)
  rpses = result_set["rawData"]["plaintext"]["hapi"].map { |run| run.fetch("totalRequests") }
  rpses.reduce(&:+) / rpses.length
end

def result_set_to_results(name, result_set)
  {
    name: name,
    json_latency: get_json_latency(result_set),
    json_rps: get_json_rps(result_set),
    plaintext_latency: get_plaintext_latency(result_set),
    plaintext_rps: get_plaintext_rps(result_set)
  }
end

def results_from_file(name, file)
  result_set = JSON.parse(File.read(file))
  result_set_to_results(name, result_set)
end

def find_least_json_latency(results)
  winner = results.min { |a, b| a[:json_latency] <=> b[:json_latency] }
  winner[:name]
end

def find_highest_json_rps(results)
  winner = results.max { |a, b| a[:json_rps] <=> b[:json_rps] }
  winner[:name]
end

def find_least_plaintext_latency(results)
  winner = results.min { |a, b| a[:plaintext_latency] <=> b[:plaintext_latency] }
  winner[:name]
end

def find_highest_plaintext_rps(results)
  winner = results.max { |a, b| a[:palintext_rps] <=> b[:palintext_rps] }
  winner[:name]
end

def munge
  all_results = {node: NODE_FILE, harmony: HARMONY_FILE, babel: BABEL_FILE}
                .map { |(name, file)| results_from_file(name, file) }
                
  least_json_latency = find_least_json_latency(all_results)
  highest_json_rps = find_highest_json_rps(all_results)
  least_plaintext_latency = find_least_plaintext_latency(all_results)
  highest_plaintext_rps = find_highest_plaintext_rps(all_results)

  puts "Least json latency: #{least_json_latency}"
  puts "Highest json throughput: #{highest_json_rps}"
  puts "Least plaintext latency: #{least_plaintext_latency}"
  puts "Highest plaintext throughput: #{highest_plaintext_rps}"
end

munge