data.json

[
  {
    "startTime":1373528184507.288,
    "data":{

    },
    "children":[
      {
        "startTime":1373528184507.834,
        "data":{
          "requestId":"25508.513",
          "url":"https://example.com/mypage",
          "requestMethod":"GET"
        },
        "frameId":"25508.1",
        "type":"ResourceSendRequest",
        "usedHeapSize":36108428,
        "counters":{
          "nodes":11795,
          "documents":29,
          "jsEventListeners":59
        }
      }
    ],
    "endTime":1373528184508.3662,
    "type":"Program"
  },
  {
    "startTime":1373528185281.825,
    "data":{

    },
    "children":[
      {
        "startTime":1373528185282.174,
        "frameId":"25508.1",
        "data":{
          "requestId":"25508.513",
          "statusCode":200,
          "mimeType":"text/html"
        },
        "children":[

        ],
        "endTime":1373528185282.182,
        "type":"ResourceReceiveResponse",
        "usedHeapSize":36108428,
        "counters":{
          "nodes":11795,
          "documents":29,
          "jsEventListeners":59
        }
      }
    ],
    "endTime":1373528185282.447,
    "type":"Program"
  }
]

parse.rb

require "json"

def get_events(raw)
  events = JSON.parse(raw)

  [get_requests(events), get_responses(events)]
end

def get_requests(events)
  events.select do |event|
    if event["children"].any?
      child = event["children"][0]
      child["type"] == "ResourceSendRequest" && child["data"]["url"] == "https://example.com/mypage"
    end
  end
end

def get_responses(events)
  events.select do |event|
    if event["children"].any?
      child = event["children"][0]
      child["type"] == "ResourceReceiveResponse" && child["data"]["statusCode"] == 200
    end
  end
end

def get_times(requests, responses)
  requests.inject([]) do |times, request|
    request_child = request["children"][0]

    responses.each do |response|
      response_child = response["children"][0]

      if response_child["data"]["requestId"] == request_child["data"]["requestId"]
        times << (response["endTime"] - request["endTime"]) / 1000
      end
    end

    times
  end.sort
end

raw = File.read("./data.json")
requests, responses = get_events(raw)
times = get_times(requests, responses)

puts "= #{requests.length} Requests"
puts "  Min Time: #{times[0].round(2)}"
puts "  Max Time: #{times.last.round(2)}"
puts "  Avg Time: #{(times.inject { |sum, el | sum + el } / times.length).round(2) }"

parser.go

package main

import (
  "encoding/json"
	"fmt"
	"io/ioutil"
	"os"
	"sort"
	"strconv"
)

type Event struct {
	Children []Child
	EndTime  float64
}

type Child struct {
	Data ChildData
	Type string
}

type ChildData struct {
	RequestId  string
	Url        string
	StatusCode int
}

func main() {
	file := readFile()
	requests, responses := getEvents(file)
	times := getTimes(requests, responses)

	fmt.Println(fmt.Sprintf("= %d Requests", len(requests)))

	if (len(times) > 0) {
		fmt.Println("  Min Time:      " + strconv.FormatFloat(times[0], 'f', 2, 64))
		fmt.Println("  Max Time:      " + strconv.FormatFloat(times[len(times)-1], 'f', 2, 64))
		fmt.Println("  Average Time:  " + averageTime(times))
	}
}

func readFile() []byte {
	args := os.Args
	file, err := ioutil.ReadFile(args[1])
	if err != nil {
		panic(err)
	}
	return file
}

func getEvents(file []byte) ([]Event, []Event) {
	events := make([]Event, 1)
	err := json.Unmarshal(file, &events)
	if err != nil {
		panic(err)
	}

	requests := getRequests(events)
	responses := getResponses(events)

	return requests, responses
}

func getRequests(events []Event) []Event {
	requests := make([]Event, 0)

	for _, event := range events {

		if len(event.Children) > 0 {
			child := event.Children[0]

			if child.Type == "ResourceSendRequest" && child.Data.Url == "https://example.com/mypage" {
				requests = append(requests, event)
			}
		}
	}

	return requests
}

func getResponses(events []Event) []Event {
	responses := make([]Event, 0)

	for _, event := range events {

		if len(event.Children) > 0 {
			child := event.Children[0]

			if child.Type == "ResourceReceiveResponse" && child.Data.StatusCode == 200 {
				responses = append(responses, event)
			}
		}
	}

	return responses
}

func getTimes(requests []Event, responses []Event) []float64 {
	times := make([]float64, 0)

	for _, request := range requests {
		requestChild := request.Children[0]

		for _, response := range responses {
			responseChild := response.Children[0]

			if responseChild.Data.RequestId == requestChild.Data.RequestId {
				times = append(times, (response.EndTime-request.EndTime)/1000)
				break
			}
		}
	}

	sort.Float64s(times)
	return times
}

func averageTime(times []float64) string {
	total := 0.0

	for _, time := range times {
		total += time
	}

	average := total / float64(len(times))

	return strconv.FormatFloat(average, 'f', 2, 64)
}

parser.js

var fs = require("fs"),
    os = require("os");

var file = readFile(),
    events = JSON.parse(file),
    requests = getRequests(events),
    responses = getResponses(events),
    times = getTimes(requests, responses);

console.log("= " + times.length + " Requests");

if (times.length) {
  console.log("  Min Time: " + times[0].toFixed(2));
  console.log("  Max Time: " + times[times.length - 1].toFixed(2));
  console.log("  Avg Time: " + averageTime(times).toFixed(2));
}

function readFile() {
  return fs.readFileSync(process.argv[2]);
}

function getRequests(events) {
  var requests = [],
      child, evt, i;

  for (i = 0; i < events.length; i++) {
    evt = events[i];

    if (evt.children.length) {
      child = evt.children[0];

      if (child.type == "ResourceSendRequest" && child.data.url == "https://example.com/mypage") {
        requests.push(evt);
      }
    }
  }

  return requests;
}

function getResponses(events) {
  var responses = [],
      child, evt, i;

  for (i = 0; i < events.length; i++) {
    evt = events[i];

    if (evt.children.length) {
      child = evt.children[0];

      if (child.type == "ResourceReceiveResponse" && child.data.statusCode == 200) {
        responses.push(evt);
      }
    }
  }

  return responses;
}

function getTimes(requests, responses) {
  var times = [],
      i, j, request, response, requestChild, responseChild;

  for (i = 0; i < requests.length; i++) {
    request = requests[i];
    requestChild = request.children[0];

    for (j = 0; j < responses.length; j++) {
      response = responses[j];
      responseChild = response.children[0];

      if (responseChild.data.requestId == requestChild.data.requestId) {
        times.push((response.endTime - request.endTime) / 1000)
        break;
      }
    }
  }

  return times.sort(function(a, b) { return a - b });
}

function averageTime(times) {
  var total = 0,
      i, time;

  for (i = 0; i < times.length; i++) {
    time = times[i];
    total += time;
  }

  return total / times.length;
}