chaos_detector 0.4.9

data/lib/chaos_detector/graphing/graphs.rb

@@ -0,0 +1,129 @@
+require 'chaos_detector/options'
+require 'chaos_detector/navigator'
+require 'chaos_detector/stacker/frame'
+require 'chaos_detector/graph_theory/appraiser'
+require 'chaos_detector/graph_theory/graph'
+require 'chaos_detector/graphing/directed_graphs'
+require 'chaos_detector/chaos_graphs/chaos_graph'
+require 'chaos_detector/utils/str_util'
+require 'chaos_detector/chaos_utils'
+
+require_relative 'directed_graphs'
+require_relative 'matrix_graphs'
+
+module ChaosDetector
+  module Graphing
+    ### Top-level Chaos-detection graphing and rendering
+    class Graphs
+      attr_reader :navigator
+      attr_reader :chaos_graph
+
+      def initialize(options: nil)
+        @options = options || ChaosDetector::Options.new
+        @render_folder = @options.path_with_root(key: :graph_render_folder)
+        # @render_folder = @options.graph_render_folder
+        ChaosDetector::Utils::FSUtil.ensure_dirpath(@render_folder)
+        @navigator = ChaosDetector::Navigator.new(options: @options)
+      end
+
+      def playback(row_range: nil)
+        fn_graph, mod_graph = @navigator.playback(row_range: row_range)
+        @chaos_graph = ChaosDetector::ChaosGraphs::ChaosGraph.new(fn_graph, mod_graph)
+        @chaos_graph.infer_all
+      end
+
+      GRAPH_TYPE_ATTRS = {
+        domain: {
+          # ratio: 'auto',
+          # size: '8, 8',
+          # rankdir: 'TB',
+          # packmode: 'clust'
+        },
+        function: {
+
+        },
+        module: {
+          rankdir: 'TB',
+          packmode: 'clust',
+          ranksep: '1.5',
+        },
+      }
+
+      def adjacency_graph(graph_type, graph: nil, graph_name: 'adj-matrix')
+        the_matrix = ChaosDetector::Graphing::MatrixGraphs.new(chaos_graph, render_folder: @render_folder)
+        graph, appraiser = @chaos_graph.graph_data_for(graph_type: graph_type)
+        matrix = appraiser.adjacency_matrix
+        the_matrix.render_adjacency(matrix, graph_name: graph_name)
+      end
+
+      def render_dep_graph(graph_type, graph: nil, as_cluster: false, domains: false, name: nil, root: true, metrics_table: false)
+        g, _appraiser = chaos_graph.graph_data_for(graph_type: graph_type)
+        rgraph = graph ? graph : g
+        graph_name = name ? name : "#{graph_type}-dep"
+
+        graph_attrs = GRAPH_TYPE_ATTRS[graph_type]
+
+        dgraph = if domains #&& graph_type != :cluster
+          build_domain_dgraph(graph_name, rgraph.nodes, rgraph.edges, graph_attrs: graph_attrs, metrics_table: metrics_table)
+        else
+          build_dgraph(graph_name, rgraph.nodes, rgraph.edges, as_cluster: as_cluster, graph_attrs: graph_attrs, metrics_table: metrics_table)
+        end
+
+        dgraph.rendered_path
+      end
+
+      def render_domain_dep(graph_name: 'domain-dep', domain_graph: nil, metrics_table: false)
+        render_dep_graph(:domain, as_cluster: true, graph: domain_graph, name: graph_name, metrics_table: metrics_table)
+      end
+
+      def render_fn_dep(graph_name: 'fn-dep', function_graph: nil, domains: false, metrics_table: false)
+        render_dep_graph(:function, as_cluster: true, graph: function_graph, domains: domains, name: graph_name, metrics_table: metrics_table)
+      end
+
+      def render_mod_dep(graph_name: 'module-dep', module_graph: nil, domains: false, metrics_table: false)
+        render_dep_graph(:module, graph: module_graph, domains: domains, name: graph_name, metrics_table: metrics_table)
+      end
+
+      private
+
+        def build_dgraph(label, nodes, edges, as_cluster: false, render: true, graph_attrs: nil, metrics_table: false)
+          # nodes.each do |n|
+          #   p("#{label} Nodes: #{ChaosUtils.decorate(n.title)}")
+          # end
+
+          # edges.each do |e|
+          #   p("#{label} Edges: #{ChaosUtils.decorate(e.src_node.title)} -> #{ChaosUtils.decorate(e.dep_node.title)}")
+          # end
+          puts("Building #{label} with as_cluster: #{as_cluster}")
+          dgraph = ChaosDetector::Graphing::DirectedGraphs.new(render_folder: @render_folder)
+          dgraph.create_directed_graph(label, graph_attrs: graph_attrs)
+          dgraph.append_nodes(nodes, as_cluster: as_cluster, metrics_table: metrics_table)
+          dgraph.add_edges(edges)
+          dgraph.render_graph if render
+          dgraph
+        end
+
+        def build_domain_dgraph(graph_name, nodes, edges, render: true, graph_attrs: nil, metrics_table: false)
+          # Add domains as cluster/subgraph nodes:
+          domain_nodes = nodes.map{|node| chaos_graph.domain_node_for(name: node.domain_name) }
+          dgraph = build_dgraph(graph_name, domain_nodes, [], as_cluster: true, render: false, graph_attrs: graph_attrs, metrics_table: metrics_table)
+
+          # Add nodes to domains:
+          dgraph.append_nodes(nodes, metrics_table: false) do |node|
+            chaos_graph.domain_node_for(name: node.domain_name)
+          end
+          dgraph.add_edges(edges)
+          dgraph.render_graph if render
+          dgraph
+          # dgraph.rendered_path
+
+          # fn_nodes = chaos_graph.function_graph.nodes.group_by(&:domain_name)
+          # fn_nodes.map do |dom_nm, fn_nodes|
+          #   dom_node = ChaosUtils.aught?(dom_nm) && chaos_graph.domain_node_for(name: dom_nm)
+          #   dgraph.add_node_to_parent(fn_node, dom_node)
+          # end
+        end
+
+    end
+  end
+end

data/lib/chaos_detector/graphing/matrix_graphs.rb

@@ -0,0 +1,101 @@
+require 'set'
+require 'ruby-graphviz'
+require 'rubyvis'
+
+require 'chaos_detector/utils/str_util'
+require 'chaos_detector/chaos_utils'
+
+module ChaosDetector
+  module Graphing
+    class MatrixGraphs
+      CELL_WIDTH = 100
+      NodeStruct = Struct.new(:node_name, :node_value, :group, :index, :link_degree)
+      LinkNodeStruct = Struct.new(:index, :link_degree)
+      LinkStruct = Struct.new(:source, :target, :source_node, :target_node, :value, :link_value, :link_degree)
+
+      def initialize(chaos_graph, render_folder: nil)
+        @chaos_graph = chaos_graph
+        @render_folder = render_folder || 'render'
+      end
+
+      def simple_graph_struct(graph)
+        groupset = graph.nodes.reduce(Set.new()) { |memo, n| memo.add(n.domain_name) }
+        groups = groupset.to_a.sort!
+
+        nodes = graph.nodes.map.with_index do |node, n|
+          group_index = groups.index(node.domain_name)
+          NodeStruct.new(node.title, node.to_k, group_index, n)
+        end
+
+        links = graph.edges.map do |edge|
+          w = edge.weight
+          src = nodes.index(edge.src_node)
+          dep = nodes.index(edge.dep_node)
+          LinkStruct.new(src, dep, LinkNodeStruct.new(0, w), LinkNodeStruct.new(0, w), w, w )
+        end
+
+        [nodes, links]
+      end
+
+      def render_adjacency(matrix, graph_name: 'adj-matrix')
+
+        puts "MATRIX COUNT: #{matrix.row_size} x #{matrix.column_size} = #{matrix.count}"
+        matrix.row_vectors.each{|v| puts v.to_a.inspect}
+
+        # simple_nodes, simple_links = simple_graph_struct(graph)
+
+        w = Math.sqrt(matrix.count) * CELL_WIDTH
+        h = w
+
+        color=Rubyvis::Colors.category19
+
+        vis = Rubyvis::Panel.new() do
+          width w
+          height h
+          top 90
+          left 90
+
+        end
+
+        # layout_matrix do
+        #   nodes simple_nodes
+        #   links simple_links
+        #   # sort {|a,b| b.group<=>a.group }
+        #   directed (true)
+        #   link.bar do
+        #     fill_style {|l| l.link_value!=0 ?
+        #      ((l.target_node.group == l.source_node.group) ? color[l.source_node.group] : "#555") : "#eee"}
+        #     antialias(false)
+        #     line_width(1)
+        #   end
+        #   node_label.label do
+        #     text_style {|l| color[l.group]}
+        #   end
+        # end
+
+        # vis
+        #   .add(Rubyvis::Layout::Grid)
+        #   .rows(matrix.to_a)
+        #   .cell
+        #   .add(Rubyvis::Bar)
+        #   .fill_style(Rubyvis.ramp("white", "black"))
+        #   .anchor("center").
+        #   .add(Rubyvis::Label)
+        #   .text_style(Rubyvis.ramp("black","white"))
+        #   .text(lambda{|v| v.is_a?(Numeric) ?  ("%0.2f" % v) : v.to_s})
+
+        vis.render();
+        svg = vis.to_svg()
+
+        @rendered_path = File.join(@render_folder, "#{graph_name}.svg").to_s
+        ChaosDetector::Utils::FSUtil.safe_file_write(@rendered_path, content: svg)
+        @rendered_path
+      end
+
+      private
+        def log(msg, **opts)
+          ChaosUtils.log_msg(msg, subject: 'MatrixDiagram', **opts)
+        end
+    end
+  end
+end

data/lib/chaos_detector/navigator.rb

@@ -0,0 +1,237 @@
+require 'pathname'
+require_relative 'options'
+require_relative 'stacker/mod_info'
+require_relative 'graph_theory/graph'
+require_relative 'chaos_graphs/function_node'
+require_relative 'chaos_graphs/module_node'
+require_relative 'stacker/frame'
+require_relative 'walkman'
+require 'chaos_detector/chaos_utils'
+
+# The main interface for intercepting tracepoints,
+# and converting them into recordable and playable
+# stack/trace frames
+
+module ChaosDetector
+  class Navigator
+    REGEX_MODULE_UNDECORATE = /#<(Class:)?([a-zA-Z\:]*)(.*)>/.freeze
+    DEFAULT_GROUP = 'default'.freeze
+    FRAME_ACTIONS = [:return].freeze # , :return, :class, :end]
+
+    attr_reader :options
+    attr_reader :domain_hash
+    attr_reader :walkman
+
+    attr_reader :nodes
+    attr_reader :edges
+
+    attr_reader :mod_nodes
+    attr_reader :mod_edges
+
+    def initialize(options:)
+      raise ArgumentError, '#initialize requires options' if options.nil?
+
+      @options = options
+      apply_options
+    end
+
+    ### Playback of walkman CSV file:
+    def playback(row_range: nil)
+      log('Chaos playing through navigator.  Total lines: ', object: @walkman.count)
+
+      @nodes = Set.new
+      @edges_call = Set.new
+      @edges_ret = Set.new
+      @mod_nodes = Set.new
+      @mod_edges = Set.new
+      @err_nodes = Set.new
+
+      @walkman.playback(row_range: row_range) do |_rownum, frame|
+        perform_node_action(frame)
+      end
+      # log('Found nodes.', object: @nodes.length)
+
+      @walkman.playback(row_range: row_range) do |_rownum, frame|
+        if [:call, :return].include?(frame.event)
+          perform_edge_action(frame)
+        else
+          perform_mod_edge_action(frame)
+        end
+      end
+
+      edges = merge_edges.to_a
+      # log('Found edges.', object: edges.length)
+
+      @mod_graph = ChaosDetector::GraphTheory::Graph.new(
+        root_node: ChaosDetector::ChaosGraphs::ModuleNode.root_node(force_new: true),
+        nodes: @mod_nodes.to_a,
+        edges: @mod_edges.to_a
+      )
+
+      @fn_graph = ChaosDetector::GraphTheory::Graph.new(
+        root_node: ChaosDetector::ChaosGraphs::FunctionNode.root_node(force_new: true),
+        nodes: @nodes.to_a,
+        edges: edges
+      )
+
+      [@fn_graph, @mod_graph]
+    end
+
+  private
+
+    def apply_options
+      @walkman = ChaosDetector::Walkman.new(options: @options)
+      @domain_hash = {}
+      # @options.path_domain_hash && options.path_domain_hash.each do |path, group|
+      #   dpath = Pathname.new(path.to_s).cleanpath.to_s
+      #   @domain_hash[dpath] = group
+      # end
+    end
+
+    # We merge/reduce edges elsewhere:
+    def merge_edges
+      c = Set.new(@edges_call)
+      r = Set.new(@edges_ret)
+
+      raise 'Call Edges should be Set' unless c.length == @edges_call.length
+      raise 'Ret Edges should be Set' unless r.length == @edges_ret.length
+
+      raise 'Call Edges should be unique' unless @edges_call.uniq.length == @edges_call.length
+      raise 'Call Edges should be unique' unless @edges_ret.uniq.length == @edges_ret.length
+
+      # log('Unique edges in call (n/total)', object: [(c - r).length, c.length])
+      # log('Unique edges in return (n/total)', object: [(r - c).length, r.length])
+
+      # @edges_call.each do |e|
+      #   log("edges_call", object: e)
+      # end
+
+      # @edges_ret.each do |e|
+      #   log("edges_ret ", object: e)
+      # end
+
+      c.union(r)
+    end
+
+    def fn_node_for(fn_info)
+      return nil unless fn_info&.fn_name
+
+      @nodes.find do |n|
+        n.fn_name == fn_info.fn_name &&
+          n.fn_path == fn_info.fn_path
+      end
+    end
+
+    def mod_node_for(mod_info)
+      return nil unless mod_info&.mod_name
+
+      @mod_nodes.find do |n|
+        n.mod_name == mod_info.mod_name &&
+          n.mod_path == mod_info.mod_path
+      end
+    end
+
+    # @return Node matching given frame or create a new one.
+    def fn_node_for_frame(frame)
+      # log("Calling fn_node_for_frame", object: frame)
+      node = fn_node_for(frame.fn_info)
+
+      if node.nil? && frame.event == :call
+        fn_info = frame.fn_info
+        node = ChaosDetector::ChaosGraphs::FunctionNode.new(
+          fn_name: fn_info.fn_name,
+          fn_path: fn_info.fn_path,
+          fn_line: fn_info.fn_line,
+          domain_name: options.domain_from_path(fn_info.fn_path),
+          mod_info: frame.mod_info
+        )
+        @nodes << node
+      end
+
+      node
+    end
+
+    def mod_node_from_info(mod_info)
+      # log("Calling fn_node_for_frame", object: frame)
+      node = mod_node_for(mod_info)
+
+      if node.nil? #&& frame.event == :call
+        node = ChaosDetector::ChaosGraphs::ModuleNode.new(
+          mod_name: mod_info.mod_name,
+          mod_path: mod_info.mod_path,
+          mod_type: mod_info.mod_type,
+          domain_name: options.domain_from_path(mod_info.mod_path)
+        )
+
+        @mod_nodes << node
+      end
+
+      node
+    end
+
+    def edge_for_nodes(src_node, dep_node, edges:, edge_type: :dependent)
+      edge = edges.find do |e|
+        e.src_node == src_node && e.dep_node == dep_node
+      end
+      if edge.nil?
+        edge = ChaosDetector::GraphTheory::Edge.new(src_node, dep_node, edge_type: edge_type)
+        edges << edge
+      end
+      edge
+    end
+
+    def perform_node_action(frame)
+      return unless [:call, :return].include?(frame.event)
+      node = fn_node_for_frame(frame)
+
+      ChaosUtils.with(node && frame.event == :return && frame.fn_info.fn_line) do |fn_line|
+        if !node.fn_line_end.nil? && node.fn_line_end != fn_line
+        end
+        node.fn_line_end = [fn_line, node.fn_line_end.to_i].max
+      end
+    end
+
+
+    def perform_edge_action(frame)
+      return unless frame.fn_info && frame.event==:call #&& frame.caller_info
+
+      dest_node = fn_node_for(frame.fn_info)
+      if dest_node.nil?
+        # unless @err_nodes.include?(dest_node)
+        #   log "Couldn't find destination node (of #{@nodes.length} / #{@edges_call.length}) on #{frame}"
+        #   @err_nodes << dest_node
+        # end
+        return
+      end
+
+      caller_node = fn_node_for(frame.caller_info)
+      if caller_node.nil?
+        caller_node = ChaosDetector::ChaosGraphs::FunctionNode.root_node
+        raise 'Caller node is required (falls back to root).' if caller_node.nil?
+
+        # log("Adding edge to root!")
+        @nodes << caller_node
+      end
+
+      edges = frame.event == :return ? @edges_ret : @edges_call
+      edge_for_nodes(caller_node, dest_node, edges: edges)
+    end
+
+    def perform_mod_edge_action(frame)
+      return unless frame.mod_info && frame.caller_info
+
+      caller_node = mod_node_from_info(frame.caller_info)
+      dest_node = mod_node_from_info(frame.mod_info)
+      edge_for_nodes(dest_node, caller_node, edges: @mod_edges, edge_type: frame.event)
+    end
+
+    def domain_from_path(local_path:)
+      key = domain_hash.keys.find { |k| local_path.start_with?(k) }
+      key ? domain_hash[key] : ChaosDetector::GraphTheory::Node::ROOT_NODE_NAME
+    end
+
+    def log(msg, **opts)
+      ChaosUtils.log_msg(msg, subject: 'Navigator', **opts)
+    end
+  end
+end