flows 0.2.0 → 0.6.0

data/lib/flows/plugin/profiler/report/events.rb

@@ -0,0 +1,43 @@
+module Flows
+  module Plugin
+    module Profiler
+      class Report
+        # @api private
+        Event = Struct.new(:method_class, :method_type, :method_name, :data) do
+          def subject
+            "#{method_class}#{delimeter}#{method_name}"
+          end
+
+          private
+
+          def delimeter
+            case method_type
+            when :instance then '#'
+            when :singleton then '.'
+            end
+          end
+        end
+
+        # @api private
+        #
+        # Method execution start event.
+        class StartEvent < Event
+          def to_s
+            "start: #{subject}"
+          end
+        end
+
+        # @api private
+        #
+        # Method execution finish event.
+        #
+        # Data is an execution time in microseconds.
+        class FinishEvent < Event
+          def to_s
+            "finish(#{data} microseconds): #{subject}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flows/plugin/profiler/report/flat.rb

@@ -0,0 +1,41 @@
+require_relative 'flat/method_report'
+
+module Flows
+  module Plugin
+    module Profiler
+      class Report
+        # Flat report. Merges similar calls, hides execution structure.
+        #
+        # It's a variation of a {Rport::Tree} where all calls of the same method
+        # are combined into a one first-level entry.
+        #
+        # @example
+        #     Flows::Plugin::Profiler.profile(:flat) do
+        #       # some code here
+        #     end
+        #
+        #     puts Flows::Plugin::Profiler.last_report
+        class Flat < Tree
+          def to_a
+            method_reports.map(&:to_h)
+          end
+
+          def to_s
+            method_reports.map(&:to_s).join("\n")
+          end
+
+          private
+
+          def method_reports
+            @method_reports ||= root_calculated_node
+                                .group_by_subject
+                                .values
+                                .map { |nodes| MethodReport.new(root_calculated_node, *nodes) }
+                                .sort_by(&:total_self_ms)
+                                .reverse
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flows/plugin/profiler/report/flat/method_report.rb

@@ -0,0 +1,80 @@
+module Flows
+  module Plugin
+    module Profiler
+      class Report
+        class Flat < Tree
+          # @api private
+          class MethodReport
+            attr_reader :root_node, :calculated_nodes
+
+            def initialize(root_node, *calculated_nodes)
+              @root_node = root_node
+              @calculated_nodes = calculated_nodes
+
+              raise 'no single node provided' if calculated_nodes.empty?
+              raise 'calculated_nodes must be about the same subject' unless nodes_have_same_subject
+            end
+
+            def subject
+              @subject ||= calculated_nodes.first.subject
+            end
+
+            def count
+              @count ||= calculated_nodes.map(&:count).sum
+            end
+
+            def total_self_ms
+              @total_self_ms ||= calculated_nodes.map(&:total_self_ms).sort.sum
+            end
+
+            def total_self_percentage
+              @total_self_percentage ||= calculated_nodes
+                                         .map { |node| node.total_self_percentage(root_node) }
+                                         .sort
+                                         .sum
+            end
+
+            def avg_self_ms
+              @avg_self_ms ||= total_self_ms / count
+            end
+
+            def direct_subcalls
+              @direct_subcalls ||= calculated_nodes
+                                   .flat_map { |node| node.children.map(&:subject) }
+                                   .uniq
+            end
+
+            def to_h
+              @to_h ||= {
+                subject: subject,
+                count: count,
+                total_self_ms: total_self_ms,
+                total_self_percentage: total_self_percentage,
+                avg_self_ms: avg_self_ms,
+                direct_subcalls: direct_subcalls
+              }
+            end
+
+            def to_s
+              [
+                '',
+                "- #{subject} -",
+                "called:                      #{count} time(s)",
+                "total self execution time:   #{total_self_ms.truncate(2)}ms",
+                "total self percentage:       #{total_self_percentage.truncate(2)}%",
+                "average self execution time: #{avg_self_ms.truncate(2)}ms",
+                "direct subcalls:             #{direct_subcalls.join(', ')}"
+              ]
+            end
+
+            private
+
+            def nodes_have_same_subject
+              calculated_nodes.all? { |node| node.subject == subject }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flows/plugin/profiler/report/raw.rb

@@ -0,0 +1,15 @@
+module Flows
+  module Plugin
+    module Profiler
+      class Report
+        # Raw report. Preserves events as is.
+        class Raw < Report
+          # @see Report#to_s
+          def to_s
+            raw_data.map(&:to_s).join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flows/plugin/profiler/report/tree.rb

@@ -0,0 +1,98 @@
+require_relative 'tree/node'
+require_relative 'tree/calculated_node'
+
+module Flows
+  module Plugin
+    module Profiler
+      class Report
+        # Tree report. Merges similar calls, saves execution structure (who called whom).
+        #
+        # @example
+        #     Flows::Plugin::Profiler.profile(:tree) do
+        #       # some code here
+        #     end
+        #
+        #     puts Flows::Plugin::Profiler.last_report
+        class Tree < Report
+          # Returns tree report as Ruby data structs.
+          #
+          # @return [Array<Hash>] tree report.
+          #
+          # @example
+          #   [
+          #     {
+          #       subject: 'MyClass#call',
+          #       count: 2,
+          #       total_ms: 100.0,
+          #       total_self_ms: 80.0,
+          #       total_self_percentage: 80.0,
+          #       avg_ms: 50.0,
+          #       avg_self_ms: 40.0,
+          #       nested: [
+          #         {
+          #           subject: 'MyClass#another_method',
+          #           count: 1,
+          #           total_ms: 20.0,
+          #           total_self_ms: 20.0,
+          #           total_self_percentage: 20.0,
+          #           avg_ms: 20.0,
+          #           avg_self_ms: 20.0,
+          #           nested: []
+          #         }
+          #       ]
+          #     }
+          #   ]
+          def to_a
+            root_calculated_node.children.map { |node| node.to_h(root_calculated_node) }
+          end
+
+          def add(*)
+            forget_memoized_values
+            super
+          end
+
+          def to_s
+            root_calculated_node.children.map { |node| node.to_s(root_calculated_node) }.join
+          end
+
+          private
+
+          def forget_memoized_values
+            @root_node = nil
+            @root_calculated_node = nil
+          end
+
+          def root_calculated_node
+            @root_calculated_node ||= CalculatedNode.new(root_node)
+          end
+
+          def root_node
+            @root_node ||= Node.new(subject: :ROOT).tap do |root_node|
+              events.each_with_object([root_node]) do |event, node_path|
+                current_node = node_path.last
+
+                case event
+                when StartEvent then process_start_event(node_path, current_node, event)
+                when FinishEvent then process_finish_event(node_path, current_node, event)
+                end
+              end
+            end
+          end
+
+          # :reek:UtilityFunction
+          def process_start_event(node_path, current_node, event)
+            node_path << current_node[event.subject]
+          end
+
+          # :reek:UtilityFunction :reek:FeatureEnvy
+          def process_finish_event(node_path, current_node, event)
+            raise 'Invalid profiling events detected' if event.subject != current_node.subject
+
+            current_node.register_execution(event.data)
+            node_path.pop
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flows/plugin/profiler/report/tree/calculated_node.rb

@@ -0,0 +1,116 @@
+module Flows
+  module Plugin
+    module Profiler
+      class Report
+        class Tree < Report
+          # @api private
+          class CalculatedNode
+            MICROSECONDS_IN_MILLISECOND = 1000.0
+
+            attr_reader :children
+
+            def initialize(node)
+              @node = node
+              @children = node.children
+                              .map { |child| self.class.new(child) }
+                              .sort_by(&:total_ms)
+                              .reverse
+            end
+
+            def subject
+              @node.subject
+            end
+
+            def count
+              @count ||= @node.executions.count
+            end
+
+            def total_ms
+              @total_ms ||= @node.executions.sort.sum / MICROSECONDS_IN_MILLISECOND
+            end
+
+            def avg_ms
+              @avg_ms ||= total_ms / count
+            end
+
+            def children_ms
+              @children_ms ||= children.map(&:total_ms).sort.sum
+            end
+
+            def total_self_ms
+              @total_self_ms ||= total_ms - children_ms
+            end
+
+            def total_self_percentage(root_node = self)
+              @total_self_percentage ||= total_self_ms / root_node.children_ms * 100.0
+            end
+
+            def total_percentage(root_node = self)
+              @total_percentage ||= total_ms / root_node.children_ms * 100.0
+            end
+
+            def avg_self_ms
+              @avg_self_ms ||= total_self_ms / count
+            end
+
+            def to_h(root_node = self) # rubocop:disable Metrics/MethodLength
+              @to_h ||= {
+                subject: subject,
+                count: count,
+                total_ms: total_ms,
+                total_percentage: total_percentage(root_node),
+                total_self_ms: total_self_ms,
+                total_self_percentage: total_self_percentage(root_node),
+                avg_ms: avg_ms,
+                avg_self_ms: avg_self_ms,
+                nested: children.map { |node| node.to_h(root_node) }
+              }
+            end
+
+            def to_s(root_node = self)
+              @to_s ||= (base_text_list(root_node) + childeren_text_list(root_node)).join("\n")
+            end
+
+            # :reek:DuplicateMethodCall
+            # :reek:NestedIterators
+            def group_by_subject
+              @group_by_subject ||= (
+                [children.group_by(&:subject)] + children.map(&:group_by_subject)
+              ).each_with_object({}) do |group, result|
+                group.each do |subject, nodes|
+                  result[subject] ||= []
+                  result[subject] += nodes
+                end
+              end
+            end
+
+            private
+
+            def base_text_list(root_node) # rubocop:disable Metrics/MethodLength
+              [
+                '',
+                "- #{subject} -",
+                "called:                      #{count} time(s)",
+                "total execution time:        #{total_ms.truncate(2)}ms",
+                "total percentage:            #{total_percentage(root_node).truncate(2)}%",
+                "total self execution time:   #{total_self_ms.truncate(2)}ms",
+                "total self percentage:       #{total_self_percentage(root_node).truncate(2)}%",
+                "average execution time:      #{avg_ms.truncate(2)}ms",
+                "average self execution time: #{avg_self_ms.truncate(2)}ms"
+              ]
+            end
+
+            def childeren_text_list(root_node)
+              return [] if @children.empty?
+
+              children.map { |node| node.to_s(root_node) }
+                      .join("\n")
+                      .split("\n")
+                      .map { |str| "|    #{str}" }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flows/plugin/profiler/report/tree/node.rb

@@ -0,0 +1,34 @@
+module Flows
+  module Plugin
+    module Profiler
+      class Report
+        class Tree < Report
+          # @api private
+          class Node
+            attr_reader :subject, :executions
+
+            def initialize(subject:)
+              @subject = subject
+              @children = {}
+              @cache = {}
+
+              @executions = []
+            end
+
+            def [](subject)
+              @children[subject] ||= Node.new(subject: subject)
+            end
+
+            def children
+              @children.values
+            end
+
+            def register_execution(microseconds)
+              @executions << microseconds
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flows/plugin/profiler/wrapper.rb

@@ -0,0 +1,53 @@
+module Flows
+  module Plugin
+    module Profiler
+      # @api private
+      module Wrapper
+        class << self
+          def make_instance_wrapper(method_name) # rubocop:disable Metrics/MethodLength
+            Module.new.tap do |mod|
+              mod.define_method(method_name) do |*args, &block| # rubocop:disable Metrics/MethodLength
+                thread = Thread.current
+                klass = self.class
+
+                return super(*args, &block) unless thread[THREAD_VAR_FLAG]
+
+                report = thread[THREAD_VAR_REPORT]
+                report.add(:started, klass, :instance, method_name, nil)
+
+                before = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_microsecond)
+                super(*args, &block)
+              ensure
+                if before
+                  after = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_microsecond)
+                  report.add(:finished, klass, :instance, method_name, after - before)
+                end
+              end
+            end
+          end
+
+          def make_singleton_wrapper(method_name) # rubocop:disable Metrics/MethodLength
+            Module.new.tap do |mod|
+              mod.define_method(method_name) do |*args, &block| # rubocop:disable Metrics/MethodLength
+                thread = Thread.current
+
+                return super(*args, &block) unless thread[THREAD_VAR_FLAG]
+
+                report = thread[THREAD_VAR_REPORT]
+                report.add(:started, self, :singleton, method_name, nil)
+
+                before = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_microsecond)
+                super(*args, &block)
+              ensure
+                if before
+                  after = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_microsecond)
+                  report.add(:finished, self, :singleton, method_name, after - before)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end