Code coverage report for tracevis/lib/trace/parse.js

Statements: 100% (44 / 44)      Branches: 77.78% (14 / 18)      Functions: 100% (9 / 9)      Lines: 100% (43 / 43)     

All files » tracevis/lib/trace/ » parse.js
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96                                2   2         2 16     16   82 82 82 82   82 82   82 24   82     16 8 87 87   63 63   22 22           1 1   1 1           16   16     2 82 82 476 476     82     2 16 2 98 98 98 82 82     16    
/*
 * Copyright 2013 LinkedIn, Inc
 *
 * Licensed under the Apache License, Version 2.0 (the 'License'); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an 'AS IS' BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
 
var CDigraph = require('graphlib').CDigraph;
 
module.exports = parse;
 
/*
 * Parses `json` and returns a directed graph representation.
 */
function parse(json) {
  var g = new CDigraph(),
      snapshotNanos = json.snapshotNanos;
 
  json.traces.forEach(function(trace) {
    // If the task was not even started, then don't display it...
    Eif (trace.startNanos !== undefined) {
      trace = shallowCopy(trace);
      var id = trace.id;
      delete trace.id;
 
      Eif (trace.pendingNanos === undefined)
        trace.pendingNanos = snapshotNanos;
 
      if (trace.endNanos === undefined)
        trace.endNanos = snapshotNanos;
 
      g.addNode(id, trace);
    }
  });
  if (json.relationships) {
    json.relationships.forEach(function(rel) {
      Eif (g.hasNode(rel.to) && g.hasNode(rel.from)) {
        switch(rel.relationship) {
          case 'PARENT_OF':
            g.parent(rel.to, rel.from);
            break;
          case 'SUCCESSOR_OF':
            g.addEdge(null, rel.to, rel.from, { relationship: 'SUCCESSOR' });
            break;
          case 'POSSIBLE_SUCCESSOR_OF':
            // Note that the change of name from POSSIBLE_SUCCESSOR_OF to
            // POTENTIAL_SUCCESSOR is intentional. The trace format is
            // inconsistent but we'll at least keep the visualization code
            // consistent.
            g.addEdge(null, rel.to, rel.from, { relationship: 'POTENTIAL_SUCCESSOR' });
            break;
          case 'POTENTIAL_PARENT_OF':
            g.addEdge(null, rel.to, rel.from, { relationship: 'POTENTIAL_PARENT' });
            break;
        }
      }
    });
  }
 
  precomputeSortOrder(g);
 
  return g;
}
 
function shallowCopy(obj) {
  var copy = {};
  Object.keys(obj).forEach(function(k) {
    Eif (obj.hasOwnProperty(k)) {
      copy[k] = obj[k];
    }
  });
  return copy;
}
 
function precomputeSortOrder(g) {
  var counter = 0;
  function dfs(u) {
    var children = g.children(u);
    children.sort(function(v, w) { return g.node(v).startNanos - g.node(w).startNanos; });
    children.forEach(function(v) {
      g.node(v).order = counter++;
      dfs(v);
    });
  }
  dfs(null);
}