roby 0.8.0 → 3.0.0

data/lib/roby/cli/gen/task/class.rb

@@ -0,0 +1,44 @@
+<% indent, open_code, close_code = ::Roby::CLI::Gen.in_module(*class_name[0..-2]) %>
+<%= open_code %>
+<%= indent %>class <%= class_name.last %> < Roby::Task
+<%= indent %>    # You usually want this
+<%= indent %>    terminates
+<%= indent %>
+<%= indent %>    # Declare an argument to the task. Use default: VALUE to set up a default
+<%= indent %>    # value. The default can be nil
+<%= indent %>    # argument :arg[, default: 1]
+<%= indent %>    
+<%= indent %>    # Declare a new event. This defines updated_event which returns a
+<%= indent %>    # Roby::EventGenerator
+<%= indent %>    # event :updated
+<%= indent %>
+<%= indent %>    # Add forwarding to say "when event X is emitted, event Y should". This is
+<%= indent %>    # usually used to make a task finish when an event is emitted
+<%= indent %>    # forward :X => :Y
+<%= indent %>
+<%= indent %>    # Poll block. The given code is called at each Roby execution cycle as long
+<%= indent %>    # as the task is running
+<%= indent %>    # poll do
+<%= indent %>    #   puts "Called !"
+<%= indent %>    # end
+<%= indent %>
+<%= indent %>    # Script. This is the recommended way to implement functionality in tasks.
+<%= indent %>    # It executes instructions in sequence, in a way that is compatible with
+<%= indent %>    # Roby's reactor. For instance, below, block given to 'execute' will only be
+<%= indent %>    # executed once the updated event is emitted
+<%= indent %>    #
+<%= indent %>    # WARNING: the top level of the script is evaluated at loading time.
+<%= indent %>    #
+<%= indent %>    # See the documentation of Roby::Coordination::Models::TaskScript. The API
+<%= indent %>    # calls are the calls available on the script
+<%= indent %>    #
+<%= indent %>    # script do
+<%= indent %>    #   # Waits for an event to be emitted
+<%= indent %>    #   wait updated_event
+<%= indent %>    #   execute do
+<%= indent %>    #     # The code in this block is going to be called at runtime, unlike the
+<%= indent %>    #     # code at the script level
+<%= indent %>    #   end
+<%= indent %>    # end
+<%= indent %>end
+<%= close_code %>

data/lib/roby/cli/gen/task/test.rb

@@ -0,0 +1,6 @@
+require '<%= require_path %>'
+<% indent, open, close = ::Roby::CLI::Gen.in_module(*class_name[0..-2]) %>
+<%= open %>
+<%= indent %>describe <%= class_name.last %> do
+<%= indent %>end
+<%= close %>

data/lib/roby/cli/gen_main.rb

@@ -0,0 +1,120 @@
+require 'roby/cli/gen/helpers'
+require 'thor'
+
+module Roby
+    module CLI
+        class GenMain < Thor
+            include Thor::Actions
+
+
+            namespace :gen
+            source_paths << File.join(__dir__, 'gen')
+
+            desc "app [DIR]", "creates a new app scaffold in the current directory, or DIR if given"
+            option :quiet, type: :boolean, default: false
+            def app(dir = nil, init_path: 'roby_app', robot_path: 'roby_app')
+                if dir
+                    if File.exist?(dir)
+                        raise CLIInvalidArguments, "#{dir} already exists"
+                    end
+                else
+                    dir = Dir.pwd
+                end
+
+                directory 'app/', dir, verbose: !options[:quiet]
+                copy_file File.join(init_path, 'config' , 'init.rb'), File.join(dir, 'config', 'init.rb'), verbose: !options[:quiet]
+                template File.join(robot_path, 'config', "robots", "robot.rb"),
+                    File.join(dir, "config", "robots", "default.rb"),
+                    context: Gen.make_context('robot_name' => 'default'),
+                    verbose: !options[:quiet]
+                dir
+            end
+
+            desc "robot ROBOT_NAME", "creates a new robot configuration"
+            def robot(name, robot_path: 'roby_app')
+                Roby.app.require_app_dir(needs_current: true)
+                Roby.app.load_base_config
+
+                template File.join(robot_path, 'config', "robots", "robot.rb"),
+                    File.join("config", "robots", "#{name}.rb"),
+                    context: Gen.make_context('robot_name' => name)
+            end
+
+            desc "action ACTION_FILE_OR_CLASS", "create a new action interface at the provided file"
+            option :robot, aliases: 'r', desc: 'the robot name for robot-specific scaffolding',
+                type: :string, default: nil
+            def actions(name)
+                Roby.app.require_app_dir(needs_current: true)
+                Roby.app.load_base_config
+
+                file_name, class_name = Gen.resolve_name(
+                    'actions', name, options[:robot], ['models', 'actions'], ["Actions"])
+
+                template File.join('actions', 'class.rb'),
+                    File.join('models', 'actions', *file_name) + ".rb",
+                    context: Gen.make_context('class_name' => class_name)
+                template File.join('actions', "test.rb"),
+                    File.join('test', 'actions', *file_name[0..-2], "test_#{file_name[-1]}.rb"),
+                    context: Gen.make_context(
+                        'class_name' => class_name,
+                        'require_path' => File.join('models', "actions", *file_name))
+            end
+
+            desc "class CLASS_NAME", "creates a new utility class in lib/"
+            def klass(name)
+                Roby.app.require_app_dir(needs_current: true)
+                Roby.app.load_base_config
+
+                file_name, class_name = Gen.resolve_name(
+                    'class', name, nil, ['lib', Roby.app.app_name], [])
+
+                template File.join('class', 'class.rb'),
+                    File.join('lib', Roby.app.app_name, *file_name) + ".rb",
+                    context: Gen.make_context('class_name' => class_name)
+                template File.join('class', "test.rb"),
+                    File.join('test', 'lib', *file_name[0..-2], "test_#{file_name[-1]}.rb"),
+                    context: Gen.make_context(
+                        'class_name' => class_name,
+                        'require_path' => File.join(Roby.app.app_name, *file_name))
+            end
+
+            desc "module MODULE_NAME", "creates a new utility module in lib/"
+            def module(name)
+                Roby.app.require_app_dir(needs_current: true)
+                Roby.app.load_base_config
+
+                file_name, class_name = Gen.resolve_name(
+                    'module', name, nil, ['lib', Roby.app.app_name], [])
+
+                template File.join('module', 'module.rb'),
+                    File.join('lib', Roby.app.app_name, *file_name) + ".rb",
+                    context: Gen.make_context('module_name' => class_name)
+                template File.join('module', "test.rb"),
+                    File.join('test', 'lib', *file_name[0..-2], "test_#{file_name[-1]}.rb"),
+                    context: Gen.make_context(
+                        'module_name' => class_name,
+                        'require_path' => File.join(Roby.app.app_name, *file_name))
+            end
+
+            desc "task NAME", "creates a new Roby task model"
+            option :robot, aliases: 'r', desc: 'the robot name for robot-specific scaffolding',
+                type: :string, default: nil
+            def task(name)
+                Roby.app.require_app_dir(needs_current: true)
+                Roby.app.load_base_config
+
+                file_name, class_name = Gen.resolve_name(
+                    'tasks', name, options[:robot], ['models', 'tasks'], ["Tasks"])
+
+                template File.join('task', 'class.rb'),
+                    File.join('models', 'tasks', *file_name) + ".rb",
+                    context: Gen.make_context('class_name' => class_name)
+                template File.join('task', "test.rb"),
+                    File.join('test', 'tasks', *file_name[0..-2], "test_#{file_name[-1]}.rb"),
+                    context: Gen.make_context(
+                        'class_name' => class_name,
+                        'require_path' => File.join('models', "tasks", *file_name))
+            end
+        end
+    end
+end

data/lib/roby/cli/log.rb

@@ -0,0 +1,276 @@
+require 'roby'
+require 'thor'
+
+Roby.app.guess_app_dir
+
+module Roby
+    module CLI
+        class Log < Thor
+            no_commands do
+                def handle_file_argument(file = nil)
+
+                    if file
+                        return file if File.file?(file)
+                        Roby.app.setup_robot_names_from_config_dir
+                        if !Roby.app.robot_name?(file)
+                            raise ArgumentError, "expected #{file} to either the path to a log file, or a robot name to get the last log file from this robot configuration"
+                        end
+                        Roby.app.robot(file)
+                    end
+                    Roby.app.log_current_file
+                end
+            end
+
+            desc 'upgrade-format', 'upgrades an older Roby log file to the newest version'
+            def upgrade_format(file)
+                require 'roby/log/upgrade'
+                Roby::Log::Upgrade.to_new_format(file)
+            end
+
+            desc 'rebuild-index', 'rebuilds the index of an existing log file'
+            def rebuild_index(file = nil)
+                file = handle_file_argument(file)
+                require 'roby/droby/logfile/reader'
+                Roby::DRoby::Logfile::Reader.open(file).
+                   rebuild_index
+            end
+
+            desc 'timepoints', 'extract timepoint information from the log file'
+            option :raw, desc: 'display the timpoints as they appear instead of formatting them per-thread and per-group',
+                type: :boolean, default: false
+            option :flamegraph, type: :string, desc: 'path to a HTML file that will display a flame graph'
+            option :ctf, type: :boolean, desc: 'generate a CTF file suitable to be analyzed by e.g. Trace Compass'
+            def timepoints(file = nil)
+                file = handle_file_argument(file)
+
+                require 'roby/droby/logfile/reader'
+                require 'roby/droby/timepoints'
+                require 'roby/droby/timepoints_ctf'
+                require 'roby/cli/log/flamegraph_renderer'
+
+                stream = Roby::DRoby::Logfile::Reader.open(file)
+
+                if options[:raw]
+                    current_context = Hash.new
+                    while data = stream.load_one_cycle
+                        data.each_slice(4) do |m, sec, usec, args|
+                            thread_id, thread_name, timepoint_name = *args
+                            path = (current_context[thread_id] ||= [thread_name])
+
+                            if m == :timepoint
+                                puts "#{Roby.format_time(Time.at(sec, usec))} #{path.join("/")}/#{timepoint_name}"
+                            elsif m == :timepoint_group_start
+                                puts "#{Roby.format_time(Time.at(sec, usec))} #{path.join("/")}/#{timepoint_name} {"
+                                path.push timepoint_name
+                            elsif m == :timepoint_group_end
+                                path.pop
+                                puts "#{Roby.format_time(Time.at(sec, usec))} #{path.join("/")}/#{timepoint_name} }"
+                            end
+                        end
+                    end
+                    return
+                end
+
+
+                analyzer = Roby::DRoby::Timepoints::Analysis.new
+                if options[:ctf]
+                    analyzer = Roby::DRoby::Timepoints::CTF.new
+                else
+                    analyzer = Roby::DRoby::Timepoints::Analysis.new
+                end
+                while data = stream.load_one_cycle
+                    data.each_slice(4) do |m, sec, usec, args|
+                        if m == :timepoint
+                            analyzer.add Time.at(sec, usec), *args
+                        elsif m == :timepoint_group_start
+                            analyzer.group_start Time.at(sec, usec), *args
+                        elsif m == :timepoint_group_end
+                            analyzer.group_end Time.at(sec, usec), *args
+                        end
+                    end
+                end
+
+                if options[:ctf]
+                    path = Pathname.new(file).expand_path.sub_ext('.ctf')
+                    path.mkpath
+                    puts "saving in #{path}"
+                    analyzer.save(path)
+                elsif options[:flamegraph]
+                    graph = analyzer.flamegraph
+                    graph = graph.map do |name, duration|
+                        [name, (duration * 1000).round]
+                    end
+                    File.open(options[:flamegraph], 'w') do |io|
+                        io.write FlamegraphRenderer.new(graph).graph_html
+                    end
+                else
+                    puts analyzer.format
+                end
+                exit 0
+            end
+
+            desc 'stats', 'show general timing statistics'
+            option :save, type: :string, desc: 'file to save the CSV data to'
+            def stats(file = nil)
+                file = handle_file_argument(file)
+
+                require 'roby/droby/logfile/reader'
+                stream = Roby::DRoby::Logfile::Reader.open(file)
+                index = stream.index
+
+                cycle_count = index.size
+
+                if cycle_count == 0
+                    puts "empty log file"
+                    exit 0
+                end
+
+                timespan    = index.range
+                puts "#{cycle_count} cycles between #{timespan.first.to_hms} and #{timespan.last.to_hms}"
+                process_utime = index.inject(0) { |old, info| old + info[:utime] }
+                process_stime = index.inject(0) { |old, info| old + info[:stime] }
+                real_time = timespan.last - timespan.first
+                ratio = (process_utime + process_stime) / real_time
+                puts "Time: %.2fs user / %.2fs sys / %.2fs real (%i%% CPU use)" %
+                    [process_utime, process_stime, real_time, ratio * 100]
+
+                min, max = nil
+                event_count = index.inject(0) do |total, cycle_info|
+                    count = cycle_info[:event_count]
+                    min = count if !min || min > count
+                    max = count if !max || max < count
+                    total + count
+                end
+                puts "#{event_count} log events, #{event_count / cycle_count} events/cycle (min: #{min}, max: #{max})"
+
+                io = STDOUT
+                if options[:save]
+                    io = File.open(options[:save], 'w')
+                end
+
+                header = %w{0_actual_start 1_cycle_index 2_log_queue_size 3_plan_task_count 4_plan_event_count 5_utime 6_stime 7_dump_time 8_duration 9_total_allocated_objects 10_minor 11_major 12_live_object_count 13_oob_removed 14_gc_total_time}
+                formatting = %w{%i %i %i %i %.3f %.3f %.3f %.3f %i %i %i %i %i %.3f}
+                formatting = formatting.join(",")
+
+                puts header.join(",")
+                index.each do |info|
+                    gc = info[:gc]
+                    oob_gc = info[:pre_oob_gc] || gc
+                    start_sec, start_usec = info[:start]
+                    start = Time.at(start_sec, start_usec)
+
+                    io.puts (start + info[:actual_start]).strftime("%H:%M:%S.%3N") + " " + formatting % [
+                        *info.values_at(:cycle_index, :log_queue_size, :plan_task_count, :plan_event_count, :utime, :stime, :dump_time, :end),
+                        gc[:total_allocated_objects],
+                        gc[:minor_gc_count],
+                        gc[:major_gc_count],
+                        gc[:total_allocated_objects] - gc[:total_freed_objects],
+                        gc[:total_freed_objects] - oob_gc[:total_freed_objects],
+                        info[:gc_total_time] || 0]
+                end
+
+                exit(0)
+            end
+
+            desc 'decode', 'show the raw events from the logfile'
+            option :replay, type: :string,
+                desc: "replay the log stream into a plan, add =debug to display more debugging information. Mainly useful to debug issues with the plan rebuilder",
+                default: 'normal'
+            def decode(file = nil)
+                file = handle_file_argument(file)
+
+                require 'roby/droby/logfile/reader'
+                require 'roby/droby/plan_rebuilder'
+
+                stream = Roby::DRoby::Logfile::Reader.open(file)
+                if replay = options[:replay]
+                    replay_debug = (replay == 'debug')
+                    rebuilder = Roby::DRoby::PlanRebuilder.new
+                end
+
+                while data = stream.load_one_cycle
+                    data.each_slice(4) do |m, sec, usec, args|
+                        header = "#{Time.at(sec, usec)} #{m} "
+                        puts "#{header} #{args.map(&:to_s).join("  ")}"
+                        header = " " * header.size
+                        if rebuilder
+                            begin
+                                rebuilder.process_one_event(m, sec, usec, args)
+                                if replay_debug
+                                    if m == :merged_plan
+                                        puts "Merged plan"
+                                        plan = args[1]
+                                        puts "  #{plan.tasks.size} tasks: #{plan.tasks.map { |id, _| id.to_s }.join(", ")}"
+                                        puts "  #{plan.task_events.size} task events: #{plan.task_events.map { |id, _| id.to_s }.join(", ")}"
+                                        puts "  #{plan.free_events.size} events: #{plan.free_events.map { |id, _| id.to_s }.join(", ")}"
+                                    end
+                                    pp rebuilder
+                                end
+                            rescue Roby::DRoby::UnknownSibling
+                                # Add some more debugging information
+                                pp rebuilder
+                                raise
+                            end
+                        end
+                    end
+                    if rebuilder
+                        rebuilder.clear_integrated
+                    end
+                end
+            end
+            
+            desc 'repair', 'attempt to repair a broken log file'
+            def repair(file)
+                require 'roby/droby/logfile/reader'
+                logfile = Roby::DRoby::Logfile::Reader.open(file)
+                last_cycle = nil
+                while !logfile.eof?
+                    current_pos = logfile.tell
+                    begin
+                        last_cycle = logfile.load_one_cycle
+                    rescue Roby::DRoby::Logfile::TruncatedFileError
+                        stat = File.stat(file)
+                        puts "last chunk(s) in the file seem to have only been partially written."
+                        puts "truncating at #{current_pos} out of #{stat.size} (removing #{stat.size - current_pos} bytes)"
+                        if last_cycle
+                            info  = last_cycle.last.last
+                            end_time = Time.at(*info[:start]) + info[:end]
+                            puts "the repaired file ends at #{end_time}"
+                        else
+                            puts "there are no valid cycles in the truncated file"
+                        end
+                        FileUtils.cp file, "#{file}.broken"
+                        puts "the original has been saved as '#{file}.broken'"
+                        File.open(file, 'a+') do |io|
+                            io.truncate(current_pos)
+                        end
+                        break
+                    end
+                end
+            ensure logfile.close
+            end
+
+            desc 'current', 'full path to the current log file'
+            option :dir, aliases: 'd', type: :boolean
+            def current(robot_name = nil)
+                if robot_name
+                    Roby.app.setup_robot_names_from_config_dir
+                    Roby.app.robot(robot_name)
+                end
+                if options[:dir]
+                    puts Roby.app.log_current_dir
+                else
+                    puts Roby.app.log_current_file
+                end
+            end
+
+            desc 'display', "start roby-display to visualize the log file's contents"
+            def display(file = nil)
+                file = handle_file_argument(file)
+                require 'roby/cli/display'
+                Display.new.file(file)
+            end
+        end
+    end
+end
+

data/lib/roby/cli/log/flamegraph.html

@@ -0,0 +1,499 @@
+<!DOCTYPE html>
+<html>
+<head>
+/**INCLUDES**/
+
+<meta charset=utf-8 />
+
+<title>Flame Graph of Page</title>
+<style>
+  .info {min-height: 50px; margin: 10px; }
+  .legend div {
+    display: block;
+    float: left;
+    width: 150px;
+    margin: 0 8px 8px;
+    padding: 4px;
+    height: 50px;
+  }
+  .code {
+    font-family: Consolas, Menlo, Monaco, "Lucida Console", "Liberation Mono", "DejaVu Sans Mono", "Bitstream Vera Sans Mono", "Courier New", monospace;
+  }
+  #frameinfo table .sample-info {
+    width: 200px;
+    color: #333;
+    font-size: 12px;
+  }
+  #frameinfo table {
+    border-collapse: collapse;
+  }
+  #frameinfo table tr {
+    border-bottom: 1px solid #eee;
+    margin-top: 5px;
+  }
+  #frameinfo td {
+    padding: 5px;
+  }
+  #frameinfo-wrapper {
+    position: fixed;
+    z-index: 1;
+    opacity: 0.7;
+    background-color: black;
+    width: 100%;
+    height: 100%;
+    top: 0;
+    left: 0;
+    display: none;
+  }
+  #frameinfo {
+    position: fixed;
+    padding: 10px;
+    z-index: 2;
+    opacity: 1.0;
+    top: 0;
+    margin-top: 50px;
+    margin-left: 40px;
+    width: 80%;
+    height: 80%;
+    background-color: white;
+    border: 2px solid #666;
+    display: none;
+    overflow: auto;
+  }
+</style>
+</head>
+<body>
+  <div class="graph"></div>
+  <div class="info code"></div>
+  <div class="legend"></div>
+  <div id="frameinfo-wrapper"></div>
+  <div id="frameinfo">
+    <h3>Frame Info</h3>
+    <table>
+    </table>
+  </div>
+  <script>
+
+var data = /**DATA**/;
+var maxX = 0;
+var maxY = 0;
+
+debounce = function(func, wait, trickle) {
+  var timeout;
+
+  timeout = null;
+  return function() {
+    var args, context, currentWait, later;
+    context = this;
+    args = arguments;
+    later = function() {
+      timeout = null;
+      return func.apply(context, args);
+    };
+
+    if (timeout && trickle) {
+      // already queued, let it through
+      return;
+    }
+
+    if (typeof wait === "function") {
+      currentWait = wait();
+    } else {
+      currentWait = wait;
+    }
+
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+
+    timeout = setTimeout(later, currentWait);
+    return timeout;
+  };
+};
+
+
+var guessGem = function(frame)
+{
+  var split = frame.split('/gems/');
+  if(split.length == 1) {
+    split = frame.split('/app/');
+    if(split.length == 1) {
+      split = frame.split('/lib/');
+    }
+
+    split = split[Math.max(split.length-2,0)].split('/');
+    return split[split.length-1].split(':')[0];
+  }
+  else
+  {
+    return split[split.length -1].split('/')[0];
+  }
+}
+
+var guessMethod = function(frame) {
+  var split = frame.split('`');
+  if(split.length == 2) {
+    var fullMethod = split[1].split("'")[0];
+    split = fullMethod.split("#");
+    if(split.length == 2) {
+      return split[1];
+    }
+    return split[0];
+  }
+  return '?';
+}
+
+var guessFile = function(frame) {
+  var split = frame.split(".rb:");
+  if(split.length == 2) {
+    split = split[0].split('/');
+    return split[split.length - 1];
+  }
+  return "";
+}
+
+$.each(data, function(){
+   maxX = Math.max(maxX, this.x + this.width);
+   maxY = Math.max(maxY, this.y);
+   this.shortName = this.frame;
+});
+
+var width = $(window).width();
+var height = $(window).height() / 1.2;
+
+$('.graph').width(width).height(height);
+
+var xScale = d3.scale.linear()
+	.domain([0, maxX])
+    .range([0, width]);
+
+var yScale = d3.scale.linear()
+    .domain([0, maxY])
+    .range([0,height]);
+
+var realHeight = 0;
+var debouncedHeightCheck = debounce(function(){
+  if (realHeight > 15) {
+    svg.selectAll('text').attr('display','show');
+  } else {
+    svg.selectAll('text').attr('display','none');
+  }
+}, 200);
+
+function zoom()
+{
+  svg.attr("transform", "translate(" + d3.event.translate + ")" + " scale(" + d3.event.scale + ")");
+
+  realHeight = yScale(1) * d3.event.scale;
+  debouncedHeightCheck();
+}
+
+var svg = d3.select(".graph")
+                    .append("svg")
+                    .attr("width", "100%")
+                    .attr("height", "100%")
+                    .attr("pointer-events", "all")
+                    .append('svg:g')
+                    .call(d3.behavior.zoom().on("zoom", zoom))
+                    .append('svg:g');
+
+
+// so zoom works everywhere
+svg.append("rect")
+    .attr("x",function(d) { return xScale(0); })
+    .attr("y",function(d) { return yScale(0);})
+    .attr("width", function(d){return xScale(maxX);})
+    .attr("height", yScale(maxY))
+    .attr("fill", "white");
+
+var color = function() {
+  var r = parseInt(205 + Math.random() * 50);
+  var g = parseInt(Math.random() * 230);
+  var b = parseInt(Math.random() * 55);
+  return "rgb(" + r + "," + g + "," + b + ")";
+}
+var info = {};
+
+// http://stackoverflow.com/questions/1960473/unique-values-in-an-array
+Array.prototype.getUnique = function() {
+    var o = {}, a = []
+    for (var i = 0; i < this.length; i++) o[this[i]] = 1
+    for (var e in o) a.push(e)
+    return a
+}
+
+var samplePercent = function(samples, exclusive){
+  var info = " (" + samples +
+    " sample" + (samples == 1 ? "" : "s") + " - " +
+    ((samples / maxX) * 100).toFixed(2) + "%) ";
+  if (exclusive) {
+    info += " (" + exclusive +
+      " exclusive - " +
+    ((exclusive / maxX) * 100).toFixed(2) + "%) ";
+  }
+  return info;
+}
+
+var mouseover =  function(d) {
+  var i = info[d.frame];
+  $('.info').text( d.frame + " " + samplePercent(i.samples.length, d.topFrame ? d.topFrame.exclusiveCount : 0));
+  d3.selectAll(i.nodes)
+     .attr('opacity',0.5);
+};
+
+var mouseout = function(d) {
+  var i = info[d.frame];
+  $('.info').text("");
+  d3.selectAll(i.nodes)
+     .attr('opacity',1);
+};
+
+var backtrace = function(frame){
+  for(var i=0; i<data.length; i++){
+    if(frame === data[i]){ break; }
+  }
+
+  frames = [frame];
+  var depth = frame.y;
+
+  while(i > 0){
+    if(depth == -1) break;
+
+    if(data[i].y === depth-1) {
+      frames.push(data[i]);
+      depth--;
+    }
+
+    i--;
+  }
+
+  return frames;
+}
+
+$('#frameinfo-wrapper').click(function(d){
+    $(this).hide();
+    $('#frameinfo').hide();
+});
+
+var click = function(d){
+  var trace = backtrace(d);
+
+  var link = function(path, dest){
+    return path.replace(/[^\/]+:\d+/, function(x){ return "<a target='_blank' href='"+ dest +"'>" + x + "</a>"})
+  };
+
+  var linkify = function(path){
+    var split = path.split("/")[0].split("-");
+    if(["activerecord","actionpack","railties","activesupport", "rails"].indexOf(split[0]) > -1) {
+      var github = "https://github.com/rails/rails/blob/";
+      var file = path.split(":")[0].split("/");
+      if(split[0] === "rails") {
+        file.shift();
+      } else {
+        file[0] = split[0];
+      }
+
+      github += (split[1].length < 6 ? "v" : "") + split[1] + "/";
+      github += file.join("/");
+      github += "#L" + parseInt(path.split(":")[1]);
+
+      return link(path, github);
+    }
+    return path;
+  }
+
+  var simplify = function(frame){
+    var split = frame.split('/gems/');
+    if(split.length > 1){
+      var path = linkify(split.pop());
+      return "<span class='full-location'>" + split.join('/gems/') + "/</span>" + path;
+    } else {
+      return frame;
+    }
+  }
+
+  var table = trace.map(function(f){
+        var i = info[f.frame];
+        return "<tr><td class='code'>" + simplify(f.frame) + "</td><td class='sample-info'>" +
+                samplePercent(i.samples.length, f.topFrame ? f.topFrame.exclusiveCount : 0) + 
+                "</td></tr>";
+      }).join("\n");
+
+  var table = $('#frameinfo table').html(table);
+  table.find(".full-location").hide().after("<span class='expand'>&hellip; </span>");
+  table.find(".expand").css({cursor: "pointer"}).click(function(){
+      $(this).hide().parent().find(".full-location").show();
+  });
+
+  $('#frameinfo-wrapper').show();
+  $('#frameinfo').show();
+};
+
+// http://stackoverflow.com/a/7419630
+var rainbow = function(numOfSteps, step) {
+    // This function generates vibrant, "evenly spaced" colours (i.e. no clustering). This is ideal for creating easily distiguishable vibrant markers in Google Maps and other apps.
+    // Adam Cole, 2011-Sept-14
+    // HSV to RBG adapted from: http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript
+    var r, g, b;
+    var h = step / numOfSteps;
+    var i = ~~(h * 6);
+    var f = h * 6 - i;
+    var q = 1 - f;
+    switch(i % 6){
+        case 0: r = 1, g = f, b = 0; break;
+        case 1: r = q, g = 1, b = 0; break;
+        case 2: r = 0, g = 1, b = f; break;
+        case 3: r = 0, g = q, b = 1; break;
+        case 4: r = f, g = 0, b = 1; break;
+        case 5: r = 1, g = 0, b = q; break;
+    }
+    var c = "#" + ("00" + (~ ~(r * 255)).toString(16)).slice(-2) + ("00" + (~ ~(g * 255)).toString(16)).slice(-2) + ("00" + (~ ~(b * 255)).toString(16)).slice(-2);
+    return (c);
+}
+
+// assign some colors, analyze samples per gem
+var gemStats = {}
+var topFrames = {}
+var lastFrame = {frame: 'd52e04d-df28-41ed-a215-b6ec840a8ea5', x: -1}
+
+$.each(data, function(){
+
+  var gem = guessGem(this.frame);
+  var stat = gemStats[gem];
+
+  if(!stat) {
+    gemStats[gem] = stat = {name: gem, samples: [], frames: []};
+  }
+
+  stat.frames.push(this.frame);
+  for(var j=0; j < this.width; j++){
+    stat.samples.push(this.x + j);
+  }
+  // This assumes the traversal is in order
+  if (lastFrame.x != this.x) {
+    var topFrame = topFrames[lastFrame.frame]
+    if (!topFrame) {
+      topFrames[lastFrame.frame] = topFrame = {exclusiveCount: 0}
+    }
+    topFrame.exclusiveCount += 1;
+    lastFrame.topFrame = topFrame;
+  }
+  lastFrame = this;
+
+});
+
+var topFrame = topFrames[lastFrame.frame]
+if (!topFrame) {
+  topFrames[lastFrame.frame] = topFrame = {exclusiveCount: 0}
+}
+topFrame.exclusiveCount += 1;
+lastFrame.topFrame = topFrame;
+
+var totalGems = 0;
+$.each(gemStats, function(k,stat){
+  totalGems++;
+  stat.samples = stat.samples.getUnique();
+});
+
+
+var gemsSorted = _(gemStats).pairs()
+                          .sortBy(function(item){
+                              return -item[1].samples.length;
+                            })
+                          .map(function(item){return item[1]})
+                          .value();
+
+var currentIndex = 0;
+_.each(gemsSorted, function(stat){
+
+  stat.color = rainbow(totalGems, currentIndex);
+
+  for(var x=0; x < stat.frames.length; x++) {
+    info[stat.frames[x]] = {nodes: [], samples: [], color: stat.color};
+  }
+
+  currentIndex += 1;
+});
+
+
+
+// see: http://bl.ocks.org/mundhradevang/1387786
+function fontSize(d,i) {
+  var size = yScale(1) / 3;
+  // var words = d.shortName.split(' ');
+  var word = d.shortName; // words[0];
+  var width = xScale(d.width+100);
+  var height = yScale(1);
+  var length = 0;
+  d3.select(this).style("font-size", size + "px").text(word);
+  while((size > 12.1) && ((this.getBBox().width >= width) || (this.getBBox().height >= height)))
+   {
+    size -= 0.1;
+    d3.select(this).style("font-size", size + "px");
+   }
+
+   d3.select(this).attr("dy", size);
+}
+
+svg.selectAll("g")
+	.data(data)
+	.enter()
+    .append("g")
+    .each(function(){
+      d3.select(this)
+      .append("rect")
+      .attr("x",function(d) { return xScale(d.x-1); })
+      .attr("y",function(d) { return yScale(maxY - d.y);})
+      .attr("width", function(d){return xScale(d.width);})
+      .attr("height", yScale(1))
+      .attr("fill", function(d){
+        var i = info[d.frame];
+        if(!i) {
+          info[d.frame] = i = {nodes: [], samples: [], color: color()};
+        }
+        i.nodes.push(this);
+        for(var j=0; j < d.width; j++){
+          i.samples.push(d.x + j);
+        }
+        return i.color;
+      })
+      .on("click", click)
+      .on("mouseover", mouseover)
+      .on("mouseout", mouseout)
+      .attr("cursor", "pointer");
+
+      d3.select(this)
+        .append("text")
+        .attr("x",function(d) { return xScale(d.x - 0.98); })
+        .attr("y",function(d) { return yScale(maxY - d.y);})
+        .on("click", click)
+        .on("mouseover", mouseover)
+        .on("mouseout", mouseout)
+        .each(fontSize)
+        .attr("cursor", "pointer")
+        .attr("display", "none");
+
+    });
+
+
+// Samples may overlap on the same line
+for (var r in info) {
+  if (info[r].samples) {
+    info[r].samples = info[r].samples.getUnique();
+  }
+};
+
+
+// render the legend
+_.each(gemsSorted, function(gem){
+  var node = $("<div></div>")
+    .css("background-color", gem.color)
+    .text(gem.name + " " + samplePercent(gem.samples.length)) ;
+  $('.legend').append(node);
+});
+
+
+
+  </script>
+</body>
+</html>